Prozeduren höherer Ordnung

Wiki-Quelltext dieser Seite.

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

<code hidden>
(define listvergleich
 (lambda(l1 l2)
  (cond
   ((and (null? l1) (null? l1)) #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 #t bzw. #f
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>;(filter liste funktion </code>
<eval>(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 einer
einstelligen Funktion f von a bis b. f, a und b sollen beim Aufruf als Parameter
übergeben werden.
     
'''Hinweis:''' Testen Sie auch mit Lambda-Ausdrücken für <math>f</math><br />
'''Aufrufbeispiel'''
 > (tabelliere (lambda (x) (* x x)) 0 5)
 (0 1 4 9 16 25)
<code>;(tabelliere tabelliere funktion untergrenze obergrenze)</code>
<eval>(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
proc2 nimmt, diese verkettet und die Verkettungsprozedur “<tt>proc2</tt> nach <tt>proc1</tt>”
zurückgibt. Wenden Sie compose 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>;(compose proc1 proc2)</code>
<eval>((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>;(nliste zahl)</code>
<eval>(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>;(filter-in liste)</code>
<eval> (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>;(filter-out liste)</code>
<eval> (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ück zur Übungsübersicht]]