Comment vérifier si un nombre entier est pair ou impair ?

Question

Comment puis-je vérifier si un nombre donné est pair ou impair en C ?

Answer 1

Utilisez l'opérateur modulo (%) pour vérifier s'il y a un reste lorsqu'on divise par 2 :

if (x % 2) { /* x is odd */ }

Quelques personnes ont critiqué ma réponse ci-dessus en déclarant que l'utilisation de x & 1 est "plus rapide" ou "plus efficace". Je ne pense pas que ce soit le cas.

Par curiosité, j'ai créé deux programmes de test triviaux :

/* modulo.c */
#include <stdio.h>

int main(void)
{
    int x;
    for (x = 0; x < 10; x++)
        if (x % 2)
            printf("%d is odd\n", x);
    return 0;
}

/* and.c */
#include <stdio.h>

int main(void)
{
    int x;
    for (x = 0; x < 10; x++)
        if (x & 1)
            printf("%d is odd\n", x);
    return 0;
}

Je les ai ensuite compilés avec gcc 4.1.3 sur l'une de mes machines 5 fois différentes :

• Sans drapeaux d'optimisation.
• Avec -O
• Avec -Os
• Avec -O2
• Avec -O3

J'ai examiné la sortie de l'assemblage de chaque compilation (en utilisant gcc -S) et j'ai constaté que dans chaque cas, la sortie de and.c et de modulo.c était identique (ils utilisaient tous deux l'instruction andl $1, %eax). Je doute que ce soit une "nouvelle" fonctionnalité, et je soupçonne que cela remonte à d'anciennes versions. Je doute également qu'un compilateur moderne (fait au cours des 20 dernières années) non-arcane, commercial ou open source, manque d'une telle optimisation. Je testerais bien sur d'autres compilateurs, mais je n'en ai aucun de disponible pour le moment.

Si quelqu'un d'autre souhaite tester d'autres compilateurs et/ou d'autres plates-formes cibles et obtient un résultat différent, je serais très intéressé de le savoir.

Enfin, la version modulo est garanti par la norme pour travailler si l'entier est positif, négatif ou nul, quelle que soit la représentation des entiers signés de l'implémentation. La version bitwise-and ne l'est pas. Oui, je réalise que le complément à deux est quelque peu omniprésent, donc ce n'est pas vraiment un problème.

Answer 2

Vous êtes beaucoup trop efficaces. Ce que vous voulez vraiment c'est :

public boolean isOdd(int num) {
  int i = 0;
  boolean odd = false;

  while (i != num) {
    odd = !odd;
    i = i + 1;
  }

  return odd;
}

Répétez pour isEven .

Bien sûr, ça ne marche pas pour les nombres négatifs. Mais avec l'intelligence vient le sacrifice...

Answer 3

Utilisez l'arithmétique des bits :

if((x & 1) == 0)
    printf("EVEN!\n");
else
    printf("ODD!\n");

C'est plus rapide que d'utiliser la division ou le modulus.

Answer 4

[Joke mode="on"]

public enum Evenness
{
  Unknown = 0,
  Even = 1,
  Odd = 2
}

public static Evenness AnalyzeEvenness(object o)
{

  if (o == null)
    return Evenness.Unknown;

  string foo = o.ToString();

  if (String.IsNullOrEmpty(foo))
    return Evenness.Unknown;

  char bar = foo[foo.Length - 1];

  switch (bar)
  {
     case '0':
     case '2':
     case '4':
     case '6':
     case '8':
       return Evenness.Even;
     case '1':
     case '3':
     case '5':
     case '7':
     case '9':
       return Evenness.Odd;
     default:
       return Evenness.Unknown;
  }
}

[Joke mode="off"]

EDIT : Ajout de valeurs déroutantes à l'enum.

Answer 5

En réponse à ffpf - J'ai eu exactement le même argument avec un collègue il y a des années, et la réponse est la suivante pas de il ne fonctionne pas avec les nombres négatifs.

La norme C stipule que les nombres négatifs peuvent être représentés de 3 façons :

• Complément à 2
• Complément à 1
• le signe et la magnitude

En vérifiant comme ça :

isEven = (x & 1);

fonctionnera pour le complément à 2 et la représentation du signe et de la magnitude, mais pas pour le complément à 1.

Cependant, je pense que ce qui suit fonctionnera dans tous les cas :

isEven = (x & 1) ^ ((-1 & 1) | ((x < 0) ? 0 : 1)));

Merci à ffpf de m'avoir fait remarquer que la zone de texte mangeait tout ce qui se trouvait après mon caractère moins que !