Discussion :

[Dranna]

Bonjour !

Alors voila, je débute en Java et je n'ai pas trop d'expérience donc avec les diverses mécaniques.

Dans le cadre d'un projet, je suis amené à faire une sorte de calculatrice en ligne de commandes avec un fichier intrant et trois sortants. L'intrant prend un calcul sous forme complètement parenthésée.
Les sortants doivent produire l'évaluation, la forme polonaise et la forme polonaise inversée de ce calcul.

Pour la notation polonaise inversée, pas de soucis, avec une pile c'est passé tout seul.

Mais là je suis à l'évaluation du calcul. J'ai produit ce code (qui, je m'en aperçois, pourra être grandement simplifié et je m'y attellerai si ce code peut être productif)

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
public String eval(String s) {
		StringBuffer eval = new StringBuffer();
		eval = getReversePolish(s);
		StringBuffer tempEval = new StringBuffer();
		tempEval = eval;
		int temp=0;
		double temp2=0;
		for(int k = 0; k<tempEval.length();k++){
			if(tempEval.charAt(k)=='+'){
				temp = Integer.parseInt(Character.toString(tempEval.charAt(k-4)))+Integer.parseInt(Character.toString(tempEval.charAt(k-2)));
				tempEval.replace(k-4, k+1, Integer.toString(temp));
				temp=0;
				k=0;				
			}
 
		}
		return eval.toString();
 
    }

Et ainsi de suite, je n'ai pas tout mis puisqu'après c'est pratiquement du c/c.

Donc le code fait appel à une autre méthode (fonctionnelle) "getReversePolish()" qui va renvoyer la notation polonaise inversée. Par exemple ( 1 + 1 + 1 ) sur appel devient 1 1 + 1 + (espaces importants).
Et je compte en fait agir sur la NPI plutôt que sur le calcul initial, cela me semble plus facile.
Le problème est que j'utilise un StringBuffer et que, chose que j'ai découvert à mon grand désarroi, il prend les nombres comme deux chiffres ! 10 n'est pas value=10 mais value1=1 et value2=0.

Donc le code fonctionne bien pour des opérations sur des chiffres, mais pas sur les nombres ! (19 + 1 ) donne 110 saperlotte !

Ainsi je me tourne vers vous pour savoir s'il y a moyen de convertir ce StringBuffer en quelque chose d'utilisable, ou bien si je me suis complètement fourvoyé en voulant partir de ce côté là.

Bien à vous,
Dranna

[thelvin]

StringBuffer n'est pas très utile, mais String tout court sera très bien. Puisque tous tes éléments sont séparés par des espaces, tu as qu'à faire un split() sur espace, et donc tu auras séparés tous tes éléments les uns des autres.

Le problème est que j'utilise un StringBuffer et que, chose que j'ai découvert à mon grand désarroi, il prend les nombres comme deux chiffres ! 10 n'est pas value=10 mais value1=1 et value2=0.

Euh... Toi aussi tu fais ça. Quand tu veux prendre le nombre 10 tu écris pas un symbole bizarre qui représente la dizaine. Tu écris d'abord 1 et ensuite 0. C'est un peu le principe d'écrire. C'est toute la différence entre les String, qui représentent du texte écrit, et les int, qui représentent les nombres eux-mêmes.
Pour transformer un nombre écrit dans une String, en un int, bah tu le sais déjà... C'est Integer.parseInt().

[Dranna]

Aaah, effectivement ça je n'y avais pas pensé, mais l'ennui c'est qu'avec un tableau, à ma connaissance on ne peut pas retirer des valeurs, on peut juste les remplacer.

Du coup je ne peux plus utiliser de remove ou replace pour remplacer plusieurs lignes par la réponse. Alors ça va fonctionner pour des petits calculs, mais pas pour les gros.

Faut-il qu'à chaque fois un nouveau tableau soit créée avec les nouvelles valeurs ? C'est ce qui me vient en tête mais j'ai l'impression que c'est assez barbare

[thelvin]

Je pense que tu t'embrouilles tout seul.

Avant de te dire "ça marchera quand ça mais pas quand ça," tu devrais déjà essayer d'abord. Commence par nous montrer (et plus important, te montrer à toi-même) à quoi ça ressemble pour les petits calculs. Il sera toujours temps de voir ce que ça change avec les gros calculs, et si oui, que peut-on faire pour l'éviter.

[Dranna]

Ah mais le code montre ci-avant fonctionne très bien, mais sans les passages à la dizaine.

( 1 + 1 + 1 ) fonctionne à merveille et rend 3
( 19 + 1 ) ne fonctionne pas et rend 110 (à cause donc du stringbuffer qu'il va falloir transformer en un tableau, la seule question qui me restait à ce sujet étant de comment supprimer une entrée dans un tableau, chose apparemment impossible donc je pars sur la création d'un nouveau tableau à chaque résolution "partielle")

Mais je viens de trouver que javax.script contenait Engine et EngineManager avec dedans eval() qui donne le même résultat que ma méthode (sauf que eval() arrive à prendre en compte les nombres également). Je vais aller voir son fonctionnement, ça sera sans doute très utile.

[thelvin]

