Moin,

wie fandet ihr die 1. P1-Klausur von heute vormittag?
Scheme-Teil fand ich richtig klasse, entsprach genau dem, was man nach der Probeklausur erwarten konnte.
Prolog-Teil war dagegen schon heftiger (wie in den vergangenen Jahren wohl auch, wenn man mal im Forum zurückblättert…)…
Mit den 120 Minuten bin ich ganz gut hingekommen, da waren die Aufgaben schon fair zusammengestellt, wie ich finde.

Wie fandet ihr's?

Ich versuche nochmal eine sehr grobe Zusammenfassung der Klausur (ihr könnt ja ergänzen, korrigieren,…):

1.) Prolog Unifikation. 4 Beispiele
2.) 4 Aussagen über Prolog, die ich nicht mehr zusammenbekomme…
3.) Eine Datenbasis eines Ostereiersammlers, die verschiedene Serien und deren Figuren mitsamt ihren Werten, Erscheinungsjahr, etc. enthält. Man sollte nun schreiben, welche Figuren älter als ein Jahr sind und solche Geschichten.
4.) -mir entfallen-
5.) Man sollte aus einer gegebenen Liste wie [[asterix,8] [idefix,5] [obelix,6] [irgendwer,8]] rausfinden, welche Elemente die meisten Stückzahlen (2. Postion in den Unterlisten) hatten. Also hier –> [[asterix,8],[irgendwer,8]]

6.) Scheme Evaluation von Ausdrücken
7.) Scheme Prädikate bauen, die mit Prozenzsätzen was ausrechnen
8.) Scheme rekursive Prädikate (war das auch in Verbindung mit der Berechnung von Prozentsätzen, weiß ich schon gar nicht mehr…) Im Zuge dieser Aufgabe sollte man auch den Unterschied von Endrekursion und allg. Rekursiuon aufzeigen.
9.) Scheme Unterlisten in Listen bearbeiten. Die Aufgabe war ziemlich ähnlich wie die "Tante Emma"-Laden Aufgabe auf dem 13. Übungszettel. Genaueres ist mir entfallen.

Ich fand die Klausur auch ok, härter als erwartet, aber machbar.
Einige Ergänzungen zu den Aufgaben:

Aufgabe 2) Begründen Sie, ob folgende Aussagen wahr oder falsch sind:

i) Anfragen an eine relationale Datenbasis terminieren immer.

ii) Man kann keine Koreferenz zu einer anonymen Variablen herstellen.

iii) Relationen über Listen (z.B. Liste A ist Anfang von Liste B) sind immer transitiv.

iv) Irgendwas mit Stelligkeit von Prädikaten / ungebundenen Variablen

Aufgabe 3)
Nicht Osterei-Sammler, sondern Überaschungseierfigurensammler ;)

Aufgabe 4)
Man sollte eine rekursive Funktion max schreiben:
max([1,2,3,4,6,7,3,2],X) –> X=7

Aufgabe 5)
Man sollte dann auch noch seine eigene Lösung mit einer gegebenen Lösung vergleichen und sagen welche Vor / Nachteile sich ergeben

Aufgabe 8)
Ja, Rekursion mit Prozentsätzen, einmal mit Funktionen höherer Ordnung (map) einmal nur Rekursion:
prozent(20 '(50 100 200)) –> (10 20 40)

Aufgabe 9)
War was mit nem Vogelpark, wobei eine Assoziationsliste gegeben war, etwa in der Art:

((1999 2) (2001 4) (2000 5))

Also im Jahr 1999 wurden 2 Vögel ausgebrütet ;) so in der Art

Dann sollte man eine Funktion schreiben:
(jahr 1999) –> 2

und dann maximum
max(vogelliste) –> 2000

und noch irgendwas?

EDIT:
Eine kleine Gemeinheit, die mir noch eingefallen ist:
Bei der Unifikation (Aufgabe 1) war gefragt:
true=not(false) ?

jau, haerter als die probeklausur. die hab ich in 100 minuten bearbeitet bekommen(allerdings hatte ich da meine buecher bei mir), in der echten klausur dann bin ich nicht ganz fertig geworden mit dem prolog-teil. scheme fand ich auch einfacher.

