Somme de deux nombres avec opérateur au niveau du bit

Je suis coller le code pour trouver la somme de deux nombres avec opérateur au niveau du bit. Veuillez indiquer, si elle peut être optimisée. Merci...

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;
}

Ne pas le faire. La Gigue optimisera pour vous déjà.
Si pour l'éducation, alors pourquoi avez-vous besoin d'optimisation? D'autre NE le faites PAS! comme @SLaks déjà dit.
pouvez-vous s'il vous plaît dites-moi quel est ce Gigue. Merci!!!
Je ne veux pas paraître impoli, mais si vous ne savez pas ce que le JIT est, vous n'avez rien à faire de bas niveau des optimisations de ce genre. Si vous voulez faire de votre programme courir plus vite, faire moins de travail. L'écriture de code comme celui-ci ne va pas aider et peut blesser.
en.wikipedia.org/wiki/Just-in-time_compilation
je le sais, mais confondre avec le mot de la Gigue!!! Mais de toute façon merci pour votre commentaire.
La réponse standard est beaucoup plus simple que cela. Voir stackoverflow.com/questions/4068033/...

InformationsquelleAutor Trying | 2013-03-10

bit-manipulation java

25

Pense que dans l'ensemble de bits:
```
public static int getSum(int p, int q)
{
    int result = p ^ q; //+ without carry 0+0=0, 0+1=1+0=1, 1+1=0
    int carry = (p & q) << 1; //1+1=2
    if (carry != 0) {
        return getSum(result, carry);
    }
    return result;
}
```
Cette récursivité se termine, comme le carry a consécutivement plus de bits 0 à droite (plus de 32 itérations).

On peut facilement écrire comme une boucle avec p = result; q = carry;.

Une autre caractéristique de l'algorithmique à l'exploration n'est pas aller trop loin dans la différenciation des cas.
Ci-dessus, vous pourriez aussi profiter de la condition: if ((result & carry) != 0).
- N'a pas l'obtenir, Pourquoi en faire décalage à gauche dans la ligne 4. Est (a ET b), n'est-ce pas?
- binaire 1+1 = 10 = (1 et 1) décalage à gauche une fois. Donc un report des chiffres pour les bits vers la gauche. Ou encore: x+y = (x^y) + ((x&y) << 1).
InformationsquelleAutor Joop Eggen
2

Je pense que les optimisations doivent être dans le domaine de la lisibilité, plutôt que sur la performance (ce qui va probablement être gérée par le compilateur).

Utiliser pour la boucle au lieu de tout

L'idiome for (int i=0; i<32; i++) est plus lisible que la boucle while si vous connaissez le nombre d'itérations à l'avance.

Diviser le nombre par deux

Diviser le nombre par deux et se les modulu:
```
n1 = p % 2;
p  /= 2;
```
Est peut-être plus lisible que:
```
(p & (1<<(i-1)))>>(i-1);
```
InformationsquelleAutor Adam Matan

Je pense que en dessous de soln est facile à comprendre & simple,

public static void sumOfTwoNumberUsingBinaryOperation(int a,int b)
{
    int c = a&b;
    int r = a|b;
    while(c!=0)
    {
        r =r <<1;
        c = c >>1;      
    }
    System.out.println("Result:\t" + r);    
}

InformationsquelleAutor Rakesh Chaudhari

Vous devez vous connecter pour publier un commentaire.

Utiliser pour la boucle au lieu de tout

Diviser le nombre par deux