EMZETT.
Login

Emzett Wiki

Racket: Praxisprojekte

Properties1
tagsprogrammiersprachen, racket

4 Min. Lesezeit

Kurz: Ein kleiner Interpreter für arithmetische Ausdrücke mit match:

Teil des Kurses Racket

Kapitel 7 von 8 im Kurs Racket. Mit Fortschritt, Quiz und Zertifikat auf der Lernseite.

Ausdrucksauswerter

Ein kleiner Interpreter für arithmetische Ausdrücke mit match:

#lang racket
 
(define (auswerten ausdruck umgebung)
  (match ausdruck
    [(? number? n) n]
    [(? symbol? s) (hash-ref umgebung s (lambda () (error 'auswerten "unbekannte Variable ~a" s)))]
    [(list '+ a b) (+ (auswerten a umgebung) (auswerten b umgebung))]
    [(list '- a b) (- (auswerten a umgebung) (auswerten b umgebung))]
    [(list '* a b) (* (auswerten a umgebung) (auswerten b umgebung))]
    [(list '/ a b) (/ (auswerten a umgebung) (auswerten b umgebung))]
    [(list 'let (list x wert) rumpf)
     (auswerten rumpf (hash-set umgebung x (auswerten wert umgebung)))]
    [(list 'if bedingung dann sonst)
     (if (zero? (auswerten bedingung umgebung)) (auswerten sonst umgebung) (auswerten dann umgebung))]
    [_ (error 'auswerten "unbekannter Ausdruck ~a" ausdruck)]))
 
(displayln (auswerten '(+ 1 (* 2 3)) (hash)))
(displayln (auswerten '(let (x 5) (* x x)) (hash)))
(displayln (auswerten '(if 0 100 200) (hash)))
(displayln (auswerten '(/ 10 4) (hash)))
(with-handlers ([exn:fail? (lambda (e) (displayln (exn-message e)))])
  (auswerten '(+ y 1) (hash)))

Ausgabe:

7
25
200
5/2
auswerten: unbekannte Variable y

Zeichenketten: Caesar und Palindrome

#lang racket
 
(define (verschiebe text schluessel)
  (list->string
   (for/list ([c text])
     (cond [(char-alphabetic? c)
            (define basis (if (char-upper-case? c) 65 97))
            (integer->char (+ basis (modulo (+ (- (char->integer c) basis) schluessel) 26)))]
           [else c]))))
 
(define (palindrom? s)
  (define bereinigt (filter char-alphabetic? (string->list (string-downcase s))))
  (equal? bereinigt (reverse bereinigt)))
 
(define geheim (verschiebe "Hallo Racket!" 3))
(displayln geheim)
(displayln (verschiebe geheim -3))
(displayln (map palindrom? '("Anna" "Racket" "Ein Esel lese nie")))
(displayln (string-join (map string-titlecase (string-split "ein kleiner satz")) " "))
(displayln (list->string (reverse (string->list "Racket"))))

Ausgabe:

Kdoor Udfnhw!
Hallo Racket!
(#t #f #t)
Ein Kleiner Satz
tekcaR

Datenverarbeitung mit Listen

#lang racket
 
(struct verkauf (region produkt menge preis))
 
(define daten
  (list (verkauf "Nord" "Apfel" 10 1.20) (verkauf "Sued" "Birne" 5 0.80)
        (verkauf "Nord" "Birne" 8 0.80) (verkauf "West" "Apfel" 20 1.10)
        (verkauf "Sued" "Apfel" 7 1.20)))
 
(define (umsatz v) (* (verkauf-menge v) (verkauf-preis v)))
(define pro-region (group-by verkauf-region daten))
(for ([gruppe (sort pro-region string<? #:key (lambda (g) (verkauf-region (first g))))])
  (printf "~a: ~a\n" (verkauf-region (first gruppe))
          (~r (apply + (map umsatz gruppe)) #:precision 2)))
(printf "Gesamt: ~a\n" (~r (apply + (map umsatz daten)) #:precision 2))
(define bester (argmax umsatz daten))
(printf "Bester Posten: ~a in ~a\n" (verkauf-produkt bester) (verkauf-region bester))
(printf "Menge Äpfel: ~a\n" (for/sum ([v daten] #:when (string=? (verkauf-produkt v) "Apfel")) (verkauf-menge v)))

Ausgabe:

Nord: 18.4
Sued: 12.4
West: 22
Gesamt: 52.8
Bester Posten: Apfel in West
Menge Äpfel: 37

Primzahlen, Sieb und Streams

#lang racket
 
(define (sieb n)
  (define prim (make-vector (add1 n) #t))
  (for ([i (in-range 2 (add1 n))] #:when (vector-ref prim i))
    (for ([j (in-range (* i i) (add1 n) i)])
      (vector-set! prim j #f)))
  (for/list ([i (in-range 2 (add1 n))] #:when (vector-ref prim i)) i))
 
(displayln (sieb 50))
(displayln (length (sieb 10000)))
 
(require racket/stream)
(define nat (stream-cons 0 (stream-map add1 nat)))
(define (ist-prim? n) (and (> n 1) (for/and ([i (in-range 2 (add1 (integer-sqrt n)))]) (not (zero? (remainder n i))))))
(displayln (stream->list (stream-take (stream-filter ist-prim? (in-naturals)) 10)))
(displayln (for/list ([x (in-stream (stream-take (stream-map sqr nat) 6))]) x))

Ausgabe:

(2 3 5 7 11 13 17 19 23 29 31 37 41 43 47)
1229
(2 3 5 7 11 13 17 19 23 29)
(0 1 4 9 16 25)

Merke

  • match macht Interpreter und Datenverarbeitung kurz und lesbar
  • group-by, argmax, for/sum, sort #:key ersetzen viele Schleifen
  • Streams (racket/stream) beschreiben lange oder unendliche Folgen
  • Kleine Projekte zeigen den Wert von Unveränderlichkeit und Rekursion

Übungsaufgabe

Erweitere den Auswerter um ** und Vergleichsoperatoren.

Quiz zur Selbstkontrolle

Weiter im Kurs

Zurück: Ein-/Ausgabe, Zeit und Nebenläufigkeit

Weiter: Referenz und Spickzettel

Alle Kapitel: Racket im Überblick

Graphansicht

Backlinks