Bonjour,
Comment le fais-tu sans penser à l'algorithme?

ce n'est pas moi qui est pensé cette algorithme ^^ j'aimerais juste avoir un exemple sur la forme,  car par la suite je serais amené à écrire des algorithme

C'est un excellent exemple.
Mais avant d'écrire l'algorithme, il faut se demander comment le faire avec un papier et un crayon.

C'est justement cette étape là que  veux apprendre à faire mais je ne trouve pas d'exemple concret

Regarde là:

Bonjour,

explication de la méthode, alors je la laisse bien que sanantonio312 ait répondu en donnant un lien pendant que je rédigeais.

Exemple : 59 s'écrit 0011 1011 en base 2 ( binaire )

que veut dire 00111011 en base 2 ?
0×2⁷ + 0×2⁶ + 1×2⁵ + 1×2⁴ + 1×2³ + 0×2² + 1×2¹ + 1(×2⁰)

si j'effectue une division entière (euclidienne) de ce nombre par 2 j'obtiens

59 = 2×(0×2⁶ + 0×2⁵ + 1×2⁴ + 1×2³ + 1×2² + 0×2¹ + 1×2⁰) + 1
= 2×29 + 1

en recommençant avec 29 = 0×2⁶ + 0×2⁵ + 1×2⁴ + 1×2³ + 1×2² + 0×2¹ + 1×2⁰
je vais obtenir successivement tous les chiffres binaires de cinquante neuf en base deux un par un en partant des poids faibles.

ça c'est une méthode "à la main" demandée
on ferait pareil à la main pour obtenir les chiffres décimaux de cinquante neuf en le divisant répétitivement par dix
ou pour n'importe quelle base
(c'est comme ça que fait "la machine" pour sortir en décimal le nombre qu'elle a en interne en binaire)

c'est un algorithme général de conversion en n'importe quelle base.

il ne reste plus qu'à la formuler en français (en "langage naturel") avec un "répéter" quelles opération précisément on fait sur quelles variables et sous quelle condition on doit "répéter".

ceci dit le problème est un problème qui en soulève d'autres parce que dans la machine qui va traduire cet algorithme, le nombre cinquante neuf est déja en binaire !!
si on était capable de lire ce nombre directement dans les entrailles de la machine il n'y aurait rien à faire !

alors en fait tout dépend comment on fournit le nombre cinquante neuf à la machine
au départ du départ c'est en tant que suite de caractères "5" et "9" et pas du tout sous forme du nombre cinquante neuf.
le traduire en un nombre binaire à partir de cette forme d'entrée est un autre problème.

Merci pour la source, je crois mieux comprendre
si je devais le rédiger je ferais ainsi :

D -> nombre en entrée ( entre 0 et 255 )
R -> Resultat  en bit

Tant que D prend une valeur comprit (entre 0 et 255)
Alors  la variable D est divisé par 2
La variable R récupére la valeurs  
Si R est un entier alors
Afficher 1
Sinon afficher 0

Tu en pense quoi ?

Je suis encore débutant soyez indulgent ^^

il faut tout de même accepter qu'on critique ce que tu as écrit , c'est en identifiant les erreurs que tu vas progresser

moi j'en pense que sans une indentation correcte il manque deja une "fin de tant que"

de plus D --> nombre entré veut dire que le contenu de la variable D quel qu'il soit est envoyé en direction de ton propre cerveau pour y injecter la valeur qui se trouvait déja dans cette variable.

correct est D <-- nombre entré
(la variable D reçoit le nombre entré)

la variable D est divisé par 2
certes mais une division donne des résultats, un quotient et un reste
que fait on de ces résultats ??

La variable R récupére la valeurs
la faute de grammaire est bien le signe que ça ne veut rien dire.
quelle "valeur" ?

