Summe der ersten n zahlen in prolog

Hallo kann mir jemand helfen bei der Berechnung der Summe der ersten n zahlen. Für das Beispiel n=4 => Summe = 10.
Bisher habe ich dies schrieb,

    predicates
  sum(integer,integer)
clauses

  sum(0,0).
   sum(N,R):-
        N1=N-1,
        sum(N1,R1),
        R=R1+N.

Diese arbeitet, aber ich brauche eine andere Implementierung. Ich habe keine Ideen wie ich das machen könnte, diese Unterschiede . Bitte helfen Sie

Was passiert, wenn Sie das Programm ausgeführt haben?
kannst du bitte editieren Sie Ihren code, um klar zu machen, was Kommentar und was ist code? Diese Datei würde nicht laden/kompilieren.
dies scheint zu sein, Visual Prolog, die verwendet benannte Abschnitte und ermöglicht die definition von Datentypen, die innerhalb der domains Abschnitt. Es ist ein wenig off-standard. Der obige code ist syntaktisch gültig Visual Prolog-code (mit der exeception der Rechtschreibfehler "intger").
Ich bin mit Turbo Prolog. Ich bekomme die folgende Fehlermeldung : Freie variable in expresion R=R+N
Turbo Prolog ist das gleiche wie Visual Prolog. Borland kaufte es vor vielen Jahren von Prolog Development Corp und verkaufte es dann später wieder auf. 🙂

InformationsquelleAutor user3043278 | 2014-01-09

6

Was @mbratch sagte.

Was du bist-computing ist eine dreieckszahl. Wenn Sie Ihre Hausaufgaben über die dreieckigen zahlen und nicht über das lernen von rekursiven denken, können Sie einfach berechnen Sie so:
```
triangular_number(N,R) :- R is N * (N+1) /2 .
```
Wenn, was wahrscheinlicher ist, Sie sind das lernen rekursiver dachte, versuchen Sie dies:
```
 sum(N,R) :-    % to compute the triangular number n,
   sum(N,1,0,R) % - invoke the worker predicate with its counter and accumulator properly seeded
   .

 sum(0,_,R,R).     % when the count gets decremented to zero, we're done. Unify the accumulator with the result.
 sum(C,X,T,R) :-   % otherwise,
   C > 0 ,         % - assuming the count is greater than zero
   T1 is T+X ,     % - increment the accumulator
   X1 is X+1 ,     % - increment the current number
   C1 is C-1 ,     % - decrement the count
   sum(C1,X1,T1,R) % - recurse down
   .               % Easy!
```
Bearbeitet, um hinzufügen:

Oder, wenn Sie lieber ein count-down-Ansatz:
```
 sum(N,R) :- sum(N,0,R).

 sum(0,R,R).       % when the count gets decremented to zero, we're done. Unify the accumulator with the result.
 sum(N,T,R) :-     % otherwise,
   N > 0 ,         % - assuming the count is greater than zero
   T1 is T+N ,     % - increment the accumulator
   N1 is N-1 ,     % - decrement the count
   sum(N1,T1,R)    % - recurse down
   .               % Easy!
```
Beide sind tail-rekursive, was bedeutet, dass die prolog-compiler können Sie in iteration (google "tail recursion optimization" für details).

Wenn Sie möchten, beseitigen Sie den Akku, müssen Sie etwas tun, wie dieses:
```
sum(0,0).
sum(N,R) :-
  N > 0 ,
  N1 is N-1 ,
  sum(N1,R1) ,
  R is R1+N
  .
```
Etwas einfacher, aber jeder Rekursion verbraucht ein weiterer Stapelrahmen (stack frame): gegeben sei ein hinreichend großen Wert für N, Ausführung schlägt fehl mit einem stack-überlauf.

Ich verstehe nicht, warum Sie verwendet werden, X und T. ich verstehe den rekursiven Algorithmus für die Summe, aber ich weiß nicht wie ich es schreiben in Prolog. Wenn meine Zahl ist größer als 1 ich hinzufügen, dass die Zahl der Ergebnis und rufen Sie dann die Summe(Zahl-1).
Ich bevorzuge zählen auf, anstatt nach unten. Sechs; ein halbes Dutzend der anderen, wie Sie sagen. Ich habe einen einfachen count-down-version auf meine Antwort. Auch etwas näher, was Sie ursprünglich hatte mit einer Erklärung, warum, habe ich den Ansatz habe ich.

InformationsquelleAutor Nicholas Carey
2
```
sum(N, Sum) :-
    Sum is (N + 1) * N /2 .
```
Noch mehr Details bitte.
siehe Arithmetische progression sum.
Ich glaube, die Antwort Nicholas hat bereits darauf hingewiesen, dass aus. 😉

InformationsquelleAutor salva
2

