EMZETT.
Login

Emzett Wiki

Scheme: Kontrollfluss, Listen und Rekursion

Properties1
tagsprogrammiersprachen, scheme

4 Min. Lesezeit

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

Teil des Kurses Scheme

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

Bedingungen

(define (zeige x) (display x) (newline))
 
(define (vorzeichen n)
  (cond ((> n 0) "positiv")
        ((< n 0) "negativ")
        (else "null")))
 
(zeige (list (vorzeichen 5) (vorzeichen -2) (vorzeichen 0)))
(zeige (if (> 3 2) "ja" "nein"))
(when (even? 4) (zeige "gerade"))
(unless (even? 5) (zeige "ungerade"))
(zeige (and 1 2 3))
(zeige (or #f #f 5))
(zeige (not #t))
(zeige (case 3
         ((1) "eins")
         ((2 3) "zwei oder drei")
         (else "viele")))
(zeige (let loop ((i 0) (akk '()))
         (if (= i 5) (reverse akk) (loop (+ i 1) (cons (* i i) akk)))))
(zeige (eq? 'a 'a))
(zeige (equal? '(1 2) '(1 2)))
(zeige (eqv? 2.5 2.5))

Ausgabe:

(positiv negativ null)
ja
gerade
ungerade
3
5
#f
zwei oder drei
(0 1 4 9 16)
#t
#t
#t

Nur #f ist falsch – alles andere (auch 0 und die leere Liste '()) ist wahr.

Paare und Listen

Eine Liste besteht aus Paaren (cons): (1 2 3) ist (1 . (2 . (3 . ()))).

(use-modules (srfi srfi-1))
(define (zeige x) (display x) (newline))
(zeige (cons 1 2))
(zeige (cons 1 '(2 3)))
(define l '(5 3 9 1 7))
(zeige (car l))
(zeige (cdr l))
(zeige (cadr l))
(zeige (caddr l))
(zeige (length l))
(zeige (list-ref l 2))
(zeige (append l '(8 9)))
(zeige (reverse l))
(zeige (list-tail l 3))
(zeige (map (lambda (x) (* x 2)) l))
(zeige (filter odd? l))
(zeige (fold + 0 l))
(zeige (assq 'b '((a 1) (b 2))))
(zeige (assoc "x" '(("x" . 1) ("y" . 2))))
(zeige (memq 9 l))
(zeige (list-copy l))
(zeige (apply max l))
(zeige (sort l <))
(zeige (iota 5))
(zeige (iota 5 1))
(zeige (null? '()))
(zeige (pair? l))
(zeige (list? 5))

Ausgabe:

(1 . 2)
(1 2 3)
5
(3 9 1 7)
3
9
5
9
(5 3 9 1 7 8 9)
(7 1 9 3 5)
(1 7)
(10 6 18 2 14)
(5 3 9 1 7)
25
(b 2)
(x . 1)
(9 1 7)
(5 3 9 1 7)
9
(1 3 5 7 9)
(0 1 2 3 4)
(1 2 3 4 5)
#t
#t
#f

Hinweis

fold, filter und iota kommen aus SRFI-1. In Guile sind sie vorinstalliert; in anderen Implementierungen lädt man sie mit (import (srfi 1)) bzw. (use-modules (srfi srfi-1)).

Rekursion und Endrekursion

Schleifen schreibt man in Scheme als Rekursion. Der Standard garantiert, dass Endaufrufe (tail calls) keinen Stack verbrauchen:

(define (zeige x) (display x) (newline))
 
(define (fakultaet n)
  (if (<= n 1) 1 (* n (fakultaet (- n 1)))))
 
(define (fakultaet-iter n)
  (let schleife ((i n) (akk 1))
    (if (<= i 1) akk (schleife (- i 1) (* akk i)))))
 
(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 (null? liste) 0 (+ (car liste) (summe (cdr liste)))))
 
(define (mein-map f liste)
  (if (null? liste) '() (cons (f (car liste)) (mein-map f (cdr liste)))))
 
(define (zaehle-runter n)
  (if (= n 0) 'fertig (zaehle-runter (- n 1))))
 
(zeige (fakultaet 25))
(zeige (fakultaet-iter 30))
(zeige (fib 90))
(zeige (summe '(1 2 3 4)))
(zeige (mein-map 1+ '(1 2 3)))
(zeige (zaehle-runter 1000000))

Ausgabe:

15511210043330985984000000
265252859812191058636308480000000
2880067194370816120
10
(2 3 4)
fertig

do-Schleifen

(do ((i 0 (+ i 1))) ((= i 5)) (display i) (display " "))
(newline)
(do ((i 1 (+ i 1)) (summe 0 (+ summe i))) ((> i 10) (display summe) (newline)))
(for-each (lambda (x) (display (* x x)) (display " ")) '(1 2 3 4))
(newline)
(for-each (lambda (a b) (display (+ a b)) (display " ")) '(1 2 3) '(10 20 30))
(newline)
(display (map + '(1 2 3) '(10 20 30)))
(newline)

Ausgabe:

0 1 2 3 4
55
1 4 9 16
11 22 33
(11 22 33)

Merke

  • cond, if, case, when, unless; nur #f ist falsch
  • Listen bestehen aus Paaren: cons, car, cdr; dazu map, filter, fold, append
  • Der benannte let (let loop (...)) und Endrekursion ersetzen Schleifen
  • do und for-each für imperative Abläufe

Übungsaufgabe

Schreibe (primzahlen n) mit filter und einer Hilfsfunktion prim?.

Quiz zur Selbstkontrolle

Weiter im Kurs

Zurück: Einführung und erstes Programm

Weiter: Strings, Vektoren, Hashtabellen und Records

Alle Kapitel: Scheme im Überblick

Graphansicht

Backlinks