Prolog: Spickzettel

Logikprogrammierung mit Fakten, Regeln und Suche

Ausführen: Datei hallo.pl speichern und mit swipl -q -g main -t halt hallo.pl ausführen (SWI-Prolog von swi-prolog.org).

swipl hallo.pl                         # interaktiv: ?- main.
swipl -q -g main -t halt hallo.pl      # main ausführen und beenden
swipl                                  # leere interaktive Konsole
?- consult('hallo.pl').                % Datei laden (in der Konsole)

main :-
    X is 2 + 3 * 4, writeln(X),
    Y is 7 / 2, writeln(Y),
    Z is 7 // 2, writeln(Z),
    M is 7 mod 3, writeln(M),
    P is 2 ** 10, writeln(P),
    Q is 2 ^ 10, writeln(Q),
    R is sqrt(16), writeln(R),
    A is abs(-5), writeln(A),
    B is max(3, 9), writeln(B),
    C is truncate(3.99), writeln(C),
    D is round(3.5), writeln(D),
    E is pi, format("~4f~n", [E]),
    F is 10 rdiv 4, writeln(F),
    G is atan2(1, 1) * 4, format("~3f~n", [G]).

main :-
    L = [1, 2, 3, 4, 5],
    L = [Kopf|Rest], writeln(Kopf), writeln(Rest),
    length(L, N), writeln(N),
    nth0(0, L, E0), nth1(1, L, E1), writeln(E0-E1),
    last(L, Letztes), writeln(Letztes),
    reverse(L, R), writeln(R),
    append([1, 2], [3], A), writeln(A),
    msort([c, a, b, a], M), writeln(M),
    sort([c, a, b, a], S), writeln(S),
    sort(0, @>=, [3, 1, 2, 3], Absteigend), writeln(Absteigend),
    sumlist(L, Summe), writeln(Summe),
    max_list(L, Max), min_list(L, Min), writeln(Min-Max),
    numlist(1, 5, NL), writeln(NL),
    sum_list([1.5, 2.5], FS), writeln(FS).

farbe(rot).
farbe(gruen).
farbe(blau).
form(kreis).
form(quadrat).

main :-
    forall((farbe(F), form(G)), format("~w ~w~n", [F, G])).

benachbart(X, Y) :- X \= Y.

faerbung(A, B, C, D) :-
    Farben = [rot, gruen, blau],
    member(A, Farben), member(B, Farben), member(C, Farben), member(D, Farben),
    benachbart(A, B), benachbart(A, C), benachbart(B, C), benachbart(B, D), benachbart(C, D).

main :-
    faerbung(A, B, C, D),
    format("A=~w B=~w C=~w D=~w~n", [A, B, C, D]),
    aggregate_all(count, faerbung(_, _, _, _), Anzahl),
    format("~d Lösungen~n", [Anzahl]).

satz --> nominalphrase, verbalphrase.
nominalphrase --> artikel, nomen.
verbalphrase --> verb, nominalphrase.
verbalphrase --> verb.
artikel --> [der].
artikel --> [die].
nomen --> [hund].
nomen --> [katze].
verb --> [sieht].
verb --> [schlaeft].

main :-
    ( phrase(satz, [der, hund, sieht, die, katze]) -> writeln(gueltig) ; writeln(ungueltig) ),
    ( phrase(satz, [hund, der, sieht]) -> writeln(gueltig) ; writeln(ungueltig) ),
    findall(S, (phrase(satz, S), length(S, L), L =< 3), Saetze), writeln(Saetze).

main :-
    tmp_file(prolog, Datei),
    setup_call_cleanup(
        open(Datei, write, Aus),
        ( format(Aus, "eins~nzwei~ndrei~n", []), format(Aus, "Zahl: ~d~n", [42]) ),
        close(Aus)),
    read_file_to_string(Datei, Text, []),
    string_length(Text, L), format("~d Zeichen~n", [L]),
    read_file_to_string(Datei, T2, []),
    split_string(T2, "\n", "", Zeilen), writeln(Zeilen),
    setup_call_cleanup(open(Datei, read, In), lies_zeilen(In), close(In)),
    delete_file(Datei),
    ( exists_file(Datei) -> writeln(da) ; writeln(geloescht) ).

lies_zeilen(In) :-
    read_line_to_string(In, Z),
    ( Z == end_of_file -> true ; format("> ~s~n", [Z]), lies_zeilen(In) ).

main :-
    sort(0, @>=, [3, 1, 2], A), writeln(A),
    predsort([O, X, Y]>>(compare(O, X, Y)), [c, a, b], B), writeln(B),
    sumlist([1, 2, 3], S), writeln(S),
    nth1(2, [a, b, c], E), writeln(E),
    sumlist([], Null), writeln(Null),
    last([1, 2, 3], L), writeln(L),
    sum_list([0.1, 0.2], F), writeln(F),
    string_code(1, "A", C), writeln(C),
    char_code(Z, 66), writeln(Z),
    succ(3, N), writeln(N),
    plus(2, P, 5), writeln(P),
    tab(2), writeln(ende).