kann da jemand vielleicht mal seine Lösungen zu den Aufgaben posten (soweit in Erinnerung)?

Also zu der
true = not(false)
hab ich geschrieben, dass hier keine Variablen vorhanden sind, und somit auch keine Unifikationen erstellt werden.

Ich muss sagen, dass ich erstmal voll platt war als ich die erste Seite aufblätterte. Prolog, dann auch noch Theorie in Prolog… Da hab ich so ein Knüppel aufn Kopp Gefühl gehabt und hab erstmal eine Seite weitergeblättert zu dem "Männer-Teil" so mit programmieren und so *G* Und weil ich so verdattert war, hab ausversehen zwei Zettel geblätter und mich gewundert, warum die Aufgaben so schwer anfangen *G*

Naja, ich habs überlebt. Der Scheme Teil viel mir relativ leicht und hat imch beruhigt. Ich hätte besser vorbereitet sein können. In meiner Aufregung hab ich nicht mal den Index des Glossars des P-Skriptes geschnallt.

Aufgabe 3) waren glaube ich noch recht simple Anfragen, alá

% serie(SerienID,Name,AnzFig,Land,Jahr). % figur(FigID,Name,Anzahl,SerienID,Wert,JahrDesWertes) % Welche Figuren hat der Typ aus der Serie XY oder so. % Hat er komplette Serien und wenn ja wieviel sind alle Figuren wert

Zu Aufgabe 2.4)
Ist es wahr dass Strukturen unterschiedlicher Stelligkeit nur unifizieren wenn sie ungebundene Variablen enthalten.


irgendwie so.


Aufgabe 5 war insofern lustig, als dass auf der nächsten Seite eine "alternative" Definition gegeben war. Es ging um eine Liste die man erstellen sollte (wie schon hier beschrieben) die Elemente mit dem größten Werten enthält. Also nicht explizit _das_ größte sondern _die_ Größten. Und ich hatte irgendwie Probleme die mehrfachen Fälle zu berücksichtigen.
Ich war drauf und dran die "alternative" Definition zu übernehmen *G* Aber mir is dann doch noch etwas mehr oder weniger sinnvolles eingefallen.
In diesem Zusammenhang sollte man glaub ich erkennen, dass diese andere Definition nicht sehr performant ist, da sie die Liste 4 Mal auf und absteigt. Man ist demnach wohl angehalten gewesen, ein Prädikat zu bauen, welches die Liste nur einmal rekursiv auf und ab steigt.


Zeit mäßig bin ich nicht ganz hingekommen. Ich hab viel Zeit mit dem Prolog Quatsch verbraten indem ich Definitonen aus dem Skript gesucht aber nicht gefunden hatte.

Also vorher echt mal so Post-It's in die Skripte machen. Lieber eins mehr als zu wenig. (Mal veruschen das auf MAthe anzuwenden ;) )

MfG
Muelli

In diesem Zusammenhang sollte man glaub ich erkennen, dass diese andere Definition nicht sehr performant ist, da sie die Liste 4 Mal auf und absteigt. Man ist demnach wohl angehalten gewesen, ein Prädikat zu bauen, welches die Liste nur einmal rekursiv auf und ab steigt.

4 mal?

Ups, dachte nur 2 mal beim findall jeweils?
Wo denn noch?

Da war noch die Maxliste, die das ganze auf- und abgebaut hat und das andere Prädikat hat meines Erachtens die Liste auch nochmal auseinander gepflückt.
Also 2 findall, die maxlist und eine andere listenfunktion glaub ich.. auf jeden Fall ein vielfaches von dem, was wir gebraucht haben

Weiß jemand wann es die Ergebnisse geben wird?

Weiß jemand wann es die Ergebnisse geben wird?

Letztes Jahr gab es die ersten Ergebnisse während des
Prolog-P-Praktikums, wo die Teilnehmer ihre Noten direkt
von Herrn Menzel erfahren konnten. [img]http://www.fb18.de/gfx/23.gif[/img]

Ein weiterer Grund, an diesem sehr interessanten Praktikum
teilzunehmen! Ich kann das nur empfehlen! [img]http://www.fb18.de/gfx/14.gif[/img]

