EMZETT.
Login

Emzett Wiki

Racket: Kontrollfluss und Listen

Properties1
tagsprogrammiersprachen, racket

5 Min. Lesezeit

Kurz: (define (vorzeichen n) (cond [(> n 0) “positiv”] [(< n 0) “negativ”] [else “null”]))

Teil des Kurses Racket

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

Bedingungen

#lang racket
 
(define (vorzeichen n)
  (cond [(> n 0) "positiv"]
        [(< n 0) "negativ"]
        [else "null"]))
 
(displayln (list (vorzeichen 5) (vorzeichen -2) (vorzeichen 0)))
(displayln (if (> 3 2) "ja" "nein"))
(when (even? 4) (displayln "gerade"))
(unless (even? 5) (displayln "ungerade"))
(displayln (and 1 2 3))
(displayln (or #f #f 5))
(displayln (not #t))
 
(define (note n)
  (case n
    [(1) "sehr gut"]
    [(2 3) "gut bis befriedigend"]
    [else "sonst"]))
(displayln (list (note 1) (note 3) (note 9)))
 
(displayln (match 5
             [0 "null"]
             [(? even?) "gerade"]
             [_ "ungerade"]))

Ausgabe:

(positiv negativ null)
ja
gerade
ungerade
3
5
#f
(sehr gut gut bis befriedigend sonst)
ungerade

Nur #f ist falsch – jeder andere Wert (auch 0 und '()) gilt als wahr.

Listen

Listen sind das Kernstück: unveränderliche, einfach verkettete Folgen:

#lang racket
 
(define l '(5 3 9 1 7))
(displayln l)
(displayln (list (first l) (rest l) (last l) (length l)))
(displayln (cons 0 l))
(displayln (append l '(8 9)))
(displayln (reverse l))
(displayln (sort l <))
(displayln (list-ref l 2))
(displayln (take l 2))
(displayln (drop l 3))
(displayln (map (lambda (x) (* x 2)) l))
(displayln (filter (lambda (x) (> x 4)) l))
(displayln (foldl + 0 l))
(displayln (apply max l))
(displayln (member 9 l))
(displayln (remove 9 l))
(displayln (range 5))
(displayln (range 1 10 3))
(displayln (build-list 5 (lambda (i) (* i i))))
(displayln (index-of '(1 3 4 5) 4))
(displayln (remove-duplicates '(1 2 2 3 3 3)))
(displayln (flatten '((1 2) (3 (4)))))
(displayln (andmap positive? l))
(displayln (ormap (lambda (x) (> x 8)) l))
(displayln (for/list ([x l] [i (in-naturals)]) (* x i)))
(displayln (count even? '(1 2 3 4)))
(displayln (argmax abs '(-5 3 4)))
(displayln (group-by even? '(1 2 3 4 5)))

Ausgabe:

(5 3 9 1 7)
(5 (3 9 1 7) 7 5)
(0 5 3 9 1 7)
(5 3 9 1 7 8 9)
(7 1 9 3 5)
(1 3 5 7 9)
9
(5 3)
(1 7)
(10 6 18 2 14)
(5 9 7)
25
9
(9 1 7)
(5 3 1 7)
(0 1 2 3 4)
(1 4 7)
(0 1 4 9 16)
2
(1 2 3)
(1 2 3 4)
#t
#t
(0 3 18 3 28)
2
-5
((1 3 5) (2 4))

Rekursion

#lang racket
 
(define (fakultaet n)
  (if (<= n 1) 1 (* n (fakultaet (- n 1)))))
 
(define (fib n)
  (let schleife ([a 0] [b 1] [i n])
    (if (= i 0) a (schleife b (+ a b) (- i 1)))))
 
(define (summe liste)
  (if (empty? liste) 0 (+ (first liste) (summe (rest liste)))))
 
(define (mein-map f liste)
  (if (empty? liste) '() (cons (f (first liste)) (mein-map f (rest liste)))))
 
(define (ggt a b) (if (zero? b) a (ggt b (remainder a b))))
 
(displayln (fakultaet 25))
(displayln (fib 90))
(displayln (summe '(1 2 3 4)))
(displayln (mein-map add1 '(1 2 3)))
(displayln (ggt 48 18))

Ausgabe:

15511210043330985984000000
2880067194370816120
10
(2 3 4)
6

Der benannte let (schleife) ist die übliche Schleifenform; Aufrufe am Ende einer Funktion (Endrekursion) verbrauchen keinen Stack.

Schleifen mit for

#lang racket
 
(for ([i 5]) (printf "~a " i))
(newline)
(for ([x '(a b c)] [i (in-naturals 1)]) (printf "~a:~a " i x))
(newline)
(displayln (for/list ([i (in-range 1 6)]) (* i i)))
(displayln (for/sum ([i (in-range 1 101)]) i))
(displayln (for/product ([i (in-range 1 6)]) i))
(displayln (for/list ([i 10] #:when (even? i)) i))
(displayln (for/and ([x '(2 4 6)]) (even? x)))
(displayln (for/fold ([acc 0]) ([x '(1 2 3)]) (+ acc (* x x))))
(displayln (for*/list ([x 3] [y 3] #:when (< x y)) (list x y)))
(displayln (for/hash ([k '(a b)] [v '(1 2)]) (values k v)))
(displayln (for/first ([x '(1 3 4 5)] #:when (even? x)) x))
(displayln (for/vector ([i 4]) (* i 10)))

Ausgabe:

0 1 2 3 4
1:a 2:b 3:c
(1 4 9 16 25)
5050
120
(0 2 4 6 8)
#t
14
((0 1) (0 2) (1 2))
#hash((a . 1) (b . 2))
4
#(0 10 20 30)

Merke

  • cond, if, case, when, unless und match verzweigen; nur #f ist falsch
  • Listen sind unveränderlich: cons, first, rest, map, filter, foldl, sort
  • Endrekursion und benannter let ersetzen Schleifen
  • for-Formen (for/list, for/sum, for/fold, …) sind sehr mächtig

Übungsaufgabe

Schreibe (primzahlen n), das alle Primzahlen bis n mit for/list und filter liefert.

Quiz zur Selbstkontrolle

Weiter im Kurs

Zurück: Einführung und erstes Programm

Weiter: Strings, Vektoren, Hashtabellen und Strukturen

Alle Kapitel: Racket im Überblick

Graphansicht

Backlinks