Prozeduren höherer Ordnung

Wiki-Quelltext dieser Seite.

<language>Scheme</language>
[[Programmierparadigmen_-_Computerübungen|zur Übungsübersicht]]

<code id="4af43622f15f4" hidden>
(define listvergleich
 (lambda(l1 l2)
  (cond
   ((and (null? l1) (null? l2)) #t)
   ((not (= (length l1) (length l2))) #f)
   ((not (= (car l1) (car l2) )) #f)
   (else (listvergleich (cdr l1) (cdr l2)))
  )
 )
)
(define groesser
  (lambda (w)
     (> w 0)))
</code>


==Filter==
Schreiben Sie eine Prozedur <tt>filter</tt>, die eine Liste und eine Filterprozedur nimmt, und eine "gefilterte" Liste zurückgibt.

'''Hinweis:''' Die Filterprozedur ist eine einstellige Prozedur, welche <tt>#t</tt> bzw. <tt>#f</tt> zurückgibt.

'''Aufrufbeispiele'''
 >(filter '(1 2 3 4 5 6 7 8 9) even?)
 (2 4 6 8)
 >(filter '(1 2 3 4 5) (lambda (x) (not (or (= x 2) (= x 5)))))
 (1 3 4)
 >(filter '(#\a 276 "blubb" 5 blah 3 5 (4 995 54)) number?)
 (276 5 3 5)
<code id="4af43622f1dda">
(define filter 
  (lambda (liste funktion)
</code>
<eval id="4af4362300acb">(filter '(1 2 3 4 5 6 7 8 9) even?)</eval>
<check>

(listvergleich '(1 2 3 4) (filter '(-1 1 -2 2 0 -3 3 -4 4) groesser)) </check>

==Tabellieren==

Schreiben Sie eine Prozedur <tt>tabelliere</tt> zur Ausgabe einer Wertetabelle mit den Spalten <math>x</math> und <math>f(x)</math>, wobei <math>f</math> eine einstellige Funktion ist, die für <math>x=a,a+1,\ldots,b</math> protokolliert werden soll. <math>f</math>, <math>a</math> und <math>b</math> sollen beim Aufruf als Parameter übergeben werden.
     
'''Hinweis:''' Testen Sie auch mit Lambda-Ausdrücken für <math>f</math>.

'''Aufrufbeispiel'''
 > (tabelliere (lambda (x) (* x x)) 0 5)
 (0 1 4 9 16 25)
<code id="4af43622f2627">
(define tabelliere
  (lambda (funktion untergrenze obergrenze)
    ...
</code>
<eval id="4af43623012b8">(tabelliere (lambda (x) (* x x)) 0 5)</eval>
<check>listvergleich '(0 2 6 12 20 30) (tabelliere (lambda (x) (* (+ x 1) x)) 0 5)</check>

==Compose==
Schreiben Sie eine Prozedur <tt>compose</tt>, die zwei einstellige Prozeduren <tt>proc1</tt> und <tt>proc2</tt> nimmt, diese verkettet und die Verkettungsprozedur "<tt>proc2</tt> nach <tt>proc1</tt>" zurückgibt. Wenden Sie <tt>compose</tt> auf geeignete Argumente an.
        
'''Aufrufbeispiel'''
 > ((compose (lambda (n) (+ n n)) (lambda (n) (* n n))) 4)
 64
'''Wichtig''' Die Klammersetzung im Aufrufbeispiel ist korrekt!     
                                     
Tipp: Das Aufrufbeispiel funktioniert folgendermaßen: Der Wert 4 wird der ersten
Prozedur und dessen Ergebnis danach an die zweite Prozedur ubergeben.

<code id="4af43622f2d70">;(compose proc1 proc2)</code>
<eval id="4af4362301a70">((compose (lambda (n) (+ n n)) (lambda (n) (* n n))) 4)</eval>
<check>(= ((compose (lambda (n) (* n n)) (lambda (n) (+ n 5))) 5) 30)</check>                                                                ̈

==Primzahlen==
Schreiben Sie eine Prozedur <tt>filter-in</tt>, die aus der Liste der natürlichen Zahlen von 1 bis 1000 alle Primzahlen herausfiltert und als Liste zurückgibt.

===Natürliche Zahlen===                                                          
Sie benötigen eine Hilfsprozedur <tt>nliste</tt>, die eine Liste mit natürlichen Zahlen von 1 bis n erzeugt.

'''Aufrufbeispiele'''
 > (nliste 5)
 (1 2 3 4 5)

<code id="4af43622f35a4">;(nliste zahl)</code>
<eval id="4af43623022e5">(nliste 1000)</eval>

===Filter-In===
Nun die Liste der Primzahlen, versuchen sie dabei die vorher erstellten Prozeduren zu benutzen

'''Aufrufbeispiele'''
 (filter-in '(nliste 1000))
 >(2 3 5 7 11 13 17 19 ...)

<code id="4af43622f3d6e">;(filter-in liste)</code>
<eval id="4af4362302a67"> (filter-in '(nliste 1000))</eval>
<check>(listvergleich '(2 3 5 7 11 13 17 19) (filter-in '(nliste 20)))</check>

==Filter-Out==
Schreiben Sie analog zu <tt>filter-in</tt> eine Prozedur <tt>filter-out</tt>, die statt der Liste mit Primzahlen die Restliste ohne Primzahlen liefert.
'''Aufrufbeispiele'''
 > (filter-out '(nliste 1000))
 (1 4 6 8 9 10 12 14 15 ...)
<code id="4af43623002f8">;(filter-out liste)</code>
<eval id="4af43623031d9"> (filter-out '(nliste 1000))</eval>
<check>(listvergleich '(1 4 6 8 9 10 12 14 15 16 18 20) (filter-out '(nliste 20)))</check>

[[Programmierparadigmen_-_Computerübungen|zur Übungsübersicht]]