Da Sie schon viel von der Beratung über Ihren code, lassen Sie mich werfen ein snippet (ein bisschen off-topic).

Zählen, und mehr im Allgemeinen, zu verdichten, es ist ein Bereich, wo der Prolog nicht Leuchten, wenn im Vergleich zu anderen relationalen,deklarative Sprachen (Lesen von SQL). Aber einige herstellerspezifische Bibliothek es viel angenehmer:
```
?- aggregate(sum(N),between(1,4,N),S).
S = 10.
```
InformationsquelleAutor CapelliC
1

Dies ist das "Herz" des Programms:
```
sum(N,R):-
    R=R+N,
    N=N-1,
    sum(N,R).
```
Den =/2 Prädikat (Hinweis: die /2 bedeutet es akzeptiert 2 Argumente) ist die Instanziierung Prädikat, nicht um eine Abtretung oder logisch gleich ist. Es versucht zu vereinen, die seine Argumente machen Sie das gleiche. Also, wenn N ist alles andere als 0, dann R=R+N wird immer scheitern, weil R kann nie die gleiche sein, wie R+N. Ebenfalls für N=N-1: es wird immer fehlschlagen, weil N und N-1 können nie gleich sein.

Im Fall von =/2 (Vereinigung), - Ausdrücke sind nicht ausgewertet. Sie sind nur Begriffe. Also, wenn Y = 1, dann X = Y + 1 vereint X mit 1+1 als ein Begriff, der (in ähnlicher Weise geschrieben +(1,1)).

Wegen der oben genannten Probleme, sum wird immer scheitern.

Numerische Zuordnung eines arithmetischen Ausdrucks erfolgt in Prolog mit der is/2 Prädikat. Wie diese:
```
X is Y + 1.
```
Dieser operator vereint der Wert X der gleiche sein wie der Wert des ausgewerteten Ausdrucks Y+1. In diesem Fall werden Sie auch nicht haben X is X+1 aus den gleichen Gründen, die oben gegeben: X kann nicht das gleiche gemacht wie X+1 und Prolog nicht erlaubt "re-Instanziierung einer Variablen innerhalb einer Klausel. So müssten Sie so etwas wie X1 is X + 1. Beachten Sie auch, dass für is/2 zur Arbeit, alles in den Ausdruck auf der rechten Seite müssen zuvor instanziiert. Wenn alle Variablen in dem Ausdruck auf der rechten Seite nicht einen Wert haben, erhalten Sie eine Instanziierung Fehler oder, im Falle von Turbo-Prolog, Freie Variablen im Ausdruck....

So müssen Sie verschiedene Variablen für den Ausdruck ergibt, und den code zu organisieren, so dass, wenn Sie mit is/2 Variablen, die im Ausdruck instanziiert.

BEARBEITEN

Ich verstehe von Sergej Dymchenko, Turbo Prolog, im Gegensatz zu GNU oder SWI, wertet Ausdrücke für =/2. Also die = wird die Arbeit in der vorgegebenen Problems. Allerdings ist der Fehler bezüglich Instanziierung (oder "freien Variablen") ist immer noch durch das gleiche Problem verursacht, die ich oben erwähnt.

Ich versuchte dies aber immer noch nicht funktioniert sum(N,R):- P=R+N, N1=N-1, sum(N1,P).
Finden Sie unter Elemente meiner Antwort bezüglich =/2 versus is/2. Siehe auch meine Beschreibung in Bezug auf die Ursache der "Freien variable in Ausdruck..." Zuerst müssen Sie is statt =. = ist nicht die richtige Prädikat. Zweitens, in der Reihenfolge, in der Sie existieren in Ihrer Klausel is scheitern wird durch eine Instanziierung (freie variable) Fehler.
mbratch, Visual Prolog (und Turbo Prolog) ist eine lustige Sache, =/2 statt/2: Beispiele hierzu finden Sie unter progopedia.com/implementation/visual-prolog
wow, das ist interessant. Es ist schon eine lange Zeit, seit ich verwendet, Turbo Prolog und ich hatte vergessen, dass Sie wichen von den basic-standard, das ist schade. Die =/2 versus is/2 ist etwas ganz grundlegendes. Ich habe versucht, das Beispiel, das Sie verknüpft GNU Prolog für das Interesse und it-stack übergelaufen (nachdem ich bearbeitet habe, aus der Turbo-Prolog-Umgebung-Gegenstände), wahrscheinlich, weil es versucht, die Vereinigung mit =/2, wie es soll. Aber das heißt, meine Kommentare über "Freie Variablen..." immer noch gelten.

InformationsquelleAutor lurker

sum(N, N, N).  
sum(M, N, S):-
  N>M,
  X is M+1,
  sum(X, N, T),
  S is M+T.


?- sum(1,5,N).
   N = 15 .

InformationsquelleAutor rashedcs

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.