Si R est un entier alors
une division Euclidienne (division entière avec reste) donne par définition des "résultats" (voir instructions d'avant)
qui sont des nombres entiers, R est donc toujours un nombre entier ! (ou une paire de nombres entiers)
corrige déja ça.

la description des opérations que l'on fait doit être précise et pas rester dans le vague avec des "valeurs" et des "résultats" sans dire précisément lesquels

D <- nombre entré
R -> Resultat  en bit

Tant que D prend une valeur comprit (entre 0 et 255)
la variable D est divisé par 2
R récupère le résultat   de D/2
si R est  Pair alors afficher 1
Sinon afficher 0
Fin

En effet j'avais oubliais  " Fin " ^^
est-ce mieux maintenant ?

R -> Resultat : du baratin, autant ne rien mettre du tout
en fait c'est un "commentaire" (qui ne fait pas partie des opérations effectuées) qui annonce que le "résultat" sera plus tard la valeur de R (quand on aura calculé des choses dans R, pour l'instant il n'y a rien dans R)
de plus les "règles" actuelles pour écrire des algorithmes connaissent le <-- pour dire

Variable <-- valeur (calculée)
que la variable reçoit une valeur
et pas du tout --> qui aurait la même signification mais dans l'autre sens :

Variable <-- valeur (calculée)

identique à
valeur (calculée) --> Variable

ni Variable --> valeur ni valeur <-- Variable n'ont de sens.


la variable D est divisé par 2 quelle sorte de division ??
R récupère le résultat de D/2 la division qui sert ici est une division entière avec reste il y a donc deux "résultats" à la division : le quotient et le reste
que fait on de chacun d'eux ?

de plus on n'écrit pas du baratin comme ça
on écrit :

la variable qui reçoit le résultat <--- de l'opération
donc ce sera
R <-- (un certain calcul)
calcul écrit explicitement ou décrit explicitement avec des mots comme "le reste de" ou "le quotient entier de" etc

attention, il y a deux façons de faire le calcul :

celle qui est décrite dans le lien de sanantonio312 ou dans ce que j'ai décrit
qui utilise une division entière avec reste
il n'y a pas de notion de pair ou impair à considérer là dedans
mais il faut dire explicitement ce qu'on fait du quotient et ce qu'on fait du reste.

celle qui utilise une division sur les nombres réels (à virgule) et pour laquelle l'opération elle même à effectuer dépend de la parité du dividende (du nombre que l'on divise)
selon cette parité on divisera D par 2 ou bien D-1 par 2 de sorte que le quotient soit toujours un nombre entier quoi qu'il arrive.
mais là aussi on doit dire explicitement ce qu'on fait du quotient. (la notion de reste n'existe pas, c'est remplacé par le test pair/impair)

Alors là je suis perdu o-O
après quelque recherche j'ai vu ce calcul tomber plusieurs fois :
x\%2        
Mais je n'aime pas reprendre des choses que je ne comprends pas
ça veut dire quoi concretement ? dans mon cas je dois remplacer x par
D\%2
donc R doit récupérer ce calcul si je comprend biens ?

foin de symbolisme ésotérique.

que fait on dans les exemples à la main ?

on effectue une division entière avec reste
les restes seront successivement les chiffres successifs en binaire cherchés
les quotients sont "recyclés" pour les diviser par deux à l'étape suivante.

et ce tant que il reste quelque chose à diviser (on s'arrête quand le quotient est nul)

le coeur de la boucle pourrait donc s'écrire

on divise D par 2, le reste est R et le quotient remis dans D (recyclé disais-je)

on peut écrire en symbolique :

R <-- reste de la division entière de D par 2
D <-- quotient de cette division entière de D par 2

on n'en demande pas plus à ce stade
celui d'un algorithme en langage "naturel"


ensuite on pourra se rapprocher du fonctionnement de la machine et commencer à traduire en un programme avec des instructions de machine qui ne comprend pas des phrases comme "le reste de la division etc"

et pour ça on utilise des opérations spécifiques à la machine, comme celle qui est symbolisé le plus souvent par "%" qui veut dire justement "le reste de la division par"

D%2 veut dire "le reste de la division de D par 2"

on va donc traduire le
R <-- reste de la division entière de D par 2
en une écriture ésotérique (qui plus est qui dépend de la machine !!)
R <-- D%2
sur d'autres machines on pourrait trouver "MOD(D, 2)" par exemple etc

après pour le quotient de la division entière on n'écrira pas "D/2"
(parce que ça c'est une division dans les réels, pas une division entière)

certains langages (Python par exemple) proposent une notation spéciale pour dire "le quotient de la division entière"
D//2
si rien n'est prévu dans le langage, il faudra utiliser ce qui est disponible

floor(D/2) la fonction "floor()" voulant dire " la partie entière de"

ou (D-R)/2
si je retranche le reste et que je divise j'ai le quotient entier

il faudra en tout cas prendre bien garde à l'ordre dans lequel on effectue les calculs

D <-- D//2
R <-- D%2

ne marchera pas parce que au moment de calculer R, D est déja modifié.

R <-- D%2
D <--- D//2

est OK parce que R <-- D%2 ne détruit pas la valeur de D

etc
mais là, on n'est déja plus vraiment dans l'algorithme, mais dans sa traduction en un programme (exécutable par une machine spécifique)