programmation d'un convertisseur decimale binaire en C

[invite175953cf]

bonsoir
je voudrais convertir un décimal en binaire,
je voudrais seulement afficher les chiffres du restes des divisions par 2, enfin vous savez le truc, si ces chiffres se lisent à l'envers du haut en bas ou le contraire je m'en fiche!!
bien!! voilà ce que j'ai fait en C :

#include <stdio.h>
#include <math.h>

main()
{
    long compteur=0, a, d, x, y; 
    float b, c;
    printf("donnez a:");
    scanf("%d", &a);
    b = log(a);
    c = b / (log(2));
    d = ceil(c);
    while (compteur < d)
   {
         compteur++;
         x = a % 2;
         y = a / 2;
         y = a;
         printf("%d\n", x);
         
   }
        system("PAUSE");	
        return 0;
}

c le truc de la division en deux!!
bon si quelkqu'un aurait une idée comment organiser les instruction du programme, ou donner une autre version parce que je pense que je suis dans une impasse là;

merci beaucoup
-----

[invite4ad25ccf]

log, c'est un log base 10, donc ca ne passera pas (enfin du moins je crois). Et surtout c'est un peu bourrin pour faire cela.

Tu as un truc qui s'appelle la division modulaire ('%') qui te permet d'avoir le reste d'une division.

Ainsi si je note 54 % 10, j'obtiens 4
Ensuite, une autre particularité du C, si tu fais une division d'entier, tu récupère la partie entiere : 54 / 10 = 5
D'ou (54 / 10)*10^1 + (54 % 10)*10^0 = 54
Voire (543 / 100)*10^2 + ((543 - (543 / 100)*10^2 ) / 10)*10^1 + (543 % 10) = 543

Avec cela, tu devrais obtenir une décomposition en base 10. Une fois que tu as compris pour la base 10, il ne te restera plus qu'a le faire en base 2

[invite74b5b8f7]

Salut,

Il me semble bien que l´on peu afficher en binaire avec la fonction sprintf (%b), ça serait le plus simple!
Sinon, utilises un pointeur sur un bool (ou sur un octet avec un masquage) et tu lis la valeur de a en mémoire...

Pour ton programme, il y a de l´idée mais il doit t´afficher toujours le même chiffre non?

Déjà, à la place de tout ça:

    b = log(a);
    c = b / (log(2));
    d = ceil(c);

Tu pourrais (s´il existe dans tes en-têtes) utiliser le logarithme binaire: d = lb (a)+1;
sinon: d = (ln(a)/ln2) +1;

Sinon, le plus simple serait de controler la valeur de a après chaque division par deux (quand il est inferieur à 2, on arrete)

while ( (a+1) >= 2)
{
    x = a%2;
    a /= 2;
    printf("%d\n", x);
}

Sauf que le résultat est inversé....

Que veux tu faire avec ça? c´est un exercice scolaire non?

[invite175953cf]

non ce n'est qu'une idée comme ça!!

[A voir en vidéo sur Futura]

[invite175953cf]

lil-vince,
un petit commentaire svp sur ton deuxième exemple !!
merci

[Philou67]

Pour afficher les bits dans l'ordre :

long a;           // nombre a afficher
long b = 1 << 15; // puissance de 2 (on commence par la plus grande)

printf("Entrer a:\n");
scanf("%ul", &a);
while (b != 0) {
  putchar('0' + (a / b) % 2);
  b /= 2;
}

L'opérateur << (dans l'expression 1 << 15) décale les bits de l'opérande de gauche, du nombre de bits spécifié dans l'opérande de droite. Ainsi :
1 << 15 correspond en binaire à :
0000000000000001 décalé 15 fois à gauche soit :
1000000000000000 soit 2¹⁵

Un nombre est stocké dans mémoire sous forme d'un polynôme dont les coefficients sont des valeurs binaires de puissances de 2.
Ainsi :
a = a₀2¹⁵ + ... + a₁₅2⁰

En divisant a pas 2¹⁵ (division entière), on obtient 0 ou 1, qui correspond au premier coefficient du nombre a (premier bit, ou bit de poids fort).
Pour trouver les autres coefficients, il suffit de diviser le diviseur par 2 à chaque fois, ainsi, on obtient successibles toutes les puissances de 2 jusqu'à 2⁰.

Voyons le calcul de a₁ :
a / 2¹⁴, en valeur entière va donner
a₀2¹⁵ + a₁2¹⁴
Pour éliminer les coefficients de puissance supérieure à celle recherchée, il suffit de prendre le reste de la division par 2 (que l'on obtient avec l'opérateur % en C).

