Wie findet man das N-te element einer Liste in Prolog

Erste von allen, es ist ein builtin nth0/3:

?- nth0(0,[a,b,c],X).
X = a.

?- nth0(1,[a,b,c],X).
X = b.

?- nth0(2,[a,b,c],X).
X = c.

?- nth0(3,[a,b,c],X).
false.

Holen Sie sich die ich-te element

Das problem ist im induktiven Fall ist:

match([Elem|Tail],Num,Counter,MatchedNumber):-
    match(Tail,Num,N,Elem),
    C is N+1.

Prolog nicht wissen, etwas über C so die Letzte Aussage doens T-force-Prolog-die Rückkehr der ich-te element. Es kann schicken Sie einfach ein beliebiges element, weil N passen Num im rekursiven Aufruf und legen Sie dann C zu Num+1 aber das ist nicht ein problem, weil C ist nicht gebunden an irgendetwas.

Einen besseren Weg, um dieses Problem zu lösen, ist die Verwendung eines Dekrementieren Zähler:

match([H|_],0,H) :-
    !.
match([_|T],N,H) :-
    N > 0, %add for loop prevention
    N1 is N-1,
    match(T,N1,H).

Beispiel:

?- match([a,b,c,d,e],0,X).
X = a.

?- match([a,b,c,d,e],1,X).
X = b.

?- match([a,b,c,d,e],2,X).
X = c.

?- match([a,b,c,d,e],3,X).
X = d.

?- match([a,b,c,d,e],4,X).
X = e.

?- match([a,b,c,d,e],5,X).
false.

Base case ist also, dass der index 0 in dem Fall kehren Sie die Kopf, da Sie sonst die Abfrage für die i-1-te element des Schwanzes. Dies ist auch ein deklarativer Ansatz.

Dieser Ansatz nutzt auch tail recursion, die in der Regel steigern die Leistung deutlich.

Änderung der ursprünglichen Prädikat

Ist es eher un-Prolog Verwendung eines iterator und ein gebunden, eine im Allgemeinen verwendet einen reverse-iterator.

Können Sie jedoch ändern, das Prädikat wie folgt:

match([Elem|_],Num,Num,Elem) :-
    !.
match([_|Tail],Num,Count,MatchedNumber) :-
    Count < Num,
    Count1 is Count+1,
    match(Tail,Num,Count1,MatchedNumber).

So ein paar Fehler:

• Verwenden Sie "cut" ! in der ersten Klausel: denn wenn es stimmt, wissen wir Prolog sollte nicht versuchen, die zweite;
• Verwenden MatchedNumber im rekursiven Aufruf statt Elem;
• Führen ein gebundenes überprüfen Count < Num,
• Tun, die Schrittweite des Zählers Count1 is Count+1 vor dem rekursiven Aufruf; und
• Ersetzen alle Variablen, die Sie nicht verwenden, durch Unterstriche _.

Beispiel ist dann:

?- match([a,b,c,d,e],0,0,X).
X = a.

?- match([a,b,c,d,e],1,0,X).
X = b.

?- match([a,b,c,d,e],2,0,X).
X = c.

?- match([a,b,c,d,e],3,0,X).
X = d.

?- match([a,b,c,d,e],4,0,X).
X = e.

?- match([a,b,c,d,e],5,0,X).
false.

Aber wie gesagt, es ist ineffizient, übergeben Sie ein zusätzliches argument, etc.

Entfernen Sie die ich-te element aus der Liste

Eine fast gleiche Ansatz kann verwendet werden, um die zu entfernen ich-te element aus der Liste:

removei([],_,[]).
removei([_|T],0,T) :-
    !.
removei([H|T],N,[H|TR]) :-
    N1 is N-1,
    removei(T,N1,TR).

Hier die Basis-Fall ist wieder, dass der index 0 in welchem Falle der Schwanz von der Liste entfernt wird (damit fallen den Kopf). Der induktive Fall legen Sie den Kopf der Liste in den Kopf der resultierenden Liste und zählen auf den rekursiven Aufruf von entfernen den richtigen Gegenstand aus dem Schwanz. Ein weiteres base-case removei([],_,[]). wird Hinzugefügt, weil es möglich ist, dass ich größer ist als die Länge der Liste, in dem Fall das Prädikat wird nicht entfernen Sie alle Artikel.

Beispiel

?- removei([a,b,c,d,e],0,X).
X = [b, c, d, e].

?- removei([a,b,c,d,e],1,X).
X = [a, c, d, e].

?- removei([a,b,c,d,e],2,X).
X = [a, b, d, e].

?- removei([a,b,c,d,e],3,X).
X = [a, b, c, e].

?- removei([a,b,c,d,e],4,X).
X = [a, b, c, d].

?- removei([a,b,c,d,e],5,X).
X = [a, b, c, d, e].

?- removei([a,b,c,d,e],6,X).
X = [a, b, c, d, e].

InformationsquelleAutor Willem Van Onsem