Ich habe leonie dreschler fischer gefragt und sie meinte so in drei wochen.

Da war noch die Maxliste, die das ganze auf- und abgebaut hat und das andere Prädikat hat meines Erachtens die Liste auch nochmal auseinander gepflückt.
Also 2 findall, die maxlist und eine andere listenfunktion glaub ich.. auf jeden Fall ein vielfaches von dem, was wir gebraucht haben

member war auch noch dabei, das wühlt auch nochmal alles durch.

Ich habe leonie dreschler fischer gefragt und sie meinte so in drei wochen.

wat, so lange? wie soll man das denn aushalten?

da gibts welche die brauchen deutlich länger… *g*

Also, ich hab' mit Dreschler-Fischer geredet und sie meinte: "Ja, gestern (Sonntag) sind wir fertig geworden, die Klausuren sind jetzt in der Verwaltung und bis spätestens Freitag hängen die Ergebnisse aus."

Also… bald hat das Warten ein Ende.

5.) Man sollte aus einer gegebenen Liste wie [[asterix,8] [idefix,5] [obelix,6] [irgendwer,8]] rausfinden, welche Elemente die meisten Stückzahlen (2. Postion in den Unterlisten) hatten. Also hier –> [[asterix,8],[irgendwer,8]]

Wie wende ich denn Maximum auf eine Liste mit Unterlisten an?
Das Maximum aus einer Liste mit den jew. isolierten "Resten" der
Unterlisten herauszubekommen ist nicht das Problem…
Aber wie bekomme ich als Ergebnis das PAAR ?
Kann bitte mal einer ne entspr. Prädikatdef. oder Vorgehensweise posten ?

5.) Man sollte aus einer gegebenen Liste wie [[asterix,8] [idefix,5] [obelix,6] [irgendwer,8]] rausfinden, welche Elemente die meisten Stückzahlen (2. Postion in den Unterlisten) hatten. Also hier –> [[asterix,8],[irgendwer,8]]

Wie wende ich denn Maximum auf eine Liste mit Unterlisten an?
Das Maximum aus einer Liste mit den jew. isolierten "Resten" der
Unterlisten herauszubekommen ist nicht das Problem…
Aber wie bekomme ich als Ergebnis das PAAR ?
Kann bitte mal einer ne entspr. Prädikatdef. oder Vorgehensweise posten ?

Gleicher Algorithmus wie bei einer normalen Maximal-Suche: Wir merken uns das bisher maximale Element und gehen die Liste durch. Dabei suchen wir nach größeren Elementen als jenes, welches wir bisher gefunden hatten. Dass unsere Elemente jetzt etwas komplexer aufgebaut sind stört ja nicht, wir haben ja pattern matching/Unifikation:

% max_stueckzahl(Liste, Groesstes_element_der_Liste). max_stueckzahl([[Name,Number]|Rest], [Maxname, Maxnumber]) :- max_stueckzahl_helper([Name,Number], Rest, [Maxname, Maxnumber]). % max_stueckzahl(Aktuell_groesstes_element, Liste, Groessteselement). % Wenn die Liste leer ist, ist unser bisher groesstes Element das % groesste der Liste. max_stueckzahl_helper([Maxname, Maxnumber], [], [Maxname, Maxnumber]). % Wenn das erste Element der Liste größer ist als das bisher größte % Element, dann ist das erste Element jetzt unser größtes. max_stueckzahl_helper([Currname, Currnumber], [[Name, Number]|Rest], [Maxname, Maxnumber]) :- Number > Currnumber, max_stueckzahl_helper([Name, Number], Rest, [Maxname, Maxnumber]). % Wenn es kleiner ist, bleibt unser bisher größtes Element das größte. max_stueckzahl_helper([Currname, Currnumber], [[Name, Number]|Rest], [Maxname, Maxnumber]) :- Number =< Currnumber, max_stueckzahl_helper([Currname, Currnumber], Rest, [Maxname, Maxnumber]).
Der kleiner-gleich Check im zweiten rekursiven Aufruf verhindert falsche Resultate beim Backtracking.


