[plt-scheme] HTDP 12.4.2

Yes now you're on a roll and 90% there except that one example is wrong.

On Jun 23, 2006, at 12:45 AM, wooks wooks wrote:

>
>
> I should have said  (????? sym (first alow)) where ????? is a function 
> that inserts sym into every position in a word and heretofore i will 
> name interperse  (instead of infiltrate - more appropriate).
>
>
> The full definition is
>
> (define (insertEverywhere sym alow)
>  (cond
>    [(empty? alow) empty]
>    [else (append (interperse sym (first alow))
>                  (insertEverywhere sym (rest alow)))]
>    )
>  )
>
> Now I can't see a way to write interperse with the design recipe used 
> so far.
>
> ;CONTRACT
> ;interperse : symbol word - list-of-words
> ; produces a list of words by interpersing symbol into each position 
> in word (including before and after)
> ;
> ;EXAMPLES
> ;(interperse 'd (list 'e 'r)  gives
> ;(list (list 'd 'e 'r)
> ;       (list 'e 'd 'r)
> ;       (list 'e 'r 'd))
>
> ;(interperse d empty) gives empty
> ;(intereperse d 'x) gives (list (list 'd 'x)
> ;                               (list 'x 'd))
> ;
> ;TEMPLATE
> ;(define (interperse sym word)
> ;   (cond
> ;      [(empty? word) ....]
> ;      [else ....sym ... (first word)
> ;                        (interperse sym (rest word))]
> ;    )
> ;  )
>
> It still looks to me that I will need some auxiliary function similar 
> to what I did with the original infiltrate though (split the word into 
> 2 parts and generate words by inserting symbol between each respective 
> split combination.
>
>
>
>
> ----Original Message Follows----
> From: Danny Yoo <dyoo at hkn.eecs.berkeley.edu>
> To: wooks wooks <wookiz at hotmail.com>
> CC: plt-scheme at list.cs.brown.edu
> Subject: Re: [plt-scheme] HTDP 12.4.2
> Date: Thu, 22 Jun 2006 20:47:44 -0700 (PDT)
>
>
>
> On Thu, 22 Jun 2006, wooks wooks wrote:
>
>>
>> So, if we are holding onto:
>>
>>   (list (list 'd 'r 'e)
>>         (list 'r 'd 'e)
>>         (list 'r 'e 'd))
>>
>> and we want to mess with it enough so we get:
>>
>>    (list (list 'd 'e 'r)
>>          (list 'e 'd 'r)
>>          (list 'e 'r 'd)
>>          (list 'd 'r 'e)
>>          (list 'r 'd 'e)
>>          (list 'r 'e 'd))
>>
>> do you see what the difference between what we're holding onto and 
>> what we want is?  Can you give a concept or name to it?
>>
>>
>> The difference is (first alow) - Right.
>
>
> Hi Wooks Wooks,
>
> I'm not quite sure if we've done that mind meld thing yet, where we 
> both are sharing the same thoughts.  *grin* Can you be more specific?
>
>
> How can (first alow), which is going to be the list
>
>          (list 'e 'r)
>
> then account for the difference between:
>
>    (list (list 'd 'r 'e)
>          (list 'r 'd 'e)
>          (list 'r 'e 'd))
>
>
>
> which is what we have on hand, and the result that we really want to 
> get back:
>
>    (list (list 'd 'e 'r)
>          (list 'e 'd 'r)
>          (list 'e 'r 'd)
>          (list 'd 'r 'e)
>          (list 'r 'd 'e)
>          (list 'r 'e 'd))
>
> I'm not saying that it isn't, but that if we're going to say that it 
> is, we have to fill in a few more ...'s till we can tell the 
> non-thinking computer how to do what we think we mean.
>
>
>
> That is, recalling that portion of the template we were looking at 
> earlier,
>
> ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
>     [else ... sym ... (first alow) ...
>           ... (insertEverywhere sym (rest alow)) ...]
> ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
>
> and knowing what the expected return value is now, can you think of 
> how to complete the definition now?
>
>
>
> If not, one way to make things easier is to fill the template will 
> concrete values, based on the test case you worked out, and see if 
> that will help:
>
>     (... sym ... (first alow) ...
>          ... (insertEverywhere sym (rest alow)) ...)
>
> ==>
>
>     (... 'd  ... (list 'e 'r) ...
>          ...  (list (list 'd 'r 'e)
>                     (list 'r 'd 'e)
>                     (list 'r 'e 'd)) ...)
>
> Does this help?
>
>
> Note that the steps we've done haven't been particularly brilliant.  
> One could rephrase the steps we're doing here as:
>
>     1.  Shaping the general program pattern.
>     2.  Cooking up simple test cases.
>     3.  Mixing in those test case situations into the pattern.
>
> We aren't aren't doing anything that couldn't be really codified in 
> some strategy, some... well, let's call this thing a "design recipe" 
> for lack of a better term.  *wink*
>
>
> _________________________________________________
>  For list-related administrative tasks:
>  http://list.cs.brown.edu/mailman/listinfo/plt-scheme