rmrgh - soluções da sessão 1.1 - The Elements of Programming

Author: rmrgh

1.1-TheElementsOfProgramming/ex-1.1/rmrgh.scm

@@ -0,0 +1,44 @@
+#lang sicp
+
+10
+; 10
+
+(+ 5 3 4)
+; 12
+
+(- 9 1)
+; 8
+
+(+ (* 2 4) (- 4 6))
+; 6
+
+(define a 3)
+;
+
+(define b (+ a 1))
+;
+
+(+ 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

1.1-TheElementsOfProgramming/ex-1.2/rmrgh.scm

@@ -0,0 +1,11 @@
+#lang sicp
+(/ (+ 5
+      4
+      (- 2
+         (- 3
+            (+ 6
+               (/ 4
+                  5)))))
+   (* 3
+      (- 6 2)
+      (- 2 7)))

1.1-TheElementsOfProgramming/ex-1.3/rmrgh.scm

@@ -0,0 +1,10 @@
+#lang sicp
+(define (square x) (* x x))
+
+(define (square-sum x y)
+  (+ (square x) (square y)))
+
+(define (square-2lg3 x y z)
+  (cond ((and (< x y) (< x z)) (square-sum y z))
+        ((< y z) (square-sum x z))
+        (else (square-sum x y))))

1.1-TheElementsOfProgramming/ex-1.4/rmrgh.scm

@@ -0,0 +1,6 @@
+#lang sicp
+(define (a-plus-abs-b a b)
+((if (> b 0) + -) a b))
+
+; The application will invert the signal of the operation based if the b
+; argument is positive of negative, so the returned number will always be absolute.

1.1-TheElementsOfProgramming/ex-1.5/rmrgh.scm

@@ -0,0 +1,19 @@
+#lang sicp
+(define (p) (p))
+(define (test x y)
+(if (> x 0) 0 y))
+
+(test 0 (p))
+
+; applicative-order
+; (if (= 0 0) 0 (p (p (p (p (... and so on))))))
+; infinite recursion
+;
+; normal-order
+; (if (= 0 0) 0 (p))
+; (if (true) 0 (p))
+; 0
+
+; This environment uses applicative-order evaluation, trying to expand
+; everything and resulting in a infinite recursion. In normal-order evaluation
+; the expression evaluates first then expand.

1.1-TheElementsOfProgramming/ex-1.6/rmrgh.scm

@@ -0,0 +1,27 @@
+#lang sicp
+
+; if uses a normal order evaluation to check values, the Evan's new if
+; uses applicative order witch infinitely expands sqrt-iter.
+
+(define (new-if predicate then-clause else-clause)
+  (cond (predicate then-clause)
+        (else else-clause)))
+
+(define (sqrt-iter guess x)
+  (new-if (good-enough? guess x)
+    guess
+    (sqrt-iter (improve guess x) x)))
+
+(define (improve guess x)
+  (average guess (/ x guess)))
+
+(define (average x y)
+  (/ (+ x y) 2))
+
+(define (good-enough? guess x)
+  (< (abs (- (square guess) x)) 0.001))
+
+(define (sqrt x)
+  (sqrt-iter 1.0 x))
+
+(define (square x) (* x x))

1.1-TheElementsOfProgramming/ex-1.7/rmrgh.scm

@@ -0,0 +1,20 @@
+#lang sicp
+
+(define (sqrt-iter guess oldguess x)
+  (if (good-enough? guess oldguess x)
+    guess
+    (sqrt-iter (improve guess x) guess x)))
+
+(define (improve guess x)
+  (average guess (/ x guess)))
+
+(define (average x y)
+  (/ (+ x y) 2))
+
+(define (good-enough? guess oldguess x)
+  (< (abs (- oldguess guess)) 0.001))
+
+(define (sqrt x)
+  (sqrt-iter 1.0 2.0 x))
+
+(define (square x) (* x x))

1.1-TheElementsOfProgramming/ex-1.8/rmrgh.scm

@@ -0,0 +1,20 @@
+#lang sicp
+
+(define (cbrt-iter guess x)
+  (if (good-enough? guess x)
+    guess
+    (cbrt-iter (improve guess x) x)))
+
+(define (improve guess x)
+  (/ (+ (/ x (square guess))
+        (* 2 guess) )
+     3))
+
+(define (good-enough? guess x)
+  (< (abs (- (cube guess) x)) 0.001))
+
+(define (cbrt x)
+  (cbrt-iter 1.0 x))
+
+(define (square x) (* x x))
+(define (cube x) (* x x x))