Salut!

Il y a plusieurs détails dans ta démarche qui sont à réviser (en général, tes idées sont sur la bonne voie).

Bonjour Elouan et Johnny.
L'algorithme ci-dessus donne le nombre binaire à l'envers (en miroir)!

programme binaire
variable y, x, a, e : entiers ; e est l'exposant
a:= 0; e:= 0
lire y
répéter
x:= entier(y/2)
si y = 2x+1 ; y est impair
alors
a:= a + 10 ^ e
finsi
e:= e+1 ; on passera au chiffre binaire à gauche, même si le chiffre binaire actuel est 0
y:= x
jusqu'à x = 0
montrer a
fin

En clair, la représentation binaire d'un nombre est son dernier chiffre binaire, précédé de la représentation binaire de la moitié entière du nombre.

Salut, Plume!

Deux commentaires sur ton algorithme:

1. Il ne me semble pas nécessaire de demander si y est impaire.

2. Les operations avec des puissances sont plus "chères" et lourdes du point de vue de l'ordinateur que les operations arithmétiques de base.

Bonne journée!

Johnny

Bonjour Johnny.
J'ai essayé ton algorithme avec 13; je trouve 1011 au lieu de 1101.
Ta ligne erronée est :
A := A*10 + Y - 2*X
les chiffres binaires se dévoilent à partir du plus dernier (à partir de celui qui devrait se retrouver le plus à droite); or ici, plus tôt un chiffre a été trouvé, plus de fois est-il multiplié par 10 et plus à gauche se trouvera-t-il dans le résultat; ce qui donne un résultat en miroir.

Ton programme en Visual Basic pour tableur :
Function binaire(y)
Dim a As Long, x As long, z As long
z = y
Do
x = Int(z / 2)
a = a * 10 + z - 2 * x
z = x
Loop While x > 0
binaire = a

Mon programme en Visual Basic pour tableur :
Function binair(y)
Dim a As Long, x As Long, z As Long, e As Byte
z = y
Do
x = Int(z / 2)
If z = 2 * x + 1 Then a = a + 10 ^ e
e = e + 1
z = x
Loop While z > 0
binair = a
End Function
End Function

Bonjour tout le monde,
Tout d'abord, merci beaucoup pour vos réponses.

Pourriez-vous m'expliquer vos algorithmes ? Ils ont l'air bon mais si vous pouviez mettre un petit commentaire par-ci par-là pour que je le comprenne et que j'utilise vos démarches dans le mien, ce serait sympathique.

Pour afficher le nombre en binaire, dans le bon sens, je pense avoir trouvé la solution :

Quand le reste r = 0, alors faire 0+"b"
Quand le reste r = 1, alors faire 1+"b"
  Sachant que b est une variable de type chaine, et que c'est le code binaire final à avoir.

Je suis pas sûr de ce que j'avance mais je crois que ça devrait fonctionner.

Bonjour Elouan.
Voici mon algorithme plus commenté :
programme binaire
variable y, x, a, e : entiers ; e est l'exposant; a est le résultat final
a:= 0; e:= 0
lire y
répéter
x:= entier(y/2)
si y = 2x+1 ; si y est impair, alors son dernier chiffre binaire est 1
alors
a:= a + 10 ^ e ; ajout ou non de la puissance de 10 pour former le résultat
finsi
e:= e+1 ; on passera au chiffre binaire à gauche, même si le chiffre binaire actuel est 0
y:= x ; on calculera le dernier chiffre binaire de la moitié de y
jusqu'à y = 0 ; à ce moment, y est réduit à 0
montrer a
fin

Une chaîne est plus appropriée pour le résultat, car un nombre composé uniquement de 0 et de 1 reste quand même un nombre décimal, à moins d'être précédé d'un préfixe

programme binaire
variables y, x, reste : entier, b : chaîne
lire y
b = ""
répéter
x:= entier(y/2)
reste:= y - 2*x
si reste = 1
alors
b:= "1" & b
sinon
b:= "0" & b
finsi
y:= x
jusqu'à y = 0
montrer b
fin

Bonsoir plumemeteore !

Je vais tester ton premier algorithme mais dis-moi, la variable a (résultat final binaire), c'est une variable de type chaine non ?
Et qu'appelles-tu l'exposant (e) ?

Merci.

Salut, Elouan et Plume.

Plume: t'as raison par rapport à l'effet miroir. J'ai raté une autre variable qui tient compte de la position de chaque chiffre.

PROGRAMME BINAIRE;

VARIABLES X, Y, A, D: ENTIERS

A := 0
D := 1   !*** D gardera le puissance de 10 succesives ***!
LIRE Y ; /*** LE CHIFFRE À CONVERTIR ***/

REPETER

X := [Y/2]  /*** S'ASSURER QUE C'EST LA DIVISION ENTIÈRE ***/
A := A*D + Y - 2*X  /*** RESTE DE LA DIVISION ADDITIONNÉ AU NOMBRE A***/
D := D*10  
Y := X  /*** PASSER À L'ÉTAPE SUIVANTE ***/

JUSQU'A X=0

MONTRER A