Concernant l'affichage avec putchar, j'ai usé d'un artifice pour éviter un test. On peut aussi écrire l'affichage ainsi :

if ((a / b) % 2) {
  putchar('1');
}
else {
  putchar('0');
}

ou encore

putchar(((a / b) % 2) ? '1' : '0');

[invite6de5f0ac]

Bonjour,

Je prends ce fil en cours, j'interviens juste pour mettre mon souk de développeur en C qui se la joue comme en assembleur...

On n'écrit jamais

a /= 2

mais plutôt

a >>= 1

Et dans la même idée

a % 2

est exactement pareil que

a & 1

Mais les bons compilos le font d'eux-mêmes. En principe...

-- françois

[Philou67]

On utilise un langage évolué justement pour ne pas utilisé un langage basique.

En programmant a >>= 1 au lieu de a /= 2 :
- on oublie que conceptuellement, on veut diviser par 2
- on suppose que le codage des nombres au format binaire (et pas pour les nombres en virgule flottante).

En génie logiciel, on ne doit jamais préjugé de la nécessité "d'optimiser le code source". Cela doit toujours être la conséquence d'une contrainte de performance, et être ciblés sur les éléments critiques (après profilage). Cela pour plusieurs raisons :
- l'optimisation dans les sources rends la compréhension et la maintenabilité moins bonne.
- les compilateurs optimisent souvent bien mieux que nous-même
- d'un compilateur à l'autre, une écriture "optimisée" pourra ne plus l'être

En revanche, il n'est pas exclu de concevoir des algorithmes efficaces.

[invite6de5f0ac]

On utilise un langage évolué justement pour ne pas utilisé un langage basique.

En programmant a >>= 1 au lieu de a /= 2 :
- on oublie que conceptuellement, on veut diviser par 2
- on suppose que le codage des nombres au format binaire (et pas pour les nombres en virgule flottante).

En génie logiciel, on ne doit jamais préjugé de la nécessité "d'optimiser le code source". Cela doit toujours être la conséquence d'une contrainte de performance, et être ciblés sur les éléments critiques (après profilage). Cela pour plusieurs raisons :
- l'optimisation dans les sources rends la compréhension et la maintenabilité moins bonne.
- les compilateurs optimisent souvent bien mieux que nous-même
- d'un compilateur à l'autre, une écriture "optimisée" pourra ne plus l'être

En revanche, il n'est pas exclu de concevoir des algorithmes efficaces.

Je ne peux qu'être entièrement d'accord. C'est pour ça que j'ai mis un smiley à "mettre mon souk" !

J'ose à peine imaginer ce que cette "optimisation" donnerait sur une machine ternaire. Il est clair que le choix d'un bon algorithme (en principe avec une évaluation de sa complexité, mais dans la vraie vie on s'en dispense bien souvent) est bien plus crucial que des optimisations à la main, au coup par coup, et qui ne feront jamais que grappiller quelques cycles d'exécution. Je n'ai eu à faire ce genre de choses que dans des applications temps réel, avec un processeur minable et une mémoire vive plus que restreinte. Un collègue m'avait passé à cette occasion un dessin légendé "Nos crédits ont tellement été diminués que nous ne pouvons plus calculer que sur des nombres à un chiffre"...

Cela dit, les "a >>= 1" et "a & 1" sont des "idiomes" en C, des tics de langage qui sont tellement souvent utilisés qu'ils sont reconnaissables au premier coup d'œil. Et en l'occurrence ils ne sont pas complètement injustifiés puisque le problème est une conversion décimal -> binaire : il est alors parfaitement légitime d'exploiter le fait que les entiers sont représentés en base 2.

Mais sur le fond, bien entendu, un vrai algorithme vraiment portable est bien mieux. Si après le compilo ne fait pas correctement son boulot d'optimisation, on n'en est pas responsable.

-- françois

[Philou67]

J'ai également travaillé sur l'optimisation de code, écrit en C, sur un micro minable... j'en viens presque à me demander si c'est le même

Avec ce micro (ce compilo devrait-je dire), je gagnais d'innombrables cycles d'exécution en décomposant dans des variables intermédiaires, de simples calculs arithmétiques sur des entiers. Sans cela, pour une simple addition, il faisait systématiquement appel à une fonction de la librairie C. A devenir complètement fou !