Comment ajouter un élément à une liste en place dans le Prologue?

Si j'ai une liste dans le Prologue comme X = [1, 2, 3, 4], comment puis-je ajouter l'élément 5 à la fin de la liste pour avoir X = [1, 2, 3, 4, 5]?

L'ajout de la fonction a besoin de deux listes, c'est à dire ajouter(A,B,C) pour obtenir A et B concaténé à la liste C.

Je peux le faire avec un temporaire de la liste des Y = [1, 2, 3, 4] et Z = [5], pour ensuite faire un append(Y, Z, X), mais je n'aime pas avoir une liste temporaire.

Les avertissements habituels s'appliquent ici - ce n'est pas de devoirs et j'apprends juste Prolog.

Réponse courte: Vous n'avez pas; vous n'avez simplement pas.

OriginalL'auteur No One in Particular | 2013-02-22

  1. 5

    Variables Prolog ne peut être attribuée qu'une seule fois. Dès que X a la valeur [1,2,3,4], il ne peut jamais avoir une autre valeur. Une variable temporaire et ajouter/3, comme vous l'avez dit, c'est la façon de le faire.

    Avoir dit que, vous pouvez faire un truc qui n'est probablement pas recommandé. Si X = [1,2,3,4,Y], alors vous pouvez faire Y=5 et X a la valeur que vous souhaitez. Je crois que cette technique est appelée une différence liste.

    Pensez Prologue de variables comme des variables mathématiques à la place de lieux de stockage. Je suis conscient que c'est un changement de paradigme majeur, mais quand vous l'avez compris, rien dans le Prologue sera très facile (ou logique au moins).
    belle réponse. Cette opération efface pense. Donc, si je comprends bien, si je dis que X=[A,B,C,D], puis plus tard, affecter A=[1], B=[2], alors X=[[1], [2], C, D]. Puis, plus tard, si je cède C=[3], D=[4], puis j'ai enfin X=[[1],[2],[3],[4]] et il est fixé dans la pierre.
    oui, c'est vrai
    Afin d'utiliser une différence de liste, vous avez besoin de garder une trace de "trou" dans la liste (dans ce cas, sa queue). I. e une différence liste est toujours une paire de deux termes, l'un étant une liste avec le "trou" et l'autre "trou" de lui-même. Le "trou" est lui-même une variable logique. La manière traditionnelle de représenter la paire est d'utiliser un haut-opérateur infixe.
    pas exactement. avec X = [1,2,3,4 | Y] et puis Y = [5 | Z] ce est la différence-liste technique: ajout de 5 à la fin de X...Y nous obtient de l'allongement de X...Z. l'ancien X...Y est un valide, plus court différence de liste, représentant le même préfixe 1,2,3,4 comme il l'a fait avant l'extension. différence-liste sont faciles à comprendre que ouvert ou des listes de préfixes. Aussi, l'extension d'une différence de liste de cette façon est un O(1) oepration.

    OriginalL'auteur mndrix

  2. 7

    Comme les autres l'ont souligné, vous allez être coincé avec le problème de performances.

    Mais juste comme un exercice, j'ai décidé d'essayer et de créer un prédicat qui pourrait ajouter un élément à la fin d'une liste, sans l'aide de append.

    % add_tail(+List,+Element,-List)
