2016 Update

Task/Combinations/JavaScript/combinations-3.js

@@ -0,0 +1,29 @@
+(function () {
+
+  function comb(n, lst) {
+    if (!n) return [[]];
+    if (!lst.length) return [];
+
+    var x = lst[0],
+        xs = lst.slice(1);
+
+    return comb(n - 1, xs).map(function (t) {
+      return [x].concat(t);
+    }).concat(comb(n, xs));
+  }
+
+
+  // [m..n]
+  function range(m, n) {
+    return Array.apply(null, Array(n - m + 1)).map(function (x, i) {
+      return m + i;
+    });
+  }
+
+  return comb(3, range(0, 4))
+
+    .map(function (x) {
+      return x.join(' ');
+    }).join('\n');
+
+})();

Task/Combinations/JavaScript/combinations-4.js

@@ -0,0 +1,46 @@
+(function (n) {
+
+  // n -> [a] -> [[a]]
+  function comb(n, lst) {
+    if (!n) return [[]];
+    if (!lst.length) return [];
+
+    var x = lst[0],
+      xs = lst.slice(1);
+
+    return comb(n - 1, xs).map(function (t) {
+      return [x].concat(t);
+    }).concat(comb(n, xs));
+  }
+
+  // f -> f
+  function memoized(fn) {
+    m = {};
+    return function (x) {
+      var args = [].slice.call(arguments),
+        strKey = args.join('-');
+
+      v = m[strKey];
+      if ('u' === (typeof v)[0])
+        m[strKey] = v = fn.apply(null, args);
+      return v;
+    }
+  }
+
+  // [m..n]
+  function range(m, n) {
+    return Array.apply(null, Array(n - m + 1)).map(function (x, i) {
+      return m + i;
+    });
+  }
+
+  var fnMemoized = memoized(comb),
+    lstRange = range(0, 4);
+
+  return fnMemoized(n, lstRange)
+
+  .map(function (x) {
+    return x.join(' ');
+  }).join('\n');
+
+})(3);

Task/Combinations/JavaScript/combinations-5.js

@@ -0,0 +1,10 @@
+0 1 2
+0 1 3
+0 1 4
+0 2 3
+0 2 4
+0 3 4
+1 2 3
+1 2 4
+1 3 4
+2 3 4

Task/Combinations/JavaScript/combinations-6.js

@@ -0,0 +1,47 @@
+(function (n) {
+    'use strict';
+
+
+    // n -> [a] -> [[a]]
+    let comb = (n, xs) => {
+            if (n < 1) return [[]];
+            if (xs.length === 0) return [];
+
+            let h = xs[0],
+                tail = xs.slice(1);
+
+            return comb(n - 1, tail)
+                .map((t) => [h].concat(t))
+                .concat(comb(n, tail));
+        },
+
+
+
+        // Derive a memoized version of a function
+        // Function -> Function
+        memoized = (f) => {
+            let m = {};
+
+            return function (x) {
+                let args = [].slice.call(arguments),
+                    strKey = args.join('-'),
+                    v = m[strKey];
+
+                return (
+                    (v === undefined) &&
+                    (m[strKey] = v = f.apply(null, args)),
+                    v
+                );
+            }
+        },
+
+        range = (m, n) =>
+            Array.from({
+                length: (n - m) + 1
+            }, (_, i) => m + i);
+
+
+    return memoized(comb)(n, range(0, 4))
+
+
+})(3);