Aller au contenu

Un mot pour Fahmio

Tu écris. Tu continues.

Un problème, une idée — assez pour qu’on comprenne, puis tu retournes à ta copie.

On lit. Tu n’as rien d’autre à faire.

Où veux-tu aller ?

↑ ↓ pour parcourir · Entrée pour ouvrir · Échap pour fermer

Fahmio
Fahmio
Bac Tunisie
Informatique/RA-M
RA-MAlgorithmes récurrents et arithmétiques

Conversion d’un entier en base B (2 ≤ B ≤ 16) modularisée : ranger les restes, renverser, convertir un chiffre, concaténer, reconvertir

Idée directrice

La conversion décimal → base B est l’outil le plus régulier de l’épreuve d’algorithmique de la section Sciences de l’informatique. L’énoncé la découpe en modules imposés : divisions euclidiennes successives dont on range les restes dans un tableau jusqu’à un quotient nul, renversement du tableau par permutations symétriques (le premier reste est le chiffre de poids faible), conversion d’un reste 0–15 en caractère ("A" pour 10), concaténation, puis un programme principal qui ne fait qu’appeler. Le chemin inverse — valeur d’une écriture en base B par le schéma de Horner — sert de vérification.

Ce qui aide à reconnaître la démarche

« on effectue des divisions euclidiennes par B » ; « les restes successifs seront rangés dans un tableau » ; « qui permet de retourner le caractère qui correspond à l’entier » ; « qui renverse les … éléments rangés dans le tableau » ; « En faisant appel uniquement aux modules déjà définis »

Besoin d’un point de départ ? Voir la méthode
  • Divisions successives : Répéter reste ← N Mod B ; N ← N Div B jusqu’à N = 0 (Répéter, pour que N = 0 donne quand même le chiffre "0").
  • Les restes sortent du poids faible au poids fort : les ranger puis renverser, ou les ajouter en tête de la chaîne (ch ← Chiffre(r) + ch).
  • Renverser : Pour i de 0 à (nb Div 2) − 1, échanger R[i] et R[nb − 1 − i].
  • Chiffre → caractère : Chr(Ord("0") + c) si c < 10, Chr(Ord("A") + c − 10) sinon ; caractère → chiffre : l’inverse.
  • Taille du tableau : nombre de chiffres de la plus grande valeur dans la plus petite base.
Les pièges à vérifier dans ta démarche

Concaténer les restes dans l’ordre où ils sortent (on obtient l’écriture à l’envers). Boucler jusqu’à nb − 1 pour renverser : le tableau revient à son état initial. Utiliser Tant que N ≠ 0, qui ne produit rien pour N = 0. Convertir 10 à 15 avec Convch (on obtient "10" au lieu de "A"). Oublier @ devant R et nb dans Restes, ou devant P dans Saisir. Réécrire les divisions dans le programme principal au lieu d’appeler les modules.

Sujet principal

Exercice (6,5 points) — dans l’esprit des sessions de contrôle 2018 et 2022, section Sciences de l’informatique

8 questionsCorrigé masqué

On se propose d’écrire un programme qui affiche l’écriture, dans une base B (2 ≤ B ≤ 16), d’un entier naturel N (50 ≤ N ≤ 30000), puis vérifie ce résultat par la conversion inverse vers le décimal. Les chiffres de 10 à 15 sont notés "A" à "F", comme en hexadécimal.

Principe : on effectue des divisions euclidiennes successives par B (on divise N par B, puis le quotient obtenu par B, etc.) jusqu’à obtenir un quotient nul ; les restes sont rangés au fur et à mesure dans un tableau R, puis on renverse ce tableau et on concatène les caractères qui correspondent à ses valeurs.

Exemple : pour N = 2026 et B = 16 : 2026 = 126 × 16 + 10 ; 126 = 7 × 16 + 14 ; 7 = 0 × 16 + 7. Après rangement, R = [10, 14, 7] ; après renversement, R = [7, 14, 10] ; l’écriture obtenue est "7EA". Vérification : (7 × 16 + 14) × 16 + 10 = 2026.

