Partage
  • Partager sur Facebook
  • Partager sur Twitter

Programme binaire

Sujet résolu
    17 octobre 2019 à 19:41:23

    Bonsoir,

    j'ai un programme à faire concernant les décompositions binaire, je bloque beaucoup voici l'énoncé:

    On suppose dans cet exercice que l'on travaille sur des entiers non signés codés sur deux octets. Construire un programme permettant : • de saisir un tel entier, • de permuter sur choix de l'utilisateur deux demi-octets le constituant, • d'afficher le résultat.
     
    Par exemple, pour n = 32742, on obtient la décomposition binaire :
    1 2 3 4 0111 1111 1110 0110
     
    La permutation du demi-octet 1 et du demi-octet 3 donnerait :
    1 2 3 4 1110 1111 0111 0110
     
    Le résultat serait donc ici de : 61302.
     
    Remarques :  • l'utilisation d'opérateurs de manipulation binaire est interdite, • le résultat doit être affiché en binaire et en décimal.

    et voici le programme que je suis entrain de faire:

    #include <stdio.h>
    #include <stdlib.h>

    int main(int argc, char **argv)
    {
        unsigned long binairepart1=0;
        unsigned long binairepart2=0;
        unsigned long binairepart3=0;
        unsigned long binairepart4=0;
        long increment=0;
        int e;
        unsigned long binairefinal;
        int i=0;
        int interchange1;
        int interchange2;
        unsigned long numberdecimal;
        unsigned long numbergarde;
       
        printf("Entrez votre nombre: \n");
        scanf("%lu", &numberdecimal);
        numbergarde=numberdecimal;
       
        while(numberdecimal != 0){
            e= numberdecimal%2;
            numberdecimal=numberdecimal/2;
            e=e*ceil(pow(10,increment));
            binairedecimal=e+binairedecimal;
            increment++;
            i++;
        if(numbergarde<=15 && numberdecimal==0){
            binairepart4=binairefinal;
        }else{
            if(i==4}{
               binairepart4=binairefinal;
               increment=0;
               e=0;
               binairefinal=0;
               }
            if(numbergarde <= 255 && numberdecimal==0){
                binairepart3=binairefinal;
                }
            if(i==8)
                binairepart3=binairefinal;
            increment=0;
            e=0;
            binairefinal=0;
           
        }
        }

    j'ai beaucoup de mal concernant les demi octets que je dois interchanger, j'espère que vous pourriez m'aider.

    • Partager sur Facebook
    • Partager sur Twitter
      17 octobre 2019 à 19:43:42

      Bonjour,

      Le message qui suit est une réponse automatique activée par un membre de l'équipe. Les réponses automatiques leur permettent d'éviter d'avoir à répéter de nombreuses fois la même chose, ce qui leur fait gagner du temps et leur permet de s'occuper des sujets qui méritent plus d'attention.
      Nous sommes néanmoins ouverts et si vous avez une question ou une remarque, n'hésitez pas à contacter la personne en question par Message Privé.

      Pour plus d'informations, nous vous invitons à lire les règles générales du forum

      Merci de colorer votre code à l'aide du bouton Code

      Les forums d'Openclassrooms disposent d'une fonctionnalité permettant de colorer et mettre en forme les codes source afin de les rendre plus lisibles et faciles à manipuler par les intervenants. Pour cela, il faut utiliser le bouton Code de l'éditeur, choisir un des langages proposés et coller votre code dans la zone prévue. Si vous utilisez l'éditeur de messages en mode Markdown, il faut utiliser les balises <pre class="brush: cpp;">Votre code ici</pre>.

      Liens conseillés

      • Partager sur Facebook
      • Partager sur Twitter
        17 octobre 2019 à 19:50:00

        #include <stdio.h>
        #include <stdlib.h>
        
        int main(int argc, char **argv)
        {
            unsigned long binairepart1=0;
            unsigned long binairepart2=0;
            unsigned long binairepart3=0;
            unsigned long binairepart4=0;
            long increment=0;
            int e;
            unsigned long binairefinal;
            int i=0;
            int interchange1;
            int interchange2;
            unsigned long numberdecimal;
            unsigned long numbergarde;
            
            printf("Entrez votre nombre: \n");
            scanf("%lu", &numberdecimal);
            numbergarde=numberdecimal;
            
            while(numberdecimal != 0){
                e= numberdecimal%2;
                numberdecimal=numberdecimal/2;
                e=e*ceil(pow(10,increment));
                binairedecimal=e+binairedecimal;
                increment++;
                i++;
            if(numbergarde<=15 && numberdecimal==0){
                binairepart4=binairefinal;
            }else{
                if(i==4}{
                   binairepart4=binairefinal;
                   increment=0;
                   e=0;
                   binairefinal=0;
                   }
                if(numbergarde <= 255 && numberdecimal==0){
                    binairepart3=binairefinal;
                    }
                if(i==8)
                    binairepart3=binairefinal;
                increment=0;
                e=0;
                binairefinal=0;
                
            }
            }
        • Partager sur Facebook
        • Partager sur Twitter
          18 octobre 2019 à 3:10:41

          Salut,
          si j'ai bien compris, tu veux interchanger les bits 7-4 et 3-0 sans opérateurs binaires.
          Tu peux faire:
          haut = nombre / 16;
          bas = nombre % 16;
          nombre2 = bas * 16 + haut;
          Est-ce ce que tu cherchais?
          • Partager sur Facebook
          • Partager sur Twitter

          Le Tout est souvent plus grand que la somme de ses parties.

            18 octobre 2019 à 6:02:57

            Alors enfaîte il y a 6 façons d'interchanger, et je veux interchanger des 6 façons:

            1=2 et 2=1

            1=3 et 3=1

            1=4 et 4=1

            2=3 et 3=2

            3=4 et 4=3

            2=4 et 4=2

            le problème, je ne sais pas comment le montrer dans mon programme. Au début, je pensais à un if(…&&…)|| if(…&&…)||...

            mais je ne sais pas qu'est ce que je dois mettre après. Et en plus six if, ça fait un peu beaucoup..

            M

            • Partager sur Facebook
            • Partager sur Twitter
              18 octobre 2019 à 11:02:27

              Voici une un petit bout de code permettant d'inverser les 2 quartets d'un octet:

              	int i = 0x53;
              	i = i << 4;
              	i = i | (i >> 8);
              	i = i & 0xff; // et i = 0x35 désormais
              

              A toi de comprendre son fonctionnement et de l'adapter à ta manière, l'idéal étant d'en faire une fonction.

              • Partager sur Facebook
              • Partager sur Twitter
                18 octobre 2019 à 18:27:42

                mais je n'ai pas le droit au fonction, et Ox, c'est la base 10 mais que veux dire ff?
                • Partager sur Facebook
                • Partager sur Twitter
                  18 octobre 2019 à 18:48:28

                  jeffrey95140 a écrit:

                  mais je n'ai pas le droit au fonction, et Ox, c'est la base 10 mais que veux dire ff?


                  Il n'y a aucune fonction dans le code zoup. 0x (zero suiivi de x [ou X] ) indique au compilateur que le nombre qui va suivre est de l'hexadécimal. Je te laisse donc chercher ce que veut dire 0xff

                  Mais hélas pour zoup, si son code est bon, il enfreint la consigne: pas d'opérateur de manipulation de bits

                  -
                  Edité par edgarjacobs 18 octobre 2019 à 18:49:40

                  • Partager sur Facebook
                  • Partager sur Twitter

                  On écrit "j'ai tort", pas "tord" qui est le verbe "tordre" à la 3ème personne de l'indicatif présent

                    18 octobre 2019 à 19:20:03

                    Tu as regardé la proposition de PierrotLeFou ? Il me semble qu'elle correspond bien à ce que tu recherches.

                    C'est une solution pour permuter les demi-octets 1 et 2, il restera à généraliser aux octets i et j quelconques.

                    Une idée possible serait de d'abord séparer chaque demi-octet, quelque chose comme :

                    demi_octet[1] = nombre % 16;
                    reste = nombre /16;
                    demi_octet[2] = reste % 16;
                    reste = reste / 16 ;
                    demi_octet[3] = reste % 16;
                    reste = reste / 16 ;
                    demi_octet[4] = reste % 16;
                    reste = reste / 16 ;
                    

                    qu'on peut bien sûr écrire de façon plus concise avec une boucle. (Mais j'écris comme les idées me viennent, tant pis pour l'optimisation.) Note que j'ai numéroté les demi-octets dans le « bon » ordre (contrairement à toi). Exemple : avec 32742 on obtient 6, 14, 15, 7 (correspondant à l'écriture hexadécimale 7ED6 si je me trompe pas).

                    Ensuite, on demande à l'utilisateur d'indiquer les deux numéros de demi-octets à permuter. Mettons qu'il saisisse 2 et 4 (qui correspondent à ceux que tu as numéroté 1 et 3). Il suffit alors de reconstituer le nombre après avoir permuté les éléments du tableau :

                    printf("Entrer les numéros à permuter : ") ;
                    scanf ("%u %u", &i, &j) ;
                    /* penser à vérifier qu'ils sont entre 1 et 4 ! */
                    
                    // 1) On permute
                    tmp = demi_octet[i] ;
                    demi_octet[i] = demi_octet[j] ;
                    demi_octet[j] = tmp ;
                    
                    // 2) On reconstitue le nombre
                    nombre = demi_octet[1] + 16 * (demi-octet[2]
                                           + 16 * (demi_octet[3]
                                           + 16 *  demi_octet[4])) ;
                    

                    (Là aussi, le 2) peut être écrit de façon plus concise avec une boucle.) Avec les valeurs 6, 14, 15, 7 que, une fois permutées, deviennent 6, 7, 15, 14, on obtient 61302.

                    Bref, il y a peut-être des petites erreurs, mais je pense que l'idée est bonne.

                    PS : désolé si j'en ai trop dit. Je suis parti de l'idée de PierrotLeFou que j'ai juste voulu généraliser, et je me suis peut-être un peu emporté. Il faut dire que je sujet est amusant !

                    -
                    Edité par robun 18 octobre 2019 à 19:24:52

                    • Partager sur Facebook
                    • Partager sur Twitter
                      19 octobre 2019 à 0:42:43

                      edgarjacobs a écrit:

                      Mais hélas pour zoup, si son code est bon, il enfreint la consigne: pas d'opérateur de manipulation de bits

                      Mince, pas vu.

                      Bin dans ce cas on fait la même chose mais avec des opérations arithmétiques:

                      	i = i * 16;        // i = i << 4;
                      	i = i + (i / 256); // i = i | (i >> 8);
                      	i = i % 256;       // i = i & 0xff;

                      Mais ça ne permet d'interchanger les demi octets d'un seul et même octet, ce qui n'est pas précisément ce qui est demandé.

                      La solution proposée plus haut d'isoler les nibbles dans un tableau et de les mélanger pour reconstituer l'entier au final me semble bien au final.


                      -
                      Edité par zoup 19 octobre 2019 à 0:48:40

                      • Partager sur Facebook
                      • Partager sur Twitter
                        23 octobre 2019 à 23:16:15

                        Merci à tous pour vos réponses, j'ai donc fait le programme mais j'ai un problème, ça ne m'affiche pas le résultat que je veux c'est-à-dire le nombre decimal interchanger et le nombre binaire. 

                        #include <stdio.h>
                        #include <stdlib.h>
                        #include <math.h>
                        
                        int main(int argc, char **argv)
                        {
                            unsigned long binairepart1=0;
                            unsigned long binairepart2=0;
                            unsigned long binairepart3=0;
                            unsigned long binairepart4=0;
                            unsigned int interchange1;
                            unsigned int interchange2;
                            long increment=0;
                            int e;
                            unsigned long binairefinal;
                            int i=0;
                            unsigned long numberdecimal;
                            unsigned long numbergarde;
                            unsigned long numbergarde1;
                            unsigned int binairedecimal;
                        
                            printf("Entrez votre nombre: \n");
                            scanf("%lu", &numberdecimal);
                            numbergarde=numberdecimal;
                        
                            while(numberdecimal != 0){
                                e= numberdecimal%2;
                                numberdecimal=numberdecimal/2;
                                e=e*ceil(pow(10,increment));
                                binairedecimal=e+binairedecimal;
                                increment++;
                                i++;
                            if(numbergarde<=15 && numberdecimal==0){
                                binairepart4=binairefinal;
                            }else{
                                if(i==4){
                                   binairepart4=binairefinal;
                                   increment=0;
                                   e=0;
                                   binairefinal=0;
                                   }
                                if(numbergarde <= 255 && numberdecimal==0){
                                    binairepart3=binairefinal;
                                    }
                                if(i==8)
                                    binairepart3=binairefinal;
                                increment=0;
                                e=0;
                                binairefinal=0;
                        
                            }
                            printf("Entrer les numéros à permuter : ") ;
                            scanf ("%u %u", &interchange1, &interchange2) ;
                        
                            numbergarde1= interchange1 ;
                            interchange1 = interchange2 ;
                            interchange2 = numbergarde1;
                        
                            numberdecimal = binairepart1 + 16 * (binairepart2 + 16 * (binairepart3 + 16 *  binairepart4));
                            printf("%ld", numberdecimal);
                            printf("%ld", binairefinal);
                            return 0;
                        }
                        }
                        

                        Je pense que je devrais rajouter pour chaque bit, les opérateurs mathématiques pour passer du decimal en binaire, vous pensez que c'est une bonne idée?

                        -
                        Edité par sneekid 23 octobre 2019 à 23:22:27

                        • Partager sur Facebook
                        • Partager sur Twitter
                          25 octobre 2019 à 22:23:31

                          Bonsoir,

                          je voulais vous demander, parce que dans mon programme, je dois convertir un nombre décimal en binaire, ça je l'ai fait mais la 2eme partie consiste à interchanger deux demi-octets( sachant qu'il y en a 4).

                          Par exemple: 32742 donne 1111 1111 1100 1100 et par exemple si j'échange le demi-octet 1 et le 4, ça me donne:

                          1100 1111 1100 1111

                          Mais je ne sais pas comment procéder dans le programme, pourriez-vous m'aider s'il vous plaît

                          • Partager sur Facebook
                          • Partager sur Twitter
                            25 octobre 2019 à 23:20:47

                            jeffrey95140 a écrit:

                            Par exemple: 32742 donne 1111 1111 1100 1100

                            Hem! hem! Ca commence mal 37742 donne 
                            Une solution t'a déjà été donnée avec des tableaux par robun.

                            Sinon, sans tableaux:

                            #include <stdint.h>
                            
                            int main()
                            {
                            	uint16_t v = 32742; // ‭0111 1111 1110 0110‬
                            	uint16_t nibble1 = v / (16 * 16 * 16); // 0000 0000 0000 0111
                            	uint16_t nibble4 = v * (16 * 16 * 16); // 0110 0000 0000 0000
                            
                            	v = v - (nibble1 * 16 * 16 * 16); // 0000 1111 1110 0110
                            	v = v + nibble4; // 0110 1111 1110 0110
                            
                            	v = v - nibble4 / (16 * 16 * 16); // 0110 1111 1110 0000
                            	v = v + nibble1; // 0110 1111 1110 0111
                            
                            	return 0;
                            }

                            Après, personnellement, j'en ferais une fonction à 2 paramètres représentant les numéros des demi-octets à échanger.

                            -
                            Edité par zoup 25 octobre 2019 à 23:21:55

                            • Partager sur Facebook
                            • Partager sur Twitter
                              27 octobre 2019 à 15:28:40

                              ouiii, j'ai réussi, merci à tout veux qui m'ont aidé, pour aider d'autres personnes qui s'interraisseraient à l'exercice, voici la solution:

                              #include <stdio.h>
                              #include <stdlib.h>
                              #include <math.h>
                              
                              int main(int argc, char **argv)
                              {
                                  unsigned int nbdecimal=0;
                                  unsigned int nb2decimal=0;
                                  int rt0=0;
                                  int rt1=0;
                                  int rt2=0;
                                  int rt3=0;
                                  int rt4=0;
                                  int rt5=0;
                                  int rt6=0;
                                  int rt7=0;
                                  int rt8=0;
                                  int rt9=0;
                                  int rt10=0;
                                  int rt11=0;
                                  int rt12=0;
                                  int rt13=0;
                                  int rt14=0;
                                  int rt15=0;
                                  int interchange1=0;
                                  int interchange2=0;
                              
                              
                                  printf("Entrez votre nombre decimal: ");
                                  scanf("%d", &nbdecimal);
                              
                                  if(nbdecimal<0)
                                      printf("Il y a une erreur");
                              
                                  do{
                                  rt0=nbdecimal%2;
                                  nbdecimal=(nbdecimal/2);
                                  rt1=nbdecimal%2;
                                  nbdecimal=(nbdecimal/2);
                                  rt2=nbdecimal%2;
                                  nbdecimal=(nbdecimal/2);
                                  rt3=nbdecimal%2;
                                  nbdecimal=(nbdecimal/2);
                                  rt4=nbdecimal%2;
                                  nbdecimal=(nbdecimal/2);
                                  rt5=nbdecimal%2;
                                  nbdecimal=(nbdecimal/2);
                                  rt6=nbdecimal%2;
                                  nbdecimal=(nbdecimal/2);
                                  rt7=nbdecimal%2;
                                  nbdecimal=(nbdecimal/2);
                                  rt8=nbdecimal%2;
                                  nbdecimal=(nbdecimal/2);
                                  rt9=nbdecimal%2;
                                  nbdecimal=(nbdecimal/2);
                                  rt10=nbdecimal%2;
                                  nbdecimal=(nbdecimal/2);
                                  rt11=nbdecimal%2;
                                  nbdecimal=(nbdecimal/2);
                                  rt12=nbdecimal%2;
                                  nbdecimal=(nbdecimal/2);
                                  rt13=nbdecimal%2;
                                  nbdecimal=(nbdecimal/2);
                                  rt14=nbdecimal%2;
                                  nbdecimal=(nbdecimal/2);
                                  rt15=nbdecimal%2;
                              
                                  }while(nbdecimal!=0);
                                  printf("Binaire: %d%d%d%d | %d%d%d%d | %d%d%d%d | %d%d%d%d\n", rt15, rt14, rt13, rt12, rt11, rt10, rt9, rt8, rt7, rt6, rt5, rt4, rt3, rt2, rt1, rt0);
                              
                                  printf("Quels nombres voulez vous interchanger? ");
                                  scanf("%d\n%d", &interchange1, &interchange2);
                              
                                  if((interchange1==1 && interchange2==3) || (interchange1==3 && interchange2==1)){
                                      printf("Binaire: %d%d%d%d | %d%d%d%d | %d%d%d%d | %d%d%d%d\n", rt7, rt6, rt5, rt4, rt11, rt10, rt9, rt8, rt15, rt14, rt13, rt12, rt3, rt2, rt1, rt0);
                                      nb2decimal= (rt7*pow(2,15))+ (rt6*pow(2,14))+ (rt5*pow(2,13))+ (rt4*pow(2,12))+ (rt11*pow(2,11))+ (rt10*pow(2,10))+ (rt9*pow(2,9))+ (rt8*pow(2,8))+ (rt15*pow(2,7)) +(rt14*pow(2,6))+ (rt13*pow(2,5))+ (rt12*pow(2,4))+ (rt3*pow(2,3))+ (rt2*pow(2,2))+(rt1*pow(2,1)) +(rt0*pow(2,0));
                                      printf("decimal: %d", nb2decimal);
                              
                                      }else if((interchange1==1 && interchange2==2) || (interchange1==2 && interchange2==1)){
                                          printf("Binaire: %d%d%d%d | %d%d%d%d | %d%d%d%d | %d%d%d%d\n", rt11, rt10, rt9, rt8, rt15, rt14, rt13, rt12, rt7, rt6, rt5, rt4, rt3, rt2, rt1, rt0);
                                      nb2decimal= (rt11*pow(2,15))+ (rt10*pow(2,14))+ (rt9*pow(2,13))+ (rt8*pow(2,12))+ (rt15*pow(2,11))+ (rt14*pow(2,10))+ (rt13*pow(2,9))+ (rt12*pow(2,8))+ (rt7*pow(2,7)) +(rt6*pow(2,6))+ (rt5*pow(2,5))+ (rt4*pow(2,4))+ (rt3*pow(2,3))+ (rt2*pow(2,2))+(rt1*pow(2,1)) +(rt0*pow(2,0));
                                      printf("decimal: %d", nb2decimal);
                              
                                      }else if((interchange1==1 && interchange2==4) || (interchange1==4 && interchange2==1)){
                                      printf("Binaire: %d%d%d%d | %d%d%d%d | %d%d%d%d | %d%d%d%d\n", rt3, rt2, rt1, rt0, rt11, rt10, rt9, rt8, rt7, rt6, rt5, rt4,  rt15, rt14, rt13, rt12);
                                      nb2decimal= (rt3*pow(2,15))+ (rt2*pow(2,14))+ (rt1*pow(2,13))+ (rt0*pow(2,12))+ (rt11*pow(2,11))+ (rt10*pow(2,10))+ (rt9*pow(2,9))+ (rt8*pow(2,8))+ (rt7*pow(2,7)) +(rt6*pow(2,6))+ (rt5*pow(2,5))+ (rt4*pow(2,4))+ (rt15*pow(2,3))+ (rt14*pow(2,2))+(rt13*pow(2,1)) +(rt12*pow(2,0));
                                      printf("decimal: %d", nb2decimal);
                              
                                      }else if((interchange1==2 && interchange2==3) || (interchange1==3 && interchange2==2)){
                                          printf("Binaire: %d%d%d%d | %d%d%d%d | %d%d%d%d | %d%d%d%d\n", rt15, rt14, rt13, rt12, rt7, rt6, rt5, rt4, rt11, rt10, rt9, rt8, rt3, rt2, rt1, rt0);
                                      nb2decimal= (rt15*pow(2,15))+ (rt14*pow(2,14))+ (rt13*pow(2,13))+ (rt12*pow(2,12))+ (rt7*pow(2,11))+ (rt6*pow(2,10))+ (rt5*pow(2,9))+ (rt4*pow(2,8))+ (rt11*pow(2,7)) +(rt10*pow(2,6))+ (rt9*pow(2,5))+ (rt8*pow(2,4))+ (rt3*pow(2,3))+ (rt2*pow(2,2))+(rt1*pow(2,1)) +(rt0*pow(2,0));
                                      printf("decimal: %d", nb2decimal);
                              
                                      }else if((interchange1==3 && interchange2==4) || (interchange1==4 && interchange2==3)){
                                          printf("Binaire: %d%d%d%d | %d%d%d%d | %d%d%d%d | %d%d%d%d\n", rt15, rt14, rt13, rt12, rt11, rt10, rt9, rt8, rt3, rt2, rt1, rt0, rt7, rt6, rt5, rt4);
                                      nb2decimal= (rt15*pow(2,15))+ (rt14*pow(2,14))+ (rt13*pow(2,13))+ (rt12*pow(2,12))+ (rt11*pow(2,11))+ (rt10*pow(2,10))+ (rt9*pow(2,9))+ (rt8*pow(2,8))+ (rt3*pow(2,7)) +(rt2*pow(2,6))+ (rt1*pow(2,5))+ (rt0*pow(2,4))+ (rt7*pow(2,3))+ (rt6*pow(2,2))+(rt5*pow(2,1)) +(rt4*pow(2,0));
                                      printf("decimal: %d", nb2decimal);
                              
                                      }else if((interchange1==2 && interchange2==4) || (interchange1==4 && interchange2==2)){
                                          printf("Binaire: %d%d%d%d | %d%d%d%d | %d%d%d%d | %d%d%d%d\n", rt15, rt14, rt13, rt12, rt3, rt2, rt1, rt0, rt7, rt6, rt5, rt4, rt11, rt10, rt9, rt8);
                                     nb2decimal= (rt15*pow(2,15))+ (rt14*pow(2,14))+ (rt13*pow(2,13))+ (rt12*pow(2,12))+ (rt3*pow(2,11))+ (rt2*pow(2,10))+ (rt1*pow(2,9))+ (rt0*pow(2,8))+ (rt7*pow(2,7)) +(rt6*pow(2,6))+ (rt5*pow(2,5))+ (rt4*pow(2,4))+ (rt11*pow(2,3))+ (rt10*pow(2,2))+(rt9*pow(2,1)) +(rt8*pow(2,0));
                                      printf("%d", nb2decimal);
                              
                                      }else{
                                          printf("Il y a une erreur");
                                      }
                              
                                      return 0;
                              }



                              • Partager sur Facebook
                              • Partager sur Twitter
                                27 octobre 2019 à 15:51:13

                                Un peu "bourrin" à mon avis: tes rtx auraient avantageusement pu être remplacés par un tableau, dynamique idéalement de manière à ne pas restreindre la taille des nombres.

                                Du coup, tes interminables lignes dans la boucle auraient pu se ramener à 2 .

                                • Partager sur Facebook
                                • Partager sur Twitter
                                  27 octobre 2019 à 17:01:45

                                  zoup, j'ai oublié de préciser que que je n'ai pas le droit au tableau, ni aux operateurs binaires
                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                    27 octobre 2019 à 17:24:21

                                    Et tu m'écris ce code pour une valeur sur 64 bits ?
                                    • Partager sur Facebook
                                    • Partager sur Twitter

                                    On écrit "j'ai tort", pas "tord" qui est le verbe "tordre" à la 3ème personne de l'indicatif présent

                                      27 octobre 2019 à 20:11:37

                                      jeffrey95140 a écrit:

                                      zoup, j'ai oublié de préciser que que je n'ai pas le droit au tableau

                                      Et pourquoi ne le précises-tu que maintenant? Ca fait un moment qu'on te propose des solutions utilisant des tableaux, mais tu laisses courir. Franchement, je ne comprends pas ...


                                      Du coup, tant qu'on y est, il y a encore d'autres trucs auxquels tu n'as pas droit?

                                      -
                                      Edité par zoup 27 octobre 2019 à 20:12:37

                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                        28 octobre 2019 à 0:20:43

                                        C'est vrai que jeffrey95140 précise que les opérateurs binaires sont interdits.
                                        Je me suis donné la peine de faire une recherche virtuelle et il n'est pas fait mention de la restriction pour les tableaux.
                                        • Partager sur Facebook
                                        • Partager sur Twitter

                                        Le Tout est souvent plus grand que la somme de ses parties.

                                          28 octobre 2019 à 19:41:58

                                          pierrotLeFou, je suis vraiment désolé.

                                          Zoup, je n'ai pas droit aux tableaux et aux opérateurs binaires.

                                          edgarjacobs, comment ça?

                                          • Partager sur Facebook
                                          • Partager sur Twitter

                                          Programme binaire

                                          × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                                          × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                                          • Editeur
                                          • Markdown