Discussion :

[num_a]

bonjour. J'ai deja posé quelques questions dans ce forum, pour avoir a chaque fois des réponses qui m'ont aidé, merci bcp!

une question complémentaire:

J'aimerais savoir comment on pourrait écrire l'algorithme permettant de vérifier si l'expression arithmétique choisie par un joueur (durant le jeu, celui ci a collecté au hasard des opérateurs et des opérandes) est correcte.

les opérandes sont des chiffres, les opérateurs (mettons + * -) sont de priorité diverses (définie par une fonction de classe du type class function TC_Plus.Priority: Integer;
begin
Result := 3 ; )

merci d'avance;

E.B

[Gilbert Geyer]

num_a a écrit :
J'aimerais savoir comment on pourrait écrire l'algorithme permettant de vérifier si l'expression arithmétique choisie par un joueur (durant le jeu, celui ci a collecté au hasard des opérateurs et des opérandes) est correcte

Il manque les règles du jeu dans l'énoncé de ton problème! :
- l'expression arithmétique choisie : sur quels critères est-elle déclarée correcte/incorrecte ???

Si par exemple '45698 - 111 + 22*3' est correct parcequ'il y a un seul opérateur '*' l'algo sera différent de celui où tu considères que c'est la présence du sous-résultat 66 que ton jeu considère comme correct ... car on peut imaginer toutes sortes de règles de jeu.

[num_a]

en fait, le joueur va donc ramasser des symboles placés de façon aléatoire et parmi ces symboles il y a également des = (en plus des nombres et operateurs)
J'avais oublié cette précison

5+5 -10*1 = 0 sera juste par exemple (le joueur a ramassé respectivement 5 + 5 - 10 * 1 = 0)
5+5-10*1 = 1 sera fausse

il s'agit d'une expression "entière", et on doit vérifier si cette expression est correcte ou non

[Gilbert Geyer]

Il faudrait par exmple que ce que le le jouer "ramasse" il les place dans une série de TEdit placés côte à côte par exemple des blancs pour y mettre les nombres et des bleus pour les opérateurs cela simplifiera la suite.

1) Tu ajoutes au début de la zone implementation
Var N1,N2,N3,N4 : integer; pour les nombres
et op1,op2,op3 : char; pour les opérateurs

2) Dans les procédures TForm1.Edit1Change(Sender..)
tu utilises une instruction du style Val(Edit1.text,N1,code); et tu en pour récupérer la valeur integer N1 de Edit1 dont tu retiens la valeur absolue avec N1:=abs(N1); puis tu fais pareil pour les TEdit réservés aux nombres. (pour Val voir l'aide de Delphi avec F1 ou avec click-souris-droite ... puis rechercher une rubrique)

3) Pour capter les opérateurs tu fais des procédures TForm1.Edit2Change(Sender..) dans lesquelles tu fais if length(Edit2.text)=1 then op1:=Edit1.text[1]; et pareil avec les autres TEdit réservés aux opérateurs.

4) Arrivé à ce stade on a la valeur numérique des nombres et la valeur des opérateurs choisis

5) A côté du dernier Edit tu places un label qui affiche le signe "=" et un bouton1 affichant "J'ai gagné ?" et lorsqu'il appuye dessus ce qui est marqué sur ce bouton est remplacé par "Oui" ou "Non" ou autre chose selon le résultat de l'opération.

5) Reste plus qu'à faire la routine qui doit vérifier si l'opération arithmétique du type '5+5 -10*1' est juste ou fausse :

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
procedure Form1.Button1Click(Sender..)
var n1n2 : integer; // < pour le résultat de l'op sur les deux premiers
     n3n4 : integer; // < pour le résultat de l'op sur les deux derniers
     resul : integer; // < pour le résultat final
begin n1n2 := 0;
         // Pour les 2 premiers nombres :
         case op1 of
               '+' : n1n2 := N1 + N2;
               '-' : n1n2 := N1 - N2;
               '*' : n1n2 := N1 * N2;
        end;
        // Pour les 2 premiers nombres :
        n3n4 := 0;
        case op3 of
               '+' : n3n4 := N3 + N4;
               '-' : n3n4 := N3 - N4;
               '*' : n3n4 := N3 * N4;
        end;
       // Et pour les 4 nombres : opérateur du milieu
        resul := 0;
        case op2 of
               '+' : resul := n1n2 + n3n4;
               '-' : resul := n1n2 - n3n4; 
               '*' : resul := n1n2 * n3n4;
        end;
        if Resul=0 then Button1.caption := 'Tu as gagné'
                      else  Button1.caption := 'Tu as perdu';
end;

[num_a]

merci de ta réponse! c'est sympa

je vais voir

[num_a]

dsl de revenir si longtemps après.

dans le cas d'une opération 5+1*2-2 par exemple (dont le résultat est 5), comment pourrait on écrire l'algorithme comme celui ci dessus, en incluant la priorité des opérateurs (* prioritaire sur le +...), et non en calculant l'expression terme par terme.

(la priorité des opérateurs est deja défnie :

exemple: class function TC_Plus.Priority: Integer;
begin
Result := 3 (2 pour opérateur *)

function TC_operateur.estprioritaire(autreoperateur :TC_operateur): boolean;
begin
result := self.classname.priority < autreoperateur.classname.priority

@+
manu


l

[sjrd]

J'ai déjà répondu ça une fois sur un autre thread. Le truc, c'est de prendre tout le calcul, de rechercher le premier opérateur de plus faible priorité (donc +), de découper la chaîne autour de cet opérateur. Puis de calculer récursivement la partie gauche et la partie droite, et finalement d'additionner (ou toute autre opération) les deux résultats.

[Ludo_360]

L'algorythme polonais inversé:
tu examine une equation en entrée: (opérateurs et opérandes sont des tokens)

Tant qu'il y a des tokens en entrée {

1. Examiner le token courant sur le fichier d'entrée
2. Si c'est un opérande, le placer sur le fichier de sortie
3. Si c'est une parenthèse ouvrante, la mettre sur la pile
4. Si c'est un opérateur, alors
5.
1. Si la pile est vide, pousser l'opérateur sur la pile
2. Si le sommet de la pile est une parenthèse ouvrante, pousser l'opérateur sur la pile
3. Si l'opérateur est prioritaire sur celui au sommet de la pile, pousser l'opérateur sur la pile
4. Sinon, enlever l'opérateur de la pile et le mettre sur le fichier de sortie. Replacer ensuite l'opérateur courant sur la pile
6. Si c'est une parenthèse fermante, enlever les opérateurs de la pile et les placer sur le fichier de sortie jusqu'à ce que l'on rencontre la parenthèse ouvrante, que l'on élimine.

}

Enlever tous les opérateurs restants et les placer sur le fichier de sortie.


tu peux essayer cet exemple voir si tu as bie ntout saisi:

http://www.crlf.be/rpn01.html

voila a +


ps: C'est avec cet algorythme que j'avais utilisé un listbox d'ailleurs, sjrd...

ludo