EMZETT.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))(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))(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
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))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)0 1 2 3 4 55 1 4 9 16 11 22 33 (11 22 33)
Merke
cond,if,case,when,unless; nur#fist falsch- Listen bestehen aus Paaren:
cons,car,cdr; dazumap,filter,fold,append - Der benannte
let(let loop (...)) und Endrekursion ersetzen Schleifen doundfor-eachfür imperative Abläufe
Aufgabe
Schreibe (primzahlen n) mit filter und einer Hilfsfunktion prim?.