Remove multiple characters from a list if they are next to each other in Scheme

Question

I have to make a Dr. Racket program that removes letters from a list if they are following the same letter as itself. For example: (z z f a b b d d) would become (z f a b d). I have written code for this but all it does is remove the first letter from the list. Can anyone help?

#lang racket 
(define (remove-duplicates x)
(cond ((null? x)
     '())
    ((member (car x) (cons(car(cdr x)) '())))
     (remove-duplicates (cdr x))
    (else
     (cons (car x) (remove-duplicates (cdr x))))))

(define x '( b c c d d a a))
(remove-duplicates x)

Answer 1

(define (remove-dups x)
   (cond
     [(empty? x) '()]
     [(empty? (cdr x))  (list (car x))]
     [(eq? (car x) (cadr x))  (remove-dups (cdr x))]
     [else  (cons (car x) (remove-dups (cdr x)))]))

(cadr x) is short for (car (cdr x)) in case you didn't know.

Also, pattern matching makes list deconstruction often much more readable. In this case not so much, but it's still better than the other version:

(define (rmv-dups x)
  (match x
    [(list)  (list)]
    [(list a)  (list a)]
    [(cons a (cons a b))  (rmv-dups (cdr x))]
    [__  (cons (car x) (rmv-dups (cdr x)))]))

Answer 2

This problem will be simpler if you introduce a helper function.

I recommend something like this (where angle brackets mean you need to fill out the details):

(define (remove-duplicates x)
  (cond
    [ <x is empty>                             '()]  ; no duplicates in empty list
    [ <x has one element>                      x]    ; no duplicates in a list with one element
    [ <first and second element in x is equal> (cons (car x) (remove-from-front (car x) (cdr x)))]
    [else                                      (cons (car x) (remove-duplicates (cdr x)))]))

(define (remove-from-front e x)
  (cond
    [ <x is empty>                  '()]                 ; e is not the first element of x
    [ <e equals first element of x> (remove-from-front e (cdr x))] ; skip duplicate
    [else                           (remove-duplicates x)]))       ; no more es to remove