Quel est le moyen le plus rapide pour savoir si un nombre est pair ou impair?

C'est un bon débutant C question. +1 de moi.
N'est pas au niveau du bit-XOR plus rapide que bit-à-bit-ET? Il n'est pas possible avec l'opération XOR?
Si vous êtes en utilisant une fonction de compilateur, que back-end presque certainement le sait ces trucs mieux que vous. Écrire pour la clarté et de la lisibilité et de laisser le peu de violon, cycle de l'optimisation du pro. Vraiment. Et si vous n'êtes pas heureux avec les résultats, le profil, puis examiner les points chauds dans le détail.
De toute façon j'aimerais voir une solution à l'aide d'une seule instruction XOR. Je ne pense pas que ce soit possible...
Assurez-vous que vous avez lu avant de microoptimization: linux-kongress.org/2009/slides/...
Non, il n'est pas possible de modèle ET en utilisant uniquement XOR. Vous ne pouvez pas masquer bits XOR - vous ne pouvez passer à l'identique, ou basculer.

InformationsquelleAutor aks | 2010-02-09

c micro-optimization

57

Il est assez bien connu que
```
static inline int is_odd_A(int x) { return x & 1; }
```
est plus efficace que
```
static inline int is_odd_B(int x) { return x % 2; }
```
Mais avec l'optimiseur de suite, sera is_odd_B pas être différente de is_odd_A? Pas — avec gcc-4.2 -O2, nous obtenons, (dans les BRAS de montage):
```
_is_odd_A:
    and r0, r0, #1
    bx  lr

_is_odd_B:
    mov r3, r0, lsr #31
    add r0, r0, r3
    and r0, r0, #1
    rsb r0, r3, r0
    bx  lr
```
Nous voyons que is_odd_B prend 3 plus d'instructions que is_odd_A, la principale raison est parce que
```
((-1) % 2) == -1
((-1) & 1) ==  1
```
Cependant, toutes les versions suivantes génère le même code que is_odd_A:
```
#include <stdbool.h>
static inline bool is_odd_D(int x) { return x % 2; }      //note the bool
static inline int  is_odd_E(int x) { return x % 2 != 0; } //note the !=
```
Qu'est-ce que cela signifie? L'optimiseur est généralement assez sophistiqué que, pour ces choses simples, le plus clair de code est suffisant pour garantir une meilleure efficacité.
- encore mieux, spécifiez l'argument comme unsigned.
- ou x&1U. 🙂
- que faire si vous avez entrée 1, il est dit bizarre
- x & 1 va donner de mauvaises réponses sur un complément de systèmes. Pour le portable code qui permet de compiler efficacement sur la normale complément de 2 systèmes qui nous intéressent, vous devez utiliser signé ou x % 2 != 0
InformationsquelleAutor kennytm
7

