Discussion :

[david_chardonnet]

Bonjour,

Je recherche une fonction de conversion de nombre en lettres, et j'ai pas envie de réinventer la roue. Est-ce-que quelqu'un aurait ça dans ses tiroirs?

Une fonction qui convertirait: 3458984 en 'TROIS MILLIONS QUATRE CENT CINQUANTE HUIT MILLE NEUF CENT QUATRE VINGT QUATRE' par exemple.

Merci d'avance.

David

[MD Software]

Houlà, c'est compliqué ça.

Tu peux tenter un truc du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
case unite of
  1 : chaine := 'un';
  2 : chaine := 'deux';
  ...
end;

A toi de séparer les unité du reste ...

[david_chardonnet]

Merci MisterD, mais développe un peu plus tu fais une ligne par nombre, jusqu'au milliard?

[Lung]

Question déjà posée : fais une recherche sur le forum ...

[Bloon]

T'as de la chance, je l'ai sous la main :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
function NombreEnLettres(n : integer) : string;
Const
  unite : array[1..16] of string  = ('un','deux','trois','quatre','cinq','six',
                                     'sept','huit','neuf','dix','onze','douze',
                                     'treize','quatorze','quinze','seize');
  dizaine : array[2..8] of string = ('vingt','trente','quarante','cinquante',
                                     'soixante','','quatre-vingt');
  coefs : array[0..3] of string   = ('cent','mille','million','milliard');
Var
  temp    : string;
  c, d, u : byte;
  coef    : byte;
  i       : word;
  neg     : boolean;
Begin
  If n = 0 then
    begin
    result := ' zero';
    exit;
    end;
 
  result := '';
  neg := n < 0;
  If neg then n := -n;
 
  coef:=0;
  Repeat
    u:=n mod 10; n:=n div 10; {Récupère unité et dizaine}
    d:=n mod 10; n:=n div 10; {Récupère dizaine}
    If d in [1,7,9] then
      begin
      Dec(d);
      Inc(u,10);
      end;
    temp := '';
    if d > 1 then
      begin
      temp := ' ' + Dizaine[d];
      if (d < 8) and ((u = 1) or (u = 11)) then
        temp := temp + ' et';
      end;
    if u > 16 then
      begin
      temp := temp + ' ' + unite[10];
      Dec(u,10);
      end;
    if u > 0 then temp := temp + ' ' + unite[u];
    If (result = '') and (d = 8) and (u = 0) then result := 's';
    result := temp + result;
 
    c := n mod 10; n := n div 10; {Récupère centaine}
    If c > 0 then
      begin
      temp := '';
      if c > 1 then temp := ' ' + unite[c] + temp;
      temp := temp + ' ' + coefs[0];
      If (result = '') and (c > 1) then result := 's';
      result := temp + result;
      end;
 
    if n > 0 then
      begin
      Inc(coef);
      I := n mod 1000;
      If (i > 1) and (coef > 1) then result := 's' + result;
      If i > 0 then result := ' ' + coefs[coef] + result;
      If (i = 1) and (coef = 1) then Dec(n);
      end;
  until n = 0;
  result := Trim(result);
  if neg then result := 'moins ' + result;
End;

Bloon

[MD Software]

Merci MisterD, mais développe un peu plus tu fais une ligne par nombre, jusqu'au milliard?

T'inquiète pas, j'avais pas l'intention d'aller jusque là. Je penser m'arrêter à dix, et gérer ensuite les dixaine etc...

Sinon, le code de Bloon à l'air de marcher.

[david_chardonnet]

Merci Bloon!!

[MD Software]

Pense au tag [RESOLU]

[adaneels]

Merci Bloon, ça m'a permis un gain de temps. De plus, je trouve le code et astucieux.

J'ai modifié le code donné par Bloon pour correspondre à l'orthographe de la langue française, avec actualisation de 1990 : http://www.academie-francaise.fr/lan...s.html#nombres.

