Interesting how my skills is stripped to the bone if I am not able to use
string functions that are available in other languages.  Someone had to do
the work for me to benefit ... which is why I'm trying to understand the
process of programming / problem solving in more detail.

So ... I realise this must be simple - but it has me stumped.

I'm playing with lists so I can understand them better.  Clearly I don't.
Further, I don't even know how to approach the small problem and it is
driving me nuts :).

I can remove negatives values from a list easily enough, but if I try to
translate that approach to, say, removing item 3 (the third item - I know
they begin at item 0 through to n-1) from a list of values, I have no clue.
The code for remove-negatives is based upon code from my lecturer that
replaced negatives in a list.  (Do not want to take credit for another
person's work.)

Anyway, I thought I understand it quite well.  Evidently not well enough to
translate it to another context.  I was hoping to use a similar approach so
I can remove a specific item in the list (by place), if that is even
possible.
;--------------- template for recursion  (bored with factorial :)--------
;
(define [remove-negatives numbers]
  (cond
    ;; Base case: No numbers provided, so return empty list
    [(empty? numbers)
     empty]
    ;; Recursive case: First number is negative, so return a
    ;; list constructed the rest of the
    ;; numbers
    [(negative? (first numbers))
     (remove-negatives (rest numbers))]
    ;; Recursive case: First number is non-negative, so
    ;; return a list constructed from this number followed by
    ;; the rest of the numbers with negatives removed
    [else
     (cons (first numbers) (remove-negatives (rest numbers)))]))

;; Test
(remove-negatives (list 1 2 -9 3 4 0 5 6 -8 7))
; ==> (list 1 2 3 4 0 5 6 7)

I can almost see what 'needs' to be done by playing with this in a logical
sense.

For example: Remove the 'x' item from this list (list 1 2 3 4 5).

(define list1 (list 1 2 3 4 5))
'x' = 1 then the result is (rest (list 1 2 3 4 5))
'x' = 2 then (cons (first list1) (cons (third list1) (cons (fourth list1)
(fifth list1))))
; ==> (1 3 4 . 5)

This is not my desired result but is shows that aside from the first item in
the list, I add the first item in the list to the remainder to be processed.
Then when I get to the item to be removed I add the first item to those
remaining, excluding the one to be removed.  I need a list as a result with
no pair anywhere.

Aside from the case where I want to exclude the first item in the list
(which is just (rest list1)), I suspect this 'should' be able to be solved
recursively but I do not know how to lay out the process.

Can someone please push me in the right direction?

Kindest regards,

;; remove the nth item from a list ..
(define (remove n a-list)
  (cond
    [(empty? a-list) empty]
    [(> n 1) (cons (first a-list)(remove (- n 1) (rest a-list)))]
    [else (rest a-list)]))

hope this helps ..

luca

Mike ha scritto: