Question

In a practice exam that I’m taking, there is a question that asks to create a procedure that takes a list and creates a new list that contains two of each element in the old list while preserving the order. The example they provide:

    (double-duplicate (list 1 2 3 4 4 5))

produces

    (1 1 2 2 3 3 4 4 4 4 5 5)

I managed to find a solution that uses map and flatten:

    (define (flatten list)
       (cond ((null? list) '())
             ((list? (car list)) (append (flatten (car list)) (flatten (cdr list))))
             (else (cons (car list) (flatten (cdr list))))))

    (define (double-duplicate ls)
      (define (helper list1 list2)
        (flatten (map list list1 list2)))
      (helper ls ls))

while it does work, I do not feel that it is the most effective solution since I am using the form of map that takes 3 parameters and I do not like the idea of having to write a second procedure (flatten) just to get rid of the excess parentheses. Can anyone think of a better way to doing this? I’m a bit lost as to how else I can write it. I appreciate any ideas.

*Note: I am using MIT scheme for all this.

Answer 1

Are you using Racket? If so, you can use append-map:

(define (double-duplicate lst)
  (append-map (lambda (x) (list x x)) lst))

append-map is analogous to the likes of Scala’s flatmap.

It’s not hard to write your own version of append-map if you need to:

(define (append-map func lst)
  (fold-right (lambda (e r)
                (append (func e) r)) '() lst))