You are **on
your honor** to make a good-faith effort to solve problems on your
own, or with your partners, before using these hints. This typically
means *at least* 10 minutes of brainstorming, attacking the problem
with pencil and paper, drawing small diagrams, and so on. The hints are
provided with the intention of reducing frustration when course staff
support is not available. Remember that the main purpose of this
problem set is to help you prepare for Exam 1, so it will defeat that
purpose if you use the hints in place of thinking about the problems
yourself.

The hints are written in white text on a white background. On most browsers
you make the hint visible by moving your mouse over it. If that
doesn't work, click your mouse on the screen and drag it over the box: the
text will become visible. Try it out on the apparently-empty box below:

If you can read these words, you are doing it correctly.

Use `list-map`.

`string-to-baudot` Hint 2:

Use `string->list` to convert your argument to a list, and then use
`list-map` on it.

Check out Example 7.5 (Length) in the course book.

You could use `list-append` to place the `cdr` of the wheel at the front of
your answer. Remember that `list-append` takes two lists as arguments.
To turn *X* into a one-element list containing *X*, use `(list X)`.

Revisit the `n-times` code from PS3.

Use `list-map` to apply `rotate-wheel` to every wheel in the list.

The running time of
`rotate-wheel-list-by` depends on both inputs
— the wheels passed in and the number of rotates, `n`. To
avoid confusion, use *w* to represent the number of
wheels, *p* to represent the number of positions in each wheel
(fixed as 5 in the problem set, but the procedure we defined would work
for any length), and *r* as the number of rotates to do (the
value passed in as `n`). Express your answer in terms of those
three variables.

How much work are we doing per wheel? How many wheels are there?

Running Time Hint 2:

From Example 7.4, `list-append` has running time in Θ(*l*) where *l* is
the number of elements in the first list passed to `list-append`.

Running Time Hint 3:

We are doing Θ(*p* * *r*) work for each wheel,
and there are *w* wheels.

The `list-map` procedure we defined only works on one list at a
time, but this problem requires processing two lists at once. Ambitious
students will define a `twolist-map` procedure that takes a
procedure and two lists as its inputs. The input procedure should take
two inputs. The output of `twolist-map` is the list that result
from applying the input procedure to each of the corresponding elements from the two
input lists. For example, (twolist-map + (list 1 7 3) (list 9 5
2)) should evaluate to `(10 12 5)`.

The built-in `map` procedure already works on any number of input
lists! For example, (map + (list 1 7 3) (list 9 5 2)) evaluates to
`(10 12 5)` (so does: `(map (lambda (a b) (+ a b)) (list 1 7 3)
(list 9 5 2))`.)

Use `list-map` to apply `xor` to two lists: the Baudot letter
(which is just a list of bits) and the list consisting of the first
part of each `wheel`. How can you get the first part of each wheel?
`map` again!

This is a recursive procedure in which the base case is
`(null? list-of-baudots)`, the
results are combined by `(cons ...)`,
and the recursive call is to `do-lorenz` with each of the four
arguments modified as per the text.

`do-lorenz` Hint 2:

This works as the heart of the recursive call:

(do-lorenz (cdr list-of-baudots) (rotate-wheel-list kwheels) (if (= (car mwheel) 1) (rotate-wheel-list swheels) swheels) (rotate-wheel mwheel))... but you'll still need two calls to

To call `something` on all of the numbers between 1 and 5, we might do:

(list-map (lambda (i) (something i)) (intsto 5))

`brute-force-lorenz` Hint 2:

To consider all pairs of numbers between 1 and 5, we might do:

(list-map (lambda (i) (list-map (lambda (j) (something i j)) (intsto 5))) (intsto 5))