Umsetzung der "For-Schleife" auf prolog

Die kurze Antwort ist, dass Sie nicht.

Prolog ist eine Beschreibungssprache, keine prozedurale Sprache. Es kommt aus dem Prädikat Kalkül. Beschreiben Sie das problem Raum in Form von Fakten und Regeln ("Datenbank"). Dies bildet eine Sammlung von verbundenen, gerichteten Graphen.

Formulieren Sie eine erste Ziel beschreibt, dass die Lösung für dein "problem" und lassen Sie die ableitungsfunktion finden Sie die Lösung(en), wenn überhaupt.

Die Inferenz-engine beginnt mit dem ersten Ziel, das Sie sich geben. Es wertet Sie in Bezug auf die Datenbank, Wandern auf dem Diagramm, wie es geht, backtracking auf Versagen, bis er eine Lösung gefunden (oder auch nicht). Backtracking in der ersten Ziel verursacht einen look für die nächste Lösung, wenn überhaupt.

So die Vorstellung von einem prozessualen Konstrukt wie eine Schleife ist das eher nicht-idiomatische (um das Mindeste zu sagen), und (meiner Erfahrung nach zumindest) ist so ziemlich eine Garantie für schlechte Leistung.

InformationsquelleAutor Nicholas Carey

Nicholas Carey ist korrekt, in der Beratung, dass Sie denken, deklarativ statt prozedural für Prolog. Allerdings nehme ich die Frage auf so etwas bedeuten wie, "Wie kann ich mithilfe von Prolog zu lösen, eine bestimmte Art von Aufgabe, für die ich mich einsetzen würden, loops in anderen Sprachen: vor allem, wie bekomme ich einige Ergebnisse oder Ergebnisse?" Denn es gibt sicherlich Zeiten, wenn die Arbeit vollständig innerhalb einer deklarativen Sprache, die wir beschreiben möchten, N etwas. Der wesentliche Unterschied wird sein, dass anstatt zu passen, jedes problem in einer Schleife, gibt es verschiedene Möglichkeiten der Lösung dieser Art von Problemen, je nach der Natur des Problems selbst.

twinterer Antwort funktioniert, ist aber beschränkt auf ein Imperativ idiom innerhalb einer bestimmten Sprache.

Hier sind mögliche Lösungen für die drei häufigsten Fälle, geschrieben in Allgemeine, deklarative Prolog-Redewendungen:

Für die zahlen von N bis M verwenden, können Sie das eingebaute Prädikat between(N,M,Num):

?- between(1, 5, X).
X = 1 ;
X = 2 ;
X = 3 ;
X = 4 ;
X = 5.

Für eine Liste mit N Instanzen von X, wir können ein Prädikat wie diese:

n_xs(N, X, Xs) :-
    length(Xs, N),          % Creates a list of N uninstantiated variables.
    maplist('='(X), Xs).    % Unifies each variable with X

Dann, um Ihre Liste:

?- n_xs(5, dingo, Ds).
Ds = [dingo, dingo, dingo, dingo, dingo].

Dieses Prädikat kann auch verwendet werden, um zu überprüfen, die Länge einer Liste, die enthält bereits ein homogenes element,

?- n_xs(5, dingo, [dingo, dingo, dingo, dingo, dingo]).
true.

?- n_xs(N, dingo, [dingo, dingo, dingo, dingo, dingo]).
N = 5.

Für das durchführen einer Aktion N-mal, wir können so etwas wie dies:

x_written_n_times(X, N) :-
    foreach(between(1,N,_), write(X)).

?- x_written_n_times('dingo\n', 5).
dingo
dingo
dingo
dingo
dingo
true.

Mehr Informationen über die Arten von looping Verhalten können sein gefunden an der Unterseite von diesem tutorial: http://www.pathwayslms.com/swipltuts/student/index.html

InformationsquelleAutor Shon Feder

Habe ich geschrieben Dolmetscher für imperative Funktionen in Prolog. Dies ist ein Beispiel für die Verwendung:

