This is how my initial definitions file looks like for this chapter:
1
2
3
4
5
6

#lang racket
(require "little_schemer.rkt")
(#%require racket/trace)

Note that with the (#%require racket/trace)
line I can use trace
ðŸ™‚
I’m requiring this file in order to deal with an issue described later.
Note that they specify for purposes of this chapter we’re focused on nonnegative integers.
Commandments
Selected Portions of Exercises
+ (addition)
I named mine plus
in order to avoid any issues with the existing +
function:
1
2
3
4
5
6
7

(define plus
(lambda (a b)
(cond
((zero? b) a)
(else
(plus (add1 a)(sub1 b))))))

So basically, I recursively call plus
while adding 1 to the first value and subtracting 1 from the second value until the second value is 0, at which point I return the first value. I kinda use the computer like an abacus that moves one bead at a time from b to a until b is zero, at which point a is returned.
This was their solution:
I found their approach slightly more complex than mine.
Basically what they do is add 1 to the result of calling their plus function with n and the result of running sub1
on m.
So suppose the initial values for n and m are 4 and 3. After you evaluate sub1 m
, you have a 4 and a 2 to evaluate so that you can add 1 to them. When you try to evaluate that +
with the 4 and 2, first you check whether m is equal to zero. Since it’s not, you have a further recursive call to +
, this time with 4 and 1. This keeps going until you reach 4 and 0, and all the while, you are building up a recursive chain of add1
‘s that are waiting to get evaluated.
When you get to the point where m is zero, you finally return 4 and can evaluate the chain of add1
‘s you’ve built up:
Seems like these Commandments are going to have a lot of nuance ðŸ˜‰
– (subtraction)
My attempt at a subtraction function:
1
2
3
4
5
6

(define minus
(lambda (a b)
(cond
((zero? b) a)
(else (minus (sub1 a)(sub1 b))))))

I recursively call minus
while subtracting 1 from each of a and b until b is zero, at which point I return a.
This is their solution:
This works similarly to their addition function, in that they build up a chain of sub1
‘s until the second value is 0. Then they evaluate their chain of sub1
‘s using the first value.
I had some hesitancy around the idea of having two sub1
‘s in the same expression. I think maybe I had an intuition that that’d be too much subtraction. But you need both for it to work. The first sub1
, right after the else
, becomes part of the chain of sub1
‘s by which we reduce the first number. The second sub1
, which actually gets evaluated as we go “down” in the steps of recursive calls, reduces the second number. If we didn’t reduce the second number as we tried to build up our chain of recursive calls, we’d get an infinite loop.
addtup (add a tup up)
A tup is a list of numbers. It includes the empty list. We can do operations on tups.
1
2
3
4
5
6

(define addtup
(lambda (tup)
(cond
((null? tup) 0)
(else (+ (car tup) (addtup (cdr tup)))))))

x (multiplication)
My answer:
1
2
3
4
5

(define x
(lambda (n m)
(cond ((zero? m) 0)
(else (+ n (x n (sub1 m)))))))

This method builds up a chain of (+ n...
calls until m hits 0. Then we return 0. (x 3 0)
is 0. But we add 0 to 3 and then keep moving up the chain of recursive calls until we’re done adding.
Good point. Equations are another way to think about recursive functions.
tup+ (combine tups)
For the initial version below, the tups have to be the same length. Thus the questions we need to worry about are (and (null? tup1)(null? tup2))
and else
.
1
2
3
4
5
6
7
8

(define tup+
(lambda (tup1 tup2)
(cond
((and (null? tup1)(null? tup2)) '())
(else
(cons (+ (car tup1)(car tup2))
(tup+ (cdr tup1)(cdr tup2)))))))

The book then wants a variant that will work even if one tup is shorter than another.
1
2
3
4
5
6
7
8
9
10

(define tup+
(lambda (tup1 tup2)
(cond
((and (null? tup1)(null? tup2)) '())
((null? tup2) tup1)
((null? tup1) tup2)
(else
(cons (+ (car tup1)(car tup2))
(tup+ (cdr tup1)(cdr tup2)))))))

This works because, at the point one of the tups “runs out” of values, the entirety of the remaining part of the nonempty list is returned, without further use of car
or cdr
.
You can actually remove the ((and (null? tup1)(null? tup2)) '())
at this point. If both tups are the same length, then when null? tup2
goes to check if the second tuple is null, and it is null, then it’ll return the (also empty) tup1 as an empty list, which is what we want to return when both tups are null anyways…
1
2
3
4
5
6
7
8
9

(define tup+
(lambda (tup1 tup2)
(cond
((null? tup2) tup1)
((null? tup1) tup2)
(else
(cons (+ (car tup1)(car tup2))
(tup+ (cdr tup1)(cdr tup2)))))))

> (greater than)
The book calls this >
but I used my own name
1
2
3
4
5
6
7
8

(define greaterthan
(lambda (n m)
(cond
((zero? n) #f)
((zero? m) #t)
(else (greaterthan (sub1 n) (sub1 m))))))

< (less than)
The procedure for <
is pretty similar
1
2
3
4
5
6
7

(define lessthan
(lambda (n m)
(cond
((zero? m) #f)
((zero? n) #t)
(else (lessthan (sub1 n) (sub1 m))))))

If the second number is 0, and given that we’re not worrying about the possibility of negative numbers, then the first number has to be at least 0 as well, which would be a tie between m and n, not a case where n is less than m. (n could also be greater than m). So we’d return false. OTOH, if we know m isn’t zero, but n is zero, then that means n is less than m, so we return true.
= (equal)
My solution (I only used <
):
1
2
3
4
5
6

(define equal
(lambda (n m)
(cond ((< m 1)(< n 1))
((< n 1) #f)
(else (equal (sub1 n)(sub1 m))))))

Given that we’re not worried about negative numbers, if m is less than 1 it has to be 0. If m is 0, then if n is also less than 1 (0), the function should return true. OTOH, if m is 0, but n is not 0, then the function should return false. That’s what happens with ((< m 1)(< n 1))
. First we test for the value of m. Then if m is 0, we test for the value of n, and get true or false back depending on the value of n.
OTOH, if we get to the second cond
clause, ((< n 1) #f)
, then we know that m isn’t 0. If we know that, and then we also know that n is less than 1 (so zero), then we know that n and m aren’t equal, and thus we should return false.
Otherwise we recurse.
Their solution is actually more straightforward. I think I was trying to follow the previous definition of =
or something when I came up with mine:
But yeah. This solution kind of speaks for itself ðŸ™‚
â†‘ (exponents)
1
2
3
4
5
6

(define powerof
(lambda (n m)
(cond
((zero? m) 1)
(else (* n (powerof n (sub1 m)))))))

Ã· (division)
This is how they do division
length (length of a list of atoms)
My answer, same as theirs:
1
2
3
4
5
6

(define length
(lambda (lat)
(cond
((null? lat) 0)
(else (add1 (length (cdr lat)))))))

pick (nth value of a list)
Mine was a little different than theirs:
1
2
3
4
5

(define pick
(lambda (n lat)
(cond ((= n 1) (car lat))
(else (pick (sub1 n)(cdr lat))))))

I used =
. Seemed like fair game since it had been introduced.
Theirs was:
Totally valid solution, but I think ((zero? (sub1 n))
is a bit less straightforward than mine. I get that their version is compatible with the First Commandment though.
rempick (remove value from a list)
Mine was close, except I also had a null check for the lat:
1
2
3
4
5
6
7

(define rempick
(lambda (n lat)
(cond ((null? lat) '())
((zero? (sub1 n)) (cdr lat))
(else (cons (car lat) (rempick (sub1 n) (cdr lat))))
)))

I wasn’t sure whether the null?
was necessary when I wrote it, I had the idea that it might come up when the n was out of range of the values in the lat.
Trace results for my version:
And trace results for their version:
So basically for my version, if the n is out of range, the whole lat winds up getting returned, which I think makes sense (since the value you specified to remove is not in the range of the lat). Whereas with theirs you get an error message. I don’t think this is a huge deal but mine seems better.
nonums (return everything but numbers)
My answer:
1
2
3
4
5
6

(define nonums
(lambda (lat)
(cond ((null? lat) '())
((number? (car lat)) (nonums (cdr lat)))
(else (cons (car lat) (nonums (cdr lat)))))))

Theirs was basically the same but they did the cond/else structure that they like:
allnums (return only the numbers)
My answer, same as theirs:
1
2
3
4
5
6

(define allnums
(lambda (lat)
(cond ((null? lat) '())
(else (cond ((number? (car lat)) (cons (car lat) (allnums (cdr lat))))
(else (allnums (cdr lat))))))))

eqan? (eq? for atoms and numbers)
This was my first attempt:
1
2
3
4
5
6
7

(define eqan?
(lambda (n m)
(cond ((and (number? n)(number? m))
(= n m))
(else (cond ((eq? n m) #t)
(else #f))))))

This is theirs:
The eq?
in my Racket takes numeric arguments for eq?
. Therefore, my procedure works to handle some input like (eqan? 3 'potato)
. When that gets to the ((eq? n m)
part, it evaluates as true. Whereas with their version of eq?
, if you tried to evaluate that I guess you would get an error. That’s why, after they test whether both a1 and a2 are numbers, they test whether either one is. And only after that test do they try to use eq?
.
Also now that I think about it, I think the last line of my version may be redundant. Maybe it’s better as:
1
2
3
4
5
6

(define eqan?
(lambda (n m)
(cond ((and (number? n)(number? m))
(= n m))
(else (cond ((eq? n m) #t))))))

Anyways, it seems like I should get my functions on the same page as the Little Schemer definitions in order to avoid future confusion. So I’m now using this file to do so.
hurrah
occur (count occurrences)
Mine:
1
2
3
4
5
6
7
8
9

(define occur2
(lambda (a lat)
(cond
((null? lat) 0)
(else
(cond
((eqan? a (car lat))(add1 (occur2 a (cdr lat))))
(else (occur2 a (cdr lat))))))))

theirs is basically the same except they use eq?
instead of eqan?
.
one? (is the value 1?)
Mine:
1
2
3
4
5

(define myone?
(lambda (n)
(cond ((number? n)(= n 1))
(else #f))))

Their two options:
My version handles nonnumbers without an error message cuz of the check for number?
.
If you’re not worried about nonnumeric input, you could do:
1
2
3
4

(define myone?
(lambda (n)
(= n 1)))

They agree.
rempick rewrite
My answer:
1
2
3
4
5
6

(define rempick
(lambda (n lat)
(cond ((one? n) (cdr lat))
(else (cons (car lat) (rempick (sub1 n) (cdr lat))))
)))

Their answer was the same.