Ajouter deux nombres entiers en utilisant seulement les opérateurs au niveau du bit?

En C#, il est possible d'effectuer la somme de deux nombres entiers de 32 bits sans utiliser des choses comme if..else, boucles etc?

Qui est, peut-il être fait en utilisant uniquement les opérations bit à bit OU (|), ET (&), XOR (^), PAS (!), maj gauche (<<) et décalage à droite (>>)?

Par curiosité, pourquoi voulez-vous faire une telle chose?
Université d'affectation?
Selon lui, il veut juste comprendre la logique derrière l'ajout de nombres binaires.
Rien de spécial, juste pour le savoir. Je ne suis pas dans l'université 🙁
si vous êtes intéressés par ce genre de chose, découvrez un livre qui s'appelle Hacker Plaisir
Assurez-vous que vous avez lu Structuré Organisation de l'Ordinateur de Tanenbaum. C'est un putain de bon livre qui commence avec beaucoup de bas niveau, des trucs comme ça et va jusqu'à la pile par la suite.
C'est une grande question pour informatique quantique.

InformationsquelleAutor Delta | 2010-11-01

bit-manipulation c#

60

Voici un exemple pour votre amusement
```
unsigned int myAdd(unsigned int a, unsigned int b)
{
    unsigned int carry = a & b;
    unsigned int result = a ^ b;
    while(carry != 0)
    {
        unsigned int shiftedcarry = carry << 1;
        carry = result & shiftedcarry;
        result ^= shiftedcarry;
    }
    return result;
}
```
La boucle peut être déroulé. Nombre de fois qu'il exécute, dépend du nombre de bits définis dans opérandes, mais il n'est jamais plus grande que la largeur de unsigned int. Une fois carry devient 0, prochaines itérations de ne pas changer quoi que ce soit.
- Je vous remercie. C'est ce que je cherchais. Maintenant je vais essayer de comprendre pourquoi cela fonctionne. ty
- Un concis de solution qui fonctionne. +1 pour que.
- Quelqu'un peut-il produire une forme concise, la preuve pourquoi une version sans boucle ou la récursivité n'est pas possible pour l'arbitraire de la représentation de la taille?
- Je ferai remarquer que cela devrait fonctionner dans les modernes Fortran, car il n'y a pas de type entier non signé. On peut simplement utiliser une normale entier et de cette procédure afin de garantir entier non signé de l'addition modulo 2^w où w est le nombre de bits dans votre modèle entier. Habituellement, les entiers sont deux compliment en Fortran, de sorte que les bits représentent des entiers non signés, mais si vous imprimez la valeur de votre entier qu'elle va interpréter les bits comme un signé deux compliment entier. Si vous souhaitez utiliser les grands entiers et vérifiez que votre addition marche & modulo 2^w attention de l'interprétation des résultats.
- Prenons le cas de la N sur un côté et un seul bit d'autre part. Chaque fois que vous boucle une fois, le report se déplace un peu vers la gauche. Vous avez de la boucle au moins N fois pour obtenir les transporter à aller tout le chemin vers la gauche pour le dépassement de soit dans la partie suivante ou dans la résultante bit de retenue.
InformationsquelleAutor Maciej Hehl
21

Essayez ceci:
```
    private int add(int a, int b) {
        if(b == 0)
            return a;

        return add( a ^ b, (a & b) << 1);
    }
```
Edit:
Corrigé if déclaration
- Avons-nous besoin de l'instruction si ici, lorsque b = 0, a^b = a et donc le résultat reste le même .
- oui. Vous avez besoin de la base de cas à la fin de la récursivité.
InformationsquelleAutor Shatazone
6

Réfléchir à comment l'ajout arrive peu à peu. Maj les valeurs pour chaque bit de chaque opérande à son tour, puis regarder les quatre valeurs possibles pour les deux bits et de calculer le résultat de bits doit être et si il y a un bit de retenue à s'inquiéter. Puis voir comment le résultat et peut transporter caculated à l'aide de la bit-à-bit de la fpo.

InformationsquelleAutor The Archetypal Paul

public static int getSum(int p, int q)
{
    int carry=0, result =0;
    for(int i=0; i<32; i++)
    {
        int n1 = (p & (1<<(i)))>>(i); //find the nth bit of p
        int n2 = (q & (1<<(i)))>>(i); //find the nth bit of q

        int s = n1 ^ n2 ^ carry; //sum of bits
        carry = (carry==0) ? (n1&n2): (n1 | n2); //calculate the carry for next step
        result = result | (s<<(i)); //calculate resultant bit
    }

    return result;
}

Prenant 32 bits int 32 bits. Merci!!!

i++ est que pas plus? 😉

InformationsquelleAutor Trying

static int binaryadd(int x, int y)
{
  while (x != 0)
  {
    int c = y & x;
    y = y ^ x; 
    x = c << 1;             
  }
  return y;
}

InformationsquelleAutor stt106

int Add(int a, int b)
{
      int result = 0,
          //carry now contains common set bits of "a" and "b"
          carry = a & b;

      if (Convert.ToBoolean(carry))
      {
          //Sum of bits of "a" and "b" where at least one 
          //of the bits is not set
          result = a ^ b;

          //carry is shifted by one so that adding it 
          //to "a" gives the required sum
          carry = carry << 1;

          result = add(carry, result);
      }
      else
      {
          result = a ^ b;
      }

      return result;
}

De la somme de deux bits peuvent être effectuées à l'aide de la XOR ^ opérateur et bit de retenue peuvent être obtenus par l'utilisation ET la & de l'opérateur.
Fourni a et b n'ont pas de définir les bits à la même position, puis à l'aide ^ opérateur donne la somme de a et b.

Commentaires de geeksforgeeks

InformationsquelleAutor John Kennedy

-5

        int  b =  25;
        for (int t = 128; t > 0; t = t / 2)
        {
            if ((b & t) != 0) Console.Write("1 ");
            if ((b & t) == 0) Console.Write("0 ");
        }
        Console.WriteLine();
        //b = (sbyte)~b;
        int e = 22;
        for (int t = 128; t > 0; t = t / 2)
        {
            if ((e & t) != 0) Console.Write("1 ");
            if ((e & t) == 0) Console.Write("0 ");
        }
        Console.WriteLine();
        int c = b | e;
        for (int t = 128; t > 0; t = t / 2)
        {
            if ((c & t) != 0) Console.Write("1 ");
            if ((c & t) == 0) Console.Write("0 ");
        }

-1 code fourni est juste "int c = b | e" qui est OU, pas AJOUTER. Le reste du code est tout simplement mauvais exemple de la conversion de int en une chaîne binaire.

InformationsquelleAutor naresh

Vous devez vous connecter pour publier un commentaire.