Discussion :

[divervince]

bonjour, je me permets de vous contacter car j'ai un petit souci je ne sais pas faire un code prolog...

en fait le but est de trouver les combinaisons possibles d'un code (N,O,P,Q,R) dont on a les "vecteurs" sources qui sont défini par
0 0 0 1 0 pour A
0 0 0 0 1 pour B
1 0 0 0 0 pour C
0 1 0 0 0 pour D
0 0 1 0 0 pour E
0 1 0 0 0 pour F
0 0 2 0 0 pour G
1 0 0 0 2 pour H
0 4 0 0 0 pour I
4 0 0 0 0 pour J
0 0 1 0 2 pour K
0 0 0 5 3 pour L
3 0 5 0 0 pour M

Ainsi par exemple pour faire le code (4,0,0,0,0) on peut avoir 4 C ou J

on m'a conseiller de faire un code en Prolog et on m'a donné cet exemple (qui ne fonctionne pas chez moi)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
sont_dans_interval(a,b,c,d,A,B,C) :-vA is 2*b + c is, vB is a + 2*c + 3*d, vC is a+b+2*c is,
                                         vA >= 0, vB >=0, vC =< 0, vA =< C, vB =< B, vC =< C
combinaison(a,b,c,d,A,B,C) :- 2*b + c is A, a + 2*c + 3*d is B, a+b+2*c is C, print([a,b,c,d])
combinaison(a,b,c,d,A,B,C) :- sont_dans_interval(a,b,c,d,A,B,C), a_plus_1 is a + 1, 
                                         combinaison(a_plus_1,b,c,d)
combinaison(a,b,c,d,A,B,C) :- sont_dans_interval(a,b,c,d,A,B,C), b_plus_1 is b + 1, 
                                         combinaison(a,b_plus_1,c,d)
combinaison(a,b,c,d,A,B,C) :- sont_dans_interval(a,b,c,d,A,B,C), c_plus_1 is c + 1, 
                                         combinaison(a,b,c_plus_1,d)
combinaison(a,b,c,d,A,B,C) :- sont_dans_interval(a,b,c,d,A,B,C), d_plus_1 is d + 1, 
                                         combinaison(a,b,c,d_plus_1)
 
? combinaison(0,0,0,0,18,15,14)

j'ai donc essaye de l'adapté avec les éléments que j'ai crut comprendre
pour une variable, il faut une majuscule donc remplacement de a,b,c,d,e par A,B,C,D,E...
il faut mettre des espaces entre chaque éléments différents "C + H + 4 * J + 3 * M " et non pas "C+H+4J+3M"

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
interval(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R) :- vN is C + H + 4 * J + 3 * M, vO is D + f + 4 * i, vP is E + 2 * G + K + 5 * M, vQ is A + 5 * L, vR is B + 2 * H + 2 * K + 3 * L, vN >= 0, VO >= 0, vP >= 0, VQ >= 0, vR >= 0, vN =< N, vO =< O, vP =< P, vQ =< Q, vR =< R .
combinaison(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R) :- C + H + 4 * J + 3 * M is N, D + F + 4 * I is O, E + 2 * G + K + 5 * M is P, A + 5 * L is Q, B + 2 * H + 2 * K + 3 * L is R, print([A,B,C,D,E,F,G,H,I,J,K,L,M]) .
combinaison(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R) :- interval(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R), A_plus_1 is A + 1, combinaison(A_plus_1,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R) .
combinaison(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R) :- interval(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R), B_plus_1 is B + 1, combinaison(A,B_plus_1,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R) .
combinaison(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R) :- interval(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R), C_plus_1 is C + 1, combinaison(A,B,C_plus_1,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R) .
combinaison(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R) :- interval(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R), D_plus_1 is D + 1, combinaison(A,B,C,D_plus_1,E,F,G,H,I,J,K,L,M,N,O,P,Q,R) .
combinaison(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R) :- interval(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R), E_plus_1 is E + 1, combinaison(A,B,C,D,E_plus_1,F,G,H,I,J,K,L,M,N,O,P,Q,R) .
combinaison(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R) :- interval(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R), F_plus_1 is F + 1, combinaison(A,B,C,D,E,F_plus_1,G,H,I,J,K,L,M,N,O,P,Q,R) .
combinaison(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R) :- interval(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R), G_plus_1 is G + 1, combinaison(A,B,C,D,E,F,G_plus_1,H,I,J,K,L,M,N,O,P,Q,R) .
combinaison(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R) :- interval(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R), H_plus_1 is H + 1, combinaison(A,B,C,D,E,F,G,H_plus_1,I,J,K,L,M,N,O,P,Q,R) .
combinaison(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R) :- interval(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R), I_plus_1 is I + 1, combinaison(A,B,C,D,E,F,G,H,I_plus_1,J,K,L,M,N,O,P,Q,R) .
combinaison(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R) :- interval(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R), J_plus_1 is J + 1, combinaison(A,B,C,D,E,F,G,H,I,J_plus_1,K,L,M,N,O,P,Q,R) .
combinaison(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R) :- interval(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R), K_plus_1 is K + 1, combinaison(A,B,C,D,E,F,G,H,I,J,K_plus_1,L,M,N,O,P,Q,R) .
combinaison(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R) :- interval(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R), L_plus_1 is L + 1, combinaison(A,B,C,D,E,F,G,H,I,J,K,L_plus_1,M,N,O,P,Q,R) .
combinaison(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R) :- interval(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R), M_plus_1 is M + 1, combinaison(A,B,C,D,E,F,G,H,I,J,K,L,M_plus_1,N,O,P,Q,R) .

