Not logged in. · Lost password · Register

Forum: Bachelor Archiv Algorithmik II RSS
Hat da jemand was draus gemacht? Die sind eigentlich recht interessant...
kynan
Member since Dec 2005
158 posts
Subject: Aufgaben aus learn prolog now
Hi Leute,

hat sich jemand von euch schon Übungen aus dem learn prolog now gemacht? (was ich übrigens sehr gut gemacht finde - wenn auch stellenweise etwas sehr ausführlich - und sehr empfehlen kann)

Im Allgemeinen find ich die Aufgaben relativ einfach, manche sind aber auch etwas tricky. Die reiten auch immer ziemlich auf den traces rum, was sicher sinnvoll ist, aber mit der Zeit irgendwie langweilt.

Um zum Punkt zu kommen: Die definieren prefix und suffix von Funktionen so:
prefix(P,L) :- append(P,_,L).
suffix(S,L) :- append(_,S,L).
Und dann ist die Frage: Warum findet prefix (wenn man es mit einer Variablen für P aufruft) zuerst kurze Listen und suffix zuerst lange?
Meine Vermutung ist, dass es an append liegt und append zunächst versucht kurze Listen an lange anzuhängen.

Was meint ihr?

Gruß,
kynan
Comrade
THI-Survivor
Avatar
Member since Nov 2005
623 posts
Sieh dir an was append(X,Y,[a,b,c]) macht und dann siehst du dass es wohl so ist wie du sagst....
der liefert dann fuer X=[] Y=[a,b,c],X=[a],Y=[b,c] usw...
"My uzi weighs a ton..."
andy
your local λ-dealer
Member since Oct 2005
248 posts
Kommt natürlich ganz auf die Def. an, hier mal 2 charakteristische (meistens wird append3 genommen, das von kleinen A, zu grossen A geht):
append2(A,[],A).
append2([AH|AT],[BH|BT],[AH|RT]) :- append2(AT,[BH|BT],RT).
append2([],B,B).

append3([],B,B).
append3([AH|AT],[BH|BT],[AH|RT]) :- append3(AT,[BH|BT],RT).
append3(A,[],A).
Bei solchen Sachen kommt es natürlich extrem auf die Klauselordnung an!
Je nachdem ob erst die Klausel kommt die A=[] oder erst die die B=[] unifiziert ist die Abfolge der Ergebnisse für A und B genau invers. Die ganzen anderen Möglichkeiten zur Klauselordnung hab ich mir auch mal angeschaut, sind aber weniger intuitiv. Einige könnte man als Reissverschluss bezeichnen. :>
"Destroy your lucrative career as a Java programmer: Learn Haskell!"
This post was edited 3 times, last on 2006-09-17, 16:15 by andy.
kynan
Member since Dec 2005
158 posts
Zu den cuts gibts auch noch ne Aufgabe. Da soll man eine prozedur nu/2 schreiben, die Yes zurückgibt, wenn die beiden übergebenen Ausdrücke nicht unifizierbar sind, No wenn sie unifizierbar sind. Dafür soll man weder = noch \+ verwenden. Jemand eine Idee?

Gar keinen Plan hab ich bei der Aufgabe drunter: unifiable(List1,Term,List2).
This post was edited on 2006-09-17, 16:39 by kynan.
andy
your local λ-dealer
Member since Oct 2005
248 posts
Zu den cuts gibts auch noch ne Aufgabe. Da soll man eine prozedur nu/2 schreiben, die Yes zurückgibt, wenn die beiden übergebenen Ausdrücke nicht unifizierbar sind, No wenn sie unifizierbar sind. Dafür soll man weder = noch \+ verwenden. Jemand eine Idee?
Also entweder \= benutzen... ;P
Oder halt einfach:
nu(A,A) :- !, fail.
nu(A,B).

Poste mal die andere Aufgabe, habs grad nicht zur Hand. :>
"Destroy your lucrative career as a Java programmer: Learn Haskell!"
This post was edited on 2006-09-17, 16:47 by andy.
kynan
Member since Dec 2005
158 posts
Oh ja, das wär ne Idee, stimmt. Hab ich wieder nicht genug um die Ecke rum gedacht.

Die andere Aufgabe ist folgende:

Define a predicate
unifiable(List1,Term,List2)
where List2 is the list of all members of List1 that match Term , but are not instantiated by the matching.

For example,
unifiable([X,b,t(Y)],t(a),List]
should yield
List = [X,t(Y)].

Note that X and Y are still not instantiated. So the tricky part is: how do we check that they match with t(a) without instantiating them? (Hint: consider using the test
\+ (term1 = term2)
. Why? Think about it. You might also like to think about the test
\+(\+ (term1 = term2))
.)