Je le dépose ici au cas où ça peut intéresser du monde.

Ecrire un nombre en toutes lettres :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
function NombreEnToutesLettres(n : integer) : string;
Const
  unite : array[1..16] of string  = ('un','deux','trois','quatre','cinq','six',
                                     'sept','huit','neuf','dix','onze','douze',
                                     'treize','quatorze','quinze','seize');
  dizaine : array[2..8] of string = ('vingt','trente','quarante','cinquante',
                                     'soixante','','quatre-vingt');
  coefs : array[0..3] of string   = ('cent','mille','million','milliard');
Var
  temp    : string;
  c, d, u : byte;
  coef    : byte;
  i       : word;
  neg     : boolean;
Begin
  If n = 0 then begin
    Result := ' zéro';
    exit;
  end;
 
  Result := '';
  neg := n < 0;
  If neg then n := -n;
 
  coef:=0;
  Repeat
    u:=n mod 10; n:=n div 10; {Récupère unité et dizaine}
    d:=n mod 10; n:=n div 10; {Récupère dizaine}
    If d in [1,7,9] then begin
      Dec(d);
      Inc(u, 10);
    end;
    temp := '';
    if d > 1 then begin
      temp := Dizaine[d];
      if (d < 8) and ((u = 1) or (u = 11)) then
        temp := temp + '-et';
    end;
    if u > 16 then begin
      if temp = '' then
        temp := unite[10]
      else
        temp := temp + '-' + unite[10];
      Dec(u, 10);
    end;
    if u > 0 then begin
      if temp <> '' then
        temp := temp + '-';
	    temp := temp + unite[u];
    end;
    If (d = 8) and (u = 0) and ((Result = '') or (LeftStr(Result, 6) = '-milli')) then
	    Result := 's' + Result;
    Result := temp + Result;
 
    c := n mod 10; n := n div 10; {Récupère centaine}
    If c > 0 then begin
      temp := '';
      if c > 1 then
	      temp := unite[c] + '-';
      temp := temp + coefs[0];
      if (Result <> '') and (LeftStr(Result, 1) <> '-') then
        Result := '-' + Result;
      if (c > 1) and ((Result = '') or (LeftStr(Result, 6) = '-milli')) then
        Result := 's' + Result;
      Result := temp + Result;
    end;
 
    if n > 0 then begin
      Inc(coef);
      I := n mod 1000;
      If (Result <> '') and (LeftStr(Result, 1) <> '-') then
	      Result := '-' + Result;       
      If (i > 1) and (coef > 1) then
	      Result := 's' + Result;     
      If i > 0 then
        Result := '-' + coefs[coef] + Result;
      If (i = 1) and (coef = 1) then
  	    Dec(n);
    end;
  until n = 0;
  Result := Trim(Result);
  if neg then
    Result := 'moins ' + Result;
End;

Écrire un montant en euros en toutes lettres :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
function MontantEnToutesLettres(f : double) : string;
const
  Centieme = 'centime';
  Monnaie = 'euro';
var
  i : Integer;
begin
  Result := '';
 
  // partie décimale 
  i := Round(Frac(f) * 100);
  if i > 0 then begin // n'écrit pas "zéro centime" si partie décimale nulle
    if i > 1 then
      Result := 's';
    Result := ' ' + NombreEnToutesLettres(i) + ' ' + Centieme + Result;
  end;
 
  // partie entière
  i := Trunc(f);
  if i > 1 then
    Result := 's' + Result;
  Result := NombreEnToutesLettres(i) + ' ' + Monnaie + Result;
end;

Un projet de test en pièce jointe.

Si vous pensez que cela mérite d'aller dans la FAQ, ravi d'avoir participer

Arnaud D.

[popo]

