Listen in Prolog


1. Allgemeines


SWI-Prolog Listenmanipulation Teil 1 (library lists)
SWI-Prolog Listenmanipulation Teil 2 (built in)

Eine Liste in Prolog (engl. List) ist eine Liste aus Elementen z.B. [a,b,c,d,e].

Eine Liste besteht aus einem Kopfelement K und dem Rest R [K | R]. -> K = a, R = [b,c,d,e]

Eine Menge (egl. Set) ist eine Liste mit einzigartigen Elementen. Die Elemente kommen jeweils nur einmal in der Liste vor.

Prädikate zum manipulieren von Listen in SWI-PrologKeine Zugangsberechtigung


2. Sortieren


Liste sortieren (sort entfernt Duplikate, msort nicht)
msort([e, i, a, c, g, h, f, b, d ],A).


3. Umkehren


Liste umkehren
reverse([a,b,c], L).



4. Ausgabe


Die Elemente zeilenweise ausgeben
gib_aus([]).
gib_aus([H|T]):-writeln(H), gib_aus(T).


Die Elemente zeilenweise, rückwärts ausgeben
gib_ausr([]).
gib_ausr([H|T]):-gib_ausr(T), writeln(H).


Liste rückwärts ausgeben
gib_aus([ ]):-nl.
gib_aus([H|T]):-gib_aus(T),write(H).



5. Zusammenführen


append([a,b],[c,d],L).


Nachbildung von append
append2([],L,L).
append2([H|T],L,[H|M]):-append2(T,L,M).
?- append2([a,b,c],[d,e,f],L).
L = [a, b, c, d, e, f].


6. Trennen


trennen(Lin,N,L1,L2):-append(L1,L2,Lin),length(L1,N),!.
?- trennen([a,b,c,d,e,f,g,h],5,L1,L2).
L1 = [a, b, c, d, e],
L2 = [f, g, h].



7. Löschen


7.1 delete

Entfernt alle Elemente aus List1
delete(+List1, ?Elem, ?List2)


7.2 nur ein Element entfernen

Entfernt nur ein Element
entferne(E, [E|R], R).
entferne(E, [K|R], [K|R2]):-entferne(E,R,R2),!.


Zusatz für entferne, wenn entferne nicht Scheitern soll, wenn Element nicht vorhanden.
entferne(_,[],[]).


7.3 entferne_alle

Entfernt alle Element unter Verwendung entferne
Identisch mit delete von SWI-Prolog
entferne_alle(E, Lin, Lin):-not(entferne(E,Lin,_)).
entferne_alle(E, Lin, Lout):-entferne(E,Lin,Lzw), entferne_alle(E, Lzw, Lout).


Tests
?- entferne_alle(l,[h,a,l,l,o],L),!.
L = [h, a, o].
?- entferne(l,[h,a,l,l,o],L),!.
L = [h, a, l, o].


7.4 Mehrere Elemente gleichzeitig löschen

delete_list_all(Liste1, Liste2, Liste3).
Alle Elemente aus Liste1 in Liste2 löschen und in Liste3 ausgeben.
delete_list_all([],Liste,Liste).
delete_list_all([H|T],Liste,Restliste):-delete_all(H,Liste,RestlisteTemp), delete_list_all(T,RestlisteTemp,Restliste).
?- delete_list_all([3,4,5],[1,1,2,2,3,3,4],X).
X = [1, 1, 2, 2] ;



8. Länge


length([a,b,c], N).


Nachbildung von length
length2([], 0).
length2([_|T], L):-length2(T, La), L is La + 1.



9. Findall


findall(+Variable, +Ausdruck, +Liste)

Lege alle Variablen für die der Ausdruck gilt in der Liste ab.

zahl(1).
zahl(3).
zahl(7).
?- findall(N, zahl(N), L).
L = [1, 3, 7].


10. List Memebers


10.1 member


Member of a list. Wahr, wenn Elem in der Liste vorhanden.
member(Elem, List).  


Gib die Liste aus
?- member(Elem, [1, a, [x,y] ]).  
Elem = 1 ;
Elem = a ;
Elem = [x, y] ;
fail.


10.2 in_liste


Nachbildung des Prädikats member
in_liste(Elem,[Elem|_]).
in_liste(Elem,[_|Tail]):-in_liste(Elem,Tail).


10.3 first


first_elem(First,[First|_]).


10.4 last


last_elem(Last,[Last]).
last_elem(Last,[_|Tail]):-last_elem(Last,Tail).


10.5 Get element by index


Zugriff auf Element mit Index N, startend bei 1

gebi([K|_],1,K).
gebi([_|R],N,E):-M is N-1, gebi(R,M,E).


?- gebi([a,b,c,d],3,E).
E = c


10.6 mem


mem ( Struktur,Zugriffspfad,Teilstruktur)
gebi([K|_],1,K).
gebi([_|R],N,E):-M is N-1, gebi(R,M,E).
mem(Struktur,[],Struktur).
mem(Struktur,[H|T],Teilstruktur):-gebi(Struktur,H,StrukturTemp),mem(StrukturTemp,T,Teilstruktur).


Test
?- mem ([a,[1,2,[x,y,z],[s,t,u,v,w],3],b,c], [2,3], X).
X = [x,y,z]
?- mem ([a,[1,2,[x,y,z],[s,t,u,v,w],3],b,c], [2,4,3], X).
X = u



11. Permutation


Eine Liste mit Variablen (Lv) wird mit den Werten aus der Liste Le belegt.

permutation(+Lv, +Le).

permu(A,B,C):-permutation([A,B,C,_], [a,b,c,d]).
run:-permu(A,B,C), write(A), write(B), write(C).



12. Extremwerte


Extremum innerhalb einer Liste (Skript S. 37) mittels Rekursion

maximum([K],K).
maximum([K|R],K):-maximum(R,M),K>M,!.
maximum([_|R],M):-maximum(R,M).


minimum([K],K).
minimum([K|R],K):-minimum(R,M),K<M,!.
minimum([_|R],M):-minimum(R,M).


Mittels Sortieren

max(Liste, Maximum) :-
    sort(Liste, SortierteListe),
    reverse(SortierteListe, [Maximum|_]).


min(Liste, Minimum):-sort(Liste, [Minimum|_]).



13. Summe aller elemente


summe([], 0).
summe([H|T], S):-summe(T, A), S is A + H.  


Mit Absicherung gegen nicht-numerische Listeninhalte

summe([], 0).
summe([H|T], S):-number(H), summe(T, A), S is A + H.  


Test
?- summe([1,-2,1,4.2,-1],S).
S = 3.2.





Siehe auch Prolog

There are no comments on this page. [Add comment]

Valid XHTML 1.0 Transitional :: Valid CSS :: Powered by WikkaWiki