stuck at Q19

Author: czahie

Project/scheme/.ok_history

@@ -10,3 +10,10 @@
 'Problem 10-correct', (4608, 70)
 'Problem 11-correct', (5120, 70)
 'Problem 12-correct', (5632, 70)
+'tests.scm-correct', (6144, 70)
+'Problem 13-correct', (6656, 70)
+'Problem 14-correct', (7168, 70)
+'Problem 15-correct', (7680, 70)
+'Problem 16-correct', (8192, 70)
+'Problem 17-correct', (8704, 70)
+'Problem 18-correct', (9216, 70)

Project/scheme/.ok_messages

@@ -10,3 +10,10 @@
 'Problem 10-correct', (4608, 70)
 'Problem 11-correct', (5120, 70)
 'Problem 12-correct', (5632, 70)
+'tests.scm-correct', (6144, 70)
+'Problem 13-correct', (6656, 70)
+'Problem 14-correct', (7168, 70)
+'Problem 15-correct', (7680, 70)
+'Problem 16-correct', (8192, 70)
+'Problem 17-correct', (8704, 70)
+'Problem 18-correct', (9216, 70)

Project/scheme/.ok_storage.bak

@@ -6,27 +6,42 @@
 ; Some utility functions that you may find useful to implement.
 
 (define (cons-all first rests)
-  'replace-this-line)
+ (define (f lst) (cons first lst))
+ (map f rests)
+ )
 
 (define (zip pairs)
-  'replace-this-line)
+ (list (map car pairs) (map cadr pairs))
+)
 
 ;; Problem 17
 ;; Returns a list of two-element lists
 (define (enumerate s)
   ; BEGIN PROBLEM 17
-  'replace-this-line
+ (define (enumerate_helper s n)
+  (if (null? s)
+   s
+   (cons (list n (car s)) (enumerate_helper (cdr s) (+ n 1)))))
+ (enumerate_helper s 0)
   )
   ; END PROBLEM 17
 
 ;; Problem 18
 ;; List all ways to make change for TOTAL with DENOMS
 (define (list-change total denoms)
   ; BEGIN PROBLEM 18
-  'replace-this-line
+ (cond
+  ((null? denoms) nil)
+  ((= total 0) (cons nil nil)) ; Return (())
+  ((> (car denoms) total) (list-change total (cdr denoms)))
+  (else
+   (define with_car (list-change (- total (car denoms)) denoms))
+   (define without_car (list-change total (cdr denoms)))
+   (append (cons-all (car denoms) with_car) without_car))
   )
   ; END PROBLEM 18
 
+)
 ;; Problem 19
 ;; Returns a function that checks if an expression is the special form FORM
 (define (check-special form)

Project/scheme/.ok_storage.dat

@@ -301,12 +301,30 @@ def do_and_form(expressions, env):
     """Evaluate a (short-circuited) and form."""
     # BEGIN PROBLEM 13
     "*** YOUR CODE HERE ***"
+    if expressions is nil:
+        return True
+    else:
+        first_expr = scheme_eval(expressions.first, env)
+        if expressions.second is nil:
+            return first_expr
+        elif scheme_falsep(first_expr):  # The first expression is False
+            return False
+        elif scheme_truep(first_expr):  # The first expression is True
+            return do_and_form(expressions.second, env)
     # END PROBLEM 13
 
 def do_or_form(expressions, env):
     """Evaluate a (short-circuited) or form."""
     # BEGIN PROBLEM 13
     "*** YOUR CODE HERE ***"
+    if expressions is nil:
+        return False
+    else:
+        first_expr = scheme_eval(expressions.first, env)
+        if scheme_falsep(first_expr):  # The first expression is False
+            return do_or_form(expressions.second, env)
+        else:  # The first expression is True
+            return first_expr
     # END PROBLEM 13
 
 def do_cond_form(expressions, env):
@@ -323,6 +341,10 @@ def do_cond_form(expressions, env):
         if scheme_truep(test):
             # BEGIN PROBLEM 14
             "*** YOUR CODE HERE ***"
+            if clause.second is nil:  # When the true predicate does not have a corresponding result sub-expression, return the predicate value
+                return test
+            else:  # When a result sub-expression of a cond case has multiple expressions, evaluate them all and return the value of the last expression
+                return eval_all(clause.second, env)
             # END PROBLEM 14
         expressions = expressions.second
 
@@ -341,6 +363,15 @@ def make_let_frame(bindings, env):
         raise SchemeError('bad bindings list in let form')
     # BEGIN PROBLEM 15
     "*** YOUR CODE HERE ***"
+    formals, vals = nil, nil
+    while bindings is not nil:
+        check_form(bindings.first, 2, 2)
+        val = scheme_eval(bindings.first.second.first, env)  # Evaluate expressions in this env first
+        formals = Pair(bindings.first.first, formals)
+        check_formals(formals)  # Check formals
+        vals = Pair(val, vals)
+        bindings = bindings.second
+    return env.make_child_frame(formals, vals)
     # END PROBLEM 15
 
 def do_define_macro(expressions, env):
@@ -429,6 +460,10 @@ def __init__(self, formals, body):
 
     # BEGIN PROBLEM 16
     "*** YOUR CODE HERE ***"
+    def make_call_frame(self, args, env):
+        """Make a frame that binds my formal parameters to ARGS, a Scheme list
+        of values, for a dynamically-scoped call evaluated in environment ENV."""
+        return env.make_child_frame(self.formals, args)
     # END PROBLEM 16
 
     def __str__(self):
@@ -445,6 +480,8 @@ def do_mu_form(expressions, env):
     check_formals(formals)
     # BEGIN PROBLEM 16
     "*** YOUR CODE HERE ***"
+    body = expressions.second
+    return MuProcedure(formals, body)
     # END PROBLEM 16
 
 SPECIAL_FORMS['mu'] = do_mu_form

Project/scheme/.ok_storage.dir

@@ -62,11 +62,18 @@
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; Move the following (exit) line to run additional tests. ;;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(exit)
+
 
 
 ;;; 1.1.2
 
+(define n 1)
+; expect n
+(define n (+ n 1))
+; expect n
+n
+; expect 2
+
 (define size 2)
 ; expect size
 size
@@ -86,6 +93,11 @@ circumference
 
 ;;; 1.1.4
 
+(define (cube x) (* x x x))
+; expect cube
+(cube 3)
+; expect 27
+
 (define (square x) (* x x))
 ; expect square
 (square 21)

Project/scheme/__pycache__/scheme.cpython-36.pyc

@@ -7,32 +7,20 @@
         {
           'code': r"""
           scm> (and)
-          a87b4aa619df2eba30bc86785b816612
-          # locked
-          # choice: True
-          # choice: False
-          # choice: SchemeError
+          True
           scm> (and 1 False)
-          55275a3300eb11ce47998c15403d99c6
-          # locked
-          # choice: 1
-          # choice: True
-          # choice: False
+          False
           scm> (and (+ 1 1) 1)
-          2894dd5fa65c8aa8f2b9d920d0e542e0
-          # locked
+          1
           scm> (and False 5)
-          55275a3300eb11ce47998c15403d99c6
-          # locked
+          False
           scm> (and 4 5 (+ 3 3))
-          7964a777121da6350b0e6ecd16129317
-          # locked
+          6
           scm> (and True False 42 (/ 1 0))
-          55275a3300eb11ce47998c15403d99c6
-          # locked
+          False
           """,
           'hidden': False,
-          'locked': True
+          'locked': False
         },
         {
           'code': r"""
@@ -106,32 +94,24 @@
         {
           'code': r"""
           scm> (or)
-          55275a3300eb11ce47998c15403d99c6
-          # locked
+          False
           scm> (or (+ 1 1))
-          e56af2bab40778990634a527fe4407f8
-          # locked
+          2
           scm> (or False)
-          55275a3300eb11ce47998c15403d99c6
-          # locked
+          False
           scm> (define (t) True)
-          f16aec3dd21e3756aa445ca3e2d11a8d
-          # locked
+          t
           scm> (or (t) 3)
-          a87b4aa619df2eba30bc86785b816612
-          # locked
+          True
           scm> (or 5 2 1)
-          19a0c723c8c2fa9e2860916af61035e6
-          # locked
+          5
           scm> (or False (- 1 1) 1)
-          346bede49af9f8a0fafbc46acfa3395c
-          # locked
+          0
           scm> (or 4 True (/ 1 0))
-          8ad686581488b3cc40d870a8db32810e
-          # locked
+          4
           """,
           'hidden': False,
-          'locked': True
+          'locked': False
         },
         {
           'code': r"""

Project/scheme/questions.scm

@@ -10,16 +10,14 @@
           ....       ((> 2 4) 6)
           ....       ((< 2 5) 7)
           ....       (else 8))
-          047f42cf449bafcfed749a052e47904a
-          # locked
+          7
           scm> (cond ((> 2 3) 5)
           ....       ((> 2 4) 6)
           ....       (else 8))
-          7160af5f6893bd49bb63dee6b8320930
-          # locked
+          8
           """,
           'hidden': False,
-          'locked': True
+          'locked': False
         }
       ],
       'scored': True,

Project/scheme/scheme.py

@@ -7,43 +7,34 @@
         {
           'code': r"""
           scm> (define x 1)
-          9d01e356a925e61e19645aef1b1fdd64
-          # locked
+          x
           scm> (let ((x 5))
           ....    (+ x 3))
-          7160af5f6893bd49bb63dee6b8320930
-          # locked
+          8
           scm> x
-          2894dd5fa65c8aa8f2b9d920d0e542e0
-          # locked
+          1
           """,
           'hidden': False,
-          'locked': True
+          'locked': False
         },
         {
           'code': r"""
           scm> (let ((a 1) (b a)) b)
-          87c30138f7979b4f5a454aacfb191b98
-          # locked
-          # choice: SchemeError
-          # choice: 1
-          # choice: x
-          # choice: y
+          SchemeError
           """,
           'hidden': False,
-          'locked': True
+          'locked': False
         },
         {
           'code': r"""
           scm> (let ((x 5))
           ....    (let ((x 2)
           ....          (y x))
           ....        (+ y (* x 2))))
-          5fb541ba24eaf504edc7eae61bda4f97
-          # locked
+          9
           """,
           'hidden': False,
-          'locked': True
+          'locked': False
         },
         {
           'code': r"""

Project/scheme/tests.scm

@@ -7,20 +7,16 @@
         {
           'code': r"""
           scm> (define y 1)
-          17cb57908ef08e52f95d9f071151342f
-          # locked
+          y
           scm> (define f (mu (x) (+ x y)))
-          0f95edcd87e28fa8e0cb767981adc36d
-          # locked
+          f
           scm> (define g (lambda (x y) (f (+ x x))))
-          f52d1b972c48783316eb00d88d4d300f
-          # locked
+          g
           scm> (g 3 7)
-          82b58f6e2f61a1a4b7dee17cb8ac08e0
-          # locked
+          13
           """,
           'hidden': False,
-          'locked': True
+          'locked': False
         }
       ],
       'scored': True,

Project/scheme/tests/13.py

@@ -7,22 +7,18 @@
         {
           'code': r"""
           scm> (let-to-lambda 1)
-          2894dd5fa65c8aa8f2b9d920d0e542e0
-          # locked
+          1
           scm> (let-to-lambda 'a)
-          bcba5a8b5eb148269b808d42d0d4fef5
-          # locked
+          a
           scm> (let-to-lambda '(+ 1 2))
-          07bf87256cd8dfa90c86841a1d37643a
-          # locked
+          (+ 1 2)
           scm> (let-to-lambda '(let ((a 1)
           ....                 (b 2))
           ....                (+ a b)))
-          a28e3e321fa8868c1949f68b122a8253
-          # locked
+          ((lambda (a b) (+ a b)) 1 2)
           """,
           'hidden': False,
-          'locked': True
+          'locked': False
         },
         {
           'code': r"""