Question

disclaimer: I’m pretty sure I’ve managed to muck up something really simple, possibly because I’ve been poking at this in between
“real work” while waiting for some slow C++ builds, so my head’s not
in the right place.

In looking at
What's the most efficient way of generating all possible combinations of skyrim (PC Game) potions? I had the naïve notion that it would be a really, really simple recursive filter in Lisp to generate all combinations of size “n.” The answer given there, in R, is elegant and shows off the language well, but that combn(list,n) method caught my attention. ( http://stat.ethz.ch/R-manual/R-patched/library/utils/html/combn.html )

(defun combn (list n)
  (cond ((= n 0) nil)
        ((null list) nil)
        ((= n 1) (mapcar #'list list))
        (t (mapcar #'(lambda (subset) (cons (car list) subset))
                   (combn (cdr list) (1- n))))))

(combn '(1 2 3 4 5 6 7 8 9) 3)

((1 2 3) (1 2 4) (1 2 5) (1 2 6) (1 2 7) (1 2 8) (1 2 9))

Except, this just returns the first set of combinations … I can’t wrap my head around what’s wrong, precisely. It seems that the (= n 1) case works right, but the t case should be doing something differently, such as stripping (1 2) off the list and repeating?

So, my attempt to fix it, got nastier:

 (defun combn (list n)
  (cond ((= n 0) nil) ((= n 1) (mapcar #'list list))
        ((null list) nil)
        (t (cons (mapcar #'(lambda (subset) (cons (car list) subset))
                         (combn (cdr list) (1- n)))
                 (combn (cdr list) n)))))

which is wrong at the point of (t cons(… I think. But, if cons is the wrong answer, I’m not sure what is right…? (Reduced to using 2 to demonstrate output…)

(combn '(1 2 3 4 5 6 7 8 9) 2)
(((1 2) (1 3) (1 4) (1 5) (1 6) (1 7) (1 8) (1 9))
 ((2 3) (2 4) (2 5) (2 6) (2 7) (2 8) (2 9))
 ((3 4) (3 5) (3 6) (3 7) (3 8) (3 9))
 ((4 5) (4 6) (4 7) (4 8) (4 9))
 ((5 6) (5 7) (5 8) (5 9))
 ((6 7) (6 8) (6 9))
 ((7 8) (7 9))
 ((8 9))
  NIL)

… which appears to be right, except for the extraneous nesting and the bonus NIL at the end. (I had anticipated that ((null list) nil) would have filtered that out?)

What did I do wrong? 🙁

(And, also, is there a standard routine for doing this more efficiently?)

Answer 1

Yes, the cons is not the right thing, you need an append. And that’s also what gets you the NIL at the end. I can’t write Lisp, so I’ll give you Haskell:

comb :: Int -> [a] -> [[a]]
comb 0 _ = [[]]
comb k (x:xs) = [x:ys | ys <- comb (k-1) xs] ++ comb k xs
comb _ _ = []

That’s short and sweet, but inefficient (and doesn’t check for negative k). It will often try to choose more elements than the list has for a long time. To prevent that, one would keep track of how many elements are still available.

comb :: Int -> [a] -> [[a]]
comb 0 _ = [[]]
comb k xs
  | k < 0     = []
  | k > len   = []
  | k == len  = [xs]
  | otherwise = go len k xs
    where
      len = length xs
      go l j ys
        | j == 1 = map (:[]) ys
        | l == j = [ys]
        | otherwise = case ys of
                        (z:zs) -> [z:ws | ws <- go (l-1) (j-1) zs] ++ go (l-1) j zs

Ugly, but efficient.