Manière habituelle de le faire:
```
int number = ...;
if(number % 2) { odd }
else { even }
```
Alternative:
```
int number = ...;
if(number & 1) { odd }
else { even }
```
Testé sur GCC 3.3.1 et 4.3.2, les deux ont la même vitesse (sans optimisation du compilateur) comme la fois le résultat de la and instruction (compilé sur x86) - je sais que l'utilisation de la div instruction pour modulo serait beaucoup plus lent, donc je n'ai pas de test du tout.
- Le compilateur a probablement enlevé le tester complètement, comme le sont tous les deux probablement constante. Rappelons que gcc sans options est équivalent à gcc -O2 qui est un non-trivial niveau de l'optimisation de la vitesse. Vérifier l'assembly généré pour être sûr..
- N'est pas au niveau du bit-XOR plus rapide que bit-à-bit-ET? Il n'est pas possible avec l'opération XOR?
- Je ne sais pas pourquoi vous pensez que le niveau 2 est la valeur par défaut. La page de man dit clairement: "- O0 Ne pas optimiser. C'est la valeur par défaut.". Mais j'ai vérifié le code assembleur de toute façon et il n'a pas été supprimée dans le code (c'est pourquoi il faut 7 secondes pour chaque test à exécuter).
- J'ai testé XOR au niveau du bit et c'est à la même vitesse ET/modulo (BTW ces deux produisent le même code sur x86, à savoir un "et" de l'enseignement). De toute façon pourriez-vous me dire comment faire pour déterminer pair/impair avec que un XOR déclaration?
- Scandinavie niveaux d'optimisation: Mea Culpa.
InformationsquelleAutor AndiDog
6
```
bool is_odd = number & 1;
```
- c'est rapide, mais l'habitude de compiler moins qu'il y ait quelque part une définition de type
- Cette échoue sur une machine à l'aide d'un complément.
- Vous avez raison bien sûr, cette mise en œuvre implique en complément à deux de la logique. Je ne suis pas au courant de tout contemporain complément de matériel, cependant. Si vous connaissez, s'il vous plaît commentaire.
- Comme indiqué dans d'autres réponses "% 2" est la "bonne" réponse, car il permettra de compiler pour "& 1" sur la plupart des matériels de toute façon, et il montre l'intention correcte du code. "& 1" est de l'époque avant de les plus intelligents, les optimisations du compilateur.
- vous pouvez créer une fonction pour vérifier si la machine est ceux ou deux compliment. Mais je suis trop paresseux pour chose maintenant
- il réussit sur une machine à l'aide de ceux complément si vous modifiez le 1 à 1U.
InformationsquelleAutor digitalarbeiter
5

if (x & 1) est vrai, alors c'est bizarre, sinon c'est le même.
- Cette échoue sur une machine à l'aide d'un complément.
- Aussi, et c'est un commentaire général pour toutes les réponses à ce jour, la question ne précise pas le nombre est un entier. Vous ne pouvez pas faire des opérations bit à bit sur les flotteurs (au moins, pas sans un certain type de coulée hackery).
- Définir, même étrangeté ou pour un non-entier.
- float i=2.0 f; // un nombre pair! mais j'ai & 1 qui ne fonctionne pas.
- vous pouvez définir l'2.0 parce que il a une expression entière. Donc, la meilleure chose à faire est de les convertir en int et gérer le résultat tel que discuté.
InformationsquelleAutor Vicky
2
```
int i=5;
if ( i%2 == 0 )
{
   //Even
} else {
   //Odd
}
```
- Vérifier le bit le moins significatif serait plus rapide que le module de l'opérateur. Cependant, je parie que la plupart des compilateurs serait à son tour "mod 2" dans "et 1"
- ils ne peuvent pas s' i est signé.
- êtes-vous sûr? Par exemple, le complément à deux est de 127 "01111111", et -127 est "10000001", les deux ont le bit le moins significatif jeu.
InformationsquelleAutor lamas
2

Si c'est un entier, probablement par juste vérifier le bit le moins significatif. Zéro sera compté comme même si.
- Le zéro est un nombre pair. Échec également sur une machine à l'aide d'un complément.
InformationsquelleAutor Marcel
2

La portable façon est d'utiliser l'opérateur de modulo %:
```
if (x % 2 == 0) //number is even
```
Si vous savoir que vous n'êtes jamais allez courir sur le complément à deux architectures, vous pouvez utiliser un bit à bit et:
```
if (x & 0x01 == 0) //number is even
```
En utilisant le module de l'opérateur peut entraîner une baisse de code par rapport à la bit-à-bit; et cependant, je serais rester avec elle, à moins que toutes les conditions suivantes sont remplies:
1. Vous ne parviennent pas à répondre à un dur exigence de performance;
2. L'exécution d' x % 2 un beaucoup (disons dans une boucle serrée, qui est exécuté des milliers de fois);
3. Profilage indique que l'utilisation de l'opérateur mod est le goulot d'étranglement;
4. Profilage indique également que l'utilisation de l'or au niveau du bit et soulage le goulot d'étranglement et vous permet de répondre à l'exigence de rendement.
- == a une priorité plus élevée que &, donc x & 0x01 == 0 permettra d'évaluer dans x & (0x01 == 0) qui est équivalent à x & 0 qui signifie 0 de sorte que votre if branche ne sera jamais exécutée.
- De Plus, vous devez vérifier si le compilateur vraiment sorties différentes en code machine pour les deux. Mon pari est qu'il devrait sortir le même, surtout avec les optimisations activées.
InformationsquelleAutor John Bode
2

Vérifier pour voir si le dernier bit est à 1.
```
int is_odd(int num) {
  return num & 1;
}
```
- Voir le commentaire de Tom, même s'applique ici. Ce ne compile pas en C.
- Droit... changé de type int. (FWIW, certains environnements de build #define ou définition de type bool int).
InformationsquelleAutor 0xfe
1
```
int is_odd(int n)
{
   if (n == 0)
      return 0;
   else if (n == 1)
      return 1;
   else
      return !is_odd(n - 1);
}
```
Oh, attendez, vous avez dit plus rapide façon, pas plus drôle. Mon mauvais 😉

Fonction ci-dessus ne fonctionne que pour les nombres positifs, bien sûr.
- Je voudrais effectuer une factorisation sur n, puis vérifier si elle a un facteur de 2. :p
- qu'en est: int is_odd(int n) { return cos(M_PI * n) < 0.0; }
- Un bon compilateur devrait sortir le même assembleur comme avec {return n & 1;} 🙂
- C'est un bon test pour le compilateur "bonté"
InformationsquelleAutor Maurits Rijk
1

Votre question n'est pas complètement spécifié. Peu importe, la réponse dépend de votre compilateur et de l'architecture de votre machine. Par exemple, êtes-vous sur une machine à l'aide d'un complément ou en complément à deux signé nombre de représentations?

J'écris mon code pour être correct tout d'abord, effacer deuxième, concis troisième et rapide dernier. Par conséquent, je voudrais le code de cette routine comme suit:
```
/* returns 0 if odd, 1 if even */
/* can use bool in C99 */
int IsEven(int n) {
    return n % 2 == 0;
}
```
Cette méthode est correcte, il exprime plus nettement l'intention de tester le bit de poids faible, c'est concis et, croyez-le ou pas, il est ultra-rapide. Si et seulement si le profilage m'a dit que cette méthode ont été un goulot d'étranglement dans mon application je envisager de s'en écarter.
- Je suis assez sûr qu'il y est, et a été pendant plus de 10 ans (depuis C99)
InformationsquelleAutor jason
0

Vérifier le bit le moins significatif:
```
if (number & 0x01) {
  //It's odd
} else {
  //It's even
}
```
- Par curiosité: Pourquoi 0x01 au lieu de simplement 1?
- C'est l'habitude. Je suis habitué à toujours utilisation de la représentation hexadécimale lorsque vous effectuez des opérations bit à bit 🙂
InformationsquelleAutor holygeek

Vous devez vous connecter pour publier un commentaire.