Evaluation d'un nombre écrit en chiffres romains

 

Nous allons réaliser maintenant un programme permettant d'évaluer un nombre romain, mais auparavant on va introduire les chiffres romains:

M = 1000

D =  500

C =  100

L =   50

X =   10

V =    5

I =    1

On constate que les nombres s'arrêtaient au milliers; cela montre le progrès des mathématiques depuis le temps des romains.

L'écriture des nombres romains

1 s'écrit I.

2 s'écrit II.

3 s'écrit III.

4 s'écrit IV.

5 s'écrit V.

6 s'écrit VI.

7 s'écrit VII.

8 s'écrit VIII.

9 s'écrit IX.

10 s'écrit X.

Tous les nombres finissant par 1,2 ou 3 se terminent dans l'écriture romaine par I,II ou III. Idem pour 6,7 ou 8.

Ceci est valable aussi bien pour les unités, comme on vient de le voir que pour les dizaines et les centaines; ainsi 30 s'écrit XXX, 300 s'écrit CCC.

Tous les nombres finissant par 4, se terminent dans l'écriture romaine par IV. 

Tous les nombres finissant par 9, se terminent dans l'écriture romaine par IX. Ainsi 49 se termine par IX, et il s'écrit XLIX.

Identiquement, les nombres finissant par 90 se terminent dans l'écriture domaine par XC.

15 s'écrit XV.

47 s'écrit XLVII.

97 s'écrit XCVII.

14 s'écrit XIV.

149 s'écrit CXLIX (et non CIL, comme on pourrait le penser)

    On constate ici la décomposition 100+40+9 = C + XL + IX

1490 s'écrit MCDXC = 1000 + 400 + 90 = M + CD + XC

1900 s'écrit MCM = 1000+900 = M + CM.

1990 s'écrit MCMXC (et non MXM, comme on pourrait le penser)

     1000+900+90 = M + CM + XC

1999 = MCMXCIX

Observations

Soit deux chiffres romains. Si le premier chiffre a une valeur inférieure au deuxième, alors on le soustrait de la valeur de tout le reste, sinon on l'additionne à la valeur de tout le reste.

En effet, étudions cela sur un exemple :

MCMXCIX.

|On est sur le premier M.

|Son successeur est C, il est plus petit, donc notre résultat final sera la

|valeur de M (1000) plus la valeur du reste (CMXCIX).

|  La valeur du reste est la suivante :

|  C est plus petit que M (une soustraction aura lieu) donc la valeur de

|  CMXCIX est égale à la valeur de MXCIX moins la valeur de C

|  |   La valeur de MXCIX est la suivante :

|  |   |M est plus grande que X donc on a 1000+valeur(XCIX).

|  |   |   La valeur de XCIX est égale à la valeur de CIX moins la valeur de X

|  |   |   |car le premier X est plus petit que son successeur.

|  |   |   |   La valeur de CIX est égale à 100 + valeur(IX) car C est plus

|  |   |   |   |grand que I.

|  |   |   |   |    La valeur de IX est égale à la valeur de X moins la valeur   

|  |   |   |   |    de I, soit 10-1 = 9.

|  |   |   |   CIX = C + 9 = 109

|  |   |   XCIX = CIX - X = 109 - 10 = 99

|  |   MXCIX = M + XCIX = 1000 + 99 = 1099

|  CMXCIX = MXCIX - C = 1099 - 100 = 999

MCMXCIX = 1000 + 999 = 1999 

 On voit la forme de l'algorithme général:

Soit un nombre romain. Si le premier chiffre de ce nombre a une valeur inférieure au deuxième, alors on le soustrait de la valeur de tout le reste, sinon on l'additionne à la valeur de tout le reste.

Si le nombre romain a un seul chiffre, alors on prend simplement la correspondance (M=1000, D = 500,...).

Appelons "Eval" la fonction d'évaluation d'un nombre romain.

Son point d'appui est "Eval(r)= valeur(r)" si r est un caractère romain.

Le cas général est le suivant :

- si la valeur du premier chiffre romain est plus grande que la valeur du  

  deuxième, alors "Eval(r)=valeur(premier chiffre)+Eval(reste)"

- si la valeur du premier chiffre romain est plus petite que la valeur du

  deuxième, alors "Eval(r)=Eval(reste)-valeur(premier chiffre)"

On constate qu'avec l'algorithme ci-dessus, le nombre MIM (qui pourtant n'existe pas chez les romains) est évalué à 1999. Le programme décrit ci-dessus n'effectue pas un test d'exactitude de la chaîne passée en paramètre pour être évaluée, il se contente seulement de l'évaluer.

 

function valeur(c: char): integer;
begin
  case c of
    'M': valeur := 1000;
    'D': valeur := 500;
    'C': valeur := 100;
    'L': valeur := 50;
    'X': valeur := 10;
    'V': valeur := 5;
    'I': valeur := 1;
  end;
end;
 
function eval(s: string): integer;
var n1: integer;
begin
  if length(s) = 1 then
    eval := valeur(s[1])
  else
  begin
    n1 := valeur(s[1]);
    if n1 < valeur(s[2]) then n1 := -n1;
    eval := n1 + eval(copy(s, 2, length(s) - 1));
  end;
end;
 

 

Télécharger le code source Delphi