Chiffre Romain, convertir une chaîne de caractères en chiffre.

Bonjour

Je n'arrive pas à trouver comment passez des chiffres Romain en Chiffre Arabe.

Plus exactement lorsque mon utilisateur rentre des chiffres Romain je ne sais pas comment faire pour décortiquer sa ligne afin de dissocier les différents chiffres Romain pour pouvoir les convertir.

Voici le code que j'ai pour l'instant :

Code:

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
import java.util.Scanner;
 
class Romain {
 
    public static void main(String[] args) {
        Scanner clavier = new Scanner(System.in);
        int[] nombres = {1000, 500, 100, 50, 10, 5, 1 };
        String symboles = "MDCLXVI";
 
 
String [] unit = {"I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};
String [] diz = {"X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"};
String [] cent = {"C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"};
String [] mil = {"M"};
int n =0;
String r;
char M = 1000;
char D = 500;
char C = 100;
char L = 50;
char X = 10;
char V = 5;
char I = 1;
 
 
// ROMAIN ==> ARAB
 
System.out.print("Entrez un nombre en chiffres romains : ");
 
	 r = clavier.nextLine();
	 r.toUpperCase(); 	
 
 
 
	 int longeur = r.length();
 
	 for (int i = 0; i < longeur; i++) {
	 int convert = r.charAt(longeur - (longeur-i));
	 convert = r.charAt(i)+convert;
 
	 System.out.println(convert);
	 }
 
	 System.out.println("Conversion impossible, nombre romain mal formé.");
}
}

Je ne sais absolument pas si je suis partie sur la bonne piste, j'ai du mal avec les tableaux.

Merci d'avance.

Salut,

La conversion romain vers int(base 10 arabique sous-entendu) est beaucoup plus simple que la conversion arabique vers romain : on n'a pas besoin des valeurs correspondants aux combinaisons (dugenre IX qui vaut 9, IV qui vaut 4, etc.).

Il y a 2 règles, ou plutôt une avec une sorte d'exception :
Chaque caractère de la chaîne d'entrée vaut une valeur, et il suffit d'ajouter toutes ces valeurs ; On peut le résoudre par une table de convrsion, ou tout simplement un switch :
Code:

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 public static int romanCharToInt(char c){ final int number; switch(c) { case 'I': number=1; break; case 'V': number=5; break; case 'X': number=10; break; case 'L': number=50; break; case 'C': number=100; break; case 'D': number=500; break; case 'M': number=1000; break; default: throw new IllegalStateException("Caractère inconnu: " + c); } return number; }
Il suffit donc de parcourir tous les caractères de la chaîne d'entrée et de sommer toutes les valeurs correspondantes.
l'exception c'est les cas du type IV, IX, LX... c'est-à-dire lorsque la valeur d'un caractère est supérieure à la valeur du caractère précédent, alors on doit faire quelque chose de particulier.
Prenons le cas du IV : si j'applique la règle 1, j'obtiens 1 + 5 = 6, alors qu'on devrait avoir 4. A noter que VI vaut bien 6.
Prenons le cas du XL : si j'applique la règle 1, j'obtiens 60, alors que je devrais obtenir 40. A noter que LX vaut bien 60.
Prenons le cas du XC : si j'applique la règle 1, j'obtiens 110, alors que je devrais obtenir 90. A noter que CX vaut bien 110.
Qu'observe-t-on ? Que la différence entre le résultat obtenu et le résultat attendu est égal à 2 fois la valeur du caractère précédent celui qu'on traite. Il suffit donc, lorsque la valeur du caractère courant est supérieure à la valeur du caractère précédent, de retirer de la somme obtenue par la règle 1, le double de la valeur du caractère précédent.
En résumé, il faut faire une boucle sur tous les caractères en entrée, faire la somme des valeurs correspondant, mémoriser la valeur correspondante du caractère courant pour l'itération suivante, et gérer la condition de l'exception à la règle.

Merci pour la réponse, hélas pour moi je n'ai pas encore vu "switch" et "break", je dois résoudre ce problème en utilisant uniquement avec des branchements conditionnels, des itérations et des tableaux.
Je me demandé si il était possible découper la ligne "string" entré par l'utilisateur caractères par caractères pour les placer dans un tableau et ainsi faire une correspondance avec les chiffres arabes.
Si cela est possible comment puis-je faire cela?

Une autre question mon code ci dessus affiche la valeur 120 si je rentre X ( et 88 pour x), pourquoi d'où provient elle?

merci d'avance.

Dans ce cas, au plus simple, il te faut une table de conversion des motifs caractéristiques. Une Map serait le mieux, mais si tu n'as pas encore vu les Maps, utilise 2 tableaux.

Dans cette table, M vaut 1000, MM 2000, MMM 3000, MMMM 4000, C 100, CC 200, CCC 300, CD 400, D 500, DC 600, DCC 700 DCCC, 800, CM 900, etc... On a 31 motifs (9 pour les unités(1,2,3...8,9), 9 pour les dizaines (10, 20, 30...80,90), 9 pour les centaines, 4 pour les milliers (il y a les extensions bien sûr mais je ne pense pas que tu doives les traiter).

Tu peux éventuellement construire les 2 tableaux par programme.

Ensuite, tu parcours ta chaîne, et tu cherches si un des motifs correspond au début : tant que tu trouves un motif (qui existe) plus grand que celui trouvé précédemment, tu continues. Sinon, tu prends la valeur correspondant au motif, tu l'ajoutes à la somme jusque-là, et tu recommences, en prenant en compte le reste de la chaine.

Exemple : MMMMCMLXXXIV (4984)
On a un motif : M on le prend, et on continue
On a un motif : MM on le prend, et on continue
On a un motif : MMM ...
On a MMMM ...
On n'a pas MMMMC, donc on convertit MMMM = 4000, et on reprend sur CMLXXXIV
On a C, OK
On a CM, ok
On n'a pas CML : on converti CM : 900 + 4000, et on reprend sur LXXXIV
On a L
On a LX
On a LXX
On a LXXX
On n'a pas LXXXI, on converti LXXX : 80 + 4900, eton reprend sur IV...

Pour faire ça, il te faut 2 index : un pour avancer dans la chaîne pour traiter chaque nouveau caractère, et un qui dit le début du motif en cours dans la chaîne.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 int nombre=0; // pour calculer le résultat int last=0; for(int i=0; i<chaine.lenth; i++) { // on test si motif existe dans la table if ( !existe(chaine.substring(last, i+1)) ) { // le motif existe pas, on prend le précédent if ( i<=last ) { // il y a une erreur quelque part throw new IllegalArgumentException(chaine+" n'est pas un nombre romain"); } else { String motif = chaine.substring(last,i); // on cherche la valeur de motif nombre += valeurDeMotif(motif); last=i; // on reprend d'ici } } // ici, il faut penser qu'on a encore la fin de la chaîne à traiter (chaine.substring(last))... }
valeurMotif(String motif) correspond à chercher l'index de motif dans le premier tableau et de prend la valeur de l'index trouvé dans le second tableau (nos 2 tableaux qui constitue la table de correspondances). Si le motif n'est pas trouvé dans le tableau, faire throw new IllegalArgumentException(motif + " n'est pas un nombre romain");

Citation:

Envoyé par hoturi

Une autre question mon code ci dessus affiche la valeur 120 si je rentre X ( et 88 pour x), pourquoi d'où provient elle?

Tu veux dire 88 pour X et 120 pour x, non ? Ce sont les valeurs de codage des caractères en mémoire (dans l'encodage utilisé par Java pour coder les caractères), respectivement 88 pour X et 120 pour x. Ça n'a pas beaucoup de sens de chercher à passer par ces valeurs pour convertir du romain en décimal, à moins qu'il y ait une formule, un truc, que je ne connais pas, mais j'en doute (la progression I,V,X,L,C,M est numériquement croissante, alors qu'elle ne suit pas l'ordre alphabétique, alors que la progression numérique des codes de caractères est croissante aussi). Il a peut-être un truc avec le modulo...
Je n'ai pas parlé de la casse parce que ça me semblait évident : il faut tout passer en majuscule avant de chercher à convertir, par un toUpperCase().

Citation:

Envoyé par joel.drigo

Tu veux dire 88 pour X et 120 pour x, non ? Ce sont les valeurs de codage des caractères en mémoire (dans l'encodage utilisé par Java pour coder les caractères), respectivement 88 pour X et 120 pour x. Ça n'a pas beaucoup de sens de chercher à passer par ces valeurs pour convertir du romain en décimal, à moins qu'il y ait une formule, un truc, que je ne connais pas, mais j'en doute (la progression I,V,X,L,C,M est numériquement croissante, alors qu'elle ne suit pas l'ordre alphabétique, alors que la progression numérique des codes de caractères est croissante aussi). Il a peut-être un truc avec le modulo...
Je n'ai pas parlé de la casse parce que ça me semblait évident : il faut tout passer en majuscule avant de chercher à convertir, par un toUpperCase().

Merci pour la réponse je ne savais a quoi elle correspondaient même en supprimant des lignes de codes. Je vais regarder plus amplement ton code afin de m'en inspirer, je pense avoir un début afin de m'aider à faire mon programme.

C'est super sympa.

Merci de ton aide Joel mais je ne comprend pas vraiment ton code il doit,y avoir des notions que je n'ai pas encore vu, je suis vraiment perdu sur cette histoire de tableau cela ne m'inspire pas (et je ne suis que sur l'exercice intermédiare, le suivant me fait déjà peur), une personne ma aidé pour le début du code voila son travail :
Code:

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 import java.util.Scanner; class Romain { public static void main(String[] args) { Scanner clavier = new Scanner(System.in); int[] nombres = {1000, 500, 100, 50, 10, 5, 1 }; String symboles = "MDCLXVI"; /******************************************* * ComplÃ©tez le programme Ã* partir d'ici. *******************************************/ int j=1; int tot=0; int count=0; int som [] =new int [20] ; String [] s = {"M","D","C","L","X","V","I" }; System.out.println("Entrez un nombre en chiffres romains : "); String rom = clavier.nextLine(); rom = rom.toUpperCase(); //***************************************************************************** for(int i=0;i<rom.length();i++){ //determiner les valeurs des symboles de rom for(int k=0;k<7;k++){ if(rom.substring(i,j).equals(s[k])){ //pour tester tableau rom par rapport au s // som [k] =nombres[k]; tot=tot+nombres[k]; count=count+1;} } j++; } //********************* AFFICHAFE DES CALCULES *************** if(count==rom.length()){ // for(int i=0;i<som.length;i++){tot=tot+som[i];} System.out.println("arabes("+rom+") = "+tot);} else{ System.out.println("Conversion impossible, nombre romain mal formé."); }
Il reste encore les cas particulier a savoir comment traiter les soustractions et autres petites complications :

-un symbole positionné avant un autre symbole de valeur plus forte se retranche de ce dernier (ex: «IX» = 10 (X) - 1 (I) = 9); les symboles «V», «L» et «D» ne peuvent pas être utilisés en tant qu'élément soustracteur;

-on n'emploie jamais successivement quatre symboles identiques (ex: 90 s'écrit 100 (C) - 10 (X), soit «XC» et non pas «LXXXX» - ni «LXL», en vertu des règles précédentes), et en cas d'ambiguïté, la séquence la plus courte sera retenue (ex: 150 s'écrit 100 (C) + 50 (L), soit «CL» et non pas 200 (CC) - 50 (L), soit «LCC»).

j'avais pensé commencer par faire une boucle pour voir les caractères inférieures a celui qui suit : (mal dit, dsl)
Code:

1 2 3 4 5 6 7 8 9 for(int i=0;i<rom.length();i++){ char c1 = rom.charAt(0); char c2 = rom.charAt(0+count); if (c1>c2) { } count++; }
Je ne sais pas ci cela peut vraiment me permettre d'y voir plus clair.

J'ai lu tes réponses mais je ne comprend pas comment faire avec les 2 index.

Merci d'avance.

Salut

Bon voici ce que j'ai pondu en 2h et je suis toujours bloqué,

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
  for(int i=0;i<rom.length();i++){ //determiner les valeurs des symboles de rom  	
 
        for(int k=0;k<19;k++){
 
        if(rom.substring(i,j).equals(s[k])){ //pour tester tableau rom par rapport au s
 
        if (i+1<rom.length()){
        char c1 = rom.charAt(i);
        char c2 = rom.charAt((rom.length()+i+1)-rom.length()); 
        System.out.println(c1 +" "+c2);
        if (c1<c2) {
 
        t = t+nombres[k];
 
 
        System.out.println(t);}
        }
        	// som [k] =nombres[k];
        tot=tot+nombres[k]-t;
        System.out.println(t);
        count=count+1;} } 
        j++; }

Je suis un peu dans le flou en faite je dois être en train de comparer des références et non des valeurs c'est pour cela que je n'arrive pas a avancer je pense.

Citation:

Envoyé par hoturi

Il reste encore les cas particulier a savoir comment traiter les soustractions et autres petites complications :

-un symbole positionné avant un autre symbole de valeur plus forte se retranche de ce dernier (ex: «IX» = 10 (X) - 1 (I) = 9); les symboles «V», «L» et «D» ne peuvent pas être utilisés en tant qu'élément soustracteur;

-on n'emploie jamais successivement quatre symboles identiques (ex: 90 s'écrit 100 (C) - 10 (X), soit «XC» et non pas «LXXXX» - ni «LXL», en vertu des règles précédentes), et en cas d'ambiguïté, la séquence la plus courte sera retenue (ex: 150 s'écrit 100 (C) + 50 (L), soit «CL» et non pas 200 (CC) - 50 (L), soit «LCC»).

Ce sont les règles qui régissent la notation : elles sont surtout utiles pour construire un nombre en notation romaine, ou éventuellement pour tester si un nombre noté en romain est bien conforme aux règles. On peut s'en servir pour convertir mais ce que je t'ai donné comme algorithme est plus simple, surtout si tu n'as ni le droit aux switchs et ni au map.
Bon, la règle 2 est erronée (!), ou plutôt il y a une exception : on écrit MMMM (donc 4 symboles identiques successifs), car il n'y a pas de caractères qui représentent 5 milles (en notation standard, comme en étendue d'ailleurs, ou on aura soit des traits soit des points en plus).

Citation:

Envoyé par hoturi

J'ai lu tes réponses mais je ne comprend pas comment faire avec les 2 index.

Et bien, pour remplacer une map avec deux tableaux, il suffit d'avoir donc 2 tableaux de même taille, et d'avoir une méthode qui fait :
Code:

1 2 3 4 5 6 7 8 9 10 getValeur(param) { index = index de param dans tableau 1 si index trouvé return element situé à indexe sinon error ou return null fin si fin getValeur }
Donc par exemple :
Code:

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 public class ArrayMap<K,V> { private K[] keys; private V[] values; public ArrayMap(K[] keys, V[] values) { if ( keys.length==values.length) { this.keys=keys; this.values=values; } else { throw new IllegalArgumentException(); } } private int getIndex(K key) { int index=-1; for(int i=0; i<keys.length && index==-1; i++) { if ( k==null ) { if ( keys[i]==null ) { index = i; } } else if ( key.equals(keys[i]) ) { index = i; } } return index; } public V getValue(K key) { final int index = getIndex(key); // on cherche l'index de la clef dans le tableau de clefs if ( index==-1 ) { return null; // si pas trouvé, on retourne null } else { return values[index]; // on retourne la valeur correspondant à l'index depuis le tableau de valeurs } } public boolean hasValue(K key) { return getIndex(key) != -1; } }
Citation:
Envoyé par hoturi
Bon voici ce que j'ai pondu en 2h et je suis toujours bloqué,
Code:

1 2 3 4 5 6 7 8 for(int i=0;i<rom.length();i++){ //determiner les valeurs des symboles de rom for(int k=0;k<19;k++){ /* ... */ count=count+1;} } j++; }
Je suis un peu dans le flou en faite je dois être en train de comparer des références et non des valeurs c'est pour cela que je n'arrive pas a avancer je pense.
Le problème c'est appliquer les règles que tu as énoncées dans ton précédent message sans tous les outils de Java va t'oblige à faire une usine à gaz avec plein de variables. Si c'est le but de l'exercice, il faut reprendre les règles une à une, les décomposer en règles plus simples et les transcrire, en méthode de préférence afin de ne pas avoir 36 boucles imbriquées et 50 variables, ce qui est déjà difficile à mettre au point pour quelqu'un d'aguerri, mais pour un débutant, c'est très compliqué et ça amène à écrire des trucs comme ça rom.charAt((rom.length()+i+1)-rom.length());(dans ton dernier code) qui complique encore plus (alors que rom.charAt(i+1) est déjà beaucoup plus simple, tout en faisant la même chose du point de vue fonctionnel).
En plus, ces règles sont inexactes (exception du M déjà, et puis pour un caractère de valeur supérieur suivant un autre, il faut aussi dire que 2 caractères ne peuvent se suivre que s'ils sont l'un à côté de l'autre dans la table de valeurs (ainsi XM n'existe pas, et ne vaut pas 990 !).

Pour en revenir à mon premier algorithme, simplissime, si c'est le switch qui pose problème, c'est assez facile de le convertir en méthode qui n'utilise pas de switch :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 public static int romanCharToInt(char c){ final int number; if (c=='T) { number=1; } else if (c=='X) { number=5; } ... else { throw new IllegalStateException("Caractère inconnu: " + c); } return number; }
Ou en utilisant 2 tableaux et la méthode que je t'ai indiquée au début.

L'astuce, donnée dans ma première réponse, de retirer le double de la valeur lorsque qu'un caractère de plus forte valeur suit un caractère de plus faible valeur. Elle consomme une addition de plus mais évite d'avoir un traitement différencié à chaque itération (mais une règle unique avec une exception simple) : mais on traite la même règle. Tu peux appliquer la même chose : elle est toute fois plus complexe à mettre en œuvre parce qu'on ne peut traiter un symbole que lorsqu'on connait son suivant (et que si son suivant est à prendre en compte dans une itération, il ne faut pas le prendre dans l'itération suivante), contrairement à ma méthode, qui en contrepartie va consommer une addition de plus. Mathématiquement on peut démontrer facilement que ( a - b) = ( b + a - 2b) ! En tout cas, on voit qu'on n'est pas obligé de se prendre la tête avec le découpage (et la seconde règle), sauf si on veut un contrôle de validité (à la limite, si nécessaire, on peut faire une première passe, pour vérifier que le nombre romain est conforme aux règles, ce sera toujours plus simple que de chercher à tout faire en même temps).

Enfin dans ton dernier code, tu compares les valeurs de char(if (c1<c2) {), et non pas les valeurs des chiffres romains. Les valeurs des chars (comme déjà expliqué) n'a rien à voir avec les valeurs des symboles des chiffres romains.

Salut merci de ton aide comme toujours, je reprend depuis de début car je pense être partie dans une mauvaise direction, il faut donc que je créé un tableau comme celui-ci :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 int j=1; int tot=0; int count=0; int t = 0; int som [] =new int [25] ; String [] s = {"I", "II", "III", "IV", "V", "VI", "VII", "VIII","IX", "X", "XX", "XXX", "XL", "L", "XC", "C", "CC", "CCC", "CD", "D", "CM", "M", "MM", "MMM" }; int [] nombres1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 20, 30, 40, 50, 90, 100, 200, 300, 400, 500, 900, 1000, 2000, 3000}; System.out.print("Entrez un nombre en chiffres romains : "); String rom = clavier.nextLine(); rom = rom.toUpperCase();
Je ne trouve que 24 caractères.

Ensuite je lis l'entré clavier exemple :

MMCMXLVIII pour la transformer en MM+CM+XL+VIII et la convertir en 2000+900+40+8.

Je ne comprend pas comment lire mon code par bloc a savoir que plusieurs caractères correspondent à une valeur.

Pouvez vous m'aider a commencer mon code.

Merci d'avance.

Citation:

Envoyé par hoturi

Salut merci de ton aide comme toujours, je reprend depuis de début car je pense être partie dans une mauvaise direction, il faut donc que je créé un tableau comme celui-ci :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
int j=1;
        int tot=0;
        int count=0;
        int t = 0;
 
        int som [] =new int [25] ;
        String [] s = {"I", "II", "III", "IV", "V", "VI", "VII", "VIII","IX", "X", "XX", "XXX", "XL", "L", "XC", "C", "CC", "CCC",  "CD", "D", "CM", "M", "MM", "MMM" };
 
        int [] nombres1 = {1, 2, 3, 4, 5, 6, 7, 8,  9, 10, 20, 30,  40, 50, 90, 100, 200, 300, 400, 500, 900, 1000, 2000, 3000}; 
        System.out.print("Entrez un nombre en chiffres romains : ");
        String rom = clavier.nextLine();
        rom = rom.toUpperCase();

Je ne trouve que 24 caractères.

Et 60 ? 70 ? 80 ? 110 ? 4000 ? etc... C'est le problème de cette méthode : il faut que toutes les combinaisons de base soient répertoriées.

Citation:

Envoyé par hoturi

Ensuite je lis l'entré clavier exemple :

MMCMXLVIII pour la transformer en MM+CM+XL+VIII et la convertir en 2000+900+40+8.

Je ne comprend pas comment lire mon code par bloc a savoir que plusieurs caractères correspondent à une valeur.

Ce que je t'ai déjà expliqué : utilise 2 curseurs (curseur 1 (ou gauche, ou de début), et curseur 2 (ou droite, ou à la fin). Au début, ils sont au début (0) : puis tu avances le second curseur de 1 caractère vers l'avant. La partie surlignée ci-après correspond à la chaîne située entre le curseur 1 et le curseur 2 :

Citation:

MMCMXLVIII.

Tu avances comme ça le curseur 2 jusqu'à ce que la combinaison située entre curseur 1 et curseur2 n'existe pas dans le tableau. M existe, donc on continue :

Citation:

MMCMXLVIII.

MM existe, on continue

Citation:

MMCMXLVIII.

MMC n'existe pas. On prend la combinaison trouvée à l'itération précédente, on cherche son correspondant dans la tableau de valeur, et on additionne cette valeur à la somme totale. On déplace curseur 1 en curseur 2-1. Et on recommence tant qu'il y a des caractères non traités. A la sortie de la boucle on traite ce qui reste entre curseur 1 et la fin.

Le curseur 2 est incrémenté systématiquement, donc on peut en faire l'index d'une boucle.

Après tout ce que je t'ai dit, je ne vois pas quoi ajouter hormis le code. Attention, ça te servira pas forcément de prendre le code tout fait. Il vaut mieux que tu cherches et que tu ne trouves pas, plutôt que tu ne trouves pas et que tu prennes un code tout fait sans comprendre.

Code:

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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
public class DemoRomain {
 
	public static void main(String[] args) {
 
		final String[] romanValues = new String[9*3+4];
		final int[] intRomanValues = new int[9*3+4];
 
		int p=1;
		for(int i=0;i<intRomanValues.length;i+=9) {
			for(int j=1; j<=9 && (i+j-1)<intRomanValues.length; j++) {
				intRomanValues[i+j-1]=j*p; 
				romanValues[i+j-1] = getNombreRomain(i/9,j);
			}
			p*=10;
		}
 
		// pour vérif
		System.out.println(Arrays.toString(intRomanValues));
		System.out.println(Arrays.toString(romanValues));
 
		final String s = "MMCMXLVIII";
 
		int somme = 0;
		int debut = 0;
		int oldValue = -1;
		for(int i=1; i<=s.length(); i++) { // je traite tous les caractères suivant debut
			String combiCourante = s.substring(debut, i);
			int value = getValeur(romanValues, intRomanValues, combiCourante); // je cherche la valeur correspondant à ma combinaison actuelle
			if ( value==-1 ) { // pas trouvé : la combinaison actuelle n'existe pas, on prend la précédente
				System.out.println("Combinaison trouvée: " + combiCourante.substring(0, combiCourante.length()-1));
				if ( oldValue!=-1 ) { // valeur trouvée précedemment
					somme += oldValue;
				}
				i--; // le caractère courant doit être traité à nouveau
				debut = i; // on continue de traiter à partir du caractère courant
			} 
			oldValue = value; // pour qu'à la prochaine itération oldValue soit value de l'itération d'avant
		}
		if ( oldValue!=-1 ) { // après la boucle, il faut gérer ce qu'il reste et qu'on a pas traiter...
			System.out.println("Combinaison trouvée: " + s.substring(debut, s.length()));
			somme += oldValue;
		}
		System.out.println(s +" s'affiche en arabique de telle manière : "+ somme);
 
	}
 
	private static int getValeur(String[] romanValues, int[] intRomanValues,
			String combiCourante) {
		for(int i=0; i<intRomanValues.length; i++) {
			if ( romanValues[i].equals(combiCourante) ) {
				return intRomanValues[i];
			}
		}
		return -1; // pas trouvé
	}
 
	private static String getNombreRomain(int unite, int valeur) {
		final String cun;
		final String ccinq;
		final String csup;
		if ( unite==0 ) {
			cun = "I";
			ccinq = "V";
			csup = "X";
		}
		else if ( unite==1 ) {
			cun = "X";
			ccinq = "L";
			csup = "C";
		}
		else if ( unite==2 ) {
			cun = "C";
			ccinq = "D";
			csup = "M";
		}
		else if ( unite==3 ) {
			cun = "M";
			ccinq = "";
			csup = "";
		}
		else {
			throw new IllegalStateException();
		}
 
		String s = ""; // on devrait utiliser un StringBuilder ici, mais tu ne connais probablement pas encore...
 
		if ( valeur<4 ) {
			for(int i=1; i<=valeur; i++) {
				s+=cun;
			}
		}
		else if ( valeur<5 ) {
			if ( unite==3 ) {
				for(int i=1; i<=valeur; i++) {
					s+=cun;
				}
			}
			else {
				s = cun + ccinq;
			}
		}
		else if ( valeur<6 ) {
			s = ccinq;
		}
		else if ( valeur<7 ) {
			s = ccinq + cun;
		}
		else if ( valeur<9 ) {
			s += ccinq;
			for(int i=1; i<=valeur-5; i++) {
				s+=cun;
			}
		}
		else if ( valeur<10 ) {
			s += cun + csup;
		}
		else {
			throw new IllegalStateException();
		}
		return s;
	}
 
}

C'est une façon de faire. Une autre peut consister à chercher dans toutes les combinaisons qu'on a, la plus longue qu'on trouve dans la chaîne,

Code:

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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
 
public class DemoRomain {
 
	public static void main(String[] args) {
 
		final String[] romanValues = new String[9*3+4];
		final int[] intRomanValues = new int[9*3+4];
 
		int p=1;
		for(int i=0;i<intRomanValues.length;i+=9) {
			for(int j=1; j<=9 && (i+j-1)<intRomanValues.length; j++) {
				intRomanValues[i+j-1]=j*p; 
				romanValues[i+j-1] = getNombreRomain(i/9,j);
			}
			p*=10;
		}
 
		// pour vérif
		System.out.println(Arrays.toString(intRomanValues));
		System.out.println(Arrays.toString(romanValues));
 
		final String s = "MMCMXLVIII";
 
		int somme = 0;
		int debut = 0;
		while( debut<s.length() ) {
			String combi=null;
			int value=-1;
			for(int i=0; i<romanValues.length; i++) {
				if ( s.substring(debut).startsWith(romanValues[i]) ) {
					combi = romanValues[i];
					value = intRomanValues[i];
				}
			}
			if (combi==null) {
				throw new IllegalStateException();
			}
			System.out.println("Combinaison trouvée : " + combi);
			somme += value;
			debut += combi.length();
		}
		System.out.println(s +" s'affiche en arabique de telle manière : "+ somme);
 
	}
 
	private static int getValeur(String[] romanValues, int[] intRomanValues,
			String combiCourante) {
		for(int i=0; i<intRomanValues.length; i++) {
			if ( romanValues[i].equals(combiCourante) ) {
				return intRomanValues[i];
			}
		}
		return -1; // pas trouvé
	}
 
	private static String getNombreRomain(int unite, int valeur) {
		final String cun;
		final String ccinq;
		final String csup;
		if ( unite==0 ) {
			cun = "I";
			ccinq = "V";
			csup = "X";
		}
		else if ( unite==1 ) {
			cun = "X";
			ccinq = "L";
			csup = "C";
		}
		else if ( unite==2 ) {
			cun = "C";
			ccinq = "D";
			csup = "M";
		}
		else if ( unite==3 ) {
			cun = "M";
			ccinq = "";
			csup = "";
		}
		else {
			throw new IllegalStateException();
		}
 
		String s = ""; // on devrait utiliser un StringBuilder ici, mais tu ne connais probablement pas encore...
 
		if ( valeur<4 ) {
			for(int i=1; i<=valeur; i++) {
				s+=cun;
			}
		}
		else if ( valeur<5 ) {
			if ( unite==3 ) {
				for(int i=1; i<=valeur; i++) {
					s+=cun;
				}
			}
			else {
				s = cun + ccinq;
			}
		}
		else if ( valeur<6 ) {
			s = ccinq;
		}
		else if ( valeur<7 ) {
			s = ccinq + cun;
		}
		else if ( valeur<9 ) {
			s += ccinq;
			for(int i=1; i<=valeur-5; i++) {
				s+=cun;
			}
		}
		else if ( valeur<10 ) {
			s += cun + csup;
		}
		else {
			throw new IllegalStateException();
		}
		return s;
	}
 
}

Et la méthode simple sans recherche de combinaison

Et voilà celle que j'utilise dans mon application (parce que, et oui, j'ai besoin d'afficher du chiffre romain, et de parser du chifre romain (pour des folios)) :

Mais on aurait pu faire aussi :

Merci je suis d'accord avec toi prendre le code tous fais ne sert à rien, j'ai réussi la suite de l'exercice (ce qui prouve que j'ai compris comment utiliser les tableaux), qui est de transformer les chiffres Arab en chiffres Romain. En faite j'avais bien compris t'as méthode c'est le truc avec les 2 curseurs qui me pose un PB je ne sais pas comment la mettre en oeuvre je vais travailler dessus. Je ne cherche pas a avoir a tous pris 100% sur l'exercice mais je suis frustré de ne pas comprendre la logique.

Encore merci je pense pouvoir m'en sortir.

Merci pour vos codes mais je n'arrive pas a les comprendre je ne connait pas les fonctions, "get", "return", "private static".

Je te remercie de ton aide Joel, je laisse tomber, je n'arrive pas a comprendre tes codes car il y a trop de notion que je n'ai pas encore vu (pour exemple je ne connais pas la fonction "return" ou "get"), j'ai essayé de faire fonctionner mon code mixé avec l'un des tiens mais cela ne marche pas, voila mon code final qui ne fonctionne hélas que dans un sens.

Et encore merci pour toute tes réponses.

Code:

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
import java.util.Scanner;
 
class Romain {
 
    public static void main(String[] args) {
        Scanner clavier = new Scanner(System.in);
        int[] nombres = {1000, 500, 100, 50, 10, 5, 1 };
        String symboles = "MDCLXVI";
 
        /*******************************************
         * ComplÃ©tez le programme Ã* partir d'ici.
         *******************************************/
        int t = 0;
        int j=1;
        int tot=0;
        int count=0;
        int som [] =new int [20] ;
        String [] s = {"M","D","C","L","X","V","I" };
 
        System.out.println("Entrez un nombre en chiffres romains : ");
        String rom = clavier.nextLine();
        rom = rom.toUpperCase();
 
 
        //***************************************************************************** 
        for(int i=0;i<rom.length();i++){ //determiner les valeurs des symboles de rom
        	for(int k=0;k<7;k++){
        	if(rom.substring(i,j).equals(s[k])){//pour tester tableau rom par rapport au s
        	// som [k] =nombres[k];
        	tot=tot+nombres[k];
        	count=count+1;} } 
        	j++; }
        //********************* AFFICHAFE DES CALCULES ***************
        if(count==rom.length()){
        // for(int i=0;i<som.length;i++){tot=tot+som[i];}
        System.out.println("arabes("+rom+") = "+tot);} 
        else{
        System.out.println("Conversion impossible, nombre romain mal formé."); }
        //**********************************************************
 
        int arb;
        int c=1000;
        int rest=0;
 
        final int MAX = 3999;
 
        int nr[]=new int [4];
        do { 
        System.out.print("Entrez un nombre (en chiffres arabes) compris entre 1 et " + MAX + " : ");
        arb = clavier.nextInt();//a suivre
 
        }while(arb<=1 || arb>MAX);
        System.out.print("romains("+arb+") = ");
 
        for(int i=0;i<4;i++){ // Avance sur la ligne et rempli le tableau 
        nr[i]=arb/c; 
        rest=(nr[i]*c);
        arb=arb-rest;
        c=c/10;
        }
 
        for(int i=0;i<nr[0];i++){System.out.print("M");} // MILLE
        if(nr[1]==9){System.out.print("CM");} 
        else if(nr[1]==1){System.out.print("C");} 
        else if(nr[1]>5 ) {System.out.print("D");
 
        for(int i=1;i<=nr[1]-5;i++){System.out.print("C");}}//CENTAINE
        else if(nr[1]==5){System.out.print("D"); }
        else if(nr[1]<5 && nr[1]>0){
        if(nr[1]==4){System.out.print("CD"); }
        else
 
        for(int i=0;i<nr[1];i++){System.out.print("C");}} //DIZAINE
        if(nr[2]==9){System.out.print("XC");} 
        else if(nr[2]==1){System.out.print("X");}
        else if(nr[2]>5 ) {System.out.print("L");
        for(int i=1;i<=nr[2]-5;i++){System.out.print("X");}}
        else if(nr[2]==5){System.out.print("L"); }
        else if(nr[2]<5 && nr[2]>0){if(nr[2]==4){System.out.print("XL"); }
        else
 
 
        for(int i=0;i<nr[2];i++){System.out.print("X");}} // UNITE
        if(rest==9){System.out.print("IX");}
        else if((rest>5) ) {System.out.print("V"); 
        for(int i=1;i<=rest-5;i++){System.out.print("I");} }
        else if(rest==5){System.out.print("V"); }
        else if(rest==4){System.out.print("IV"); }
        else if(rest<5&& rest>0)
 
        {for(int i=0;i<rest;i++){System.out.print("I");}} 
 
        System.out.println("");
 
 
        /*******************************************
         * Ne rien modifier aprÃ¨s cette ligne.
         *******************************************/
    }
}

Citation:

Envoyé par hoturi

Merci pour vos codes mais je n'arrive pas a les comprendre je ne connait pas les fonctions, "get", "return", "private static".

Tu n'as donc pas encore vu les méthodes (return c'est pour retourner le résultat au code appelant une méthode). get n'est pas une "fonction" (il n'y a pas de fonctions en Java), d'ailleurs il n'y a pas de get dans mon code. Et private static c'est pour déclarer une variable, privée et statique... Il y a des limites quand même : je ne vois pas l'intérêt de faire des exercices d'une certaine complexité si c'est pour utiliser 3% du langage 8O Il y a des exercices plus simples qui permettent de travailler les boucles et les extractions de chaine :roll:

Les méthodes ce sont des sous-programmes : on les définit avec un nom, des paramètres, et, éventuellement une valeur en retour :
Code:

1 2 3 4 5 6 7 "type de retour" "nom de la méthode"( liste des paramètres) { le code qu'on veut faire return "le résultat" }
Et pour l'utiliser, on utilise son nom, et on passe les paramètres demandés :

Code:

resultat = "nom de la méthode"( liste des valeurs des paramètres );

mais tu peux aussi mettre directement le code appelé à la place de la méthode (l'avantage des sous-programme, est d'une part de découper le code en petites parties plus aisées à mettre au point (et à comprendre), et aussi d'éviter de dupliquer du code lorsqu'on a besoin de faire plusieurs fois la même chose. En programmation objet, on appelle ça des méthodes : les sous-programmes sont associés soit à une classe, soit à une instance de classe, ce qui permet d'associer l'objet et ce qu'il doit ou sait faire, donc d'organiser son programme en entités (objets) isolés ayant chacun leur rôle).

Quand j'écris :
Code:

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 /* ... */ for(int i=1; i<=s.length(); i++) { // je traite tous les caractères suivant debut String combiCourante = s.substring(debut, i); int value = getValeur(romanValues, intRomanValues, combiCourante); // je cherche la valeur correspondant à ma combinaison actuelle if ( value==-1 ) { // pas trouvé : la combinaison actuelle n'existe pas, on prend la précédente System.out.println("Combinaison trouvée: " + combiCourante.substring(0, combiCourante.length()-1)); if ( oldValue!=-1 ) { // valeur trouvée précedemment somme += oldValue; } i--; // le caractère courant doit être traité à nouveau debut = i; // on continue de traiter à partir du caractère courant } oldValue = value; // pour qu'à la prochaine itération oldValue soit value de l'itération d'avant } if ( oldValue!=-1 ) { // après la boucle, il faut gérer ce qu'il reste et qu'on a pas traiter... System.out.println("Combinaison trouvée: " + s.substring(debut, s.length())); somme += oldValue; } System.out.println(s +" s'affiche en arabique de telle manière : "+ somme); } private static int getValeur(String[] romanValues, int[] intRomanValues, String combiCourante) { for(int i=0; i<intRomanValues.length; i++) { if ( romanValues[i].equals(combiCourante) ) { return intRomanValues[i]; } } return -1; // pas trouvé }
Tu peux écrire à la place :
Code:

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 /* ... */ for(int i=1; i<=s.length(); i++) { // je traite tous les caractères suivant debut String combiCourante = s.substring(debut, i); int value=-1; for(int i=0; value==-1 && i<intRomanValues.length; i++) { if ( romanValues[i].equals(combiCourante) ) { value = intRomanValues[i]; } } if ( value==-1 ) { // pas trouvé : la combinaison actuelle n'existe pas, on prend la précédente System.out.println("Combinaison trouvée: " + combiCourante.substring(0, combiCourante.length()-1)); if ( oldValue!=-1 ) { // valeur trouvée précedemment somme += oldValue; } i--; // le caractère courant doit être traité à nouveau debut = i; // on continue de traiter à partir du caractère courant } oldValue = value; // pour qu'à la prochaine itération oldValue soit value de l'itération d'avant } if ( oldValue!=-1 ) { // après la boucle, il faut gérer ce qu'il reste et qu'on a pas traiter... System.out.println("Combinaison trouvée: " + s.substring(debut, s.length())); somme += oldValue; } System.out.println(s +" s'affiche en arabique de telle manière : "+ somme); }
D'autre part, les exemples de code étaient des exemples de code (!) pour illustrer les différents algorithmes que je t'ai déjà donnés. Si tu ne comprends ni les descriptions ni les exemples de code, je ne vois pas comment faire.

Salut Joel on vient de me faire suivre la solution de mon problème, je n'étais absolument pas sur la bonne voie.

Code:

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
int j=1,tot=0,tot1=0,total=0,count=0,total1=0;
String [] s = {"M","D","C","L","X","V","I" };
System.out.print("Entrez un nombre en chiffres romains : ");
String rom = clavier.nextLine();
rom= rom.toUpperCase();
String a[] = new String[rom.length()+1];
int b[] = new int[rom.length()+2];
int som [] =new int [rom.length()+2] ;
for(int i=0;i<rom.length();i++){
a[i]=(rom.substring(i,j));
j++; } 
//***************************************************************************** 
 
for(int i=0;i<rom.length();i++){ 
for(int k=0;k<7;k++){
if(a[i].equals(s[k])){
tot=tot+nombres[k];
b[i]=tot;
count=count+1;} }
j++;i++;
if(i<rom.length()){
for(int k=0;k<7;k++){
if(a[i].equals(s[k])){
tot1=tot1+nombres[k];
b[i]=tot1;
count=count+1;}}}
j++;
tot=0;tot1=0;} 
tot=0;tot1=0; 
for(int i=0;i<rom.length();i=i+1){
if(b[i]>=b[i+1]){
tot1=tot1+b[i];
}
else{
tot=tot+b[i];
}
total1=total1+tot1-tot;
tot=0;tot1=0;}
//********************* AFFICHAFE DES CALCULES ************************************************************************
if(count==rom.length()){
System.out.println("arabes("+rom+") = "+total1);} 
else{
System.out.println("Conversion impossible, nombre romain mal formé."); }