Rekursive Prozeduren 2

Wiki-Quelltext dieser Seite.

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

==Fakultät==

Schreiben Sie eine rekursive Prozedur <tt>fak</tt>, die eine Zahl <math>n</math> als Argument erwartet und deren Fakultät <math>n!</math> als Ergebnis liefert.

<code id="4ae713bf976a6">;Ihre Fakultätsprozedur fak</code>
<eval id="4ae713bf9addf">(fak 5)</eval>
<check>(and (= 1 (fak 0)) (= 120 (fak 5)))</check>

==Fibanocci==
Schreiben Sie eine rekursive Prozedur <tt>fib</tt>, die die n-te Fibonacci-Zahl als Ergebnis liefert.

'''Hinweis:''' Die n-te Fibonacci-Zahl ergibt sich aus der Summe ihrer beiden Vorgänger. Die 0-te und 1-te Fibonacci-Zahl ist jeweils 1.
<code id="4ae713bf97e05">;Ihre Fibonacci-Prozedur fib</code>
<eval id="4ae713bf9b5b6">(fib 5)</eval>

===Fibanocci Liste===
Schreiben Sie eine rekursive Prozedur <tt>fibonacci_list</tt>, die eine Liste mit den ersten <math>n</math> Fibonaccizahlen zurückgibt

'''Hinweis:''' Verwenden Sie zur Lösung dieser Aufgabe Ihre Prozedur <tt>fib</tt> aus der vorherigen Aufgabe! <br/>
Sollte die entstehende Liste absteigend sortiert sein, kann dies mittels reverse behoben werden.
<code id="4ae713bf985d6">;Ihre Prozedur fibonacci_list</code>
<code id="4ae713bf98dcb" 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)))
  )
 )
)
</code>
<eval id="4ae713bf9bd97">(fibonacci_list 5)</eval>
<check>(listvergleich '(1 1 2 3 5 8 13 21 34 55 89 144) (fibonacci_list 12))</check>

==Ascending List==
Schreiben Sie eine Prozedur ascending, die eine Liste nimmt und #t zurückgibt, falls die Listenelemente aufsteigend geordnet sind, ansonsten #f.

'''Hinweis:''' Beachten Sie das Resultat für die leere Liste ’().
                                       
'''Aufrufbeispiele:'''
{|
|-
|<tt>
 > (ascending ’(1 2 4 7))
 #t
 > (ascending ’(1 3 4 5 2 6))
 #f
 > (ascending ’())
 #t
</tt>
|}
<code id="4ae713bf9957e">;Ihre ascending-Prozedur</code>
<eval id="4ae713bf9c4f5">;Aufrufbeispiel zum Testen Ihrer Prozedur
(ascending '(1 2 8))</eval>
<check>
(and (ascending '()) (ascending '(1 5 7 9)) (not (ascending '(1 3 4 2 8))))
</check>

==Längenbestimmung==
===Listenlänge===
Schreiben Sie eine Prozedur <tt>my-length</tt>, die eine Liste als Argument nimmt und die Anzahl der Elemente in der 1. Ebene ausgibt. Die eingebaute Prozedur '''length''' darf dabei nicht verwendet werden!

Aufrufbeispiele:
{|
|-
|<tt>
 > (my-length ’(1 2 3 4 5))
 5
 > (my-length ’(1 2 3 4 5 (6 7) (8 (9 10 (11))))
 7
</tt>
|}
<code id="4ae713bf99e70">;Ihre Prozedur my-length</code>
<eval id="4ae713bf9cc3a">;Aufrufbeispiel zum Testen Ihrer Prozedur
(my-length '(1 2 3 4 5 6 (7 2) 8))</eval>
<check>(and (= (my-length '(1 2 4)) 3) (= (my-length '(1 (1 2) (2 3) 5)) 4) (= (my-length '()) 0))</check>

===Tiefenlänge===
Schreiben Sie eine weitere Prozedur <tt>deep-length</tt> die ebenfalls eine Liste als Argument nimmt, jedoch die Anzahl aller Elemente in sämtlichen Teillisten ausgibt.
                                                   
Aufrufbeispiele:
{|
|<tt>
 > (deep-length ’(1 2 3 4 5))
 5
 > (deep-length ’(1 2 3 4 5 (6 7) (8 (9 10 (11))))
 11
</tt>
|}
<code id="4ae713bf9a617">;Ihre Prozedur deep-length</code>
<eval id="4ae713bf9d40e">;Aufrufbeispiel zum Testen Ihrer Prozedur
(deep-length '(1 (2 3) (3 (5 7))))</eval>

<check>(and (= (deep-length '()) 0) (= (deep-length '(1 2 3 4 5)) 5) (= (deep-length '(1 2 (3 4 (5 6)) 7 8)) 8))</check>

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