visiblement ça me dit que la ligne 1 est bonne, par contre ça me dit erreur syntaxe ligne 2...
j'ai essayé de mettre == qui semble être la vérification d'égalité et ça change rien

pour le reste j'ai rien compris...

[Trap D]

Bonjour

Effectivement, tu es un débutant en Prolog, mais tout le monde a commencé un jour, et il n'y a pas de mal à avoir des difficultés, surtout en Prolog !
La méthode que j'ai utilisé pour résoudre ton probleme, est d'expliquer à Prolog comment on fait pour trouver une solution, puis je lui demande de me les donner toutes:

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
% ici je définis tes données
obj(a-[0, 0, 0, 1, 0]).% pour A
obj(b-[0, 0, 0, 0, 1]).% pour B
obj(c-[1, 0, 0, 0, 0]).% pour C
obj(d-[0, 1, 0, 0, 0]).% pour D
obj(e-[0, 0, 1, 0, 0]).% pour E
obj(f-[0, 1, 0, 0, 0]).% pour F
obj(g-[0, 0, 2, 0, 0]).% pour G
obj(h-[1, 0, 0, 0, 2]).% pour H
obj(i-[0, 4, 0, 0, 0]).% pour I
obj(j-[4, 0, 0, 0, 0]).% pour J
obj(k-[0, 0, 1, 0, 2]).% pour K
obj(l-[0, 0, 0, 5, 3]).% pour L
obj(m-[3, 0, 5, 0, 0]).% pour M
 
% ici j'écris le prédicat qui permet de calculer les résultats
calcule(R, L) :-
	% premierement je regroupe toutes tes données dans une liste
	bagof(O, obj(O), Set),
 
	% je lui demande de trouver toutes les solutions possibles (triées par ordre alphabétiques)
	findall(L2, (calcule(Set, R, [], L1),msort(L1, L2)), LL1),
	% ici toutes les possibilités identiques de calculs sont regroupées en une seule 
	sort(LL1, LL2),
	maplist(pack, LL2, L).
 
 
% ici j'explique comment trouver une solution
 
% Dans cette première clause j'ai trouve une solution
% je la mémorise
calcule(_, [0,0,0,0,0], L, L).
 
% ici j'essaye une possibilité prise dans la liste des données
calcule(S, R, L, LF) :-
	member(X-O, S),
	% je teste la possibilité
	ajout_possible(X-O, R, R1),
	% je l'ajoute à la liste des calculs
	calcule(S, R1, [X | L], LF).
 
% ici je teste une possibilité
ajout_possible(_-[A,B,C,D,E], [X, Y, Z, T, U], [X1, Y1, Z1, T1, U1]) :-
	X1 is X - A, X1 >= 0,
	Y1 is Y - B, Y1 >= 0,
	Z1 is Z - C, Z1 >= 0,
	T1 is T - D, T1 >= 0,
	U1 is U - E, U1 >= 0.
 
% on paque les liste
% par exemple [a, a,a, b, c] -> [3*a, 1*b,1*c]
pack(L, L1) :-
	setof(X, pack_one(L, X), L1).
 
pack_one(L, L1) :-
	setof(A*X,(member(X, L),bagof(X, member(X, L), S), length(S, A)), [L1]).

Exemple de résultat :

?- calcule([5,0,0,0,1], L), maplist(writeln, L).
[1*b,5*c]
[1*b,1*c,1*j]
L = [[1*b,5*c],[1*b,1*c,1*j]].

?- calcule([4,0,0,0,0], L), maplist(writeln, L).
[4*c]
[1*j]
L = [[4*c],[1*j]].

Ceci veut dire que [4,0,0,0,0] peut s'obtenir avec 4 c ou 1 j.

[divervince]

merci de m'avoir écrit ce code, j'ai pas tout compris mais j'essaye de me pencher dessus... (en tout cas c'est sur que je vais essayer de le comprendre ca ca peut me servir dans ma vie pro (qui n'a rien a voir avec la programmation, je suis dans le marquage textile)

j'ai enlevé les commentaires (ce qui suit les % si j'ai bien compris)

j'arrive à ce code

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
obj(a-[0, 0, 0, 1, 0]).
obj(b-[0, 0, 0, 0, 1]).
obj(c-[1, 0, 0, 0, 0]).
obj(d-[0, 1, 0, 0, 0]).
obj(e-[0, 0, 1, 0, 0]).
obj(f-[0, 2, 0, 0, 0]).
obj(g-[1, 0, 0, 0, 2]).
obj(h-[0, 4, 0, 0, 0]).
obj(i-[4, 0, 0, 0, 0]).
obj(j-[0, 0, 0, 1, 0]).
obj(k-[0, 0, 1, 0, 2]).
obj(l-[0, 0, 0, 5, 3]).
obj(m-[3, 0, 5, 0, 0]).
calcule(R, L) :- bagof(0, obj(0), set), findall(L2, (calcule(set, R, [],L1), msort(L1, L2)), LL1), sort(LL1, LL2), maplist(pack, LL2, L).
calcule(_, [0,0,0,0,0], L, L).
calcule(S, R, L, LF) :- member(X-O, S), ajout_possible(X-O, R, R1), calcule(S, R1, [X | L], LF).
ajout-possible(_-[A, B, C, D, E], [X, Y, Z, T, U], [X1, Y1, Z1, T1, U1]) :- X1 is X - A, X1 >= 0, Y1 is Y - B, Y1 >= 0, Z1 is Z - C, Z1 >= 0, T1 is T - D, T1 >= 0, U1 is U - E, U1 >= 0.
pack(L, L1) :- setof(X, pack_one(L, X), L1).
pack_one(L, L1) :- setof(A*X, (member(X, L), bagof(X, member(X, L), S) length(S, A)), [L1]).

quand je veux lancer la requête il me dit erreur syntax ligne 17 soit:

Code :

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

ajout-possible(_-[A, B, C, D, E], [X, Y, Z, T, U], [X1, Y1, Z1, T1, U1]) :- X1 is X - A, X1 >= 0, Y1 is Y - B, Y1 >= 0, Z1 is Z - C, Z1 >= 0, T1 is T - D, T1 >= 0, U1 is U - E, U1 >= 0.

pour le code ?- je mets "calcule([5,0,0,0,1], L), maplist(writeln, L)." si je veux calculer les possibilité pour [5,0,0,0,1] si je me suis pas trompé..
j'ai mis en PJ une copie de ma vision sur "tuProlog IDE" (je ne sais pas si il est bien mais déjà il y a pas de copier coller...


par contre je ne sais pas si c'est possible, mais la finalité pour moi et de sortir les résultats et de les intégrer à excel ( j'aurais peut être dû le dire avant) sous la forme de 13 colonnes avec chaque colonne qui représente une lettre
par exemple pour le cas [5,0,0,0,1], l'idéal aurait été qu'il puisse sortir sous la forme:
[1*b,1*c,1*j]=> 0;1;1;0;0;0;0;0;0;1;0;0;0;0
[1*b,5*c] => 0;1;5;0;0;0;0;0;0;0;0;0;0;0
il semble que pour la résolution de [4,16,4,16,17] il y ai plus de 4000 possibilité donc c'est sur que ce serai pour moi un gros gain de temps, mais si ce n'est pas le cas je prendrai le temps de le faire a la main.

