[plt-scheme] HTDP 27.5.6

Well first of all I am sorry.
I didn't think it was a solution because I was stuck with it, nonetheless I 
seem to have overstepped the mark so I apologise.


>From: Matthias Felleisen <matthias at ccs.neu.edu>
>To: "wooks ." <wookiz at hotmail.com>
>CC: plt-scheme at list.cs.brown.edu
>Subject: Re: [plt-scheme] HTDP 27.5.6
>Date: Sat, 29 Jul 2006 11:04:40 -0400
>
>Wooks, it is unkosher to post solutions to student exercises on the  Web. 
>There are high school teachers all over the world who rely on  the 
>solutions being protected and not published (at least not with  
>explanations and on a `reliable' source). I must ask you to refrain  from 
>posting HtDP solutions on this mailing list. -- Matthias, for SK
>
>
>
>
>On Jul 28, 2006, at 7:10 PM, wooks . wrote:
>
>>My solution to 27.5.5 accomplished the switch by moving the top row  to 
>>the bottom of the matrix.
>>
>>However coming to Ex 27.5.6 I can see that if all the remaining  first row 
>>cells are zero I will infinitely loop. Now ok I could  check if thats the 
>>case and handle it in some way. Alternatively I  could pre sort the matrix 
>>by descending 1st colmumn which would  eliminate the need for any 
>>switching, but I am getting an uneasy  feeling about this solution esp 
>>since the fact I didn't recourse to  the hint in 27.5.5 shows some 
>>divergent thinking from the authors.
>>
>>Have I or am I about to take a wrong turn.
>>
>>Here is what I have as the result of 27.5.5 (I have annotated the  code 
>>with some extras that I felt were needed).
>>
>>
>>;triangulate : [[num]] -> [[num]]
>>;produces a matrix in lower echelon form
>>(define (triangulate matrix)
>>  (cond
>>    [(empty? matrix) empty]
>>    [else (local ((define top-row (first matrix)))
>>            (cond
>>              [(zero? (first top-row)) (triangulate (append (rest  matrix) 
>>(list top-row)))]
>>              [else (cons top-row
>>                          (triangulate (map (lambda (current-row)  
>>(subtract top-row current-row))
>>                                            (rest matrix))))]))]))
>>
>>;subtract: [number] [number] -> [number]
>>;repetitively subtracts the 1st list from the 2nd until the 1st  cell of 
>>the 2nd list is eliminated
>>(define (subtract lista listb)
>>  (cond
>>    [(empty? listb) empty]
>>    [(zero? (first listb)) (rest listb)]
>>
>>    ;;ensures that 1st cell in listb is a multiple of the first cell  in 
>>lista
>>    ;;otherwise we will infinitely loop trying to eliminate the cell  in 
>>listb
>>    [(not (zero? (remainder (first listb) (first lista))))
>>     (subtract lista (map (lambda (cell) (* (first lista) cell))  listb))]
>>
>>    ;;determines whether elimination is accomplished by addition or  
>>subtraction
>>    [else (local ((define op (if (or (and (< (first listb) 0)
>>                                          (< (first lista) 0))
>>                                     (and (> (first listb) 0)
>>                                          (> (first lista) 0))) - +))
>>                  (define (subEach lista listb)
>>                    (cond
>>                      [(empty? lista) empty]
>>                      [else (cons (op (first listb) (first lista))
>>                                  (subEach (rest lista) (rest  
>>listb)))])))
>>            (subtract lista (subEach lista listb) ))]))
>>
>>
>>_________________________________________________
>>  For list-related administrative tasks:
>>  http://list.cs.brown.edu/mailman/listinfo/plt-scheme
>