Discussion :

[sukoi]

Bonjour,

Comment écrire un code qui permet de trouver l'opération de base à effectuer:
cas 1) 1 ? 2 = 3 :- ? = addition 1+2=3
cas 2) 1 ? 2 ? 2= 1 :- ?? = addition et soustraction 1+2-2=1
?? = soustraction et addition 1-2+2=1

sur 4 opérations, la priorité est la division puis le multiplication,
(pas de parenthèse).

en faisant simple pour le cas 1

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
sol(A,B,R,addition):-
	A+B=:=R,
	format('la solution est : ~d+~d=~d~n',[A,B,R]).
sol(A,B,R,soustraction):-
	A-B=:=R,
	format('la solution est : ~d-~d=~d~n',[A,B,R]).
sol(A,B,R,multiplication):-
	A*B=:=R,
	format('la solution est : ~d*~d=~d~n',[A,B,R]).
sol(A,B,R,division):-
	A/B=:=R,
	format('la solution est : ~d/~d=~d~n',[A,B,R]).

pour le cas 2 soit 16 prédicats ....
mais pour 4 opérations cela 4*4*4*4= 128 prédicat

Comment faire plus simple :
- graphe, générer aléatoirement les 4 opérations
+++

[Trap D]

Tu veux faire un genre de compte est bon ?

[sukoi]

Oui, mais le total est toujours bon.
en reprenant le code pour 2 opérations:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
?- sol(10,2,2,10,Result).
la solution est : 10+2-2=10
Result = 'addition et soustraction' ;
la solution est : 10-2+2=10
Result = 'soustraction et addition' ;
la solution est : 10*2/2=10
Result = 'mutiplication et division' ;
la solution est : 10/2*2=10
Result = 'division et multiplication'.

si pas les bon nombres, alors le resultat est FALSE.

Code :

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

1
2
3
 
?- sol(10,4,2,10,Result).
false.

[Trap D]

Tu peux t'inspirer de ce code qui te donne une idée de ce qu'on peut faire :

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
sol(L_nombres, Resultat, L_op) :-
	genere(L_nombres, L_op, Expr),
	Resultat =:= Expr.
 
 
genere([A | B], L_op, Expr) :-
	genere(B, [], L_op, A, Expr).
 
 
genere([], L_op, L_opf, Expr, Expr) :-
	reverse(L_op, L_opf).
 
 
genere([A | T], L_op, L_opf, Exp, Expr) :-
	genere(T, [+ | L_op], L_opf, Exp + A, Expr).
 
genere([A | T], L_op, L_opf, Exp, Expr) :-
	genere(T, [- | L_op], L_opf, Exp - A, Expr).
 
genere([A | T], L_op, L_opf, Exp, Expr) :-
	genere(T, [* | L_op], L_opf, Exp * A, Expr).
 
genere([A | T], L_op, L_opf, Exp, Expr) :-
	genere(T, [/ | L_op], L_opf, Exp / A, Expr).

Par exemple :

1 ?- sol([10,2,2], 10, L_op).
L_op = [+,-] ;
L_op = [-,+] ;
L_op = [*,/] ;
L_op = [/,*] ;
false.

2 ?- sol([10,4,2], 10, L_op).
false.

[sukoi]

Merci TrapD,

pour ma compréhension:
genere/3 lance l'analyse de la liste des données
genere/5 pour chaque élément de la liste on génère une opération(L_op), et une expression (Expr) à évaluer. Lorsque la liste est vide, on inverse la liste des opérations (chaînage arrière)
puis on teste le résultat demandé à l'expression en retour.
le "moteur" de PROLOG fait tout, il examine tous les cas du + à /

une solution élégante et simple, je ne sais pas si dans un autre langage, on pourrait faire si efficacement.

[Trap D]

C'est exactement ça, Prolog a parfois de bon côté grâce au backtrack.
On déclare ce qu'on veut et, quand c'est bien fait, Prplog se charge du travail.