Travail demandé :

  1. Justifier qu’un tableau R de 15 entiers suffit pour ranger tous les restes, quelle que soit la base B.
  2. Écrire l’algorithme d’une procédure Saisir(P, Binf, Bsup) qui permet de saisir un entier P tel que Binf ≤ P ≤ Bsup.
  3. Écrire l’algorithme d’une procédure Restes(N, B, R, nb) qui range dans R les restes successifs des divisions par B jusqu’à un quotient nul et calcule leur nombre nb.
  4. Écrire l’algorithme d’une procédure Inverser(R, nb) qui renverse les nb premières valeurs de R par permutations symétriques (R[0] avec R[nb − 1], R[1] avec R[nb − 2], etc.). Justifier la valeur finale du compteur.
  5. Écrire l’algorithme d’une fonction Chiffre(c) qui retourne le caractère correspondant à un entier c (0 ≤ c ≤ 15). Exemples : Chiffre(9) retourne "9", Chiffre(14) retourne "E".
  6. En faisant appel à Inverser et à Chiffre, écrire l’algorithme d’une fonction Ecriture(R, nb) qui retourne la chaîne représentant N dans la base B.
  7. Écrire l’algorithme d’une fonction Valeur(ch, B) qui retourne la valeur décimale d’une chaîne ch écrite en base B, par le schéma de Horner (v ← v × B + chiffre, de gauche à droite).
  8. En faisant appel uniquement aux modules précédents, écrire l’algorithme du programme principal qui saisit N et B, affiche l’écriture de N en base B, puis affiche « Vérification réussie » si la conversion inverse redonne N.

N.B. : dresser les tableaux de déclaration des nouveaux types et des objets.

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

1. Idée : le nombre de restes est le nombre de chiffres de N en base B, maximal pour B = 2. 2¹⁴ = 16384 ≤ 30000 < 2¹⁵ = 32768 : en binaire, N s’écrit sur au plus 15 chiffres (30000 = (111010100110000)2(111010100110000)_2), et sur moins de chiffres dans toute base plus grande. 15 cases suffisent\boxed{15 \text{ cases suffisent}}.

2.

Procédure Saisir (@P : Entier,
                  Binf, Bsup : Entier)
DEBUT
    Répéter
        Ecrire("Donner un entier : ")
        Lire(P)
    Jusqu'à (P ≥ Binf) Et (P ≤ Bsup)
FIN

3. Idée : Répéter, car il y a toujours au moins une division ; nb sert d’indice de la prochaine case avant d’être incrémenté.

Procédure Restes (N, B : Entier, @R : TAB,
                  @nb : Entier)
DEBUT
    nb ← 0
    Répéter
        R[nb] ← N Mod B
        nb ← nb + 1
        N ← N Div B
    Jusqu'à N = 0
FIN

Pour 2026 et 16 : R[0] = 10 (N devient 126), R[1] = 14 (N devient 7), R[2] = 7 (N devient 0) ; nb = 3.

4. Idée : chaque échange place deux valeurs à leur rang définitif ; il faut nb Div 2 échanges. Aller plus loin referait les échanges déjà faits.

Procédure Inverser (@R : TAB, nb : Entier)
DEBUT
    Pour i de 0 à (nb Div 2) - 1 Faire
        x ← R[i]
        R[i] ← R[nb - 1 - i]
        R[nb - 1 - i] ← x
    Fin Pour
FIN

TDOL : i, x — Type/Nature : Entier — compteur, variable d’échange. Pour nb impair (N = 2026, B = 5 : R = [1, 0, 1, 1, 3]), la valeur du milieu ne bouge pas et l’on obtient [3, 1, 1, 0, 1]. Avec la borne nb Div 2 au lieu de (nb Div 2) − 1, un tableau de 4 valeurs [1, 2, 3, 4] deviendrait [4, 2, 3, 1] : la paire du milieu serait échangée deux fois.

