C#: Comment décalage de bits chiffres hexadécimaux

D'accord, je suis en train de travailler sur un programme de lecture de carte, et je suis le stockage de la valeur des cartes que des chiffres hexadécimaux. Voici le tableau:

 public int[] originalCards = new int[54]
        {
            0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D,
            0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D,
            0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D,
            0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D,
            0x50, 0x51
        };

Le premier chiffre se réfère à la combinaison (1 = pique; 2 = clubs; .... 5 = Jokers)
Le deuxième chiffre est le numéro de la carte (1 = as, 5 = 5; 13 = K, etc).

Je voudrais faire quelque chose comme ce qui suit:


Pseudocode:
    public int ReturnCard(int num)
    {
        int card = currentDeck[num];
        int suit = card.firsthexdigit;
        int value = card.secondhexdigit;
        return 0;
    }

Je n'ai pas besoin d'une nouvelle méthode de travail sur ints, j'ai juste compris pour plus de clarté.

Ce que quelqu'un sait comment faire cela en C#?

Edit: Bon, je suis en utilisant le décalage de bits tel que décrit dans l'une des réponses. Je peux obtenir le deuxième chiffre (le costume), mais le premier chiffre ne cesse de revenir comme '0'. Aucune idée pourquoi?

Edit:edit: ok, fonctionne très bien maintenant. Merci les gars.

Est-il une raison quelconque vous souhaitez stocker vos cartes comme ints? Sinon je conseille le stockage de chaque carte stuct ou de la classe. Il fera de vous un code beaucoup plus lisible.
Je viens de réaliser: Une structure fonctionnera beaucoup mieux, car, sinon, je vais devoir faire un énorme Cas de déclaration d'imprimer un costume et de la valeur de la carte.
Ils sont nombreux les réponses déjà sur la façon de faire ce que vous voulez avec l'octet de décalage. Puisque votre question visée de l'analyse, vous pouvez également mettre la valeur dans la chaîne et de vérifier le caractère en indice (moins optimal en terme de performance), mais une alternative :). par exemple. string x = currentDeck[num].ToString("X2"); ce qui vous donnera une chaîne comme "11" pour 0x11 entier ou 17, ou "4A" pour 0x4A ou integer 74
Vous pouvez rendre les choses encore plus compact à l'aide d'un seul octet pour représenter l'ensemble de la terrasse. Mettre rois dans les 25 premiers, puis les reines dans les 25 prochaines, etc. Maintenant, créez un enum pour les costumes. Maintenant, pour trouver la suite de toute id de la carte il vous suffit de diviser par 25 et jeté comme votre suite enum.

OriginalL'auteur Biosci3c | 2010-03-11

bit-manipulation c#hex

3

Voici une réponse à l'aide de champs de bits.
```
struct {
    unsigned int suit:4;
    unsigned int value:4;
} card    = currentDeck[num];
int suit  = card.suit;
int value = card.value;
```
Vous devrez peut-être ajouter en int pour le rembourrage que ce soit le premier ou le dernier champ de la ligne de bits correctement. Champs de bits sont normalement utilisés pour matériel d'accès en raison des registres matériels fréquemment pack de plusieurs indicateurs en un seul octet.

Par ailleurs, si vous utilisez le décalage de bits, vous souhaitez décaler par le nombre de bits dans un chiffre hexadécimal. Un chiffre hexadécimal détient des valeurs de 0 - 15 0 - F, cela nécessite 4 bits de pas 8. Donc, ce doit être utilisée:
```
int suit = (card & 0xF0) >> 4;
```
Le décalage de bits ne fonctionne toujours pas pour int costume.

OriginalL'auteur Robert Menteer
5

Vous n'êtes pas vraiment "analyse" en tant que tel, juste une simple manipulation de bits.
```
int card = currentDeck[num];
int suit = (card & 0xF0) >> 4;
int value = card & 0x0F;
```
Faire ce que vous souhaitez.

Oh, il est possible d'effectuer le décalage de bits. C'est effectivement ce que je voulais faire, en premier lieu, mais j'ai pensé qu'il ne travaille que quand vous voulez travailler avec les bits en code binaire. Je vais essayer très bientôt. Edit: Juste par curiosité, quelle est la logique derrière cela, en particulier le 0xF0 partie?
Ok, int valeur, qui fonctionne bien, mais le costume juste le lit '0'.
Doit être de type int costume = (carte & 0xF0) >> 4;
Désolé, j'ai édité ma réponse, le >> avait tort, il doit avoir été 4, pas 8.

OriginalL'auteur Dean Harding
3

Pour répondre à votre question au sujet de l'utilisation de 0xF0 et 0x0F dans le décalage de bits exemple ce qu'ils font est un au niveau du bit ET. Lorsque vous ne card & 0xF0 ce que vous faites est anding les deux valeurs, cela entraîne définition de tous les bits sauf le 4 qui vous intéresse pour en 0. Ex:
```
 0x48   01001000     0x48   01001000
&0x0F  &00001111    &0xF0  &11110000
-----   --------     ----   --------
 0x08   00001000     0x48   01000000 >> 4
                            --------
                            00000100
```
Comment ai-je reçois à zéro lorsque j'essaie d'obtenir de la partie supérieure chiffres?

OriginalL'auteur Robert Menteer

Vous pouvez essayer

int card = originalCards[1];
int suit = card /16;
int value = card % 16;

OriginalL'auteur Adriaan Stander

Ici est un exemple:

using System;
namespace Test
{
class MainClass
{
static int[] currentDeck = new int[54] {
0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D,
0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D,
0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D,
0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D,
0x50, 0x51 };
static void printParts (int num)
{
int card  = currentDeck[num];
int suit  = (card & 0xF0) >> 4;
int value = (card & 0x0F);
Console.Out.WriteLine(
String.Format ("Card: {0:x4},   ", card) +
String.Format ("Suit: {0:x4},   ", suit) +
String.Format ("Value: {0:x4}", value ));
}
public static void Main (string[] args)
{
printParts(  7 );
printParts( 18 );
printParts( 30 );
printParts( 48 );
}
}
}

Ce produit est le suivant:

Card: 0018,   Suit: 0001,   Value: 0008
Card: 0026,   Suit: 0002,   Value: 0006
Card: 0035,   Suit: 0003,   Value: 0005
Card: 004a,   Suit: 0004,   Value: 000a

Je ne suis pas sûr pourquoi, la partie supérieure de votre chiffres ne sont pas corrects.

OriginalL'auteur Robert Menteer

Vous devez vous connecter pour publier un commentaire.