Edit: Beim zweiten Teil sollte die Rekursion natürlich mit Currname und Currnumber laufen!

…Das leuchtet ein. "1" Paar mit dem Maximum (8) wird geliefert,
aber wie sieht die Def. aus wenn alle Paare ausgegeben werden sollen
die "8", also das Maximum als Wert haben, also [asterix, 8], [irgendwer, 8]?
Wäre nett wenn du dafür eine Lösung bringen könntest…

…Das leuchtet ein. "1" Paar mit dem Maximum (8) wird geliefert,
aber wie sieht die Def. aus wenn alle Paare ausgegeben werden sollen
die "8", also das Maximum als Wert haben, also [asterix, 8], [irgendwer, 8]?
Wäre nett wenn du dafür eine Lösung bringen könntest…

Du bestimmst das Maximum und lässt dann ein findall drüberlaufen.

"Left as an exercise to the reader" - wenn man alle ausgeben soll, dann ist das "bisher größte" eben kein einzelner Eintrag sondern eine Liste. Vergleichen kann man mit dem Kopf der Liste.

Probier das mal zu implementieren. Du wirst dabei feststellen wo du noch Probleme hast. Versuche diese Probleme als Frage zu formulieren ("Ich habe xy gemacht. Dabei dachte ich, dass ab passiert. Irgendwie passiert aber ef. Häh?"). Kannst du dann hier posten, samt Lösungsversuch, ich kommentiers gerne…

Edit:

Du bestimmst das Maximum und lässt dann ein findall drüberlaufen.

Daumenregel: Wenn die Antwort findall beinhaltet, ist sie fast immer falsch :-)

max_stueckzahl2([[Name,Number]|Rest], [[Maxname, Maxnumber]|R]) :-
max_stueckzahl_helper2([[Name,Number]], Rest, [[Maxname, Maxnumber]|R]).


max_stueckzahl_helper2([[Maxname, Maxnumber]|R], [], [[Maxname, Maxnumber]|R]).

max_stueckzahl_helper2([[Currname, Currnumber]|R], [[Name, Number]|Rest], [[Maxname, Maxnumber]|R]) :-
Number > Currnumber,
max_stueckzahl_helper2([[Name, Number]], Rest, [[Maxname, Maxnumber]|R]).

max_stueckzahl_helper2([[Currname, Currnumber]|R], [[Name, Number]|Rest], [[Maxname, Maxnumber]|R]) :-
Number < Currnumber,
max_stueckzahl_helper2([[Currname, Currnumber]|R], Rest, [[Maxname, Maxnumber]|R]).

max_stueckzahl_helper2([[Currname, Currnumber]|R], [[Name, Number]|Rest], [[Maxname, Maxnumber]|R]) :-
Number = Currnumber,
max_stueckzahl_helper2([[Name, Number]|R], Rest, [[Maxname, Maxnumber]|R]).



liste([[asterix,8],[idefix,5],[obelix,6],[irgendwer,8],[idefix,2]]).

%?-liste(_L),max_stueckzahl2(_L, Maxpaare).
%–> bringt: maxpaare = [[irgendwer, 8]]

Das Problem steckt mind. im 3. Fall (Number = Currnumber), jedenfalls
werden Paare mit gleichen Werten nicht in Liste übernommen. Hab schon div.
Versionen probiert…. Hast du nen Tip ? Danke!

Du bekommst:
- Die bisherige Liste: [[Currname, Currnumber]|R]
- Das aktuelle Element: [Name, Number]
Du willst:
- Das neue "bisherige" liste an den rekursiven Aufruf übergeben.

Keine Idee, wie du das machen könntest?

Daumenregel: Wenn die Antwort findall beinhaltet, ist sie fast immer falsch :-)

warum sollte das falsch sein:
max_stueckzahl(Liste,[Maxname,Maxnumber]),findall([Name,Maxnumber],Liste,Ergebnis).

warum sollte das falsch sein:
max_stueckzahl(Liste,[Maxname,Maxnumber]),findall([Name,Maxnumber],Liste,Ergebnis).

Hast du das mal ausprobiert?

