在Lisp函数中使用带有缺点的嵌套汽车

Question

I'm making a recursive lisp function that takes two lists and makes a sublist of index pairs

ex: put in (ABCD) and (1 2 3 4) and get ((1 A) (2 B) (3 C) (4 D))

However, I'm having trouble using car along with cons to make said sublist. Here's my code:

(DEFUN zipper (a b)
    (if (= (OR (list-length a) (list-length b)) 0)
        (setq c NIL)
        (progn (zipper (cdr a) (cdr b))
        (cons '((car a) (car b)) c))
    )
)

I played around for a little and it appears using car to create lists just doesn't work most of the time. Additionally, I'm using CLISP. Any ideas?

Thanks!

Answer 1

The general idea goes into the right direction. There are a bunch of problems, though. Let's have a look.

(DEFUN zipper (a b)
    (if (= (OR (list-length a) (list-length b)) 0)
        (setq c NIL)
        (progn (zipper (cdr a) (cdr b))
        (cons '((car a) (car b)) c))
    )
)

First indentation:

(DEFUN zipper (a b)
  (if (= (OR (list-length a) (list-length b)) 0)
      (setq c NIL)
      (progn (zipper (cdr a) (cdr b))
        (cons '((car a) (car b)) c))                 ; <--
    )
  )

Next dangling parentheses:

(DEFUN zipper (a b)
  (if (= (OR (list-length a) (list-length b)) 0)
      (setq c NIL)
      (progn (zipper (cdr a) (cdr b))
        (cons '((car a) (car b)) c))))

Return the empty list in IF for the true case:

(defun zipper (a b)
  (if (= (OR (list-length a) (list-length b)) 0)
      nil
      (progn (zipper (cdr a) (cdr b))
        (cons '((car a) (car b)) c))))

Now cons to the result in the false case:

(defun zipper (a b)
  (if (= (OR (list-length a) (list-length b)) 0)
      nil
      (cons '((car a) (car b))
            (zipper (cdr a) (cdr b)))))

What remains to be done?

• see the comment by 'rsm': replace the quote with a call to list .
• don't use list-length . Use null instead. It checks if a list is empty. list-length would traverse the input whole lists on each call -> inefficient.

Answer 2

If you call list-length at each step of recursion, you are going to traverse both lists entirely each time, which gives your zipper function a quadratic time complexity with respect to the sum of your lists' sizes:

(zipper '(1 2 3) '(4 5 6))
=> (list-length (1 2 3))
=> (list-length (2 3))
=> (list-length (3))
=> (list-length ())

=> (list-length (4 5 6))
=> (list-length (4 5))
=> (list-length (5))
=> (list-length ())

(zipper '(2 3) '(5 6))
=> (list-length (2 3))
   ...
=> (list-length (5 6))
   ...

...

This is inefficient and not necessary here. Since you are already visiting both lists, you can directly check if any of them is empty using null or endp , which take constant time. You return NIL as soon as one of the list is empty, which is by the way the default behaviour of mapcar . Notice also that mapcar can work on multiple lists at the same time, for example:

(mapcar #'+ '(1 2) '(5 8))
=> (6 10)

If you know a function that takes (at least) two arguments and return a list, then you could mapcar that function over your lists and have a list of lists.

Answer 3

The zip function from other languages such as Python and Haskell is a special case of mapcar .

The traditional zip function can be achieved via:

> (mapcar #'list list1 list2 ... listn)

Such that for this case:

> (mapcar #'list '(A B C D) '(1 2 3 4))
((A 1) (B 2) (C 3) (D 4))

To swap the order of the pairs as you indicated, simply change the function passed to mapcar accordingly:

> (mapcar #'(lambda (x y) (list y x)) '(A B C D) '(1 2 3 4))
((1 A) (2 B) (3 C) (4 D))

Checkout the documentation for mapcar for more details.

Answer 4

zip function with arbitrary number of lists

(defun zip (&rest lists)
  (apply #'mapcar #'list lists))

Shortest list determines depth of zipping.

CL-USER> (zip '(1 2 3) '(a b c) '("a" "b" "c"))
((1 A "a") (2 B "b") (3 C "c"))
CL-USER> (zip '(1 2 3) '(a b c) '("a" "b" "c" "d"))
((1 A "a") (2 B "b") (3 C "c"))

Answer 5

You could do something such as this:

(defun zipper (a b)
   (if (or (null a) (null b))
       nil
       (cons (list (car b) (car a)) (our-combiner (cdr a) (cdr b)))))

We can check if either of the lists is null, so that we could stop when one of the lists runs out (similar to how mapcar will stop applying a function to lists when one of the lists runs out). We can then cons a nested list with the car's of the lists in each recursive call. Your output would be:

CL-USER> (zipper '(a b c d) '(1 2 3 4))
((1 A) (2 B) (3 C) (4 D))
CL-USER> 

We could also use mapcar as it will iterate over both lists and returns the result of applying the function to both lists (unlike mapc). This is fewer lines of code, and since it will return when some list runs out, there's no need for a conditional:

(defun zipper (a b)
  (mapcar #'list b a))