Data commit

Task/Combinations/Common-Lisp/combinations-1.lisp

@@ -0,0 +1,18 @@
+(defun map-combinations (m n fn)
+  "Call fn with each m combination of the integers from 0 to n-1 as a list. The list may be destroyed after fn returns."
+  (let ((combination (make-list m)))
+    (labels ((up-from (low)
+               (let ((start (1- low)))
+                 (lambda () (incf start))))
+             (mc (curr left needed comb-tail)
+               (cond
+                ((zerop needed)
+                 (funcall fn combination))
+                ((= left needed)
+                 (map-into comb-tail (up-from curr))
+                 (funcall fn combination))
+                (t
+                 (setf (first comb-tail) curr)
+                 (mc (1+ curr) (1- left) (1- needed) (rest comb-tail))
+                 (mc (1+ curr) (1- left) needed comb-tail)))))
+      (mc 0 n m combination))))

Task/Combinations/Common-Lisp/combinations-2.lisp

@@ -0,0 +1,9 @@
+(defun comb (m list fn)
+  (labels ((comb1 (l c m)
+		  (when (>= (length l) m)
+		    (if (zerop m) (return-from comb1 (funcall fn c)))
+		    (comb1 (cdr l) c m)
+		    (comb1 (cdr l) (cons (first l) c) (1- m)))))
+    (comb1 list nil m)))
+
+(comb 3 '(0 1 2 3 4 5) #'print)

Task/Combinations/Common-Lisp/combinations-3.lisp

@@ -0,0 +1,46 @@
+(defun next-combination (n a)
+    (let ((k (length a)) m)
+    (loop for i from 1 do
+        (when (> i k) (return nil))
+        (when (< (aref a (- k i)) (- n i))
+            (setf m (aref a (- k i)))
+            (loop for j from i downto 1 do
+                (incf m)
+                (setf (aref a (- k j)) m))
+            (return t)))))
+
+(defun all-combinations (n k)
+    (if (or (< k 0) (< n k)) '()
+        (let ((a (make-array k)))
+            (loop for i below k do (setf (aref a i) i))
+            (loop collect (coerce a 'list) while (next-combination n a)))))
+
+(defun map-combinations (n k fun)
+    (if (and (>= k 0) (>= n k))
+        (let ((a (make-array k)))
+            (loop for i below k do (setf (aref a i) i))
+            (loop do (funcall fun (coerce a 'list)) while (next-combination n a)))))
+
+; all-combinations returns a list of lists
+
+> (all-combinations 4 3)
+((0 1 2) (0 1 3) (0 2 3) (1 2 3))
+
+; map-combinations applies a function to each combination
+
+> (map-combinations 6 4 #'print)
+(0 1 2 3)
+(0 1 2 4)
+(0 1 2 5)
+(0 1 3 4)
+(0 1 3 5)
+(0 1 4 5)
+(0 2 3 4)
+(0 2 3 5)
+(0 2 4 5)
+(0 3 4 5)
+(1 2 3 4)
+(1 2 3 5)
+(1 2 4 5)
+(1 3 4 5)
+(2 3 4 5)