findall/3 arbeitet über den Backtrackingergebnissen eines Prädikats. D.h. wenn man am Prompt mit ; durch die ganzen Ergebnisse cyclen kann, könnte man diese Ergebnisse mit findall in eine Liste packen. Es arbeitet nicht über eine Liste.

Wenn du das direkt mit findall/3 machen könntest, wäre der Syntax:

findall(Einzelmax, max_stueckzahl(Liste, Einzelmax), Ergebnis).
Bedeutet: Wir geben max_stueckzahl(Liste, Einzelmax) ein und wollen alle Backtracking-Ergebnisse dieses Prädikats haben. Aus diesen Ergebnissen interessiert uns nur der Wert von Einzelmax. Bitte packe also alle Werte von Einzelmax in Ergebnis. Danke.

findall(+Template, +Goal, -Bag) Creates a list of the instantiations Template gets successively on backtracking over Goal and unifies the result with Bag. Succeeds with an empty list if Goal has no solutions. findall/3 is equivalent to bagof/3 with all free variables bound with the existence operator (^), except that bagof/3 fails when goal has no solutions.
So. Preisfrage: Warum funktioniert Backtracking bei dem Prädikat da oben nicht?

?- max_stueckzahl([[foo, 8],[bar,9],[baz,9],[qux,7]], R). R = [bar, 9] ; No
Preisfrage 2: Warum funktioniert diese Lösung hier?
Ist diese Lösung besser oder schlechter als max_stueckzahl2, welches hier im Thread besprochen wurde?

?- Liste=[[foo, 8],[bar,9],[baz,9],[qux,7]], max_stueckzahl(Liste,[Maxname,Maxnumber]), findall([Name, Maxnumber], member([Name, Maxnumber], Liste), Ergebnis). Liste = [[foo, 8], [bar, 9], [baz, 9], [qux, 7]] Maxname = baz Maxnumber = 9 Name = _G195 Ergebnis = [[bar, 9], [baz, 9]]

Deine Lösung ist schon mal deswegen besser weil sie funktioniert ;)

Findall ist in diesem Fall anwendbar, weil es auf die Funktion
member angewendet wird, und member in diesem Fall ja soetwas ausgibt:

Name = bar
Maxnumber = 9 ;

Name = baz
Maxnumber = 9 (Maxnumber muss wegen max_stueckzahl ja Maximum,also hier "9" sein)

findall sammelt die Ergebnisse dann auf und setzt sie jew. in []
so dass eine Liste von Paaren entsteht…. oder?

Also ist das so praktikabel sagst du.
Was max_stueckzahl2 betrifft bin ich ratlos ! Lösung?
Oder ist die findall-Geschichte good enough ?

Findall ist in diesem Fall anwendbar, weil es auf die Funktion
member angewendet wird, und member in diesem Fall ja soetwas ausgibt:
[…]
findall sammelt die Ergebnisse dann auf und setzt sie jew. in []
so dass eine Liste von Paaren entsteht…. oder?

Genau. findall/3 sammelt alle Lösungen eines Prädikats in eine Liste.

Also ist das so praktikabel sagst du.
Was max_stueckzahl2 betrifft bin ich ratlos ! Lösung?
Oder ist die findall-Geschichte good enough ?

Die findall/3-Lösung ist ineffizient: Man geht zwei mal durch die Liste durch, anstatt nur einmal.

Kleiner Bug in deiner Lösung: Du hast mehrfach die Variable R doppelt verwendet - sowohl für den Rest der "aktuell größten" Liste, als auch für die Liste, die den Rückgabewert darstellt. Ist das gewollt? :-)

Ich schreib mal die richtige Lösung für max_stueckzahl_helper2/3 im Fall von Currnumber = Number auf. Dabei verwende ich einen "Trick", den ich recht hilfreich fand um Prolog zu verstehen: Ich nehme nur normale Variablen als Argumente und splitte sie per Unifikation erst später auf. Das ist genau das gleich was Prolog auch so macht, nur mit einem Zwischenschritt. Vielleicht hilft das beim Verständnis:

