# sicp-ex-3.71

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))
(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-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))
(+ (* 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))
```

Sphinxsky

```

(define (ramanujan-numbers)
(define (cubic-sum pair) (+ (expt (car pair) 3) (expt (cadr pair) 3)))
(define cubic-pairs (weighted-pairs integers integers cubic-sum))
(define (rec s1 s2)
(let ((car-s1 (stream-car s1))
(car-s2 (stream-car s2)))
(if (= (cubic-sum car-s1) (cubic-sum car-s2))
(cons-stream
car-s1
(rec (stream-cdr s1) (stream-cdr s2)))
(rec (stream-cdr s1) (stream-cdr s2)))))
(stream-map cubic-sum (rec (stream-cdr cubic-pairs) cubic-pairs)))

(show-streams 6 (ramanujan-numbers))

; (1729)
; (4104)
; (13832)
; (20683)
; (32832)
; (39312)

```

master

``` (define (sum-of-cubes x y)