Topic: [challenge] A07 : Eliminate consecutive duplicates from a list

[JohnK]

Using only AutoLisp, and given a list that contains repeated elements, return a list where the consecutive duplicates are replaced by a single copy of the item. The order of the elements, in the list, should not be changed. -i.e. transform a list into a compressed version.

Example:
(compress '(a a a a b c c a a d e e e e))
> (A B C A D E)
(compress '(A B C A D E))
> (A B C A D E)
(compress '(A A))
> (A)
(compress '())
nil

[Tharwat]

My attempt.
Append function may slow down the process a bit as known to many but anyway I have chosen it to avoid using reverse at the end.

Code - Auto/Visual Lisp: [Select]

1. (defun Eliminate:Duplicates (lst / itm rtn)
2.   (while lst (or (member (setq itm (car lst)) rtn)
3.                  (setq rtn (append rtn (list itm)))
4.                  )
5.     (setq lst (cdr lst))
6.     )
7.   rtn
8.   )
9.  

[JohnK]

Mine:

Code - Auto/Visual Lisp: [Select]

1. (defun compres-se7en (aList / finddupli complst)
2.    (defun finddupli (lst)
3.      (if (not (member lst complst))
4.        (setq complst (cons lst complst))))
5.   (mapcar 'finddupli aList)
6.   (reverse complst)
7.  )

(compres-se7en '(a a a a b c c a a d e e e e))
(compres-se7en '(A B C A D E))
(compres-se7en '(A A))
(compres-se7en '())

I didn't consider trying not to use reverse. I'll see if I can break away from work to pen another version in a bit.

[gile]

Code - Auto/Visual Lisp: [Select]

1. (defun compress (lst)
2.   (cond
3.     ((null lst) nil)
4.     ((= (car lst) (cadr lst)) (compress (cdr lst)))
5.     (T (cons (car lst) (compress (cdr lst))))
6.   )
7. )

[Marc'Antonio Alessi]

Code: [Select]

(defun ALE_RemConsDup (l / o p)
  (reverse
    (foreach f l
      (if (equal f p)
        (progn (setq p f) o)
        (setq  p f  o (cons f o))
      )
    )
  )
)

[Marc'Antonio Alessi]

Mine:

Code - Auto/Visual Lisp: [Select]

1. (defun compres-se7en (aList / finddupli complst)
2.    (defun finddupli (lst)
3.      (if (not (member lst complst))
4.        (setq complst (cons lst complst))))
5.   (mapcar 'finddupli aList)
6.   (reverse complst)
7.  )

(compres-se7en '(a a a a b c c a a d e e e e))
(compres-se7en '(A B C A D E))
(compres-se7en '(A A))
(compres-se7en '())

I didn't consider trying not to use reverse. I'll see if I can break away from work to pen another version in a bit.

Code: [Select]

(compres-se7en '(a a a a b c c a a d e e e e)) => (A B C D E) not > (A B C A D E)
(compres-se7en '(A B C A D E))                 => (A B C D E) not > (A B C A D E)


[JohnK]

clarification:
It should be only grouping consecutive duplicates
Therefore:

(compres-se7en '(a a a a b c c a a d e e e e)) => (A B C D E) not > (A B C A D E)
is incorrect.
This is how it should work.
(a a a a b c c a a d e e e e) -> ((A A A A) (B) (C C) (A A) (D) (E E E E)) => (A B C A D E)

That being said, my processing of (A B C A D E) is incorrect. I should return the same list because there are not any CONSECUTIVE duplicates in that list. (A B C A D E)

I will have to redo my entry.

[JohnK]

Tharwat and I have incorrect entries.

gile and Marc'Antonio Alessi have correct entries.

(from my limited testing)

[gile]

Imperative way.

Code - Auto/Visual Lisp: [Select]

1. (defun compress (lst / ret)
2.   (while lst
3.     (if (/= (car lst) (cadr lst))
4.       (setq ret (cons (car lst) ret))
5.     )
6.     (setq lst (cdr lst))
7.   )
8.   (reverse ret)
9. )

[Lee Mac]

Another -

Code - Auto/Visual Lisp: [Select]

1. (defun compress ( l / r x )
2.     (while (setq x (car l))
3.         (setq l (cdr l)
4.               r (cons x r)
5.         )
6.         (while (= x (car l)) (setq l (cdr l)))
7.     )
8.     (reverse r)
9. )

[Stefan]

Code - Auto/Visual Lisp: [Select]

1. (defun compress (l / r)
2.   (while
3.     (progn
4.       (or
5.         (= (car l) (car r))
6.         (setq r (cons (car l) r))
7.       )
8.       (setq l (cdr l))
9.     )
10.   )
11.   (reverse r)
12. )

[Stefan]

Another -

Code - Auto/Visual Lisp: [Select]

1. (defun compress ( l / r x )
2.     (while (setq x (car l))
3.         (setq l (cdr l)
4.               r (cons x r)
5.         )
6.         (while (= x (car l)) (setq l (cdr l)))
7.     )
8.     (reverse r)
9. )

Code: [Select]

(compress '(nil 1 1 2 2))

[JohnK]

corrected entry

Code - Auto/Visual Lisp: [Select]

1. (defun compress (aList / dupli-subarray)
2.   (defun dupli-subarray (element seg lst)
3.     (cond
4.       ((null lst)
5.        (cons element seg))
6.       ((eq element (car lst))
7.         (dupli-subarray element '() (cdr lst)))
8.       (t
9.         (append
10.           (cons element seg)
11.           (dupli-subarray (car lst) '() (cdr lst)))))
12.     )
13.   (if (null aList)
14.     '()
15.     (dupli-subarray (car aList) '() (cdr aList)))
16.   )

[Lee Mac]

Code - Auto/Visual Lisp: [Select]

1. (defun compress (l / r)
2.   (while
3.     (progn
4.       (or
5.         (= (car l) (car r))
6.         (setq r (cons (car l) r))
7.       )
8.       (setq l (cdr l))
9.     )
10.   )
11.   (reverse r)
12. )

Code: [Select]

(compress '(nil 1 1 2 2))
 

[Marc'Antonio Alessi]

New version to avoid:  (compress '(nil 1 1 2 2)) > (1 2)

Code: [Select]

(defun ALE_RemConsDup (L / o p)   ; r1.02
  (setq p (cons 0 (car L)))       ; #02 ex (setq p L)
  (reverse
    (foreach f L
      (if (equal f p)
        o                         ; #01 ex (progn (setq p f) o)
        (setq p f  o (cons f o))
      )
    )
  )
)
Edit: see#nn

[Stefan]

Code: [Select]

(compress '(nil 1 1 2 2))
 

Don't tell anyone. They will test it on a, b, c

[apricot125]

a simple, but ugly one

Code: [Select]

;;;====================================================================================
  ;  P08 (**) Eliminate consecutive duplicates of list elements.
  ;      If a list contains repeated elements they should be
  ;      replaced with a single copy of the element. The order
  ;      of the elements should not be changed.
  ;  Example:      (compress '(a a a a b c c a a d e e e e))
  ;            --> (A B C A D E)
;;;====================================================================================
(defun compress (mylst / 1st ans len i)
  (setq 1st (car mylst)
        ans (list 1st)
        len (length mylst)
        i  1
  )
  (while (< i len)
    (if (equal 1st (nth i mylst))
      t
      (setq 1st (nth i mylst)
            ans (append ans (list 1st))
      )
    )  ; _ end of if
    (setq i (1+ i))
  )  ; _ end of while
  ans
)  ; _ end of defun

[ElpanovEvgeniy]

Express Tools:

Code - Auto/Visual Lisp: [Select]

1. (ACET-LIST-REMOVE-ADJACENT-DUPS '(a a a a b c c a a d e e e e))
2. > (A B C A D E)
3. (ACET-LIST-REMOVE-ADJACENT-DUPS '(A B C A D E))
4. > (A B C A D E)
5. (ACET-LIST-REMOVE-ADJACENT-DUPS '(A A))
6. > (A)
7. (ACET-LIST-REMOVE-ADJACENT-DUPS '())
8. nil

[domenicomaria]

(setq   l (list nil nil 1 1 1 2 2 3 nil nil 3 3 4 4 4 nil nil) )
(ACET-LIST-REMOVE-ADJACENT-DUPS l)

returns :
(     1 2 3 nil 3 4 nil)

... while it has to return

(nil 1 2 3 nil 3 4 nil)