Kennt sich jemand mit Racket oder vergleichbarem aus?(Lisp,Scheme)

Hätte eine frage zu Racket aber finde kein Forum dafür. Falls mir trotzdem jemand helfen kann wäre ich dankbar

Also ich will eine Funktion erstellen die eine Liste mit Zahlen und eine Zahl aufnimmt.
Ich gehe bei dem beispiel davon aus dass die zahl irgendwo in der liste vorkommt.
Sagen wir die liste ist (5 4 3 2 1) und die zahl ist 2 dann will ich, dass die Zahl der liste hinzugefügt wird und zwar genau hinter der Zahl mit der sie equal ist. Also sollte mein output dann (5 4 3 2 2 1) sein.

Hier mein Problem:

Code:
(define (update-list my-list number)
   (cond [(= (first my-list) number)
          (cons (first my-list) (cons number (rest my-list)))]
         [else
          (update-list (rest my-list) number)]))

Wenn hier die liste wie oben (5 4 3 2 1) und die zahl 2 ist dann bekomme ich als Return eine liste mit (2 2 1) . Das liegt daran dass ich durch die Rekursion jedes mal das erste Element der Eingabeliste verliere und dann nicht mehr darauf zugreifen kann. Aber es gibt meines wissens nach in Racket keine andere Möglichkeit eine liste zu "filtern" und ich kann die verlorenen Elemente auch nicht zwischenspeichern bevor ich sie verliere soweit ich weiß.

Ich bin noch recht neu was Racket angeht. Hoffe dass mir hier jemand helfen kann.
Danke fürs lesen
 
So?
Code:
(define (update-list my-list number)
   (cond [(<= (first my-list) number)
          (cons number my-list)]
         [else 
          (cons (first my-list) (update-list (rest my-list) number))]))
 
Es funktioniert!... Versteh ich aber nicht also den Teil hier "
(cons (first my-list) (update-list (rest my-list) number))"

Wie kann ich das erste Element an den Rekursionsaufruf hängen? Wenn das dann mit dem Rest verbunden wird, müsste es doch auch mit getestet werden...

Aber danke dir! Hänge da schon extrem lange dran.
 
Wie kann ich das erste Element an den Rekursionsaufruf hängen?
Das erste Element partizipiert ja gerade nicht an der Rekursion.

Die Grundidee ist folgende: Wir haben eine Liste mit n Elementen (e1, ..., en) mit e1 >= e2 >= ... >= en. Wir wollen eine Funktion einfuegen(x, (e1, ..., en)) := (e1, ..., ei, x, ej, ..., en) mit ei > x >= ej.

Wenn das einzufügende Element x größer oder gleich dem Kopfelement ist, dann ist das Ergebnis einfach eine Liste (x, e1, ..., en). Damit haben wir den ersten Fall, der zugleich eine Abbruchbedingung der Rekursion darstellt:

einfügen(x, (e1, ..., en)) := (x, e1, ..., en) falls x >= e1

Wenn aber x kleiner als das Kopfelement ist, dann wissen wir nur, dass das x in den Rest der Liste eingefügt werden muss - aber nicht wo. Das müssen wir aber nicht wissen, denn durch Rückgriff (=Rekursion) auf die Funktion einfügen wissen wir, dass einfügen(x, (e2, ..., en)) eine Liste liefert, die das x an der passenden Stelle enthält.

D. h. das Kopfelement bildet zusammen mit dem Ergebnis von einfügen(x, (e2, ..., en)) eine neue Liste, die das Gesamtergebnis darstellt.

einfügen(x, (e1, ... en)) := (e1, einfügen(x, (e2, ..., en))) falls x < e1
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben