RA-HAlgorithmes récurrents et arithmétiques

Conversion d'un entier décimal en binaire

Idée directrice

La conversion d'un entier décimal (base 10) vers le binaire (base 2) accumule les bits $N\bmod 2$ en divisant $N$ par 2. Chaque bit de poids faible sort en premier : on le place en tête du résultat.

Signature de reconnaissance — l'énoncé se trahit ainsi

« base 10 vers la base 2 »

« N mod 2 »

« conversion »

Sujet principal

Exercice — dans l'esprit des sujets d'informatique

3 questionsCorrigé masqué

Écrire l'algorithme itératif de conversion `Conv(N)` qui renvoie l'écriture binaire d'un entier décimal $N$ (base 10 → base 2). Chaque bit est `chr(N mod 2 + ord('0'))` (devoir i-s1-01).
Tracer la conversion de $N=13$ : tableau des valeurs de $N$ , du bit (`mod 2`), et du résultat partiel.
En base 16 (hexadécimal), quels caractères codent les chiffres ? Donner la valeur décimale de `2F`₁₆.

Voir la correction commentéeAprès avoir posé votre démarche

1. Conversion décimal → binaire (i-s1-01).

```
DEF FN Conv(N : entier) : chaîne
Variables R : chaîne
Début
R ← ''
Répéter
R ← chr(N mod 2 + ord('0')) + R
N ← N div 2
Jusqu'à N = 0
Retourner R
Fin
```

Le bit est collé à gauche car `mod 2` livre le poids faible d'abord.

**2. Trace $N=13$ (binaire).

| N | bit | résultat |
|---:|---:|---|
| 13 | 1 | `1` |
| 6 | 0 | `01` |
| 3 | 1 | `101` |
| 1 | 1 | `1101` |
| 0 | — | `1101`** |

Vérification : $13 = 8+4+1$ .

3. Hexadécimal. Chiffres de la base 16 : `0..9` puis `A..F` (devoir i-s1-01). `2F`₁₆ = $2\times 16 + 15 = \mathbf{47}$ en décimal.

Exercices d'entraînement — une nuance à la fois

Entraînement 01 / 01

Drill RA-H.1 — Choisir la bonne conversion

1 questionCorrigé masqué

Trois versions d'une conversion base 10 → base 2 sont proposées (i-s1-01). La version correcte construit le binaire en plaçant chaque nouveau bit à gauche (`bit + R`) ou via un schéma équivalent. Pourquoi `R ← R + bit` est-elle fausse pour l'écriture binaire usuelle ?

Voir la correction commentéeAprès avoir posé votre démarche

`mod 2` sort le bit de poids faible en premier. Coller ce bit à droite (`R ← R + bit`) produit l'image miroir de l'écriture binaire standard (poids forts à gauche). D'où la bonne conversion du devoir i-s1-01 : `R ← chr(N mod 2 + ord('0')) + R` (bit en tête). La version qui concatène à droite est donc marquée fausse dans le QCM de conversion base 10 → base 2.

Méthode / Automatismes

Conversion de base : restes = chiffres ; pour le binaire, reste 0/1 = bit.
Ne pas confondre avec le comptage de chiffres décimaux (divisions par 10, RA-E).

Pièges classiques

Concaténer le bit à droite (inverse l'écriture binaire) ; utiliser `mod 10` au lieu de `mod 2`.