Discussion :

[zilis]

Bonjour,

j'ai UNE chaîne de caractère contient des chiffres codée sous un format littéraire
je veux convertir la chaîne caractère a son équivalant en format numérique
exemple
Input:

undeuxquatre;unzerodeuxquatre;deuxdeuxsix;undeuxhuit;deuxcinqsix

Output:

undeuxquatre,124
unzerodeuxquatre,1024
deuxdeuxsix,226
undeuxhuit,128
deuxcinqsix,256

merci de m'avoire aider

[wax78]

je veux couverture la chaîne caractère

Couverture la chaine, bon ca -> convertir j'imagine

Mis a part cette mauvaise blague:

Il te faudrait un tableau avec tout les string ("un", "deux", "trois", ...)

et faire une boucle sur la chaine a étudier avec un index que tu avancerais dés que le morceau que tu test startWith() un des elements du tableau et ainsi de suite...

Bref un truc du genre ceci, mais c'est encore te mâcher le travail...

Code :

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

1
2
3
4
5
6
7
8
9
10
11
String vars [] = {"un","deux","trois"};
		String sentence = "untroisdeuxununun";
		for (int i = 0; i < sentence.length(); i++) {
			for (int j = 0; j < vars.length; j++) {
				if (sentence.substring(i).startsWith(vars[j])==true)
				{
					System.err.println("-->"+vars[j]);
					i+=vars[j].length()-1;
				}
			}
		}

[Mathieu.J]

Ou plus simple :

Code :

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

s = s.replaceAll("un","1");

Et ainsi de suite pour chaque chiffre.

[wax78]

Bien vu Mathieu, maintenant il faudrait comparer la vitesse d'exécution des 2 codes sur divers cas histoire de choisir le plus rapide

[Deadpool]

Ou plus simple :

Code :

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

s = s.replaceAll("un","1");

Et ainsi de suite pour chaque chiffre.

Dans ce cas, et vu que les expressions régulières ne sont pas utilisées, il faut mieux privilégier la méthode replace(java.lang.CharSequence, java.lang.CharSequence) plutôt que replaceAll.

Elle est sensiblement plus rapide vu qu'il n'y a pas d'expression régulière à compiler.

Code :

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

1
2
 
s = s.replace("un","1");

[Mathieu.J]

J'avais toujours pensé que replace ne changeait que le premier rencontré...

Bien vu

[wax78]

Le replaceAll ou le replace est ultra lent entres nous ...

Mais peut etre mon exemple n'est pas le meilleur (oui ce benchmark est un peu simpliste en utilisant qu'une seul phrase d'entrée) mais voici un mini benchmark ma méthode vs replace

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
 
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
 
/**
 * @author user
 *
 */
public class Snippet
{
 
	String sentence = "untroisdeuxunununquatreneuftroisdeuxununcinquncinqquatre";
 
	public static void main(String args[]) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException
	{
 
 
		new Snippet();
 
	}
 
	public Snippet() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException
	{
 
		bench_(Snippet.class.getMethod("method_1", String.class));
		bench_(Snippet.class.getMethod("method_2", String.class));
		bench_(Snippet.class.getMethod("method_1", String.class));
		bench_(Snippet.class.getMethod("method_2", String.class));
		bench_(Snippet.class.getMethod("method_2", String.class));
		bench_(Snippet.class.getMethod("method_1", String.class));
	}
 
	/**
         * @param method
         * @throws InvocationTargetException 
         * @throws IllegalArgumentException 
         * @throws IllegalAccessException 
         */
	private void bench_(Method method) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException
	{
		long start = System.currentTimeMillis();
		for (int i = 0; i < 50000; i++)
		{
			String retour = (String) method.invoke(this, sentence);
			//System.err.println("Retour = "+retour.toString());
		}
 
		long stop = System.currentTimeMillis();
		long elapsed = stop-start;
		System.err.println("Elapsed for method "+method.getName()+ " : "+elapsed+ " ms");
 
	}
 
	public String method_1(String sentence)
	{
		String vars [] = {"un","deux","trois","quatre", "cinq", "six", "sept", "huit", "neuf"};
		String vars2 [] = {"1","2","3","4", "5", "6", "7", "8", "9"};
 
		String finalSent = "";
 
		for (int i = 0; i < sentence.length(); i++) {
			for (int j = 0; j < vars.length; j++) {
				if (sentence.substring(i).startsWith(vars[j])==true)
				{
					//System.err.println("-->"+vars[j]);
					finalSent+=vars2[j]+";";
					i+=vars[j].length()-1;
				}
			}
		}
		return finalSent;
	}
 
