Derterminer si un nombre st pair avec les calcul

[Magistrat1]

Bonjour,
J'aimerais savoir comment peut-on déterminer si un nombre est pair avec des calculs dans tous le temps écrire que x et pair si : x mod 2 =0

[GaBuZoMeu]

Un entier naturel est pair si et seulement si son chiffre des unités est pair. Tu ne le savais pas ???

[Magistrat1]

Merci pour ton retour GaBuZoMeu, oui bien sur que je le savais, je ne mettais peut etre pas assez bien expliquer, ce que j'assai de dire c'est comment le calculer sans detection visuel ( sans connaitre le nombre)...

[GaBuZoMeu]

C'est une blague ? Sans connaître un nombre, tu veux décider s'il est pair ou non ?

[fatal_error]

bj,

variante avec division entiere (telle que en c++ par ex)
x pair => (x/2)*2==x
123/2=61, 61*2=122, 122!=123

[Magistrat1]

Oui @GaBuZoMeu il suffit de le remplacer par ... une variable ! Merci @fatal_error vous m'avez encore bien aider

[GaBuZoMeu]

J'ai du mal à comprendre le sens de ce fil. Quelqu'un pourrait-il me l'expliquer ?

Le fin mot de l'histoire c'est que Magistrat1 a cassé la touche % de son clavier ? C'est ça ? Sinon, quelqu'un peut-il m'expliquer la différence entre x==2*(x/2) et x%2==0 ?

[fatal_error]

slt gbzm,

une explication parmi celles que je peux pas connaitre...
on peut se demander si il existe pas une fonction plus rapide que modulo, ne serait-ce que pour la curiosité.

en l'occurrence:

Code: Tout sélectionner

int main(int argc, char* argv[]){
    return (argc/2)*2 == 0;
}


Code: Tout sélectionner

int main(int argc, char* argv[]){
    return (argc%2) == 0;
}


ne génèrent pas (ouf!) les même instructions

Code: Tout sélectionner

//div.cpp                             //mod.cpp
.LFB0:                                   .LFB0:
...
        movl    %eax, %edx            |          andl    $1, %eax
        shrl    $31, %edx             <
        addl    %edx, %eax            <
        sarl    %eax                  <
        addl    %eax, %eax            <
        testl   %eax, %eax                       testl   %eax, %eax
        sete    %al                              sete    %al
        movzbl  %al, %eax                        movzbl  %al, %eax
        popq    %rbp                             popq    %rbp
        .cfi_def_cfa 7, 8                        .cfi_def_cfa 7, 8
        ret                                      ret



notamment en O3:

Code: Tout sélectionner

//div.cpp                     //mod.cpp
.LFB0:                          .LFB0:
        .cfi_startproc                  .cfi_startproc
        addl    $1, %edi     |          movl    %edi, %eax
        xorl    %eax, %eax   |          andl    $1, %eax
        cmpl    $2, %edi     |          xorl    $1, %eax
        setbe   %al          <
        ret                             ret
                             >          .cfi_endproc



je passe les interprétations (parce que jconnais pas mes instructions et ca m'intéresse pas outre mesure) mais on retient que _peut-être_ sur une architecture étrange, mod sera plus lent qu'appliquer une division. et si on retient pas ça on peut se demander de combien la division sera plus lente

edit: asm tronqué...à partie intéressante

[pascal16]

en binaire, la parité, c'est juste regarder si le dernier bit est à 0 ou à 1.
et on a même pas à faire un "et 0000001" car le processeur a un "parity flag"
les processeurs récents faisant les flags sans passer par le CPU, on peut même mettre 0 cycle équivalent horloge comme temps d'exécution.
donc tout dépend de l'intelligence du compilateur quand à la vitesse finale.

[GaBuZoMeu]

Ça serait plutôt
return (argc/2)*2 == argc;

[fatal_error]

return (argc/2)*2 == argc;

bien vu Sherlock

les processeurs récents faisant les flags sans passer par le CPU

je présume que tu voulais dire ALU

[pascal16]

vi