CHANGEMENT DE BASE

L'algorithme décrit ci-dessous demande à l'utilisateur un nombre N exprimé dans la base Base et l'exprime dans la base NewBase.
En clair, un nombre tel que 123, exprimé en base 10 peut être transformé en son équivalent hexadécimal, binaire ou autre.

L'ordinateur calculant en base 10, la première tâche est de ramener N dans la base 10. Pour ce faire, nous allons exploiter le fait que nous travaillons avec une numération de position, à savoir qu'en base 10

12345 = 1 * 104 + 2 * 103 + 3 * 102 + 4 * 101 + 5 * 100

Chaque chiffre est donc multiplié par la base élevée à la puissance adéquate. Dans notre algorithme, c'est la fonction Base10 qui se chargera de la transformation de N en base 10.
Le passage à la base NewBase se fait de manière inverse en procédant à des divisions successives du nombre exprimé en base 10.
Mais un exemple rendra les choses plus claires.
Prenons 756 exprimé en base 9 et que nous désirons écrire en base 8.
(1) Vérifions d'abord que le nombre 756 est un nombre "valide" dans la base 9. Pour ce faire, regardons si chaque chiffre est "acceptable" pour cette base. En base 9, il y a 9 chiffres: 0, 1, 2, 3, 4, 5, 6, 7 et 8. Dans l'algorithme décrit ci-dessous, c'est la fonction Verifie qui se charge de cette vérification.
(2) Exprimons 756 en base 10:
7569 = 7 * 92 + 5 * 91 + 6 * 90 = (7 * 9 + 5) * 9 + 6 = 61810
et le passage à la base 10 se fera par des multiplications/additions successives plutôt qu'avec des exponentiations moins rapides et moins précises.
(3) La transformation en base 8 se fera par des divisions successives:
61810 = 2 + 8 * (5 + 8 * (1 + 8 * 1)) = 1 * 83 + 1 * 82 + 5 * 81 + 2 * 80 = 11528 
chaîne: Chiffres, N
entier: Base, NBase


Fonction Verifie(St,Base) Vérifie si le nombre est valable
 paramètre:  St: chaîne
             Base : entier
 à valeur: booléen


booléen: Verif
entier: i, Cpt


Cpt <--  0
pour i de 1 à|St| faire
   si Pos(Sti, Chiffres) > Base alors Cpt <-- Cpt+1 Cpt compte le nombre de chiffres non valables
   fsi
fpour
si Cpt>0 alors Verif <-- faux
sinon Verif <-- vrai
fsi
Résultat (Verif)


Fonction Majuscules(St)   Met le nombre en majuscules (intéressant pour les bases supérieures à 10)
 paramètre: St: chaîne
 à valeur: chaîne


entier: i


pour i de 1 à |St| faire
  si (Sti > "a") et (Sti  < "z") alors Sti <-- UpCase(Sti)UpCase est une fonction Pascal
  fsi
fpour
Résultat (St)


Fonction Base10(St, Base)     Transforme le nombre en base 10
 paramètre:  St: chaîne
             Base: entier
 à valeur: entier


 entier: i, B10


B10 <-- 0
pour i de 1 à |St| faire
 B10 <-- B10 * Base + Pos(Sti,Chiffres) - 1
fpour
Résultat(B10)


Fonction NewBase(N, Base)    Transforme le nombre de base 10 en NewBase
 paramètre: N, Base: entier
 à valeur: chaîne


entier i
chaîne: B


B <-- ""
tant que NOT (N = 0) faire
 i <-- N mod Base
 B <-- Chiffresi+1 + B
 N <-- N \ Base
ftant
Résultat(B)


Chiffres <-- "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
écrire  "Introduisez le nombre (0 pour arrêter):"
lire N       Le nombre est lu sous forme de chaîne (pour les bases > 10, on utilise les chiffres A, B, ...)
tant que NOT (N="0") faire
 N <-- Majuscules(N)
 écrire "Dans quelle base est-il exprimé: "
 lire Base
 si NOT Verifie(N,Base) alors écrire "Le nombre n'est pas correct!"
 sinon écrire "Dans quelle base faut-il l'exprimer: "
       lire NBase
       écrire N," en base ",Base, " = ", NewBase(Base10(N,Base),NBase), " en base ",NBase
 fsi
 écrire "Introduisez le nombre (0 pour arrêter): "
 lire N
ftant

PROGRAM Chgt_Base;

VAR Chiffres, N : STRING;
    Base, NBase : BYTE;

FUNCTION Verifie(St:STRING;Base:BYTE):BOOLEAN;
VAR i, Cpt : BYTE;
BEGIN
Cpt:=0;
FOR i:=1 TO LENGTH(St) DO
  IF POS(St[i],Chiffres)>Base THEN INC(Cpt);
IF Cpt>0 THEN Verifie:=FALSE
ELSE Verifie:=TRUE
END;

FUNCTION Majuscules(St:STRING):STRING;
VAR i : BYTE;
BEGIN
FOR i:=1 TO LENGTH(St) DO
  IF (St[i]>='a') AND (St[i]<='z') THEN St[i]:=UPCASE(St[i]);
Majuscules:=St
END;

FUNCTION Base10(St:STRING;Base:BYTE):LONGINT;
VAR i   : BYTE;
    B10 : LONGINT;
BEGIN
B10:=0;
FOR i:=1 TO LENGTH(St) DO
  B10:=B10*Base+POS(St[i],Chiffres)-1;
Base10:=B10
END;

FUNCTION NewBase(N:LONGINT;Base:BYTE):STRING;
VAR i : BYTE;
    B : STRING;
BEGIN
B:='';
WHILE NOT (N=0) DO
  BEGIN
  i:=N MOD Base;
  B:=Chiffres[i+1]+B;
  N:=N DIV Base
  END;
NewBase:=B;
END;

BEGIN
Chiffres:='0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';
WRITE('Introduisez le nombre (0 pour arrêter):');
READLN(N);
WHILE NOT (N='0') DO
  BEGIN
  N:=Majuscules(N);
  WRITE('Dans quelle base est-il exprimé ');
  READLN(Base);
  IF NOT Verifie(N,Base) THEN WRITELN('Le nombre n''est pas correct!')
  ELSE BEGIN
       WRITE('Dans quelle base faut-il l''exprimer: ');
       READLN(NBase);
       WRITELN(N,' en base ',Base, ' = ', NewBase(Base10(N,Base),NBase), ' en base ',NBase);
       END;
  WRITE('Introduisez le nombre (0 pour arrêter):');
  READLN(N);
  END;
END.

Page d'accueil.