Comment faire pour supprimer le dernier élément d'une liste dans le Prologue?

Je suis dans la situation suivante: j'ai une liste et je voudrais en supprimer uniquement le dernier élément.

J'ai appliquer la règle suivante (qui ne fonctionnent pas bien):

deleteLastElement([Only],WithoutLast) :-
    !,
    delete([Only],Only,WithoutLast).
deleteLastElement([_|Tail],WithoutLast) :-
    !,
    deleteLastElement(Tail,WithoutLast).

Le problème est que lorsque je l'appelle, tous les éléments de la liste sont supprimés, en fait, si j'ai exécutez l'instruction suivante-je obtenir:

[debug]  ?- deleteLastElement([a,b,c], List).
List = [].

À la recherche à la trace je pense que c'est clairement la cause de ce problème:

[trace]  ?- deleteLastElement([a,b], List).
   Call: (7) deleteLastElement([a, b], _G396) ? creep
   Call: (8) deleteLastElement([b], _G396) ? creep
   Call: (9) lists:delete([b], b, _G396) ? creep
   Exit: (9) lists:delete([b], b, []) ? creep
   Exit: (8) deleteLastElement([b], []) ? creep
   Exit: (7) deleteLastElement([a, b], []) ? creep
List = [].

Lorsque le cas de base est atteint, le WithoutLast liste est unifié avec le liste vide [] et lors de la mandature est effectuée la WithoutLast toujours de la liste vide.

Ce n'est pas bon.

Je pensais à le mettre en œuvre en faisant l'opération suivante:

De compter le nombre d'élément dans la liste avant d'appeler la fonction qui supprime le dernier élément.
Itérer par récurrence et de décrémenter la valeur du nombre d'élément à chaque fois
S'il est vrai que le nombre d'élément est 0, cela signifie que c'est le dernier élément, donc je l'ai supprimer de la liste originale

Mais cela ne me paraît pas clair, et ne pas bon, je voudrais savoir si il existe un déclarative bonne solution pour ce problème.

InformationsquelleAutor AndreaNobili | 2013-04-23

list prolog

Pour empêcher la création de l'inutile choicepoints, utilisez la traîne de bénéficier de premier argument de l'indexation:

list_butlast([X|Xs], Ys) :-                 % use auxiliary predicate ...
   list_butlast_prev(Xs, Ys, X).            % ... which lags behind by one item

list_butlast_prev([], [], _).
list_butlast_prev([X1|Xs], [X0|Ys], X0) :-  
   list_butlast_prev(Xs, Ys, X1).           % lag behind by one

Exemples de requêtes:

?- list_butlast([], Xs).
false.

?- list_butlast([1], Xs).
Xs = [].                                    % succeeds deterministically

?- list_butlast([1,2], Xs).
Xs = [1].                                   % succeeds deterministically

?- list_butlast([1,2,3], Xs).
Xs = [1,2].                                 % succeeds deterministically

L'autre sens?

?- list_butlast(Xs, []).
Xs = [_A].

?- list_butlast(Xs, [1,2,3]).
Xs = [1,2,3,_A].

Que sur les plus générales de la requête?

?- list_butlast(Xs, Ys).
   Xs = [_A]            , Ys = []
;  Xs = [_A,_B]         , Ys = [_A]
;  Xs = [_A,_B,_C]      , Ys = [_A,_B]
;  Xs = [_A,_B,_C,_D]   , Ys = [_A,_B,_C]
;  Xs = [_A,_B,_C,_D,_E], Ys = [_A,_B,_C,_D]
⋯

InformationsquelleAutor repeat

12

Je trouve ton analyse un peu trop complexe. Commençons par le cas de base:
```
without_last([_], []).
```
Lorsque vous êtes sur le dernier élément, le résultat devrait être la liste vide.

Inductif cas doit donc être le cas où nous ne sommes pas au dernier élément. Dans le cas où j'ai quelques élément attaché à arbitrairement une longue liste, celle-ci sans le dernier élément est juste la queue de la liste sans le dernier élément avec l'élément en cours sur le devant. Ou:
```
without_last([X|Xs], [X|WithoutLast]) :- 
    without_last(Xs, WithoutLast).
```
Cela fonctionne dans tous les sens.
```
?- without_last([1,2,3,4], X).
X = [1, 2, 3] ;
false.

?- without_last([1,2], X).
X = [1] .

?- without_last([1], X).
X = [] ;
false.

?- without_last([], X).
false.

?- without_last(X, [1,2,3]).
X = [1, 2, 3, _G294].

?- without_last([1,2,3,4], [1,2,3]).
true.

?- without_last([1,2,3,X], [1,2,3]).
true.
```
InformationsquelleAutor Daniel Lyons
8

Si vous développez une procédure récursive, qui passe par chaque élément de la liste de saisie, de votre base de cas, arrêtez-vous quand vous trouver le dernier élément unificateur de la liste avec la liste vide. Ensuite, de retour de l'appel récursif vous venez d'ajouter tout autre élément à la liste:

Sans l'aide de la coupe:
```
deleteLastElement([_], []).
deleteLastElement([Head, Next|Tail], [Head|NTail]):-
  deleteLastElement([Next|Tail], NTail).
```
La première clause (cas de base) unifie le deuxième argument avec la liste vide quand il n'est qu'un élément de la première liste d'arguments.

Le deuxième alinéa précise que lorsque le premier argument est une liste comportant au moins deux éléments, alors vous récursive s'appeler lui-même (sans la tête), un complément à la Tête de la deuxième argument retourné par l'appel.

En fait, vous n'avez pas besoin de rendre explicite dans le deuxième paragraphe que la liste doit comporter au moins deux éléments,
```
deleteLastElement([Head|Tail], [Head|NTail]):-
  deleteLastElement(Tail, NTail).
```
Et, bien sûr, vous pouvez également utiliser append/3 pour supprimer le dernier élément d'une liste:
```
append(WithoutLast, [_], List).
```
InformationsquelleAutor gusbro
5

@répéter la mise en œuvre est certainement la plus efficace, avec l'actuel Prologue de processeurs, encore, je tiens à utiliser DCGs pour cela, espérant secrètement qu'un jour, la mise en œuvre de la technologie sera assez bon pour courir avec cette comparables (de l'espace) de l'efficacité.
```
list_butlast(Xs, Ys) :-
   phrase( ( seq(Ys), [_] ), Xs).

seq([]) -->
   [].
seq([E|Es]) -->
   [E],
   seq(Es).
```
InformationsquelleAutor false

Vous devez vous connecter pour publier un commentaire.