0
votes

Convertir un tableau d'entiers représentant un nombre binaire en un nombre décimal

J'ai un tableau d'entiers qui représentent un nombre binaire. Je dois le convertir en son équivalent entier décimal. Quelqu'un peut-il m'aider?

int octet[8] = {0, 1, 0, 0, 1, 0, 1, 0};

Je souhaite renvoyer l'équivalent décimal qui serait 74 dans ce cas.


4 commentaires

Comment savez-vous qu'il est 74 ans? Peut-être pouvez-vous dire à l'ordinateur comment vous l'avez calculé en utilisant C?


Quel algorithme avez-vous utilisé pour résoudre ce problème dans votre tête? Avez-vous essayé d'utiliser cet algorithme également en C? Si oui, veuillez nous montrer ce que vous avez essayé. Vous voudrez peut-être lire ceci pour plus d'informations: Comment poser des questions sur les devoirs et y répondre?


Ah - chaque entier du tableau d'octets représente un seul chiffre binaire. Et d'après votre réponse, je vois que l'octet [7] représente le bit le moins significatif. Donc donc c'est 64 + 8 + 2 == 74


int i = octet [0] * 128 + octet [1] * 64 + octet [2] * 32 + octet [3] * 16 + octet [4] * 8 + octet [5] * 4 + octet [ 6] * 2 + octet [7];


3 Réponses :


1
votes

2 ^ 0 x le dernier élément + 2 ^ 1 x l'avant-dernier élément + 2 ^ 2 x le troisième-dernier élément + ...


0 commentaires

2
votes

Voici un exemple de la façon dont vous pourriez faire quelque chose comme ça:

#include <stdio.h>                                                                                                                                      
                                                                            
int main()                                                                      
{                                                                               
                                                                            
    int octet[] = {0, 1, 0, 0, 1, 0, 1, 0};                                    
    int *p = octet;                                                             
    int len = sizeof(octet) / sizeof(octet[0]); // 8                                                                
    unsigned result = 0;                                                        
                                                                                
    while(len--) result = (result<<1) | *p++;                                   
    /* 74 */                                                                     
    printf("%u\n", result);                                                     
                                                                                
}                   


1 commentaires

cette réponse contient le nombre «magique» 8. les nombres «magiques» rendent le code beaucoup plus difficile à comprendre, à déboguer, etc. Suggérer de permettre au compilateur de faire tout le «gros du travail» en laissant le compilateur calculer le nombre d'éléments dans le tableau et en utilisant ce nombre calculé par le compilateur comme limite pour la boucle



1
votes
#include <stdio.h>

int main()                                                                      
{
  // Make array constant and let the compiler tell us how many elements are contained.
  // Doing it this way allows "octet" to grow up to the number of bits in an integer elements.  
  // It won't be an "octet" anymore though,...
  const int octet[] = {0, 1, 0, 0, 1, 0, 1, 0};         
  const int NumArrayElements = sizeof(octet) / sizeof(*octet);

  // Assign hi bit to save a loop iteration.
  int value = octet[0];
  
  // Run remaining bits, shifting up and or-ing in new values.
  for(int i=1; i<NumArrayElements; i++)
  {
    value <<= 1;
    value |= octet[i];
  }
  
  printf("%d\n", value);
}
This is a simple thing to do, but having the compiler handle some of the sizing issues and adding comments makes it much easier to maintain over time.

0 commentaires