liste de longueur, l'insertion de l'élément

Je suis en train d'écrire un programme en Prolog, qui insère un élément dans une certaine position, si par exemple la

?- ins(a, [1,2,3,4,5], 3, X).
X = [1,2,a,3,4,5].

J'ai le code suivant:

ins(X,[H|T],P,OUT) :-
   length([T3],P),
   concatenate(X,[H],T),
   ins(...).

Le problème est qu'il est l'insertion d'élément X dans l'index à partir de l'arrière (je sais même pas où est le problème -> le length([T3],P) qui est évidemment la longueur de la liste à partir de l'arrière pas de la tête) . J'essayais de me souvenir combien éléments n'ai-je couper et insérer X lorsque le "nombre de couper des éléments" = P, mais je ne peux pas vraiment écrire que dans le Prologue. Des idées?

OriginalL'auteur Johnzzz | 2012-04-08

  1. 3
    % ins(Val,List,Pos,Res)

ins(Val,[H|List],Pos,[H|Res]):- Pos > 1, !, 
                                Pos1 is Pos - 1, ins(Val,List,Pos1,Res). 
ins(Val, List, 1, [Val|List]).

    Le prédicat échoue si Pos = 0 ou Pos - > longueur(Liste) + 1

    OriginalL'auteur Alexander Serebrenik

  2. 2

    Commençons ce que vous voulez ici. Par exemple, vous pourriez dire: "je veux partager mon entrée List après Position - 1 éléments pour que je puisse insérer un nouvel élément".

    Une traduction directe avec append/3 (DCG serait mieux d'ailleurs):

    ins(Element, List, Position, Result) :-
    PrefixLength is Position - 1,
    length(Prefix, PrefixLength),
    append(Prefix, Suffix, List),
    append(Prefix, [Element], Temp),
    append(Temp, Suffix, Result).

    Ou vous pourriez dire: "je veux aller à travers les éléments de mon List Position - 1 fois sans rien toucher, puis insérez Element et puis ne pas toucher quoi que ce soit de nouveau".

    Cette fois le direct traduction serait:

    ins2(Element, List, 1, [Element|List]).
ins2(Element, [Head|Tail], Position, [Head|Result]) :-
    Position > 1,
    NewPosition is Position - 1,
    ins2(Element, Tail, NewPosition, Result).

    vous pourriez aussi de l'état: "Mon entrée List une liste égal à mon Result, sauf qu'il n'a pas mon Element comme Positionélément th." et de réaliser que si vous utilisez swi-prolog, un prédicat résout instantanément:

    ins3(Element, List, Position, Result) :-
    nth1(Position, Result, Element, List).

    Ligne de fond est: état de ce que le problème est clairement et que la solution doit apparaître dans des termes simples.

    pos - >1, newPos est P -1, wuaa c'est ce que je cherchais 🙂 thx a lot

    OriginalL'auteur m09

  3. 2

    TL;DR: Pour insérer un élément E à la position I1 dans la liste Es0, nous n'avons pas besoin d'écrire de code récursif.

    Au lieu de cela, nous pouvons déléguer le travail (et les inquiétudes sur la droite, trop!) d'auxiliaire polyvalent des prédicats, qui font partie de la Prologue prologue. Pour définir ins_/4 nous écrire:

    ins_(E, Es0, I1, S) :- 
maplist(any_thing, Es, [_|Es0]), 
ajouter(Préfixe, Suffixe, Es0), 
longueur([_|Prefix], I1), 
ajouter(Préfixe, [E|Suffixe], Es). 

any_thing(_, _). % auxiliaire de prédicat (utilisé ci-dessus)

    Noter que maplist(any_thing, Es, [_|Es0]) est équivalent à same_length(Es, [_|Es0]).

    Exemples de requêtes1,2,3 de l'utilisation de GNU Prolog version 1.4.4 (64 bits):

    ?- ins_(X, [a,b,c,d,e], N1, Xs). 
N1 = 1, Xs = [X,a,b,c,d,e] 
; N1 = 2, Xs = [a,X,b,c,d,e] 
; N1 = 3, Xs = [a,b,X,c,d,e] 
; N1 = 4, Xs = [a,b,c,X,d,e] 
; N1 = 5, Xs = [a,b,c,d,X,e] 
; N1 = 6, Xs = [a,b,c,d,e,X] 
; faux. 

?- ins_(X, [a,b,c,d,e], 3, Xs). 
Xs = [a,b,X,c,d,e] 
; faux. 

?- ins_(X, Xs0, 3, [a,b,c,d,e]). 
X = c, Xs0 = [a,b,d,e] 
; faux.

    N'oublions pas le plus général requête!

    ?- ins(X, Es0, I1, Es). 
Es0 = [], I1 = 1, Es = [X] 
; 
Es0 = [A], I1 = 1, Es = [X,] 
; Es0 = [A] I1 = 2, Es = [A,X] 
; 
Es0 = [A,B], I1 = 1, Es = [X,A,B] 
; Es0 = [A,B], I1 = 2, Es = [A,X,B] 
; Es0 = [A,B], I1 = 3, Te = [A,B,X] 
; 
Es0 = [A,B,C], I1 = 1, Es = [X,A,B,C] 
; Es0 = [A,B,C], I1 = 2, Es = [A,X,B,C] 
; Es0 = [A,B,C], I1 = 3, Te = [A,B,X,C] 
; Es0 = [A,B,C], I1 = 4, E = [A,B,C,X] 
; 
Es0 = [A,B,C,D], I1 = 1, Es = [X,A,B,C,D] 
; ...

    Juste l'énumération de toutes les solutions, OK!

    EDIT:
    J'ai répété la plus générale d'une requête avec ins3/4 tel que défini
    par @m09 dans sa réponse sur SWI-Prolog 7.3.11 et SICStus Prolog 4.3.2 (tous deux disposent de la bibliothèque de prédicat nth1/4).
    J'ai été surpris de voir les implémentations sous-jacentes de nth1/4 présentent des différences procédurales la sémantique (w.r.t. "juste énumération"). Voyez par vous-même!

    % SICStus Prolog 4.3.2 % SWI Prolog 7.3.11 
% % 
?- ins3(X, Es0, I1, Es). % ?- ins3(X, Es0, I1, Es). 
I1 = 1, Es0 = [], Es = [X] % I1 = 1, Es = [X|Es0] 
; % ; I1 = 2, Es0 = [_A|_Z], 
I1 = 1, Es0 = [_A], Es = [X,_A] % Es = [_A,X|_Z] 
; I1 = 2, Es0 = [_A], Es = [_A,X] % ; I1 = 3, Es0 = [_A,_B|_Z], 
; % Es = [_A,_B,X|_Z] 
I1 = 1, Es0 = [_A,_B], Es = [X,_A,_B] % ; I1 = 4, Es0 = [_A,_B,_C|_Z], 
; I1 = 2, Es0 = [_A,_B], Es = [_A,X,_B] % Es = [_A,_B,_C,X|_Z], 
; I1 = 3, Es0 = [_A,_B], Es = [_A,_B,X] % ; I1 = 5, Es0 = [_A,_B,_C,_D|_Z], 
; % Es = [_A,_B,_C,_D,X|_Z] 
... % ...

    leNote de bas de page 1: Tous les exemples de requêtes indiqué ci-dessus résilier universellement.

    leNote de bas de page 2: La réponse donnée par le GNU Prolog toplevel ont été assez-imprimé un peu.

    leNote de bas de page 3: Le code présenté ci-dessus est utilisé est-à -, aucune autre bibliothèque prédicats sont nécessaires.

    OriginalL'auteur repeat

  4. 0
    ins(Element,List,Nth,Result) :-
    length([_|L0],Nth),
    append(L0,[_|R],List),
    append(L0,[Element|R],Result).
    Alors que ce code peut répondre à la question, il serait mieux d'expliquer comment il résout le problème et pourquoi l'utiliser. Code-seulement les réponses ne sont pas utile dans le long terme.
    La requête ?- ins_(a,[1,2,3,4,5],3,[1,2,a,3,4,5]). échoue, il doit réussir. Otoh, que la requête ?- ins_(a,[1,2,3,4,5],3,[1,2,a,4,5]). réussit, elle doit échouer. Pour corriger le bug, vous devez supprimer exactement 4 personnages:)

    OriginalL'auteur 尾崎隆大