5. Idée : les codes ASCII de "0" à "9", puis de "A" à "F", sont consécutifs.

Fonction Chiffre (c : Entier) : Caractère
DEBUT
    Si c < 10 Alors
        Retourner Chr(Ord("0") + c)
    Sinon
        Retourner Chr(Ord("A") + c - 10)
    FinSi
FIN

6.

Fonction Ecriture (R : TAB,
                   nb : Entier) : Chaîne
DEBUT
    Inverser(R, nb)
    ch ← ""
    Pour i de 0 à nb - 1 Faire
        ch ← ch + Chiffre(R[i])
    Fin Pour
    Retourner ch
FIN

TDOL : ch — Chaîne — écriture en construction ; i — Entier ; Inverser — Procédure ; Chiffre — Fonction. Sur l’exemple : "7", puis "7E", puis "7EA".

7. Idée : chaque nouveau chiffre décale la valeur déjà lue d’un rang (× B) avant d’être ajouté.

Fonction Valeur (ch : Chaîne,
                 B : Entier) : Entier
DEBUT
    v ← 0
    Pour i de 0 à Long(ch) - 1 Faire
        Si ch[i] ≤ "9" Alors
            c ← Ord(ch[i]) - Ord("0")
        Sinon
            c ← Ord(ch[i]) - Ord("A") + 10
        FinSi
        v ← v * B + c
    Fin Pour
    Retourner v
FIN

TDOL : v, c, i — Type/Nature : Entier — valeur lue, chiffre courant, position. Pour "7EA" : v = 7, puis 7 × 16 + 14 = 126, puis 126 × 16 + 10 = 2026\boxed{2026}.

8.

Algorithme Conversion_B
DEBUT
    Saisir(N, 50, 30000)
    Saisir(B, 2, 16)
    Restes(N, B, R, nb)
    ch ← Ecriture(R, nb)
    Ecrire(N, " = (", ch, ") base ", B)
    Si Valeur(ch, B) = N Alors
        Ecrire("Vérification réussie")
    FinSi
FIN

Tableau de déclaration des nouveaux types : TAB = Tableau de 15 Entiers.

Tableau de déclaration des objets globaux :

  • N, B, nb — Type/Nature : Entier — nombre, base, nombre de restes
  • R — Type/Nature : TAB — restes successifs
  • ch — Type/Nature : Chaîne — écriture de N en base B
  • Saisir, Restes — Type/Nature : Procédure ; Ecriture, Valeur — Type/Nature : Fonction

Pour N = 2026 : B = 16 affiche « 2026 = (7EA) base 16 », B = 5 affiche « 2026 = (31101) base 5 », et la vérification réussit dans les deux cas.

Changer d’énoncé, garder le raisonnement

Choisis un seul transfert après le sujet principal. Qu’est-ce qui change ? Quel résultat ou quelle méthode peux-tu réutiliser ? Les autres exercices restent disponibles pour une prochaine séance.