max_stueckzahl_helper2(Current, List, Result) :- % Unser aktuell höchstes, mit Restliste Current = [[Currname, Currnumber]|Currrest], % Die Liste, die wir abarbeiten List = [[Name, Number]|Rest], % Wenn die Zahl aus dem Kopf der Liste gleich der % Zahl des aktuell höchsten ist... Number = Currnumber, % ...ist ab sofort das "höchste Ergebnis" eine Liste, % deren Kopf der Kopf unserer Liste ist, und deren Rest % die Liste mit den bisherig höchstem Wert ist. Newcurrent = [[Name, Number]|Current], % Rekursion! max_stueckzahl_helper2(Newcurrent, Rest, Recursive_result), % Und den Rückgabewert "hochreichen" Result = Recursive_result.
Kurform:
max_stueckzahl_helper2(Current, [[Name, Number]|Rest], Result) :- Current = [[_, Number]|_] max_stueckzahl_helper2([[Name, Number]|Current], Rest, Result).

…So hab ich das verstanden, danke! Nun hab ich hier noch ne Sache ;)

Ich übergebe eine sortierte Liste von Paaren.

?- summierte_liste([[aschneider, 30000], [rico, 470000], [rocko, 4000], [rocko, 40000]],ListOut).

summierte_liste(+Liste,?Liste) soll folgendes machen:
Sobald aufeinanderfolgende Paare den gleichen Namen haben (1.Pos),
sollen die beiden Paare zusammengefasst werden (Betrag addieren).
Wenn bei aufeinanderfolgenden Paaren die Namen unterschiedlich sind
wird das Paar unverändert in die Arbeitsliste aufgenommen.



summierte_liste([[Kunde,Betrag]|Rest],ListOut):- helper([[Kunde,Betrag]|Rest],ListOut).

helper([[Kunde,Betrag]|Rest],[[KundeX,BetragX]|RestX]):- helper2([[Kunde,Betrag]],Rest,[[KundeX,BetragX]|RestX]).

helper2([[KundeX,BetragX]|RestX],[],[[KundeX,BetragX]|RestX]).

helper2(Current, [[Name, Number]|Rest], Result) :-
[[Name,_]|_] \= Current,
helper2([[Name, Number]|Current], Rest, Result).


helper2([[Currname, Currnumber]|R], [[Name, Number]|Rest], Result) :-
Currname = Name, Number2 is Currnumber+Number,
helper2([[Name, Number2]|Current], Rest, Result).


Problem: Bei unterschiedlichen Namen wird das entspr. Paar nicht übernommen
(Summieren haut aber hin),

Es lohnt sich seinen Quellcode so zu schreiben, dass er gut lesbar
ist. In Prolog bedeutet das normalerweise, dass ein Komma und ein :-
stets die Zeile beendet und die nächste Zeile eingerückt wird. Es kann
dann teilweise auch praktisch sein bei längeren Ausdrücken die
Argumente eines Prädikats auf mehrere Zeilen - eingerückt natürlich -
aufzusplitten.

Zu deiner Lösung…

Erstmal würde ich den Betrag eines Kunden in einer einzelnen Liste
sammeln - es gibt keinen Grund die zu verschachteln.

Ansonsten (mit schöner uneinheitlichen Variablenbenamsung):

summierte_liste([[Kunde,Betrag]|Rest],ListOut) :- helper2([Kunde,Betrag], Rest, ListOut). % Es lohnt auch bei den Prädikaten dazuzuschreiben, was sie eigentlich % tun sollten. % helper2(Bisher, Liste, Ergebnis). % Ergebnis wird mit einer Liste unifiziert, in welcher alle % sukzessiven doppelten aus der Liste auf ein einzelnes Element % abgebildet wurden. % Wenn nichts da ist, bleiben wir bei dem, was wir bisher haben. helper2([Kunde, Betrag],[],[[Kunde, Betrag]]). % Wenn der aktuell zu bearbeitende Kunde nicht mehr in der Liste % folgt, schmeißen wir doppelte aus der Liste raus (mit helper/3) und % hängen das Ergebnis an den Kopf der Ergebnisliste an. helper2([Kunde, Betrag], [[Name, Number]|Rest], Result) :- Kunde \= Name, helper2([Name, Number], Rest, Temp_Result), Result = [[Kunde, Betrag]|Temp_Result]. % Wenn der Name gleich ist, addieren wir auf. helper2([Kunde, Betrag], [[Name, Number]|Rest], Result) :- Kunde = Name, Neu_Betrag is Betrag + Number, helper2([Kunde, Neu_Betrag], Rest, Result).
Man beachte hierbei, dass wir das Ergebnis nicht sammeln um es am Ende
der Ergebnisvariable zuzuweisen, sondern, dass wir hier im rekursiven
Aufstieg noch das Ergebnis berechnen.