Apparement, tu n'as besoin de gérer que les entiers.
Je te propose un truc un peu plus propre que cette procédure avec des ifs de partout et assez compliqué à lire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
Function NbreToLettre(Nbre : integer; Maj : boolean = False) : string;
const
  N0_19: array[0..19] of string =
  ('zéro','un','deux','trois','quatre','cinq','six','sept','huit','neuf', 'dix',
  'onze','douze','treize','quatorze','quinze','seize','dix-sept','dix-huit','dix-neuf');
  N20_60: array[2..6] of string =
  ('vingt','trente','quarante','cinquante','soixante');
  Separateur: array[Boolean] of string = ('-', ' et ');
var NDizaines, NCentaines : integer;
    stMaj, stMin : string;
begin
  Case Nbre of
    0..19 : Result := N0_19[Nbre];
    20..69 :
    begin
      NDizaines := Nbre div 10;
      // Gère les cas de 20, 30, 40, 50 et 60
      if (Nbre mod 10 = 0) then
        Result := N20_60[NDizaines]
      else
        Result := N20_60[NDizaines]
          + Separateur[Nbre mod 10 = 1]
          + N0_19[Nbre - NDizaines * 10];
    end;
    70..79 : Result := 'soixante' + Separateur[Nbre mod 10 = 1] + N0_19[Nbre - 60];
    80 : Result := 'quatre-vingts';
    81..99 : Result := 'quatre-vingt-' + N0_19[Nbre - 80];
    100 : Result := 'cent';
    101..199 : Result := 'cent ' + NbreToLettre(Nbre - 100);
    200..999 :
    begin
      NCentaines := Nbre div 100;
      if (Nbre mod 100 = 0) then
        Result := N0_19[NCentaines] + ' cents'
      else
        Result := N0_19[NCentaines] + ' cent '
          + NbreToLettre(Nbre - NCentaines * 100);
 
    end;
    1000 : Result := 'mille';
  end;
  if (Maj) then
  begin
    // stMaj prend la première lettre
    stMaj := UpperCase(Copy(Result,0,1));
    // stMin prend la suite
    stMin := Copy(Result,2,Length(Result));
    // Resultat la première lettre est en majuscule
    Result := stMaj + stMin;
  end;
end;

Edit : Je ne suis allé que jusqu'à mille mais le principe est le même pour les nombres plus grands

[Paul TOTH]

voici une version un peu améliorée qui tient compte du mille invariant et du s sur cent et vingt

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
 
function Int1KToText(Value: Integer; Last: Boolean): string;
const
 
  NUM_0_19 : array[0..19] of string = (
    'zéro', 'un', 'deux', 'trois', 'quatre', 'cinq', 'six', 'sept', 'huit',
    'neuf', 'dix', 'onze', 'douze', 'treize', 'quatorze', 'quinze', 'seize',
    'dix-sept', 'dix-huit', 'dix-neuf'
  );
 
  NUM_20_60: array[2..6] of string = (
    'vingt', 'trente', 'quarante', 'cinquante', 'soixante'
  );
 
  Separateur: array[Boolean] of string = ('-', ' et ');
 
var
  D, M: Integer;
 
begin
  case Value of
 
    0..19    : Result := NUM_0_19[Value];
 
    20..69   :
    begin
      D := Value div 10;
      M := Value mod 10;
      Result := NUM_20_60[D];
      if M > 0 then
        Result := Result + Separateur[Value mod 10 = 1] + NUM_0_19[M];
    end;
 
    70..79   : Result := 'soixante' + Separateur[Value mod 10 = 1] + NUM_0_19[Value - 60];
 
    80       :
    begin
      Result := 'quatre-vingt';
      if Last then
        Result := Result + 's';
    end;
 
    81..99   : Result := 'quatre-vingt-' + NUM_0_19[Value - 80];
 
    100      : Result := 'cent';
    101..199 : Result := 'cent ' + Int1KToText(Value - 100, Last);
    200..999 :
    begin
      D := Value div 100;
      M := Value mod 100;
      Result := NUM_0_19[D] + ' cent';
      if M = 0 then
      begin
        if Last then
          Result := Result + 's'
      end else begin
        Result := Result + ' ' + Int1KToText(M, Last);
      end;
    end
  else
 
    raise Exception.Create('Int99ToText overflow');
 
  end;
