Fachrat Informatik - Forum

@I-Minister

Quoted

kann bei deiner lösung aber die 2te liste nicht an stelle 1 (bzw. 0) setzen...also ganz annen anfang von liste1

Soll ja auch gar net gehen...

Die erste Liste (list1) soll hinter der x-ten Stelle (position) der zweiten Liste (list2) eingefügt werden.

Ein Anflunchen direkt an den Anfang ist gar nicht vorgesehen...!!!

ich habs jez drin, bin fertig, zufrieden und verängstigt wegen morgen

dir is das glaube ich inzwischen auch mehr als 100x egal...

hätte gestern prüfung machen sollen...ich glaub, das wär was geworden...heute eher nich....mal sehn wies morgen aussieht

Wird eigentlich mit Null oder mit Eins angefangen zu zählen??? Oder verstehe ich wieder was net! Aufgabe ist ja klar nur die Aufgabenstellung finde ich scheiße (sorry)
mfg
MAX

...fang mit 1 an....stelle 1 ist eben KOMPLETT vor der ersten liste (was wie breuti meint ja nichtmal gefragt war)
stelle 2 ist zwischen element 1 und 2 der ersten liste...

klar...

Also, angefangen wird mit der 0! Wenn man aber haben möchte, das die 2. Liste ganz am anfang eingefügt wird, dann sollte man die beiden einfach mit (append liste2 liste1) aneinander hängen, weil nichts anderes wäre das! (oder etwa doch?) Ansonsten war die Aufgabenstellung recht klar!

@MAX: Doch, es wurde an der Stelle 1 eingefügt, die Stelle Null wäre direkt hinter der ersten Zahl der 1. Liste.

also (27 18 4 ... )

Also, bis dann, und viel Glück morgen in der Prüfung!

genau die probier ich grad....
wennichs hinkrieg meld ich mich

genau hier!

