[plt-scheme] HTDP: 14.3.4 Retaining Values

P.S. The design that you came up with also has a name:

  structural recursion with accumulator

It is neither required nor really desirable in this particular  
situation.

As you move beyond Part III in HtDP (up to VI) you will encounter the  
following:

  structural recursion design
  design by abstraction, use of abstraction (aka "loops")
  generative recursion design (quick sort, merge sort vs insertion sort)
  structural and generative recursive design with accumulators

On exams and homeworks, I ask my students to identify which design  
strategy they chose to solve the problem to make them more  
conscientious problem solvers. Not everyone who solves a problem  
though can answer this question.

;; ---

Also note that HtDP (and HtDC) expose the Turing Tarpit Problem of  
Homework Assignments. Most people think that after introducing  
students to assignments, if, for/while, and arrays, the kids can more  
or less solve any problem. In principle they are correct because the  
language is equivalent to Turing machines.

In reality though, students don't know enough problem solving  
strategies to crack all problems nor do they understand enough about  
iterative refinement, the other theme in HtDP/C. So HtD is carefully  
designed so that all problems stated in section N can be solved with  
nothing but the problem solving strategies from sections 1 .. N and  
usually in a direct and immediate manner. Of course, the more you get  
to know problem solving strategies the less "immediate and obvious"  
things become because you can challenge students with more complex  
problems.

;; ---

If you also move beyond Part VI, you will get

  structural/generative recursive design with state manipulation

This is difficult, and I have started pushing this part into the HtDC  
part of the first year because I want more time for basic strategies  
to sink in.








On Sep 27, 2008, at 12:13 PM, Geoffrey Lane wrote:

> I hope this is ok, it's my first post to the group.
>
> 14.3.4 Basically counts the max depth of nested lists (what are called
> Web Pages in the example)
> '(foo) is 0 - no nesting
> '(foo (bar)
>        (baz)
>        (quux (zorch))) is 3 for the maximum depth.
>
> It's supposed to just take the Web Page (list of lists) - but I could
> only figure it out when I passed an initial zero that I could then
> increment in the proper condition (when I'm going down a level).
> Am I missing something? The reason I ask, is there's a question in 15
> that wants to do a similar thing.
>
> Code I came up with:
>
> ;; depth: WP  ->  number
> ;; to count the depth of sub-pages that occur in a-wp
> (define (depth a-wp n)
> (count-depth a-wp 0))
>
> ;; count-depth: WP number -> number
> ;; count the depth of the sub-pages of a-wp
> (define (count-depth a-wp n)
> (cond
>   [(empty? a-wp) n]
>   [(symbol? (first a-wp)) (count-depth (rest a-wp) n)]
>   [else (max (count-depth (first a-wp) (add1 n)) (count-depth (rest a-
> wp) n))]))
>
> Thanks for the help.
>
> -- 
> Geoff Lane <geofflane at gmail.com>
>
>
>
> _________________________________________________
>  For list-related administrative tasks:
>  http://list.cs.brown.edu/mailman/listinfo/plt-scheme