Und wo wir schon mal dabei sind:
Ich hab auch noch etwas Schwierigkeiten bei der Implementierung von zwei Funktionen aus der Pratice Session von Kapitel 6: set und flatten.
set(List1,List2)
soll eine Liste zurückgeben, in der alle doppelten Vorkommen von List1 eliminiert sind.
flatten(List,Flat)
soll eine eingeebnete Liste zurückgeben, ohne Verwendung von append.
This post was edited on 2006-09-17, 17:27 by kynan.
thomas_
Member since Nov 2005
100 posts
set([],[]).
set([H|T],[H|Erg]):-not(member(H,T)),!,set(T,Erg).
set([_|T],Erg):-set(T,Erg).

wenn der Head nicht Element der Restliste ist, hänge ihn an die Ergebnisliste, ansonsten verwerfe ihn.
andy
your local λ-dealer
Member since Oct 2005
248 posts
Na wenn sie schon solche Tipps geben...
check_unifiable(A,B) :- \+(\+ A = B). % check ohne Instanzierung (schlägt ja fehl ...)
unifiable(L,T,R) :- filter(check_unifiable(T), L, R).
Achso, filter übrigens als:
filter(P,[H|T],R) :- filter(P,T,R2), ( apply(P,[H]) -> R=[H|R2]; R=R2 ).
Und wenns nicht sowieso schon definiert ist (swi hats zB):
apply(F,Args) :- F=..FL, append(FL,Args,FL2), F2=..FL2, F2.
set (wäre aber wohl schöner mit if-then-else statt Cut) wurde schon erklärt und flatten steht doch in ner alten Klausur als unk (iirc ohne append).
"Destroy your lucrative career as a Java programmer: Learn Haskell!"
This post was edited on 2006-09-17, 18:11 by andy.
thomas_
Member since Nov 2005
100 posts
hm hoffe das ist alles über klausurniveau

chars(X,X):-not(is_list(X)).
chars([H|_],X):-chars(H,X).
chars([_|T],X):-chars(T,X).
flatten(X,XFlat):-findall(Y,chars(X,Y),XFlat).
ValentinesDayMassacre
Nachtelf-Irokese
Avatar
Member since Oct 2005
696 posts
ach ich denke das sogar 5 level niedriger noch zu hoch für mich sind :D
Homer: Lisa, if the Bible has taught us nothing else, and it hasn't, it's that girls should stick to girls sports, such as hot oil wrestling and foxy boxing and such and such.

Respect My Authority!
andy
your local λ-dealer
Member since Oct 2005
248 posts
filter und apply sind ziemlich sicher über Klausurniveau aber das bei nem not bzw \+ keine Instanzierung entsteht sollte doch schon durch SLD-Resultion klar sein... :>
Die entstehenden Substitutionen werden ja einfach weggeschmissen wenns ein "toter Ast" ist.

_thomas' flatten ist ein bisschen zu kompliziert für den Normalgebrauch ^^
Siehe besagte Klausur (zumindest so in der Art wars):
unk([],[]).
unk([H|T],[RH|RT]) :- !, unk(H,RH), unk(T,RT).
unk(X,[X]).
müsste eigentlich auch irgendwo hier im Forum stehen. ;D
"Destroy your lucrative career as a Java programmer: Learn Haskell!"
This post was edited on 2006-09-17, 20:23 by andy.
thomas_
Member since Nov 2005
100 posts
?- unk([1,2,3],X).

X = [[1], [2], [3]]

in den klausuren gabs glaub nur ein unk mit append am schluss
andy
your local λ-dealer
Member since Oct 2005
248 posts
Ach löl dann meinte ich das. ^^
Hätte das jetzt spontan mit Differenzlisten geschrieben oder halt einfach ein eigenes append.
Wollen die etwa wirklich deine Lösung über ein Metaprädikat?
"Destroy your lucrative career as a Java programmer: Learn Haskell!"
This post was edited 2 times, last on 2006-09-17, 20:51 by andy.
Close Smaller – Larger + Reply to this post:
Verification code: VeriCode Please enter the word from the image into the text field below. (Type the letters only, lower case is okay.)
Smileys: :-) ;-) :-D :-p :blush: :cool: :rolleyes: :huh: :-/ <_< :-( :'( :#: :scared: 8-( :nuts: :-O
Special characters:
Go to forum
Datenschutz | Kontakt
Powered by the Unclassified NewsBoard software, 20150713-dev, © 2003-2011 by Yves Goergen