(define (delete! list1 list2)
(if (null? (or list1 list2))
list1
(reduce list1 list2 '())))

(define (durchchecken list1 list2)
(if (null? list2)
#t
(if (= (car list1) (car list2))
#f
(durchchecken list1 (cdr list2)))))


(define (reduce list1 list2 final)
(if (null? list1)
final
(if (durchchecken list1 list2)
(reduce (cdr list1) list2 (append final (list (car list1))))
(reduce (cdr list1) list2 final))))

(delete! '(1 2 3 4 5 6) '(2 5))


--------------------------------
delete! is die hauptprozedur

reduce checkt mit durchchecken die komplette list1 durch
wenn durchchecken #t liefert (KEIN element aus list2 in list1) dann hängts (car list1) an die final liste, ansonsten machts weiter und lässt (car list1) wegfallen, daes in list2 ist

durchchecken testet, ob (car list1) = irgendeinem element aus list2 ist


dürften noch fehler drin sein

Sorry, aber das Forum will meinen Beitrag nicht. Die Lösungen veröffentliche ich später woanders!

SCHEIß Forum. Hab ich doch ganz am Anfang schon gesagt.

Jetzt muss ich ab ins Kino...

(define (delete! list d_liste)
(if (>(length d_liste)1)

(delete_one (delete! list (cdr d_liste)) (car d_liste))

(delete_one list (car d_liste))
)
)

(define (delete_one list pos)
(append (teilliste list 0 pos) (teilliste list (+ pos 1) (length list))
))

(define (teilliste liste von bis)
(if (not(= von bis))
(append (list(list-ref liste von)) (teilliste liste (+ von 1) bis))
(append )

)
)

; (teilliste '(1 2 3 4 5 6 7) 0 3)
; (delete_one '(1 2 3 4 5 6) 1)
(delete! '(1 2 3 4 5) '(1 2))
(delete! '(1 2 3 4 5) '(1 2 3))

hi, hab das teil - denke ich - gelöst. teilliste gibt den teil einer liste zwischen der werten von und bis aus.
delete_one benutzt teilliste um ein element aus der liste zu löschen.
delete! wendet delete_one dann mehrmals an.

kleine abwandelung: ich fange bei den listen bie element 0 mit zählen an aber da kann man ja machen wie man will.


enjoy

cowhen


ps: die aufgabe die thilo gepostet hat konnte man auch mit meiner teilliste-prozedur lösen. man brauchte also imho eingentlich nich unbedingt set-cdr!

ich hab die ja missverstanden, naja mir doch auch egal.....

Quoted

Original von migu
Sorry, aber das Forum will meinen Beitrag nicht. Die Lösungen veröffentliche ich später woanders!

Jetzt muss ich ab ins Kino...

Dann springe ich solange mal ein:


Im ersten Aufgabenteil sollte eine unsortierte(!) Baumstruktur mit folgenden Funktionen implementiert werden:

(tree value left right) liefert einen Baum zurück mit value als Wert und den Teilbäumen left und right.

(value tree) liefert den Wert des Baumes tree zurück

(left tree) liefert den linken Teilbaum des Baumes tree zurück

(right tree) liefert den rechten Teilbaum des Baumes tree zurück

(empty-tree) liefert einen leeren Baum zurück

(empty? tree) liefert #t zurück, wenn der Baum tree leer ist, sonst #f



Im zweiten Aufgabenteil sollte eine Prozedur (search tree svalue) geschrieben werden, die einen sortierten(!) Baum tree nach dem Wert svalue durchsucht. Ist svalue in diesem Baum nicht vorhanden, wird #f zurückgeliefert, sonst die Position des gesuchten Wertes in Listenform. Beispiele:
- Ist svalue die Wurzel des zu durchsuchenden Baumes, liefert search () zurück
- Ist svalue die Wurzel des linken Teilbaumes, liefert search (0) zurück
- Ist svalue die Wurzel des rechten Teilbaumes, liefert search (1) zurück
- Ist svalue die Wurzel des linken Teilbaumes des rechten Teilbaumes des rechten Teilbaums von tree (kompliziert, ich weiß...), liefert search (1 1 0) zurück. Also: Um den Wert zu finden, gehe zuerst nach rechts (1), dann wieder nach rechts (1) und dann nach links (0), dann hat man den Wert gefunden.

Ich hoffe, das ist einigermaßen verständlich...

Die Lösungen poste ich in ein paar Minuten. Wer's also selbst lösen will, sollte nicht weiterlesen.


Achso: Hier noch ein Beispielbaum zum Testen:


Habe nochwas vergessen: Bei allen Prozeduren soll davon ausgegangen werden, daß die Argumente die richtige Form haben. Eine Prüfung, ob es sich bei den Argumenten um Bäume, Zahlen, Symbole o. ä. (je nachdem) handelt, ist also nicht notwendig!

ich war mal wieder zu lahm... meine Lösung bekommt ih rtrotzdem..

Also, das hier war Aufgabe von 13.00-15.00 Uhr:

Wir haben einen binären Baum aus einer Wurzel und einem linken und einem rechten Teilbaum.
Wenn dieser Baum geordnet ist, dann stehen im linken Teilbaum immer die kleineren Zahlen
und im rechten Teilbaum die größeren (als die Wurzel).
Als erstes soll man allgemein eine Prozedur schreiben die einen ungeordneten binären Baum
erstellt (tree value left right). Dann eine um auf die Wurzel zuzugreifen (value tree),
eine um auf den linken Teilbaum zuzugreifen (left tree), eine um auf den rechten Teilbaum
zuzugreifen (right tree), eine die einen leeren Baum erstellt (empty-tree) und eine die
überprüft ob ein Baum leer ist (empty? tree).
Danach soll man eine Prozedur "search" schreiben, die eine Zahl aus einem geordneten Baum findet und
den weg zu der Zahl in Nullen und Einsen beschreibt. Wobei eine Null bedeutet, dass man von
der Wurzel aus nach links abbiegen muss und eine Eins, dass man nach rechts abbiegen muss.

Ich hoffe, dass ich das hier einigermaßen richtig wiedergegen habe.

Musterlösung folgt sofort... allerdings hab ich vergessen den geordneten Baum abzuschreiben,
mit dem man sein Programm überprüfen kann... ich denk mir gleich noch einen aus.. (s. Joachim)

(define (tree value left right)
(cons value (cons left right)))

(define (empty-tree)
'())

(define (empty? tree)
(if (null? tree)
#t
#f))

(define (value tree)
(car tree))

(define (left tree)
(cadr tree))

(define (right tree)
(cddr tree))

(define (search treeA wert)
(define (iter tree ausg)
(cond ((empty? tree) #f)
((eq? wert (value tree)) (ausg))
((< wert (value tree)) (iter (left tree) (append ausg '(0))))
((> wert (value tree)) (iter (right tree) (append ausg '(1))))))
(if (empty? tree)
'(tree is empty!)
(iter treeA (empty-tree))))

was hat das > < zu bedeuten?!?

und warum funktioniert deine (joachim) nich bei mir
deine (mieks) noch nich probiert

DER BAUM GEHT:

(define my-tree (tree 18 (tree 7 (tree 4 (empty-tree) (tree 6 (empty-tree) (empty-tree))) (empty-tree)) (tree 21 (tree 20 (empty-tree) (empty-tree)) (empty-tree))))


PS: Ist gesagt, dass in einem linken Teilbaum immer kleinere Werte als die Wurzel stehn, und im rechten grössere???
muss jawohl....dann gehts

Quoted

Original von Informatik Minister
was hat das > < zu bedeuten?!?

Größer und kleiner. (Das weißt du aber, oder?) Hier werden die Werte des Teilbäume verglichen, um zu bestimmen, ob man nach links oder rechts muß, um den gesuchten Wert zu finden.

Quoted

und warum funktioniert deine (joachim) nich bei mir deine (mieks) noch nich probiert

DER BAUM GEHT: [...]

Ja, lag am Baum. Danke. Ich ändere das oben gleich mal.

> < kennich ja, danke

aber der baum ist also geordnet, dass links immer kleinere werte als die wurzel stehn und rechts grössere

denke, dass meinst du (joaquim) mit sortiert...

und das sortierte ist vorausgesetzt ?!?

Quoted

Original von Informatik Minister
> < kennich ja, danke

Hab mich schon gewundert...

Quoted

aber der baum ist also geordnet, dass links immer kleinere werte als die wurzel stehn und rechts grössere

denke, dass meinst du (joaquim) mit sortiert...

und das sortierte ist vorausgesetzt ?!?

Geordnet. Stimmt, so heißt das ja... Das ändere ich oben aber nicht mehr.

Aber du hast Recht. Bei der ersten Teilaufgabe sollen wir das Ding ungeordnet konstruieren. In der zweiten ist Voraussetzung, daß der Baum, den search als Argument bekommt ein geordneter ist (wie in meinem Beispiel). Vielleicht kommen morgen ja geordnete Bäume dran.

Quoted

Vielleicht kommen morgen ja geordnete Bäume dran.

Dann steh ich auf, zieh Tom am Piephahn und renne schnell weg....

Bzw. das ganze nach kurzem "Überblick verschaffen"...

OBWOHL: eigentlich müsst das gehen, bäume sind mir wie gesagt nur unsympathisch durch das blöde einrücken in der aufgabe aus der übung....

nungut...man wird sehen, ich poste meine aufgabe dann zwecks selbstdarstellung bzw. selbstverarschung auch mal ins forum

glück auf!

PS: schlimmer wärs, wenns "zu ordnende" bäume wären