Struktur und Interpretation von Computerprogrammen Arbeitsblatt

MiT SICP Online Course SICP Solutions Code Report SICP Work Through

Kapitel 1

Übung 1.1

10 ;; => 10
(+ 5 3 4) ;; => 12
( - 9 1) ;; => 8
(/ 6 2) ;; => 3
(+ (* 2 4) ( - 4 6)) ;; => 6
(def a 3) ;; => #'user/a
(def b (+ a 1)) ;; => #'user/b
(+ a b ( * a b)) ;; => 19
(= a b) ;; => false
(if (and (> b a) b (* a b))
  b
  a) ;; => 4
(cond 
  (= a 4) 6
  (= b 4) (+ 6 7 a)
  :else 25 ) ;; => 16
(+ 2 (if (> b a) b a)) ;; => 6
(* (cond (> a b) a
         (< a b) b
         :else -1)
   (+ a 1) ) ;; => 16

Übung 1.2 Übertragung in die Präfixform

(/(+ 5 4 (- 2 (- 3 (+ 6 (/ 4 5)))))
  (* 3 (- 6 2) (- 2 7))) ;; => -37/150

Übung 1.3

a	b	c
5	10	15
10	5	15
10	15	5

(defn square [x](* x x)) ;; => #'user/square

(defn squareSum [a b]
  (+ (square a) (square b))) ;; => #'user/squareSum
;;
(defn f [a b c]
  (cond
    (and (> a b) (> b c)) (squareSum a b)
    (and (> b a) (> c a)) (squareSum b c)
    :else (squareSum a c)
    )) ;; => #'user/f
(f 5 10 15) ;; => 325
(f 15 10 5) ;; => 325
(f 15 5 10) ;; => 325

Übung 1.4

Machen Sie sich klar, dass unser Auswertungsmodell Kombinationen zulässt, deren Operatoren zusammengesetzte Ausdrücke sind. Nutzen Sie diese Erkenntnis um das

Verhalten der folgenden Prozedur zu beschreiben:

(defn a-plus-abs-b [a b]
  ((if ( > b 0) + -) a b)
  )

(a-plus-abs-b 3 -6)
(a-plus-abs-b 3 6)

(a + |b|) A plus absoluten Wert von b.

Übung 1.5

Ben Bitdiddle hat eine Möglichkeit gefunden, zu überprüfen, ob der Interpretierer, mit dem er zu tun hat, in applikativer Reihenfolge auswertet oder in normaler Reihenfolge. Er definiert die folgenden beiden Prozeduren:

(defn p [] (p))
(defn test [x y]
  (if (= x 0) 0 y))
// Dann wertet er folgenden Ausdruck aus:
(test 0 (p))

In Clojure wird die Funktion rekursiv bis in die Unendlichkeit aufgerufen und verursacht einen StackOverflowError. Damit wertet Clojure in applikativer Reihenfolge aus.

Beispiel 1.1.7 Berechnung der Quadratwurzel nach dem Newtonschen Iterationsverfahren

(defn wurzel-iter [schaetzwert x]
  (if (gut-genug? schaetzwert x)
    schaetzwert
    (wurzel-iter (verbessern schaetzwert x) x)))

(defn verbessern [schaetzwert x]
  (mittelwert schaetzwert (/ x schaetzwert)))

(defn mittelwert [x y] (/ (+ x y) 2))

(defn gut-genug? [schaetzwert x]
  (< (Math/abs (- (* schaetzwert schaetzwert) x)) 0.001))

(defn wurzel [x] (wurzel-iter 1.0 x))