end;
 
function IntToText(Value: Integer): string;
const
  Units: array[0..2] of string = ('milliard', 'million', 'mille');
var
  I, N, D: Integer;
begin
  Result := '';
 
  N := 1000000000;
  for I := 0 to 2 do
  begin
    if Value >= N then
    begin
      if Result <> '' then
        Result := Result + ' ';
      D := Value div N;
      Value := Value - (N * D);
      if (D > 1) or ((D = 1) and (I < 2)) then // "mille", "un million"
        Result := Result + Int1KToText(D, False) + ' ';
      Result := Result + Units[I];
      if (D > 1) and (I < 2) then // "mille" est invariant
        Result := Result + 's';
      if Value = 0 then
        Exit;
    end;
    N := N div 1000;
  end;
 
  if Result <> '' then
    Result := Result + ' ';
 
  Result := Result + Int1KToText(Value, True);
end;

[Thierry Laborde]

voici une version un peu améliorée qui tient compte du mille invariant et du s sur cent et vingt

Donc Paul, en plus d'être un expert Delphi tu es un expert en orthographe. Impressionnant, on vient de retrouver Maitre Capello.
Ok, je sors.

[Roland Chastain]

voici une version un peu améliorée qui tient compte du mille invariant et du s sur cent et vingt

Très joli !

J'ai bien aimé ça entre autres : Separateur[Value mod 10 = 1]

[Barbibulle]