Vielen Dank für die Lösung!

Ich hab bei meiner Version den Fehler gefunden:

beim letzten Fall (Namen gleich) hatte ich den Rest
im Rekursionsschritt "helper2([[Name, Number2]|R]"
mit "Current" benannt. Wenn ich ihn "R" nenne gehts.

(…)
helper2([[Currname, Currnumber]|R], [[Name, Number]|Rest], Result) :-
Currname = Name,
Number2 is Currnumber+Number,
helper2([[Name, Number2]|R], Rest, Result).

Es funktioniert. Oder siehst du ein Problem dies
so zu implementieren, nen schwerwiegenden Fehler…?

Kein Fehler, nur unnötige Arbeit :-) Überleg dir mal wie viele Element deine Current-Liste hat.

Hi, ich hab ne Frage zu Scheme:

Das Maximum aus einer Liste mit Paaren finden
…geht ja hiermit:

(define (max_p x y)
(if (> (cdr x) (cdr y)) x y))

(define (max_pl liste)
(car(reduce max_p liste (car liste))))

…aber hat jemand eine rekursive Definition für mich ?
Ich bekomme es einfach nicht hin….

(define (max_pl liste)
(cond ((= (length liste) 1) (car liste))
((> (cdr (car liste)) (max_pl (cdar(cdr liste)))
(car liste)))

(else (max_pl (cdr liste)))))

Nach "> Vergleich" wird "(max_pl (cdar(cdr liste)))" ja wieder
übergeben und dann passt es natürlich mit "length" nicht…
hab den Überblick verloren…

Ein kleiner Hinweis zum Quellcode schreiben (gilt für alle Sprachen):
Versuche ihn so zu schreiben, dass man in _lesen_ kann. Das hilft dir
selbst am meisten.

Einige Hinweise für Scheme gibts unter http://community.schemewiki.org/?scheme-style

Das Maximum aus einer Liste mit Paaren finden
…geht ja hiermit:

(define (max_p x y) (if (> (cdr x) (cdr y)) x y)) (define (max_pl liste) (car (reduce max_p liste (car liste))))
…aber hat jemand eine rekursive Definition für mich ?
Ich bekomme es einfach nicht hin….

(define (max_pl liste) (cond ((= (length liste) 1) (car liste)) ((> (cdr (car liste)) (max_pl (cdar (cdr liste)))

Und spätestens hier merkt man dank Auto-Indentierung des Editors und
sinnvollem Quellcode, dass da eine Klammer fehlt. Dazu braucht man
nichtmal Klammern-Highlighting, das geht sehr automatisch.

(define (max-pl liste) (if (null? (cdr liste)) (car liste) ;; Wir speichern jetzt erstmal das Maximum des Restes der Liste, ;; das brauchen wir nämlich mehrfach. (let ((rest-max (max-pl (cdr liste)))) ;; Wenn das erste Element größer ist als das größte Element ;; des Restes ... (if (> (cdr (car liste)) (cdr rest-max)) ;; ... ist das erste Element das größte der Liste (car liste) ;; Ansonsten ja das größte Element des Restes rest-max))))
Und endrekursiv über Akkumulator mit Hilfsfunktion:

;; Gleicher Trick wie in Prolog: Wir nehmen einfach das erste Element ;; als das bisher größte. (define (max-pl-iter liste) (max-pl-iter-i (car liste) (cdr liste))) (define (max-pl-iter-i max liste) (cond ((null? liste) max) ((> (cdr (car liste)) (cdr max)) (max-pl-iter-i (car liste) (cdr liste))) (else (max-pl-iter-i max (cdr liste)))))