Aufgaben 1-629-11-02 

Prozeduren höherer Ordnung

Aufgabe 1: Lösung:
(define filter (lambda (ls x) (cond ((null? ls) ()) ((x (car ls)) (cons (car ls) (filter (cdr ls) x))) (else (filter (cdr ls) x))))) Kommentar: Das Prädikat x wird für jedes Element der Liste ls getestet und wenn true dann wird das Element zur neuen Liste angehängt. Aufgabe: 3 Lösung: (define compose (lambda (proc1 proc2) (lambda (n) (proc2 (proc1 n))))) Kommentar: Als Ergebnis von compose soll eine Funktion mit einem Parameter herauskommen - also (lambda (n) ...) Dazu wird nun einfach das Ergebnis von proc1 mit n als Parameter für proc2 verwendet. Aufgabe: 5 Lösung: (define nliste (lambda (n) (if (= n 0) '() (append (nliste (- n 1)) (list n))))) (define prime-ls (lambda (l n) (if (null? l) '() (if (= 0 (modulo (car l) n)) (prime-ls (cdr l) n) (cons (car l) (prime-ls (cdr l) n)) )))) (define notprime-ls (lambda (ls1 ls2) (cond ((null? ls2) '()) ((memq (car ls2) ls1) (notprime-ls ls1 (cdr ls2))) (else (cons (car ls2) (notprime-ls ls1 (cdr ls2))))))) (define filter-in (lambda (l) (cond ((null? l) '()) ((= 1 (car l)) (filter-in (cdr l))) (else (cons (car l) (filter-in (prime-ls l (car l)))))))) (define filter-out (lambda (l) (notprime-ls (filter-in l) l))) Kommentar: nliste erzeugt einfach eine List mit n vielen Elementen bei 1 beginnend. Wir haben hier das Sieb des ... angewendet und schmeißen einfach immer alle Teilbaren Elemente aus der Liste und behalten die unteilbaren. Das Gegenteil bilden wir aus einer ganzen Liste (1..n) und ziehen die Primzahlenlisteelemente ab. (Der Vlad hat im Board noch eine kürzere Lösung stehen.) Aufgabe 6: Lösung: (define Kick-it (lambda (l n) (if (null? l) '() (if (equal? n (car l)) (Kick-it (cdr l) n) (cons (car l) (Kick-it (cdr l) n)) )))) (define filter-eq-out (lambda (ls) (cond ((null? ls ) '()) (else (cons (car ls) (filter-eq-out (Kick-it ls (car ls)))))))) (define killn (lambda (ls n) (cond ((null? ls ) '()) ((eq? n (car ls)) (killn (cdr ls) n)) (else (cons (car ls) (killn (cdr ls) n)))))) (define teilliste (lambda (ls n) (cond ((< n 0) '()) (else (append (cons (killn ls (list-ref ls n)) (splitliste (killn ls (list-ref ls n)))) (teilliste ls (- n 1))))))) (define splitliste (lambda (ls) (cond ((null? ls) '()) (else (teilliste ls (- (length ls) 1)))))) (define powerset (lambda (ls) (cons ls (filter-eq-out (splitliste ls))))) Kommentar: Wir gehen davon aus das eine Liste (a b c) immer aus n vielen Teillisten (b c) (a c) (a b) besteht. Um diese Teillisten zu bilden nehmen wir immer die ganze Liste (a b c) und werfen nacheinander immer ein Element raus. (killn) Das machen wir nun rekursiv mit allen Teillisten die entstehen und bekommen am Ende eine lange Liste mit doppelten Elementen heraus. Diese filtern wir nun raus (filter-eq-out). Die orginal Liste (a b c) wird bei powerset als Element noch vor die Teillisten gestellt. (sonst wäre diese Menge nicht enthalten - könnt ihr ja testen ;o)