Dr. Scheme Archives - Modius

Dr. Racket 5.3.1: Berechnung des Flächeninhaltes eines Rechteckes

Veröffentlicht am 27. März 2013 von Christian Piazzi Hinterlasse ein Kommentar , Aktualisiert am 25. März 2013

Ok heute gibt es mal einen rein praktischen Artikel. Ich habe eine kleine Funktion geschrieben, die den Flächeninhalt eines Rechteckes aufgrund von 2 Koordinaten berechnet. Wir haben dabei einen x und einen y Wert für den Startpunkt (obere Linke Ecke) und einen x und y Wert für den Endpunkt (untere Rechte Ecke) des Rechteckes.

Das heißt unsere Funktion bekommt 4 Parameter in Form von Zahlen. Aber ich will nicht länger um den heißen Brei reden. Darum hier die Funktion:

;;example: (rect-area -1 4 2 0)  = 12

(define (rect-area x1 y1 x2 y2)
        (* (- (max x2 x1) (min x2 x1)) (- (max y2 y1) (min y2 y1)))
)

;;example: (rect-area -1 4 2 0) = 12

(define (rect-area x1 y1 x2 y2)

(* (- (max x2 x1) (min x2 x1)) (- (max y2 y1) (min y2 y1)))

)

Ok ich habe hier zwei neue Befehle verwendet. min und max. Diese dient dazu, bei einem Zahlenpaar die größer bzw. kleiner zu erkenne. In der Funktion oben sorgen ich damit zum Beispiel dafür, dass immer die kleiner Zahl von der größeren abgezogen wird. Damit erhalt ich zwei Seitenlängen. Diese werden dann miteinander multipliziert und ergeben den Flächeninhalt.

Dr. Racket 5.3.1: Die Funktion member verwenden

Veröffentlicht am 20. März 2013 von Christian Piazzi Hinterlasse ein Kommentar , Aktualisiert am 20. März 2013

Heute will ich euch mal eine vordefinierte Funktion von Dr. Racket zeigen. Es handelt sich dabei um die member Funktion. Mit dieser Funktion könnt ihr feststellen, ob sich ein bestimmtes Zeichen (Character) in einer Liste befindet oder nicht. Als Rückgabewerte bekommt ihr einen Wahrheitswert. Hier mal ein Codebeispiel:

(member ‘a (list a b c))

1	(member ‘a (list a b c))

–>true

(member ‘d (list a b c))

1	(member ‘d (list a b c))

–>false

Diese Funktion kann in verschiedenen Situation recht nützlich sein und es ist gut sie einfach mal gesehen zu haben =)

Dr. Racket 5.3.1: Die Funktion map verwenden

Veröffentlicht am 13. März 2013 von Christian Piazzi 1 Comment , Aktualisiert am 13. März 2013

In diesem Artikel geht es auch wieder um eine vordefinierte Funktion von Dr. Racket. Es handelt sich dabei um die map Funktion. Mit dieser Funktion könnt ihr komplette Listen verändern. Ein kleines Beispiel währe wenn ihr eine Liste mit Zahlen habt und nun eine Liste der Quadratzahlen haben wollt. Der Code dafür währe:

(map sqr ‘( 7 2 3))

1	(map sqr ‘( 7 2 3))

–> (list 49 4 9)

Wie wir hier sehen würden wir eine neue Liste zurückgegeben bekommen, welche als Inhalt die Quadrzahlen der ersten Liste hat. Ein weiters Anwendungsbeispiel währe das Vergleichen von Listen.

(map <= '(1 2) '(2 1))

1	(map <= '(1 2) '(2 1))

–> (list true false)

In diesem Code vergleicht er nun die beiden ersten Zahlen und die beiden zweiten Zahlen miteinander und überprüft welche größer ist. Die Antwort bekommen wir in einer neuen Liste zurückgegeben.

Auch diese Funkton kann wirklich nützliche sein =)

Dr. Racket 5.3.1: Funktion anlegen und verwenden

Veröffentlicht am 6. März 2013 von Christian Piazzi Hinterlasse ein Kommentar , Aktualisiert am 6. März 2013

So langsam wird es interessant. Heute geht es um das erstellen der ersten Funktion in Dr. Racket. Und wir legen auch direkt los.

Unsere Aufgabe heute ist es, eine Funktion zu schreiben die eine Zahl erhält und davon die Quadratzahl errechnet.

Kleines Beispiel: Die Funktion bekommt die Zahl 2 übergeben. Das Ergebnis währe hier 4

Nun schreiben wir den Quellcode dafür:

(define (quadrat x)
        (* x x))

1 2	(define (quadrat x) (* x x))