[Trap D]

Oui, alors la, ce que j'ai écrit ne va plus du tout, ma méthode est beaucoup trop lente.

[Trap D]

Bon, j'ai changé mon code et maintenat le resultat en 8 secondes, attention, je pense qu'il ne fonctionne qu'en SWI-Prolog, version au moins 6.1.
[EDIT]
Code supprimé car faux !
[/EDIT]

Je ferai demain l'inscription dans un fichier excel : en fait je sortirai un fichier au format csv.

[divervince]

ERROR: c:/users/anne/documents/prolog/test.pl:1:
source_sink `library(lambda)' does not exist
Warning: c:/users/anne/documents/prolog/test.pl:1:
Goal (directive) failed: user:use_module(library(lambda))
ERROR: c:/users/anne/documents/prolog/test.pl:45: Syntax error: Operator expected
ERROR: c:/users/anne/documents/prolog/test.pl:114: Syntax error: Operator expected
% c:/Users/Anne/Documents/Prolog/test.pl compiled 0.03 sec, 79 clauses

voila ce que ca me met quand je copie le code dans swi-prolog version 7.1/8 je ne sais pas si ça aide ou si c'est normal et que j'ai pas fait les choses comme il faut...

en tout cas merci de vous pencher sur la question...

[Trap D]

D'abord, mon code est faux, je suis en train de le corriger.
Ensuite, SWI-Prolog 7.1.8 est plus ou moins expérimental je crois, il vaut mieux utiliser les versions stables, je crois qu'on en est à la 6.6.1 avec laquelle je travaille.

[Trap D]

Bon, j'ai complètement changé mon fusil d'épaule, je fais le calcul avec la librairie de contrainte clpfd, et j'ai le résultat en une demi seconde cher moi !
Et la, c'est correct. Il y 8775 résultats différents.
Le code complet avec l'insertion dans un fichier excel :

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
:- use_module(library(lambda)).
:- use_module(library(clpfd)).
 
% ici je définis tes données
obj(a-[0, 0, 0, 1, 0]).% pour A
obj(b-[0, 0, 0, 0, 1]).% pour B
obj(c-[1, 0, 0, 0, 0]).% pour C
obj(d-[0, 1, 0, 0, 0]).% pour D
obj(e-[0, 0, 1, 0, 0]).% pour E
obj(f-[0, 1, 0, 0, 0]).% pour F
obj(g-[0, 0, 2, 0, 0]).% pour G
obj(h-[1, 0, 0, 0, 2]).% pour H
obj(i-[0, 4, 0, 0, 0]).% pour I
obj(j-[4, 0, 0, 0, 0]).% pour J
obj(k-[0, 0, 1, 0, 2]).% pour K
obj(l-[0, 0, 0, 5, 3]).% pour L
obj(m-[3, 0, 5, 0, 0]).% pour M
 
% des propositions pour vérifier
input(1, [4,16,4,16,17]).
input(2, [5,0,0,0,1]).
 
 
 
toutes_les_combinaisons(N) :-
	% préparation des calculs
	bagof(O, S^obj(S-O), Set),
	input(N,Prop),
	max_list(Prop, Max),
	length(Prop, Len1),
	length(Set, Len),
	length(R, Len),
	R ins 0..Max,
	numlist(1, Len1, NL),
 
	% le calcul effectif des solutions
	setof(L, combinaison(Set, Prop, NL, L), TL),
 
	% ecriture dans excel
	tell('resultat.csv'),
	maplist(my_write, TL),
	told.
 
combinaison(Set, Prop, NL, R) :-
	maplist(calcul(Set, R), NL, Prop),
	labeling([ff],R).
 
calcul(Set, Res, Ind, Value) :-
	maplist(\X^Y^Z^(nth1(Ind, X, V1),
			Z in 0..Value,
			Z #= Y * V1),
		Set, Res, Lst),
	sum(Lst, #=, Value).
 
my_write([R]) :-
	format('~w~n', [R]).
 
my_write([R| T]) :-
	format('~w;', [R]),
	my_write(T).

j'ai pensé que kes problèmes venaient peut-être du module liambda. Il faut copier le fichier lambda.pl qu'on peut trouver la dans le répertoire library de swi-prolog.