So. Ich hab mal in den Unterlagen meines Bruders gekramt, welcher Prolog in der Schule hatte. Dort finden sich einige Sachen
über Listen. Ich weiß nicht genau, was wir davon schon in anderer (oder auch besserer) Form hatten, aber ich dachte mir,
dass es schließlich nicht schaden könnte, wenn ich es hier mal reinschreibe. Es ist teilweise nicht kommentiert, sodass die
Möglichkeit besteht, es als Übungsaufgabe zu verwenden, um herauszufinden, was das Programm eigentlich macht ;-)

erstes( E, [E | _] ).

letztes( X, [X]). % Rekursionsanfang
letztes( X, [_| L1]) :- letztes( X, L1). %ist der Rest nicht
%leer, wird der Kopf entfernt

element( E, [E| _]).
element( E, [_| Rest]) :- element( E, Rest).

element2( E, [_| Rest]) :- element2( E, Rest).
element2( E, [E| _]).


gemeinsam( X, Liste1, Liste2 ) :- element(X, Liste1),
element(X, Liste2).


laenge( [], 0).
laenge( [_ | Liste ], X) :- laenge( Liste, NewX),
X is NewX+1.


ausgabe( []) :- !.
ausgabe( [K| L1]) :- write( K), nl, ausgabe( L1).


verkettet( [], Liste, Liste).
verkettet( [K| Liste1], Liste2, [K| Liste3]) :-
verkettet( Liste1, Liste2, Liste3).


umgekehrt( [], []).
umgekehrt( [K| L1], L2) :- umgekehrt( L1, L3),
verkettet( L3, [K], L2).


vorndran( E, L1, L2):- element( E, L1),
L2 = L1,! .
vorndran( E, L1, L2):- L2 = [E| L1].

vorn_dran( X, L1, L1) :- element( X, L1).
vorn_dran( X, L1, [X | L1]).


hintendran( E, L1, L2) :- element( E, L1),
L2 = L1.
hintendran( E, L1, L2) :- umgekehrt( L1, L3),
verkettet( [E], L3, L4),
umgekehrt( L4, L2).

hinten_dran( E, L1, L2) :- verkettet( L1, [E], L2).

hintendran1( E, [], E).
hintendran1( E, [K| L1], [K| L2]) :- hintendran1( E, L1, L2).


palindrom( L1) :- umgekehrt( L1, L1).


count(_, [], 0). % Rekursionsanfang
count( X, [B| Liste], Anz) :- count(X, Liste, NewAnz),
B \= X,
Anz is NewAnz.
count( X, [B| Liste], Anz) :- count(X, Liste, NewAnz),
B = X,
Anz is NewAnz+1.
%Test: count( a, [a,b,r,a,c,a,d,a,b,r,a], Anzahl_der_a).


summiert([], 0).
summiert( [K| L1], S) :- summiert( L1, NewS),
S is NewS+K.


umkehre( L1, L2):- turn( L1, L2, L1, []).
%Initialisierung: L1 nr2 wird bis [] gekürzt
turn(_, L2, [], L2) :- !. % Abbruch wenn die Liste leer ist turn( L1, L2, [Kopf| NewL1], NewL2) :-
turn( L1, L2, NewL1, [Kopf| NewL2]).


erzeugt( Anz, L1) :- erzeugt( Anz, [], L1).
erzeugt( Anz, L0, L1) :- Anz>0,
NewAnz is Anz-1,
erzeugt( NewAnz, [NewAnz| L0], L1).
erzeugt( 0, L2, L2) :- !.

Fertig! Aber vielleicht weiß ja einer von euch, was dieses Ausrufezeichen bedeutet..? Meine Vermutung: ! gibt 'yes' zurück.
Dadurch kann man die meisten Sachen auch etwas einfach schreiben. Auch eine tolle Übungsaufgabe :-)

hmmm… da sagt unser script !/0 heisst "cut" und zwingt Prolog nach dem ersten gefundenen ergebniss ("yes") abzubrechen
und die DB nicht weiter zu durchsuchen.

gruesse.

Die Ausrufezeichen sind sog. "cuts". Ein cut !/0 macht eine exklusive Fallunterscheidung, bei der alle alternativen Praedikatsklauseln
unterhalb jener, die den cut enthaelt, weggeschnitten werden, bzw. es werden alle alternativen Loesungen fuer Ziele links
vom cut ignoriert.
Es gibt gruene und rote cuts. Die gruenen schneiden nur Suchaeste ab, veraendern die loseungsmenge aber nicht, die roten
tun das, indem sie auch unerwuenschte loesungen abschneiden.

Ist das dann aus dem Zusammenhang zu erkennen, ob es ein roter oder grüner Cut ist oder werden die unterschiedlich definiert?
Ich glaube, ich muss noch ein drittes Mal das Script durchlesen…

Das ! bedeutet "Abbruch" meiner Meinung nach. D.h., wenn die Bedingung vorher erfüllt ist, soll das Programm da nicht weitersuchen.