test

[(gile)]

(defun asso (l1 l2 / massoc group)
 (defun massoc (k l)
   (if (setq l (member (assoc k l) l))
     (cons (cadar l) (massoc k (cdr l)))
   )
 )
 (defun group (l / k)
   (if (setq k (caar l))
     (cons (cons k (massoc k l))
           (group (vl-remove-if '(lambda (x) (= k (car x))) l))
     )
   )
 )
 (group (mapcar 'list l1 l2))
)

 

Avec une fonction auxillaire à recursion terminale (tail recursive) :

 

(defun asso (l1 l2 / loop)
 (defun loop (l1 l2 acc / sub)
   (if	l1
     (loop
(cdr l1)
(cdr l2)
(if (setq sub (assoc (car l1) acc))
  (subst (append sub (list (car l2))) sub acc)
  (cons (list (car l1) (car l2)) acc)
)
     )
     (reverse acc)
   )
 )
 (loop l1 l2 nil)
)

 

Si la machine LISP d'AutoCAD optimisait la recursion terminale, la fonction ci-dessus n'atteindrait jamais de "dépassement de la pile" (stack overflow) parce qu'elle serit interprétée comme la fonction itérative ci-dessous :

 

(defun asso (l1 l2 / sub res)
 (while l1
   (setq res (if (setq sub (assoc (car l1) res))
	(subst (append sub (list (car l2))) sub res)
	(cons (list (car l1) (car l2)) res)
      )
  l1  (cdr l1)
  l2  (cdr l2)
   )
 )
 (reverse res)
)

 

W567F? 7:3 W:X W4@?5 WWl : _X _X WWl : `X `X W% WZ W7:3 W\\ : `XX W7:3 W\\ : aXXXXXX

W567F? 7:3 W: ^ =@@AX W567F? =@@A W2 3 :X W:7 WK6C@A :X 2 W=@@A 3 WZ 2 3X W`\\ :XXXX W=@@A _ ` :XX

W567F? 7:3 W: ^ 2 3 4X WD6EB 2 _ 3 `X WD6EB 4 WZ 2 3X 2 3 3 4 : W`\\ :XXX 2X

[(gile)]

(test  😎)

(test 8)