Wir definieren hier eine Funktion mit dem Namen „quadrat“ die den Parameter x übergeben bekommt. Als nächstes wollen wir die Funktion test. Dafür schreiben wir folgenden Code dazu:

(quadrat 5)

1	(quadrat 5)

Haben wir alles richtig gemacht erscheint nun das Ergebniss in unserer Ausgabe (25).

Wir sehen also das wir mit Funktionen auch komplexere Aufgaben lösen können und diese vorallem an jeder anderen Stelle weiterverwenden können.

Dr. Racket 5.3.1: Listen anlegen und verwenden

Veröffentlicht am 27. Februar 2013 von Christian Piazzi 3 Comments , Aktualisiert am 22. Februar 2013

Diesmal soll es um einen aus meiner Sicht recht wichtigen Teil für Dr. Racket. Um das Anlegen und verwenden von Listen. In Listen könnt ihr dynamische Datenstrukturen speichern die in irgendeiner Form miteinander in Beziehung stehen.

Ich möchte euch zuerst zeigen wie ihr Listen in Dr. Racket anlegen könnten und danach wie ihr die Information aus listen weiterverwenden könnt.

Anlegen von Listen

Um Listen in Dr. Racket anlegen zu können, müsst ihr natürlich zuerst die Entwicklungsumgebung starten =) Wir unterscheiden drei Möglichkeiten, Listen in Dr. Racket anzulegen.

;; Möglichkeit 1
(cons 0 (cons 1( cons 2( cons 3 emtpy))))

;; Möglichkeit 2
(list 1 2 3)

;; Möglichkeit 3
‘(1 2 3)

;; Möglichkeit 1

(cons 0 (cons 1( cons 2( cons 3 emtpy))))

;; Möglichkeit 2

(list 1 2 3)

;; Möglichkeit 3

‘(1 2 3)

Bei jeder der drei Möglichkeiten ensteht die selbe Liste, nämlich eine Liste mit den Zahlen eins, zwei und drei als Inhalt. Bei Möglichkeit 1 wird jedes Element nacheinander in die Liste geschrieben. Diese Variante wird oft für rekursive Methoden verwendet, bei denen eine List als Ergebnis zurückgegeben werden soll.
Möglichkeit zwei und drei erzeugen direkt eine Liste mit den gewünschten Inhalten. Möglichkeit 3 ist im wesentlichen nur die Kurzschreibweise von Möglichkeit 2. Ich persönliche würde aber eher die zweite Variante verwenden, da es bei der dritten Variante öfters mal zu Fehlern kommen kann. Um nun mit der Liste arbeiten zu können müssen wir eine liste anlegen und dieser einen Namen vergeben. Ich verwende dafür mal Variante zwei.

(define lon (list 1 2 3))

1	(define lon (list 1 2 3))

Listen auslesen

Ok wir haben nun mit einer der drei möglichen Varianten eine Liste mit den Zahlen von eins bis drei angelegt. Nun wollen wir auf die einzelnen Elemente zugreifen. Um auf das erste Element der Liste zuzugreifen verwenden wir den folgenden Code:

(first lon)

1	(first lon)

Wollen wir nun den Rest der Liste haben, also eine Liste die aus den Zahlen zwei und drei besteht verwenden wir den folgenden Befehl.

(rest lon)

1	(rest lon)

Woran liegt das nun? Ein Listeneintrag kann immer nur aus zwei werten bestehen, einem First und einem Rest. Habe ich nun eine Liste aus drei Zahlen habe ich als ersten Listeneintrag die Zahl eins und als zweiten Listeneintrag eine weiter Liste, welche die Zahlen zwei und drei beinhaltet.

Will ich mir nun die Zahl zwei ausgeben lassen, also die mittlere Zahl, dann verwende ich den folgenden Code:

(first (rest lon))

1	(first (rest lon))

Was passiert dabei genau. Als erstes wird die innere Klammer ausgeführt. Wir haben also den Rest der Liste ( die Liste mit dem Inhalt (2 3)). Von diesem Rest der Liste lassen wir uns nun den ersten Wert zurückgeben.

Es funktioniert genau so wenn wir die dritte Zahlen haben wollen. Es wird wieder einmal mehr verschachtelt.

(first (rest (rest lon)))

1	(first (rest (rest lon)))

Hier wird wieder zuerst der Rest der kompletten Liste genommen (2 3). Davon wird wieder der Rest genommen. Nun entsteht eine Liste die so aussieht (3 empty). Von dieser Liste brauchen wir nun den ersten Eintrag, also verwenden wir First.

Ich hoffe ich habe es nicht zu kompliziert Erklärt =) Aber falls es Probleme gibt könnt ihr diese Ja einfach in die Kommentare schreiben.

Archive

Kontakt, Datenschutz und Impressum

Schlagwörter