( 19 + 1 ) ne fonctionne pas et rend 110 (à cause donc du stringbuffer qu'il va falloir transformer en un tableau, la seule question qui me restait à ce sujet étant de comment supprimer une entrée dans un tableau, chose apparemment impossible donc je pars sur la création d'un nouveau tableau à chaque résolution "partielle")

Hem... Juste... Essaie. Ne te dis pas "ça va faire ça si jamais je le fais." Fais-le, à la place. Tu verras bien si ça fait ci ou ça.

Mais je viens de trouver que javax.script contenait Engine et EngineManager avec dedans eval() qui donne le même résultat que ma méthode (sauf que eval() arrive à prendre en compte les nombres également). Je vais aller voir son fonctionnement, ça sera sans doute très utile.

Euh, oui, forcément, un moteur d'évaluation d'expressions, est beaucoup plus facile à faire si tu as le droit d'utiliser un moteur d'évaluation de script avec expressions. Je pensais que l'idée c'était que tu le fasses toi-même.

[Dranna]

Mais le code est fait et donne ces réponses, je ne les invente pas.

Pour venir ici, j'ai d'abord codé ce que je vous ai montré en premier topic (je n'ai mis que l'addition pour éviter une redondance inutile). Et il est fonctionnel pour les chiffres, pas pour les nombres, ce n'est pas une déduction, juste une observation.

Et oui j'essaye de le coder tout seul, j'ai juste été regarder pour cette source.

Là, je suis bloqué au fait de passer des chiffres aux nombres.

[thelvin]

Ce que j'ai dit : String split() et Integer.parseInt(). Ça en est où ?

[Dranna]

ça fonctionne pour des calculs simples comme :

( 1 + 1 )

Mais quand on arrive à

( 1 + 1 + 1 )

Je n'arrive pas à trouver comment faire pour que le calcul soit réellement fait.

Sur le StringBuffer en fait le "replace" était utile dans le sens où il écrasait directement les valeurs pour ne laisser que la réponse.

Là avec le String, aucun moyen de supprimer une ligne de la liste. Je suis parti actuellement sur une idée de refaire un nouveau tableau à chaque fois qu'une partie du calcul est résolue, mais ça me semble barbare et pas très clair comme méthode.

[thelvin]

D'accord, alors voyons les choses autrement :

À quoi ça sert de remplacer, refaire, etc ?
Ne peux-tu pas te rappeler où tu en es au juste de la lecture du tableau, et quel est le résultat actuel du calcul ?

Je vois que tu fais une boucle qui va de 0 à machin.length(). Quel intérêt de repartir à zéro ? Il suffit de laisser k grandir de 0 à la taille du truc. Aucun besoin de remplacer quoi que ce soit par quoi que ce soit.

[Dranna]

Mh, mais alors la difficulté se déplacera à savoir où est la réponse attendue, et le problème est que le programme va prendre les deux nombres précédant un opérateur, si cet opérateur est devant, comment lui dire de revenir en arrière et surtout comment savoir de combien ?

Je suis au final parti sur l'idée de base de "refaire" un tableau neuf à chaque fois qu'une opération se clôture.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public String[] redef(String[] s){
		String[] newString = new String[s.length-2];
		int counter = 0;
		for(int k = 0; k<s.length;k++){
			if(s[k]==null){
 
			}
			else {
			newString[counter]=s[k];
			counter++;
			}
		}
		return newString;
	}

où le tableau retourné est chaque fois d'une taille originelle-2

Le -2 étant justifié par le fait que pour un calcul on a obligatoirement un opérateur et deux nombres/chiffres, il ne restera qu'un nombre/chiffre.

Là je suis en train de tester pour beaucoup de situations (uniquement en addition pour le moment) pour vérifier que ça fonctionne dans tous les cas, je n'ai pas encore trouvé d'erreurs et vais tenter l'implémentation des autres opérateurs à présent.

Pensez-vous que ce soit une bonne solution ou dois-je tenter l'implémentation avec le compteur à mémoire ?

[thelvin]

Mh, mais alors la difficulté se déplacera à savoir où est la réponse attendue,

Dans une variable ? Ou dans un return, si tu le fais en récursif ?

et le problème est que le programme va prendre les deux nombres précédant un opérateur, si cet opérateur est devant, comment lui dire de revenir en arrière et surtout comment savoir de combien ?

Le principe de la chose est bien entendu d'avoir un prétraitement pour qu'il n'y ait jamais aucun doute sur la position de l'opérateur. Passer par ta transformation en NPI n'était pas bête, par exemple.

Mais tu peux aussi créer une structure complexe qui représente le calcul à évaluer avec des classes crées pour, comme un OperateurPlus et un NombreLitteral qui implementeraient Expression tous les deux. NombreLitteral contiendrait juste un int, mais OperateurPlus contiendrait deux Expression, son opérande à gauche et son opérande à droite. Ce genre de choses est inévitable dès que la NPI commence à utiliser des parenthèses.

Pensez-vous que ce soit une bonne solution ou dois-je tenter l'implémentation avec le compteur à mémoire ?

Disons que c'est beaucoup s'embêter, pour pas de raison. L'intérêt de faire les choses plus simplement, c'est qu'on a moins de chances de se tromper. Il vaut mieux un compteur.