Discussion :

[GrimmJow95]

Bonjour à tous,

je suis débutant en Prolog et je dois faire un exercice ou l'on me demande de créer une règle qui renvoie
une liste d'entiers non présents dans une autre liste d'entier sans dépasser les valeurs extrêmes de cette liste.

par exemple:

Code :

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

1
2
3
4
 
rule([1,3,5,8], Res).
renvoie:
Res = [2, 4, 6 , 7]

je pense que je suis pas loin du but. mais le programme ne me retourne pas de réponse, je suis obligé d'utiliser un "write" pour afficher le résultat.
De plus si j'appuie sur espace à la fin de l'éxécution (j'utilise SWi-Prolog), le programme continue de m'enumérer des résultats qui dépasse les valeurs maximal de la liste passée en argument.

Voici mon code:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
ret(_, [], _) :- fail.
ret(0, [X | _], Y) :- Y = X, !.
ret(I, [_ | Queue], Y) :- 	I1 is I - 1, 
				ret(I1, Queue, Y).
 
rule([_ | []], Z) :- write(Z), !.
rule([X | Queue], Z) :- ret(0, Queue, U),
			X1 is X + 1,
			X1 =:= U,
			rule(Queue, Z);
			Test is X + 1,
			rule([Test | Queue], [Z | Test]).

la fonction "ret" renvoie le terme placé à la position demandée.

merci de votre aide.

[GrimmJow95]

j'ai un peu réfléchi sur le problème. j'ai éxécuté la fonction en mode trace.
La liste se construit à l'empilement.
Donc quand le programme dépile, la liste perd ses valeurs.

Faudrait, que je puisse construire la liste au dépilement, mais je vois pas du tout comment m'y prendre.

[Trap D]

Je n'ai pas regardé en détail ton code car j'ai l'impression que tu t'es fourvoyé dans ta recherche.

je suis débutant en Prolog et je dois faire un exercice ou l'on me demande de créer une règle qui renvoie une liste d'entiers non présents dans une autre liste d'entier sans dépasser les valeurs extrêmes de cette liste.

Si j'analyse bien le problème tu dois

• ranger dans l'ordre croissant les valeurs de ta liste d'entiers
• extraire le plus petit et le plus grand élément de cette liste
• Pour tous les éléments compris entre cette plus petite et cette plus grande valeur, tester si ils appartiennent à la liste, et sinon les mémoriser.

Dans un premier temps, on peut sauter les deux premières actions et passer à la troisième.
Tu auras donc une règle à 5 arguments regle(A, B, C, D, E) avec
A l'entier en cours d'étude
B l'entier MAX à tester
C la liste de nombres à tester
D la liste résultat en cours de construction
E la liste résultat finale

Quand aura-t-on terminer ? Eh bien quand l'entier A sera égale à l'entier B, on unifiera alors la liste finale à la liste en cours

Code :

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

1
2
3
regle(N, N, _, L, L) :-
    % on ne va pas plus loin d'où le cut
    !.

Je te laisse écrire la deuxième règle pour une valeur inférieure à N.

Dans ton exemple tu lanceras la règle avec

Code :

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

regle(1, 8, [1,3,5,8], [], Res).

PS Pour le test d'appartenance à une liste, en SWI-Prolog, il y a member/2.

[GrimmJow95]

Je n'ai pas regardé en détail ton code car j'ai l'impression que tu t'es fourvoyé dans ta recherche.

Effectivement, a force de faire des petites modif je n'arrivait plus a cerner le problème.

Si j'analyse bien le problème tu dois

• ranger dans l'ordre croissant les valeurs de ta liste d'entiers
• extraire le plus petit et le plus grand élément de cette liste
• Pour tous les éléments compris entre cette plus petite et cette plus grande valeur, tester si ils appartiennent à la liste, et sinon les mémoriser.

En fait , la liste d'entier est déjà trier par ordre croissant (c'est dans l'énoncé). Sinon oui c'est ce que je devais faire. Par contre, on nous impose aussi le nombre d'argument de la règle qui était de deux (le premier doit être la liste d'entier et le deuxième la réponse).

j'ai fini par trouver la solution.
-j'ai changé ma condition d'arrêt qui a lieu quand il ne reste que 2 éléments et le 1er est égal au 2ème moins 1.
-j'utilise 2 paramètres pour la liste de retour (Le premier élément et le reste) ce qui permet d'unifier les valeur à la remontée.

Voici le code:

Code :

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

1
2
3
4
5
6
7
8
9
 
compl([X, Y | []], []) :- K is X + 1, 
                          K =:= Y, !.
 
compl([X, Y | Queue], [T | P]) :- X1 is X + 1,
				   X1 =:= Y,
				   compl([Y | Queue], [T | P]);
				   T is X + 1,
				   compl([T, Y | Queue], P).

Merci beaucoup pour ton aide.
Bye.

[Trap D]

Ton code n'st pas correct : sous SWI-Prolog j'obtiens ceci :

1 ?- compl([1,3,4,5,7, 10], L).
L = [2, 6, 8, 9] .

2 ?-

si je tape entrée après l'affichage de L;
Par contre si je tape ';' pour voir s'il y a d'autres solutions, j'entre dans un processus infini qui finit par planter.

[GrimmJow95]

le programme renvoie les bonnes valeurs par contre si on recherche d'autres solution, il finit effectivement par planté. je viens de m'en apercevoir...
je vois pas trop d'ou ça vient, surtout que j'ai utilisé le Cut "!".

[Trap D]

Il y a un problème dans cette séquence :

Code :

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

1
2
3
4
X1 =:= Y,
compl([Y | Queue], [T | P]);
T is X + 1,
compl([T, Y | Queue], P).

Si X1 =:= Y échoue tu passes sans condition à T is X+1 !
Il y aurait peut-être quelque chose à faire là.

[GrimmJow95]

j'ai ajouté cette condition "X > Y, !;" qui est vérifié si "X1 =:= Y" échoue.
maintenant le code ne plante plus mais il me renvoie des valeurs non unifiées dans les autres solutions.