	public String method_2(String sentence)
	{
		String vars1 [] = {"un","deux","trois","quatre", "cinq", "six", "sept", "huit", "neuf"};
		String vars2 [] = {"1","2","3","4", "5", "6", "7", "8", "9"};
 
		for (int i = 0; i < vars2.length; i++)
		{
			sentence=sentence.replace(vars1[i], vars2[i]);
		}
		return sentence;
	}
}

Je pense même qu'en réécrivant un algorithme maison ca ira encore plus vite que mon code initial.

[Mathieu.J]

De toute facon, la question d'origine ressemble plus à un exercice d'algorithmie qu'à un souci dans un batch haute performance. Donc l'ensemble des solutions proposées devraient convenir.

[wax78]

Exercice ou pas, peu importe, même si toutes fonctionnent, il faut prendre celle qui va consommer le moins de temps (et donc d'énergie a priori) non ?

[andry.aime]

Exercice ou pas, peu importe, même si toutes fonctionnent, il faut prendre celle qui va consommer le moins de temps (et donc d'énergie a priori) non ?

@wax78: as-tu oublié la bonne façon de faire les choses (ou de bien commenter les codes) sans beaucoup de risque à prendre

// Touches pas, ça marche...

[wax78]

Ha je ne sais pas c'est possible... mais entres nous 10 lignes de code d'exemple ainsi, ca ne nécessite pas de commentaires (mais je n'ai peut être pas compris ce que tu voulais dire

[tchize_]

Exercice ou pas, peu importe, même si toutes fonctionnent, il faut prendre celle qui va consommer le moins de temps (et donc d'énergie a priori) non ?

Du tout, il faut prendre ce qui est lisible, facilement maintenable facilement et dont l'exactitude est facilement démontrable.

Ta méthode 2 est bien plus lisble que la 1 pour celui qui doit maintenir le code. L'optimisation hâtive est mère de bien des soucis et un benchmark doit être réalisé dans des conditions réelles et non pas dans des conditions théoriques comme tu le fait.

1 on code
2 on remarque éventuellement un manque de performance (genre "j'aimerais bien que ça prenne 20 minutes plutot que 1 heure)
3 on fait un profiling pour déterminer les points chaud
4 on optimise ces points chauds.

Sinon on se retrouve à faire une soupe qui ne nous aura fait gagner 0.5% de temps d'exécution.

Attention, je n'ai pas dit non plus qu'il fallait y aller comme un porcs, les bonne pratiques genre utilisation des iterateur plutot que des get(i) des stringbuilder etc qu'on peux appliquer sans effort, risque, ou perte de lisibilité sont toujours à recommander

[wax78]

Tu n'as pas tort tes conseils sont justes, mais ma soupe, avec cet exemple théorique foireux, le gain est de l'ordre de 50% du temps, pas 0.5% et je ne trouve pas ca plus illisible que l'autre code, mais ca ca reste mon avis (mais 700 ms contre 350 ms)

Mais comme tu l'as dit, c'est un exemple de benchmark théorique ultra foireux qui nécessitera un peu d'amélioration ...

[Mathieu.J]

Désolé de pourrir le topic d'origine, après j'arrête.
50% de pas grand chose, ça reste toujours pas grand chose
On parle quand même de 350 ou 700 ms pour 50 000 exécutions alors que son besoin concerne 1 chaîne de caractères.


En espérant que zilis ait trouvé une réponse qui convienne à SON problème.

[wax78]

Oui après tout on peut tourner les choses comme l'on veux ... j'arrête la...

[tchize_]

Tu n'as pas tort tes conseils sont justes, mais ma soupe, avec cet exemple théorique foireux, le gain est de l'ordre de 50% du temps, pas 0.5%

50% de gain de vitesse sur quelque chose qui a toutes les chance d'occuper grand maximum 1% du temps de travail de l'application de l'utilisateur, ca donne bien 0.5%

[zilis]

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
public static void main(String[] args) {
String[] letter = { "zero", "un", "deux", "troi", "quatre", "cinq", "six", "sept", "huit", "neuf" };
String maChaine = "unzerodeuxquatre";
String numberString = "";
int number;
while (!maChaine.equals("")) {
for (int i = 0; i <11; i++) {
if (maChaine.startsWith(letter[i])) {
numberString = numberString + i;
maChaine = maChaine.replaceFirst(letter[i], "");
break;
}
}
}
number = new Integer(numberString);
System.out.println(number);
}
}