Mais Paul n'est pas Maître Capello car d'une ce dernier était chiant et sans humour et de deux (pour le coup je vais faire Maître Capello) la règle a été réformée en 1990 concernant les traits d'union, on peut en mettre partout maintenant (enfin presque partout... sinon c'était trop beau). (C'est ce qui est enseigné dans les collèges maintenant).

Cette notation à un avantage pour différencier par exemple "51/3" cinquante-et-un tiers de "50 + 1/3" cinquante et un tiers
4220/7 quatre-mille-deux-cent-vingt septièmes
4200/27 quatre-mille-deux-cent vingt-septièmes
4000/227 quatre-mille deux-cent-vingt-septièmes
4227ième quatre-mille-deux-cent-vingt-septièmes

Je reviens sur le presque partout... car il y a un flou sur les noms millier, million et milliard (qui ne sont pas des adjectifs cardinaux) qui seraient donc exclus de cette règle (et donc non entouré de traits d'union)...
Genre on va simplifier... mais attendez il y a des pièges alors que d'autres (plus raisonnables je dirais) disent qu'on peut en mettre également autours des noms millier million et milliard.

Tout ceci, ne sont que des recommandations (mais c'est elles qui sont maintenant enseignées).

Maître Capello puissance 2 :

Pour ce qui est de l'accord de cent, la règle c'est

Le mot cent est invariable sauf quand il est précédé d'un nombre qui le multiplie et n'est pas suivi par un autre adjectif numéral cardinal

Donc
trois-cents
cinq-cent-un
mille-cent
mais...
trois-cents millions
cinq-cents milliards
car million et milliard sont des noms (<> adjectif numéral cardinal).

Mais bon c'est du chipotage si on me donne un chèque de cinq-cent milliards je le prendrai quand même

[Paul TOTH]

Mais Paul n'est pas Maître Capello car d'une ce dernier était chiant et sans humour et de deux (pour le coup je vais faire Maître Capello) la règle a été réformée en 1990 concernant les traits d'union, on peut en mettre partout maintenant (enfin presque partout... sinon c'était trop beau). (C'est ce qui est enseigné dans les collèges maintenant).

Cette notation à un avantage pour différencier par exemple "51/3" cinquante-et-un tiers de "50 + 1/3" cinquante et un tiers
4220/7 quatre-mille-deux-cent-vingt septièmes
4200/27 quatre-mille-deux-cent vingt-septièmes
4000/227 quatre-mille deux-cent-vingt-septièmes
4227ième quatre-mille-deux-cent-vingt-septièmes

Je reviens sur le presque partout... car il y a un flou sur les noms millier, million et milliard (qui ne sont pas des adjectifs cardinaux) qui seraient donc exclus de cette règle (et donc non entouré de traits d'union)...
Genre on va simplifier... mais attendez il y a des pièges alors que d'autres (plus raisonnables je dirais) disent qu'on peut en mettre également autours des noms millier million et milliard.

Tout ceci, ne sont que des recommandations (mais c'est elles qui sont maintenant enseignées).

Maître Capello puissance 2 :

Pour ce qui est de l'accord de cent, la règle c'est


Donc
trois-cents
cinq-cent-un
mille-cent
mais...
trois-cents millions
cinq-cents milliards
car million et milliard sont des noms (<> adjectif numéral cardinal).

Mais bon c'est du chipotage si on me donne un chèque de cinq-cent milliards je le prendrai quand même

Merci,

oui j'avais vu pour les traits d'union mais je trouvais ça moche ^^ mais c'est facile à corriger.

par contre pour le s, si je ne m'abuse il suffit alors de remplacer le paramètre "False" par "I < 2" en ligne 85 de mon code.

trois-cents milliards (avec un Int64 en ligne 67 et 71 dans ce cas )
trois-cents millions
trois-cent mille

[Barbibulle]

Jusqu'à présent, j'utilisais le code proposé par Bloon cité plus haut qui ne gère pas les traits tirets (aucun) ni l'accords de cent suivi de million /milliard .

Mais qui était user-friendly avec nos amis les Belges (par défaut c'est l'utilisation de la règle française mais on peut demander une écriture selon les règles belges avec des septante, octante et nonante. Il me semble que les Suisses (certains cantons) on une règle spécifique avec huitante).

On ne parlera pas des québécois qui je crois sont comme en France mis à part pour les traits-tirets qui sont chez eux obligatoires partout.

En tous les cas merci Paul pour ce code qui m'a fait réviser toutes ces règles et merci à Thierry qui a déterré feu Maître Capello.

et deux-cents francs pour le nourrain !

http://www.ina.fr/video/I09006940

[Pascal Peyremorte]

Bonjour,

Je retrouve cet antique sujet, avec la surprise de découvrir qu'il a eu des suites jusqu'en 2015 !

Comme il faut rendre à Pascal ce qui lui revient, je voulais quand même mentionner que la fonction initiale fournie par "Bloom" venait... de moi !
Et, en 2006, elle avait déjà une longue histoire :

Sa première version date de 1983, en basic sur commodore 4032. Je l'avais écrite pour un ami (Patrice C.) qui voulait afficher un chèque en fin d'un jeu de Black-Jack en consommant le moins de ressource possible.

Je l'ai ensuite réutilisée vers 1984, lors d'un stage de programmation en basic, pour la proposer en exercice, avec pour contrainte de n'utiliser qu'un minimum de mots en "data" et de faire le programme le plus court possible, contrainte d'où sont issue les tables Unité[], Dizaine[] et Coefs[].

Je l'ai ensuite transcrite en Pascal en 2002 après avoir trouvé une demande qui avait généré quelques monstruosités sur un forum francophone dédié à Delphi. Elle avait alors été complétée le 13 mars 2002, pour tenir compte de la remarque de Zacharie TCHOUALA pour gérer la règle : « L'adjectif numéral "cent" ne prend pas la marque du pluriel s'il est suivi d'un autre nombre (exemple : trois cent quatre), mais il s'accorde devant "million" et "milliard" qui sont des noms. Exemple : trois cents millions deux cent mille.> d'après "Le Robert d'aujourd'hui" (édition mise à jour d'octobre 1995). »

Amitiés, et meilleurx voeux à tous pour 2021, soit 38 ans après la première version ! :-)
(Avec un clin d'oeil à Paul en passant !)

[Paul TOTH]

Hello,

comme quoi ça sert toujours de passer du temps sur ce forum...je corrige (pour les "-") et complète mon code avec une fonction DateToText

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
function Int1KToText(Value: Integer; Last: Boolean): string;
const
  NUM_0_19 : array[0..19] of string = (
    'zéro', 'un', 'deux', 'trois', 'quatre', 'cinq', 'six', 'sept', 'huit',
    'neuf', 'dix', 'onze', 'douze', 'treize', 'quatorze', 'quinze', 'seize',
    'dix-sept', 'dix-huit', 'dix-neuf'
  );
 
  NUM_20_60: array[2..6] of string = (
    'vingt', 'trente', 'quarante', 'cinquante', 'soixante'
  );
 
  Separateur: array[Boolean] of string = ('-', '-et-');
 
var
  D, M: Integer;
 
begin
  case Value of
 
    0..19    : Result := NUM_0_19[Value];
 
    20..69   :
    begin
      D := Value div 10;
      M := Value mod 10;
      Result := NUM_20_60[D];
      if M > 0 then
        Result := Result + Separateur[Value mod 10 = 1] + NUM_0_19[M];
    end;
 
    70..79   : Result := 'soixante' + Separateur[Value mod 10 = 1] + NUM_0_19[Value - 60];
 
    80       :
    begin
      Result := 'quatre-vingt';
      if Last then
        Result := Result + 's';
    end;
 
    81..99   : Result := 'quatre-vingt-' + NUM_0_19[Value - 80];
 
    100      : Result := 'cent';
    101..199 : Result := 'cent ' + Int1KToText(Value - 100, Last);
    200..999 :
    begin
      D := Value div 100;
      M := Value mod 100;
      Result := NUM_0_19[D] + '-cent';
      if M = 0 then
      begin
        if Last then
          Result := Result + 's'
      end else begin
        Result := Result + '-' + Int1KToText(M, Last);
      end;
    end
  else
 
    raise Exception.Create('Int99ToText overflow');
 
  end;
end;
 
function IntToText(Value: Integer): string;
const
  Units: array[0..2] of string = ('milliard', 'million', 'mille');
var
  I, N, D: Integer;
begin
  Result := '';
 
  N := 1000000000;
  for I := 0 to 2 do
  begin
    if Value >= N then
    begin
      if Result <> '' then
        Result := Result + '-';
      D := Value div N;
      Value := Value - (N * D);
      if (D > 1) or ((D = 1) and (I < 2)) then // "mille", "un million"
        Result := Result + Int1KToText(D, I < 2) + '-';
      Result := Result + Units[I];
      if (D > 1) and (I < 2) then // "mille" est invariant
        Result := Result + 's';
      if Value = 0 then
        Exit;
    end;
    N := N div 1000;
  end;
 
  if Result <> '' then
    Result := Result + '-';
 
  Result := Result + Int1KToText(Value, True);
end;
 
function DateToText(Date: TDateTime): string;
var
  y, m, d: Word;
begin
  DecodeDate(Date, y, m, d);
  Result := IntToText(d) + '-' + FormatSettings.LongMonthNames[m] + '-' + IntToText(y);
end;

[Charly910]

Bonjour,
on pourrait peut-être mettre cette fonction dans la FAQ en complément de celle-ci ?

A+
Charly

[SergioMaster]

La FAQ est collaborative (donc modifiable) il suffit d'un volontaire pour se charger de rajouter cette "nouvelle" version

1983/1984 C'est à peu près l'époque où j'ai commencé à sévir comme prof d'informatique dans une "école" privée et l'un des premiers exercices d'algorithme que j'ai donné aux "deuxième année"
(langages Basic mais aussi RPG sur IBM 36) sous le titre "écrire un programme d'émission de chèques".