It looks like there’s one other guy on the internet who’s posting his answers for the exercises in this book. So, I’ll be linking to his so you (and I) can compare our answers. He knows what he’s doing. In his posts, he talks about, e.g., what he’d do in Haskell. I’m not a functional programming guy (lisp gives me the heebie-geebies, my earlier post on evolutionary programming where I used it notwithstanding). So, below are my answers (click to see more if you’re looking at the blog and not this post by itself) and here is the Japanese guy’s answers.

[erlang]
-module(sort).
-export([quicksort/1,mergesort/1]).

less([Head|Tail], Pivot) when Head >= Pivot ->
less(Tail, Pivot);
less([Head|Tail], Pivot) when Head < Pivot ->
[Head|less(Tail, Pivot)];
less([],_) ->
[].

more([Head|Tail], Pivot) when Head >= Pivot ->
[Head|more(Tail, Pivot)];
more([Head|Tail], Pivot) when Head < Pivot ->
more(Tail, Pivot);
more([],_) ->
[].

quicksort([Head|Tail]) ->
quicksort(less(Tail,Head)) ++ [Head] ++ quicksort(more(Tail,Head));
quicksort([]) ->
[].

% For reference, here’s the quicksort from wikipedia’s page on erlang… much better-looking than my crap (but in my defense, I didn’t know how to do this kind of list construction… cool!)
% quicksort([]) -> [];
% quicksort([Pivot|Rest]) ->
% quicksort([Front || Front <- Rest, Front < Pivot])
% ++ [Pivot] ++
% quicksort([Back || Back <- Rest, Back >= Pivot]).

merge([Head1|Tail1],[Head2|Tail2]) when Head2 > Head1 ->
[Head1] ++ merge(Tail1,[Head2|Tail2]);
merge([Head1|Tail1],[Head2|Tail2]) when Head2 =< Head1 ->
[Head2] ++ merge([Head1|Tail1],Tail2);
merge([],[]) ->
[];
merge(End,[]) ->
End;
merge([],End) ->
End.

mergesort([]) ->
[];
mergesort([Left]) ->
[Left];
mergesort(List) ->
{Left, Right} = lists:split(length(List) div 2, List),
merge(mergesort(Left), mergesort(Right)).

[/erlang]

[erlang]
-module(db_lists).
-export([new/0, destroy/1, write/3, delete/2, read/2, match/2]).

new() ->
[].

destroy(Db) ->
ok.

write(Key, Element, Db) ->
Db ++ [{Key, Element}].

delete(Key, List) ->
lists:keydelete(Key, 1, List).

read(Key, List) ->
case (lists:keyfind(Key, 1, List)) of
{MatchKey, Element} ->
{ok, Element};
_ ->
{error, instance}
end.

match(Element, [{DbHeadKey, DbHeadElement}|DbTail]) ->
case DbHeadElement of
Element -> [DbHeadKey] ++ match(Element, DbTail);
_ -> match(Element, DbTail)
end;
match(Element, []) ->
[].

[/erlang]