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
beginn1 := 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