Составить из 2х заданных списков третий

(defun decart (lst1 lst2)
 (apply 'append (mapcar #'(lambda (x) (mapcar #'(lambda (y) (list x y)) lst2)) lst1)))
 
==> decart
 
(decart '(1 2 3) '(a b c d))
 
==> ((1 a) (1 b) (1 c) (1 d) (2 a) (2 b) (2 c) (2 d) (3 a) (3 b) (3 c) (3 d))

(defun decart (lst1 lst2)
   (let ((res nil))
     (dolist (x lst1 res)
        (dolist (y lst2 t)
            (push (list x y) res)))))
 
==> decart
 
(decart '(1 2 3) '(a b c d))
 
==> ((3 d) (3 c) (3 b) (3 a) (2 d) (2 c) (2 b) (2 a) (1 d) (1 c) (1 b) (1 a))

(defun cartesian-product (w v) 
  (when w (nconc (mi (car w) v) (cartesian-product (cdr w) v)))) 
 
(defun mi (a v) 
  (when v (cons (list a (car v)) (mi a (cdr v))))) 
 
> (cartesian-product '(a b c d) '(1 2 3))
((A 1) (A 2) (A 3) (B 1) (B 2) (B 3) (C 1) (C 2) (C 3) (D 1) (D 2) (D 3))

(defun cartesian-product (w v)
  (apply
   #'nconc
   (mapcar
    #'(lambda (e) (mapcar #'(lambda (a) (list e a)) v)) w)))
 
> (cartesian-product '(a b c d) '(1 2 3))
((A 1) (A 2) (A 3) (B 1) (B 2) (B 3) (C 1) (C 2) (C 3) (D 1) (D 2) (D 3))

(defun cartesian-product (w v)
  (mapcan (lambda (e) (mapcar (lambda (a) `(,a ,e)) w)) v))
 
> (cartesian-product '(a b c d) '(1 2 3))
((A 1) (B 1) (C 1) (D 1) (A 2) (B 2) (C 2) (D 2) (A 3) (B 3) (C 3) (D 3))

(defun decart (lst1 lst2)
  (labels ((plist (x lst)
             (cond ((null lst) nil)
                   (t (cons (list x (car lst)) (plist x (cdr lst)))))))
          (cond ((null lst1) nil)
                (t (append (plist (car lst1) lst2) (decart (cdr lst1) lst2))))))
 
==> decart
 
(decart '(1 2 3) '(a b c))
 
==> ((1 a) (1 b) (1 c) (2 a) (2 b) (2 c) (3 a) (3 b) (3 c))

(define (decart list-1 list-2)
  (for*/list ([x list-1] [y list-2])
    (list x y)))

(defun f (x y)
  (cons (cons (car x) (cons (car y) nil))  
        (cons (cons (car x) (cons (cadr y) nil)) 
              (cons (cons (cadr x) (cons (car y) nil)) 
                    (cons (cons (cadr x) (cons (cadr y) nil)) nil))))) 
 
==> f
 
(f '(1 2) '(3 4))
 
==> ((1 3) (1 4) (2 3) (2 4))

(defun f (x y)
  (list (list (car x) (car y)) (list (car x) (cadr y))            
        (list (cadr x) (car y)) (list (cadr x) (cadr y))))
 
==> f
 
(f '(1 2) '(3 4))
 
==> ((1 3) (1 4) (2 3) (2 4))

(defun cartesian-product (w v) 
  (cond ((null w) nil)
        (t (append (mi (car w) v)
                   (cartesian-product (cdr w) v)))))
 
(defun mi (a w) 
  (cond ((null w) nil)
        (t (cons (list a (car w)) (mi a (cdr w))))))
 
> (cartesian-product '(1 2 3) '(2 3 4))
((1 2) (1 3) (1 4) (2 2) (2 3) (2 4) (3 2) (3 3) (3 4))