:- initialization(main).

main :-
    imperative(Result,[
        a = 1,
        b = 2,
        z = b + 1,
        while(a < 10,[
            a = a + 1,
            (a mod 3 = 0) ->
                [writeln(a mod 2),
                writeln(a)]
        ])
    ]),
    writeln(Result).

und dies ist seine Umsetzung:

while(List,Result,Condition,Statements) :-
    get_var(List,Condition_,Condition),
    (Condition_ -> (imperative(List,Result_,Statements),while(Result_,Result,Condition,Statements));
    List=Result).

imperative_(List,Result,Command) :-
    (member(A:_,List),
    replaceP(A:A1,A:A2,List,Result);Result=[A:A2|List]),
    (Command = increment(A,B), A2 is A1 + B;
    Command = increment(A), A2 is A1 + 1;
    Command = decrement(A), A2 is A1 - 1;
    Command = (A = B), get_var(List,A2,B)).

imperative_(List,Result,while(Condition,Statements)) :-
    while(List,Result,Condition,Statements).

imperative_(List,List,writeln(A)) :-
    get_var(List,A_,A),
    writeln(A_).

imperative_(List,Result,(Condition -> Statements)) :-
    get_var(List,Condition_,Condition),
    (Condition_ -> imperative(List,Result,Statements);List=Result).

imperative(Result,Steps) :- imperative([],Result,Steps).

imperative(List,Result,[Step]) :-
    imperative_(List,Result,Step).

imperative(List,Result,[Step|Rest]) :-
    imperative_(List,List1,Step), imperative(List1,Result,Rest).

get_var(List,A2,B) :- phrase(get_var(List,B),[A2]).

get_var(List,get_var(A)) -->
    {get_var(List,A_,A)},[A_].

get_var(List,B) -->
    {member(B:A2,List)},[A2].

get_var(_,B) -->
    {number(B)},[B].

get_var(List,(A+B)) -->
    {get_var(List,A_,A), get_var(List,B_,B), A2 is A_ + B_},[A2].

get_var(List,(A-B)) -->
    {get_var(List,A_,A), get_var(List,B_,B), A2 is A_ - B_},[A2].

get_var(List,(A/B)) -->
    {get_var(List,A_,A), get_var(List,B_,B), A2 is A_ /B_},[A2].

get_var(List,(A*B)) -->
    {get_var(List,A_,A), get_var(List,B_,B), A2 is A_ * B_},[A2].

get_var(List,(A mod B)) -->
    {get_var(List,A_,A), get_var(List,B_,B), A2 is A_ mod B_},[A2].

get_var(List,(A>B)) -->
    {get_var(List,A_,A), get_var(List,B_,B)},[A_ > B_].

get_var(List,(A<B)) -->
    {get_var(List,A_,A), get_var(List,B_,B)},[A_ < B_].

get_var(List,(A,B)) -->
    {get_var(List,A_,A), get_var(List,B_,B)},[(A_,B_)].

get_var(List,(A=B)) -->
    {get_var(List,A_,A), get_var(List,B_,B)},[(A_=B_)].

get_var(List,(A;B)) -->
    {get_var(List,A_,A), get_var(List,B_,B)},[(A_;B_)].

get_var(_,true) -->
    [true].

get_var(_,false) -->
    [false].

% code by @svick, modified to use dif/2 instead of (\=)/2
replaceP(_, _, [], []).
replaceP(O, R, [O|T], [R|T2]) :- replaceP(O, R, T, T2).
replaceP(O, R, [H|T], [H|T2]) :- dif(H,O), replaceP(O, R, T, T2).

InformationsquelleAutor Anderson Green

Gut, habe ich dieses einfache Programm implementiert, dass eine Schleife in Prolog:

:- initialization(main).

loop(I, End) :-
  I > End;
  writeln(I), Ii is I + 1, loop(Ii, End).

main :- loop(0, 10).

Es im Grunde genommen druckt die zahlen von 0 bis 10 (einschließlich).

InformationsquelleAutor Rafael Pontes