Comments on: SICP section 2.3.3

By: Chris Rathman

Chris Rathman — Wed, 08 Oct 2008 16:41:31 +0000

Ok. That makes sense. Guess I’m too used to ML where an exception would be thrown.

Thanks for the explanation.

By: eliben

eliben — Wed, 08 Oct 2008 05:39:50 +0000

@Chris,

Since the solution is in Common Lisp, in which (car nil) is nil, the function does handle the case you refer to.

By: Chris Rathman

Chris Rathman — Fri, 03 Oct 2008 17:54:33 +0000

The solution to exercise 2.62 does not seem to handle the case of set1 or set2 being null.

Not nitpicking. I’ve been using your SICP solutions in my own translation efforts. Need to get around to making sure I attribute your work. And also need to get around to posting a story on lambda-the-ultimate.

Thanks.

By: eliben

eliben — Wed, 13 Aug 2008 16:49:50 +0000

Jason,
Thanks for sharing your thoughts.
In these notes I’m just attempting to answer the exercises, and what was asked is the order of growth.
But I’m glad that people post further thoughts in comments, as it allows others to glean something deeper from the exercises.

By: Jason

Jason — Tue, 12 Aug 2008 22:53:51 +0000

Hi Eli, i’m also working through SICP, and i have a few comments about your analysis with regards to question 2.63. I believe tree->list-2 is faster than tree->list-1, if simply for the tail-recursive nature of tree->list-2. As you probably know, scheme optimizes for tail-recursion so that it does not use more stack space than their iterative siblings. Therefore, the overhead for calling functions repeatedly in tail-recursive versions are eliminated. Also, i do believe the algorithm in 2 is faster, since i believe in 2, it just visits each node once and cons the node element onto the result-list. When in 1, it is two recursions, and later appending the result from both into one list (append is a O(n) procedure). I haven’t figured the second part completely, but intuition tells me 2 is faster than 1 in this regards as well. Also i do understand that two O(n) algorithms are formally equivalent, but a large constant can make or break an algorithm as well, and i do believe if nothing else, 2 has a smaller constant than 1, and you should probably mention that

By: eliben

eliben — Tue, 13 May 2008 16:52:54 +0000

Thanks for both comments - I have fixed the post.

By: freefall

freefall — Tue, 29 Apr 2008 15:06:26 +0000

Ex. 2.60: adjoin-set is O(1), indeed, as is cons. But union-set is O(n), because append needs to scan through its first argument.
Ex. 2.61: You can’t use append here for the same reason — it scans through its first argument — and you use it once at each step of your adjoin-set-aux. That’s classical Schlemiel-the-Painter as described in Joel on Software, an O(n^2) algorithm that’s even worse than the O(n) for unordered lists. ElPicasso’s “lazy” thing with sorting also won’t do — a decent sort is O(n * log n), AFAIR, not O(n/2). Only ElPicasso’s last variant qualifies. That’s what I was looking for, by the way, — couldn’t figure out how to do it iteratively without set-cdr!, but forgot that very recursive pattern used in append

By: ElPicasso

ElPicasso — Mon, 07 Jan 2008 18:55:47 +0000

ex 2.61
(define (adjoin-set x set) (cond ((null? set) (cons x ())) ((< x (car set)) (cons x set)) ((= x (car set)) set) (else (cons (car set) (adjoin-set x (cdr set))))))

By: ElPicasso

ElPicasso — Mon, 07 Jan 2008 18:54:04 +0000

ex 2.61 (bit lazy …)
(define (adjoin-set x set) (if (element-of-set? x set) set (sort (cons x set) < )))

By: Kenjin

Kenjin — Mon, 10 Dec 2007 06:38:59 +0000

Thank you so much.
It would take a lot of time for me to understand it though,
if they are not explained as clear and easy as SICP,

Usually it takes longer for me to learn something than the average person.
But I study the book at least 12 hours a day. I just can’t stop
I’m afraid now is the final exam season.
Thank you again.

I try very very hard not to see your answers. I want to do them myself.
It’s too big a temptation:)