FIN DE PROGRAMME

Mon but, encore une fois, c'est d'éviter les opérations d'exponentiation.

Si le langage de programmation permet d'avoir des fonctions recursives, on pourrait obtenir une version un peu plus sophistiquée.

Salut.

Johnny

Ton algorithme doit contenir une erreur Johnny, lorsque je l'exécute, je trouve toujours "0" à la fin lorsque j'affiche A.

Voici mon algorithme, qui doit être le plus compliqué de tous ceux de cette page, qui a été réfléchi mais pas assez il faut croire, car je ne parviens toujours pas à la fin de l'objectif.

1     VARIABLES
2       d EST_DU_TYPE NOMBRE
3       r EST_DU_TYPE NOMBRE
4       b EST_DU_TYPE CHAINE
5       t EST_DU_TYPE NOMBRE
6       y EST_DU_TYPE NOMBRE
7     DEBUT_ALGORITHME
8       LIRE d
9       AFFICHER "Conversion de "
10      AFFICHER d
11      AFFICHER " en code binaire..."
12      t PREND_LA_VALEUR d
13      TANT_QUE ((t/2)>1) FAIRE
14        DEBUT_TANT_QUE
15        r PREND_LA_VALEUR (t-(2*(t-(1/2))))
16        SI (r=1) ALORS
17          DEBUT_SI
18          y PREND_LA_VALEUR (t-1)/2
19          b PREND_LA_VALEUR "1"+b
20          FIN_SI
21          SINON
22            DEBUT_SINON
23            y PREND_LA_VALEUR (t/2)
24            b PREND_LA_VALEUR "0"+b
25            FIN_SINON
26        t PREND_LA_VALEUR y
27        FIN_TANT_QUE
28      AFFICHER b
29    FIN_ALGORITHME

Salut!

L'effet "a l'invers" continue à me faire mal!! )

CHANGE la ligne suivante:

A := A*D + Y - 2*X
par celle ci

A := (Y-2*X)*10 + A

Je pense qu'il devrait marcher maintenant. Je n'ai pas le temps de le tester avant 18h.

Johnny

Je suis désolé mais il ne fonctionne pas.

Cependant, j'ai réussi à créer un algorithme qui fonctionne à l'endroit, et qui est assez simple à comprendre.
Le voici :

1     VARIABLES
2       d EST_DU_TYPE NOMBRE
3       x EST_DU_TYPE NOMBRE
4       b EST_DU_TYPE CHAINE
5       r EST_DU_TYPE NOMBRE
6     DEBUT_ALGORITHME
7       //d est le nombre entier à convertir.
8       //x est la variable de d, utilisée pour les calculs.
9       //b est le résultat final, le code binaire.
10      //r est le reste à la fin de chaque division par 2.
11      AFFICHER "Quel est le nombre entier décimal (positif) à convertir ?"
12      LIRE d
13      AFFICHER "Conversion de "
14      AFFICHER d
15      AFFICHER " en base de 2..."
16      SI (d<2) ALORS
17        DEBUT_SI
18        b PREND_LA_VALEUR d
19        FIN_SI
20        SINON
21          DEBUT_SINON
22          x PREND_LA_VALEUR d
23          TANT_QUE (x!=0) FAIRE
24            DEBUT_TANT_QUE
25            //r étant le reste de la division de x par 2 quand x/2 est un entier rond.
26            r PREND_LA_VALEUR x%2
27            //Ajout du reste 1 ou 0 au code binaire.
28            b PREND_LA_VALEUR r+b
29            x PREND_LA_VALEUR floor(x/2)
30            FIN_TANT_QUE
31          FIN_SINON
32      //Affichage du résultat :
33      AFFICHER "Résultat du calcul :"
34      AFFICHER "("
35      AFFICHER d
36      AFFICHER ")10 = ("
37      AFFICHER b
38      AFFICHER ")2"
39    FIN_ALGORITHME

La fin je ne sais pas si vous comprenez, c'est juste une histoire de mise en forme du résultat.

Salut!

J'ai essayé avec plusieurs chiffres et l'algo il marche bien

Si le chiffre d'entrée est égal à 25, j'obtiens les itérations suivants (j'ai ajouté une variable additionnel, R, pour garder le reste de la division à chaque itération):

Y X R D A
1 0
25 12 1 10 1
12 6 0 100 1
6 3 0 1000 1
3 1 1 10000 1001
1 0 1 100000 11001

A contient 11001 qui est 25 en binaire.

Y = 31

Y X R D A
1 0
31 15 1 10 1
15 7 1 100 11
7 3 1 1000 111
3 1 1 10000 1111
1 0 1 100000 11111


Y = 123

Y X R D         A
1         0
123 61 1 10         1
61 30 1 100         11
30 15 0 1000         11
15 7 1 10000         1011
7 3 1 100000         11011
3 1 1 1000000         111011
1 0 1 10000000 1111011

Ne fais pas attention aux résultats partielles de A, juste le dernier rang quand x=0, qui est la condition de finalisation de l'algorithme.

Le tiens me paraît tout à fait correcte aussi! Bon courage!

Johnny