Variantes rencontrées (section Sciences de l’informatique) : conversion en base B modularisée (ranger, renverser, convertir, concaténer) avec programme principal (contrôle 2022) ; fonction Convert décimal → base B avec les lettres au-delà de 9, au service des nombres à chiffres distincts (contrôle 2018) ; base B à chiffres égaux, nombres brésiliens (principale 2022) ; caractère → binaire sur 7 bits dans un cryptage (contrôle 2019) ; réel de ]0, 1[ → binaire par multiplications par 2 (principale 2017) ; code ASCII → deux chiffres hexadécimaux (contrôle 2017) ; octal → binaire par une table (principale 2021) ; binaire → hexadécimal → décimal → ASCII (contrôle 2026). Hors programme des sections Mathématiques, Sciences expérimentales et Sciences techniques.

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

1 Drill RA-M.1 — caractère → code binaire sur 8 bits, complété à gauche, puis codage d’un mot
Entraînement 01 / 05

Drill RA-M.1 — caractère → code binaire sur 8 bits, complété à gauche, puis codage d’un mot

4 questionsCorrigé masqué

Le code ASCII d’un caractère est un entier compris entre 0 et 255. On veut l’écrire en binaire sur 8 bits exactement, en complétant à gauche par des "0" si nécessaire. Exemple : Ord("O") = 79 = (1001111)2(1001111)_2, qui s’écrit sur 8 bits "01001111".

  1. Donner l’écriture sur 8 bits de "k" (Ord("k") = 107) et de "!" (Ord("!") = 33).
  2. Écrire l’algorithme d’une fonction Bin8(c) qui retourne, sous forme de chaîne, le code ASCII du caractère c sur 8 bits.
  3. En utilisant Bin8, écrire l’algorithme d’une fonction Coder(mot) qui retourne la concaténation des codes sur 8 bits des caractères de mot. Coder("Ok") retourne "0100111101101011".
  4. Pourquoi le complément à gauche est-il indispensable pour pouvoir décoder le résultat de Coder ?
Voir la correction commentéeAprès avoir posé votre démarche

1. 107 = 64 + 32 + 8 + 2 + 1 = (1101011)2(1101011)_2, soit "01101011" ; 33 = 32 + 1 = (100001)2(100001)_2, soit "00100001" (deux zéros ajoutés).

2. Idée : faire exactement 8 divisions par 2 au lieu de s’arrêter à un quotient nul ; les divisions en trop produisent les "0" de gauche, sans boucle de complément séparée.

Fonction Bin8 (c : Caractère) : Chaîne
DEBUT
    x ← Ord(c)
    ch ← ""
    Pour i de 1 à 8 Faire
        ch ← Convch(x Mod 2) + ch
        x ← x Div 2
    Fin Pour
    Retourner ch
FIN

TDOL : x, i — Type/Nature : Entier — code restant à convertir, compteur ; ch — Type/Nature : Chaîne — bits obtenus.

3.

Fonction Coder (mot : Chaîne) : Chaîne
DEBUT
    res ← ""
    Pour i de 0 à Long(mot) - 1 Faire
        res ← res + Bin8(mot[i])
    Fin Pour
    Retourner res
FIN

TDOL : res — Chaîne ; i — Entier ; Bin8 — Fonction. "O" donne "01001111", "k" donne "01101011" : Coder("Ok") = "0100111101101011".

4. Sans complément, "O" donnerait 7 bits et "!" 6 bits : on ne saurait plus où finit chaque caractère dans la chaîne concaténée. Avec une largeur fixe, le décodage découpe des blocs de 8 bits.

2 Drill RA-M.2 — réel de ]0, 1[ → binaire après la virgule par multiplications par 2, avec arrêt anticipé
Entraînement 02 / 05

Drill RA-M.2 — réel de ]0, 1[ → binaire après la virgule par multiplications par 2, avec arrêt anticipé

3 questionsCorrigé masqué

Soit x un réel de ]0, 1[. Pour obtenir ses chiffres binaires après la virgule, on multiplie x par 2 : si le résultat est supérieur ou égal à 1, le chiffre est 1 et on lui retranche 1 ; sinon le chiffre est 0. On recommence avec la nouvelle valeur. On s’arrête après n chiffres, ou plus tôt si la valeur devient nulle (l’écriture est alors exacte).

Exemple : x = 0.40625 : 0.8125 → 0 ; 1.625 → 1 (reste 0.625) ; 1.25 → 1 (reste 0.25) ; 0.5 → 0 ; 1.0 → 1 (reste 0) : arrêt, x = (0.01101)2(0.01101)_2.

  1. Donner, en détaillant, l’écriture binaire de 0.7 limitée à 6 chiffres après la virgule.
  2. Écrire l’algorithme d’une fonction ReelBin(x, n) qui retourne la chaîne "0." suivie des chiffres binaires de x, avec les deux conditions d’arrêt décrites.
  3. Pourquoi faut-il les deux conditions d’arrêt ?
Voir la correction commentéeAprès avoir posé votre démarche

1. 1.4 → 1 (0.4) ; 0.8 → 0 ; 1.6 → 1 (0.6) ; 1.2 → 1 (0.2) ; 0.4 → 0 ; 0.8 → 0. Six chiffres : 0.7≈(0.101100)2\boxed{0.7 \approx (0.101100)_2}, la valeur n’étant jamais devenue nulle.

2. Idée : boucle Tant que sur deux conditions — nombre de chiffres produits et valeur non nulle.

Fonction ReelBin (x : Réel, n : Entier) : Chaîne
DEBUT
    ch ← "0."
    i ← 0
    Tant que (i < n) Et (x ≠ 0) Faire
        x ← 2 * x
        Si x ≥ 1 Alors
            ch ← ch + "1"
            x ← x - 1
        Sinon
            ch ← ch + "0"
        FinSi
        i ← i + 1
    Fin Tant que
    Retourner ch
FIN

TDOL : ch — Type/Nature : Chaîne — écriture en construction ; i — Type/Nature : Entier — chiffres produits. x est un paramètre passé par valeur : le modifier ne change pas le réel de l’appelant.

3. 0.7 a une écriture binaire infinie : sans la limite n, la boucle ne s’arrêterait pas. 0.40625 = 13/32 a une écriture finie : sans le test x ≠ 0, on ajouterait des "0" inutiles jusqu’à n chiffres.

3 Drill RA-M.3 — intensités décimales → code couleur hexadécimal sur deux chiffres chacune, et retour
Entraînement 03 / 05

Drill RA-M.3 — intensités décimales → code couleur hexadécimal sur deux chiffres chacune, et retour

4 questionsCorrigé masqué

Dans une image, une couleur est codée par trois intensités entières comprises entre 0 et 255 (rouge, vert, bleu). Son code s’écrit "#" suivi des trois intensités, chacune sur deux chiffres hexadécimaux : le premier est v Div 16, le second v Mod 16. Exemple : (255, 140, 0) a pour code "#FF8C00", car 255 = 15 × 16 + 15, 140 = 8 × 16 + 12 et 0 = 0 × 16 + 0.

  1. Donner le code de la couleur (18, 52, 7).
  2. Écrire l’algorithme d’une fonction Hex2(v) qui retourne les deux chiffres hexadécimaux de v (0 ≤ v ≤ 255), en utilisant une fonction Chiffre(c) (0 ≤ c ≤ 15) à écrire.
  3. Écrire l’algorithme d’une fonction Code(r, g, b) qui retourne le code de la couleur.
  4. Écrire l’algorithme d’une fonction Intensite(ch2) qui retourne la valeur décimale d’une chaîne de deux chiffres hexadécimaux. Intensite("C8") retourne 200.
Voir la correction commentéeAprès avoir posé votre démarche

1. 18 = 1 × 16 + 2 → "12" ; 52 = 3 × 16 + 4 → "34" ; 7 = 0 × 16 + 7 → "07" (le 0 de gauche est obligatoire). Code : #123407\boxed{\text{\#123407}}.

2. Idée : deux chiffres exactement, même quand v < 16 : on n’utilise pas de boucle mais Div et Mod.

Fonction Chiffre (c : Entier) : Caractère
DEBUT
    Si c < 10 Alors
        Retourner Chr(Ord("0") + c)
    Sinon
        Retourner Chr(Ord("A") + c - 10)
    FinSi
FIN

Fonction Hex2 (v : Entier) : Chaîne
DEBUT
    Retourner Chiffre(v Div 16)
              + Chiffre(v Mod 16)
FIN

3.

Fonction Code (r, g, b : Entier) : Chaîne
DEBUT
    Retourner "#" + Hex2(r) + Hex2(g) + Hex2(b)
FIN

Code(255, 140, 0) : Hex2(255) = "FF", Hex2(140) = "8C", Hex2(0) = "00", d’où "#FF8C00".

4. Idée : chemin inverse — valeur de chaque caractère, puis 16 × premier + second.

Fonction Intensite (ch2 : Chaîne) : Entier
DEBUT
    Pour i de 0 à 1 Faire
        Si ch2[i] ≤ "9" Alors
            d[i] ← Ord(ch2[i]) - Ord("0")
        Sinon
            d[i] ← Ord(ch2[i]) - Ord("A") + 10
        FinSi
    Fin Pour
    Retourner 16 * d[0] + d[1]
FIN

TDOL : i — Type/Nature : Entier ; d — Type/Nature : Tableau de 2 Entiers — valeurs des deux chiffres. Intensite("C8") = 16 × 12 + 8 = 200 ; Intensite("1F") = 16 + 15 = 31.

4 Drill RA-M.4 — hexadécimal → binaire par une table de 16 codes sur 4 bits, suppression des zéros de tête
Entraînement 04 / 05

Drill RA-M.4 — hexadécimal → binaire par une table de 16 codes sur 4 bits, suppression des zéros de tête

4 questionsCorrigé masqué

Pour convertir en binaire un nombre écrit en hexadécimal, on remplace chacun de ses chiffres par son équivalent binaire sur 4 bits, lu dans un tableau TB de 16 chaînes (TB[0] = "0000", …, TB[10] = "1010", …, TB[15] = "1111"), puis on supprime les "0" inutiles à gauche. Exemple : "2F7" donne "0010" + "1111" + "0111" = "001011110111", d’où "1011110111".

  1. Convertir "A0" et "004".
  2. Écrire l’algorithme d’un module RemplirTB(TB) qui remplit chaque case TB[i] par l’écriture binaire de i sur 4 bits.
  3. Écrire l’algorithme d’une fonction HexBin(h, TB) qui retourne l’écriture binaire de la chaîne hexadécimale h (chiffres "0" à "9" et "A" à "F").
  4. Pourquoi cette méthode fonctionne-t-elle même pour une chaîne h de 20 chiffres, alors que passer par la valeur décimale échouerait ?
Voir la correction commentéeAprès avoir posé votre démarche

1. "A0" : "1010" + "0000" = "10100000" (les zéros de droite sont significatifs). "004" : "0000" + "0000" + "0100", puis suppression des zéros de tête : "100".

2. Idée : 4 divisions par 2 exactement donnent les 4 bits, zéros de gauche compris.

Procédure RemplirTB (@TB : TCH)
DEBUT
    Pour i de 0 à 15 Faire
        x ← i
        ch ← ""
        Pour j de 1 à 4 Faire
            ch ← Convch(x Mod 2) + ch
            x ← x Div 2
        Fin Pour
        TB[i] ← ch
    Fin Pour
FIN

Nouveau type : TCH = Tableau de 16 Chaînes. TDOL : i, j, x — Entier ; ch — Chaîne.

3. Idée : le rang d’un chiffre dans TB est sa valeur : Ord(c) − Ord("0") pour "0" à "9", Ord(c) − Ord("A") + 10 pour "A" à "F". On supprime ensuite les "0" de tête en gardant au moins un caractère.

Fonction HexBin (h : Chaîne, TB : TCH) : Chaîne
DEBUT
    ch ← ""
    Pour i de 0 à Long(h) - 1 Faire
        Si h[i] ≤ "9" Alors
            v ← Ord(h[i]) - Ord("0")
        Sinon
            v ← Ord(h[i]) - Ord("A") + 10
        FinSi
        ch ← ch + TB[v]
    Fin Pour
    Tant que (Long(ch) > 1) Et
             (ch[0] = "0") Faire
        ch ← Effacer(ch, 0, 1)
    Fin Tant que
    Retourner ch
FIN

TDOL : ch — Chaîne ; i, v — Entier — position, valeur du chiffre. "2F7" : v = 2, 15, 7, puis "001011110111" devient "1011110111". La condition Long(ch) > 1 garde "0" pour h = "0".

4. La table traite chaque chiffre séparément : aucune valeur numérique de h n’est calculée. Une valeur à 20 chiffres hexadécimaux dépasse de loin 2 147 483 647, la capacité d’un Entier sur 32 bits.

5 Drill RA-M.5 — plus petite base où l’écriture n’a que des chiffres égaux, testée sur les restes sans construire de chaîne
Entraînement 05 / 05

Drill RA-M.5 — plus petite base où l’écriture n’a que des chiffres égaux, testée sur les restes sans construire de chaîne

4 questionsCorrigé masqué

Un entier N (N ≥ 4) peut s’écrire, dans certaines bases B, avec des chiffres tous égaux : par exemple 13 = (111)3(111)_3 et 40 = (1111)3(1111)_3. On cherche la plus petite base B, avec 2 ≤ B ≤ 16 et B ≤ N − 2, dans laquelle l’écriture de N n’a que des chiffres égaux ; on retourne 0 si aucune base ne convient. Exemples : pour 21, on trouve 4, car 21 = (10101)2(10101)_2 = (210)3(210)_3 = (111)4(111)_4 ; pour 11, on trouve 0.

  1. Déterminer la base trouvée pour 15, puis pour 57.
  2. Écrire l’algorithme d’une fonction booléenne Egaux(N, B) qui vérifie, sans construire de chaîne, que tous les restes des divisions successives de N par B sont égaux.
  3. En utilisant Egaux, écrire l’algorithme d’une fonction BaseEgale(N).
  4. Pourquoi impose-t-on B ≤ N − 2 ?
Voir la correction commentéeAprès avoir posé votre démarche

1. 15 = (1111)2(1111)_2 : base 2. Pour 57 : (111001)2(111001)_2, (2010)3(2010)_3, (321)4(321)_4, (212)5(212)_5, (133)6(133)_6, puis 57 = 49 + 7 + 1 = (111)7(111)_7 : base 7.

2. Idée : le premier reste fixe le chiffre attendu ; on continue à diviser tant que le reste suivant lui est égal. Tous les chiffres sont égaux exactement si l’on atteint un quotient nul.

Fonction Egaux (N, B : Entier) : Booléen
DEBUT
    r ← N Mod B
    N ← N Div B
    Tant que (N ≠ 0) Et (N Mod B = r) Faire
        N ← N Div B
    Fin Tant que
    Retourner N = 0
FIN

TDOL : r — Type/Nature : Entier — chiffre de poids faible. 13 en base 3 : r = 1, N = 4, 4 mod 3 = 1, N = 1, 1 mod 3 = 1, N = 0 : Vrai.

3.

Fonction BaseEgale (N : Entier) : Entier
DEBUT
    Si N - 2 < 16 Alors
        Bmax ← N - 2
    Sinon
        Bmax ← 16
    FinSi
    B ← 1
    Répéter
        B ← B + 1
    Jusqu'à Egaux(N, B) Ou (B = Bmax)
    Si Egaux(N, B) Alors
        Retourner B
    Sinon
        Retourner 0
    FinSi
FIN

TDOL : B, Bmax — Entier — base essayée, dernière base permise ; Egaux — Fonction. Pour 11 : les bases 2 à 9 donnent 1011, 102, 23, 21, 15, 14, 13, 12, aucune ne convient : retour 0.

4. En base N − 1, on a toujours N = (11)N−1(11)_{N-1}, et dans toute base B > N, N n’a qu’un seul chiffre : Egaux serait vrai pour n’importe quel N (seule la base N donne (10)N(10)_N). La borne B ≤ N − 2 écarte ces écritures qui ne distinguent aucun nombre.

Relier ce raisonnement au bac

Choisis une filière pour voir les sujets qui étayent ce scénario.