% Add the given element to the end of the list, without using the "append" predicate.
add_tail([],X,[X]).
add_tail([H|T],X,[H|L]):-add_tail(T,X,L).

    Je voudrais des conseils que vous pouvez simplement utiliser le append fonction, une fonction intégrée, il est susceptible d'être plus rapide que ce que manuellement conçu.

    Dans le style de Benjamin Franklin: "Ceux qui donnent les éléments essentiels de l'exactitude de l'achat d'un peu de temporaire de performance, ne méritent ni l'exactitude ni les performances."
    Quelle est la différence alors entre add_tail(X,[L1],[L2]) et add_tail(X,[Y|L1],[Z|L2]) ?
    [Head1, Head2|Queue] permettrait de supprimer les 2 premières variables à partir de l'avant de la liste et mettre le reste dans une liste séparée dans la variable de la Queue. Donc, [1,2,3,4] signifierait Head1 = [1], Head2 = [2], la Queue = [3,4], qui signifie à travers la récursivité vous pouvez supprimer l'avant les éléments d'une liste. Le add_tail se lit comme suit 1. Si la première liste est vide et X est maintenant le dernier élément de la outputList, arrêter de chercher des alternatives. 2. Prendre la première variable de la inputList, passer sur X pour le vérifier, de manière récursive unifier H à l'avant de outputList quand 1. est vrai. 1. assure backstepping.
    En gros, supprimer tous les éléments de la liste 1, ajouter X à une liste vide, puis ajouter tous les éléments de la liste 1 dans l'ordre inverse de la dépose retour à la Liste 2, de la création [Liste1|X] qui, normalement, vous ne pouvez pas le faire parce que X peut être vérifié par rapport à l'existant de la Queue et de l'échec.

    OriginalL'auteur S.L. Barth

  3. 3

    Un déclarative solution est d'utiliser une différence de liste (comme Daniel l'a suggéré dans sa réponse). Une différence liste obtient son nom d'être généralement représentée comme une différence entre les deux listes: une liste et sa queue. Par exemple, une liste vide est représentée comme T-T. Une liste avec les éléments 1, 2 et 3 peut être représenté comme [1,2,3| T]-T (notez que (-)/2 est standard intégré opérateur infixe). L'avantage de cette représentation est que vous pouvez ajouter un élément à une liste en temps constant à l'aide d'un seul fait, la définition de la append/3 prédicat:

    append(L1-T1, T1-T2, L1-T2).

    Un exemple d'utilisation:

    ?- append([1,2,3,4| T1]-T1, [5| T2]-T2, Result).
T1 = [5|T2],
Result = [1, 2, 3, 4, 5|T2]-T2.

    Si nécessaire, n'est pas difficile de convertir entre une "normales" et une différence de liste. Je laisse ça comme un exercice pour vous.

    Viens de remarquer que c'est une très vieille question (à l'heure d'Internet)!
    s(X): solide comme un roc.

    OriginalL'auteur Paulo Moura

  4. 2

    Vous êtes vous soucier du mauvais côté du problème. La Structure de partage ne peut se faire que par consing un élément sur le début de la liste. Cette méthode a les caractéristiques de performance que vous souhaitez. En raison de la façon dont les listes sont définies, lorsque vous ajoutez des deux listes, l'ensemble de la première liste sera copié. Dans ce cas, ça va être de l'ensemble de la liste. Les déchets générés par un élément de la liste n'est évidemment va être beaucoup plus petite.

    Si vraiment vous devez ajouter, à envisager la création de la liste vers l'arrière, puis de l'inverser à la fin, ce qui est beaucoup moins cher, ou de l'utilisation de la différence de listes de favoriser l'efficacité de l'ajout à la fin.

    s(X) pour le classique "double renversement, ajouter l'élément" approche!

    OriginalL'auteur Daniel Lyons

  5. 2

    Vous ne pouvez pas modifier des listes en Prolog, mais vous pouvez créer une liste à une quelconque longueur:

    main :-
    A = [1,2,3,4|_].

    Ensuite, vous pouvez insérer un élément à l'aide de nth0/3 en SWI-Prolog:

    :- initialization(main).

main :-
    A = [1,2,3,4|_],
    nth0(4,A,5),
    writeln(A).

    Après cet élément est inséré, A = [1,2,3,4,5|_].

    Vous pouvez également définir une fonction qui ajoute un élément à la fin d'une liste sur place, et ensuite l'utiliser comme ceci:

    :- initialization(main).

append_to_list(List,Item) :-
    List = [Start|[To_add|Rest]],
    nonvar(Start),
    (var(To_add),To_add=Item;append_to_list([To_add|Rest],Item)).

main :-
    A = [1,2,3|_],
    append_to_list(A,4),
    append_to_list(A,4),
    writeln(A).

    Dans cet exemple, A = [1,2,3,4,4|_] après ces deux éléments sont ajoutés.

    vous pouvez également ajouter que, retraçant la liste de ses recommencer à zéro à chaque ajout sera quadratique dans l'ensemble, nous avons donc pu maintenir le bout var explicitement de la O(1) en ajoutant - et ce serait la différence liste. aussi, une autre approche est de maintenir la longueur connue et l'utilisation nth0/nth1 directement.

    OriginalL'auteur Anderson Green

  6. 1

    Depuis Prolog a ajouter qui n'accepte que des listes, pourquoi ne pas l'utiliser pour insérer notre élément dans l'une des listes. c'est à dire

    % E = element, L = list, R = result
% e.g. add_elem_in_list ([1,2,3,4], 5, R).
add_elem_in_list(L, E, R) :- append(L, [E], R).

    OriginalL'auteur Imam Bux