sicp-ex-3.71



<< Previous exercise (3.70) | Index | Next exercise (3.72) >>


meteorgan

  
  
  
 (define (Ramanujan s) 
          (define (stream-cadr s) (stream-car (stream-cdr s))) 
          (define (stream-cddr s) (stream-cdr (stream-cdr s))) 
          (let ((scar (stream-car s)) 
                    (scadr (stream-cadr s))) 
                 (if (= (sum-triple scar) (sum-triple scadr))  
                         (cons-stream (list (sum-triple scar) scar scadr) 
                                                  (Ramanujan (stream-cddr s))) 
                         (Ramanujan (stream-cdr s))))) 
 (define (triple x) (* x x x)) 
 (define (sum-triple x) (+ (triple (car x)) (triple (cadr x)))) 
 (define Ramanujan-numbers 
         (Ramanujan (weighted-pairs integers integers sum-triple))) 
  
 the next five numbers are: 
 (4104 (2 16) (9 15)) 
 (13832 (2 24) (18 20)) 
 (20683 (10 27) (19 24)) 
 (32832 (4 32) (18 30)) 
 (39312 (2 34) (15 33)) 

land

  
  
  
  
 (define ram-stream 
   (stream-map cadr  
               (stream-filter (lambda (x)(= (cube-weight (car x))(cadr x)))  
                  (stream-map list cube-stream (stream-cdr (stream-map cube-weight cube-stream)))))) 
  
 ;Wanted to do the exercise completely using stream paradigm. 

hi-artem

"Easy to understand" iterative version :-)

 (define (cubicSum  p) 
     (let ((i (car p)) 
           (j (cadr p))) 
       (+ (* i i i) (* j j j)))) 
  
 (define sortedStream (weighted-pairs cubicSum (integers 0) (integers 0))) 
  
 (define (ramanujan s pre) 
     (let (( num (cubicSum (stream-car s)))) 
       (cond ((= pre num) 
                 (cons-stream 
                         num 
                         (ramanujan (stream-cdr s) num))) 
              (else   
                     (ramanujan (stream-cdr s) num))))) 
  
  
 (display-stream (ramanujan sortedStream 0)) 

karthikk

Small bug in meteorgan's solution: You don't want to apriori exclude the possibility of three consequent pairs all having the same weight...i.e. you dont want to recurse into the cddr in case you find a pair with equal weights, because (weight cadr) might be equal to (weight caddr)...

But this would give you the same number as the one you find with car and cadr. So we are safe to skip to cddr directly.



Zeyang

My solution...

The function "repeated" should be defined in chapter one I think..

 (define (get-special-number-stream different-ways) 
   (define (proc p1 p2 p3) 
     (define (sum-of-cubed x y) (+ (cube x) (cube y))) 
     (let ((p1-sum (sum-of-cubed (car p1) (cadr p1))) 
           (p2-sum (sum-of-cubed (car p2) (cadr p2))) 
           (p3-sum (sum-of-cubed (car p3) (cadr p3)))) 
       (if (and (= p2-sum p1-sum) 
                (not (= p2-sum p3-sum))) 
           p2-sum 
           false))) 
   (stream-filter (lambda (x) x) 
     (stream-map proc 
                 ordered-pairs 
                 ((repeated stream-cdr (- different-ways 1)) ordered-pairs) 
                 ((repeated stream-cdr different-ways) ordered-pairs)))) 
                
 (define ramanujan-numbers 
   (get-special-number-stream 2))