Initial data commit

Task/Knuth-shuffle/JavaScript/knuth-shuffle-1.js

@@ -0,0 +1,25 @@
+function knuthShuffle(arr) {
+    var rand, temp, i;
+
+    for (i = arr.length - 1; i > 0; i -= 1) {
+        rand = Math.floor((i + 1) * Math.random());//get random between zero and i (inclusive)
+        temp = arr[rand];
+        arr[rand] = arr[i]; //swap i (last element) with random element.
+        arr[i] = temp;
+    }
+    return arr;
+}
+
+var res = {
+    '1,2,3': 0, '1,3,2': 0,
+    '2,1,3': 0, '2,3,1': 0,
+    '3,1,2': 0, '3,2,1': 0
+};
+
+for (var i = 0; i < 100000; i++) {
+    res[knuthShuffle([1,2,3]).join(',')] += 1;
+}
+
+for (var key in res) {
+    print(key + "\t" + res[key]);
+}

Task/Knuth-shuffle/JavaScript/knuth-shuffle-2.js

@@ -0,0 +1,46 @@
+(() => {
+
+    // knuthShuffle :: [a] -> [a]
+    const knuthShuffle = xs =>
+        enumFromTo(0, xs.length - 1)
+        .reduceRight((a, i) => {
+            const
+                iRand =  randomRInt(0, i),
+                tmp = a[iRand];
+            return iRand !== i ? (
+                a[iRand] = a[i],
+                a[i] = tmp,
+                a
+            ) : a;
+        }, xs);
+
+    const test = () => knuthShuffle(
+        (`alpha beta gamma delta epsilon zeta
+              eta theta iota kappa lambda mu`)
+        .split(/\s+/)
+    );
+
+    // GENERIC FUNCTIONS ----------------------------------
+
+    // enumFromTo :: Int -> Int -> [Int]
+    const enumFromTo = (m, n) =>
+        n >= m ? (
+            iterateUntil(x => x >= n, x => 1 + x, m)
+        ) : [];
+
+    // iterateUntil :: (a -> Bool) -> (a -> a) -> a -> [a]
+    const iterateUntil = (p, f, x) => {
+        let vs = [x],
+            h = x;
+        while (!p(h))(h = f(h), vs.push(h));
+        return vs;
+    };
+
+    // randomRInt :: Int -> Int -> Int
+    const randomRInt = (low, high) =>
+        low + Math.floor(
+            (Math.random() * ((high - low) + 1))
+        );
+
+    return test();
+})();

Task/Knuth-shuffle/JavaScript/knuth-shuffle-3.js

@@ -0,0 +1,2 @@
+["iota", "epsilon", "kappa", "theta", "gamma", "delta",
+"lambda", "eta", "zeta", "beta", "mu", "alpha"]

Task/Knuth-shuffle/JavaScript/knuth-shuffle-4.js

@@ -0,0 +1,61 @@
+(() => {
+
+    // knuthShuffle :: [a] -> [a]
+    const knuthShuffle = xs =>
+        enumFromTo(0, xs.length - 1)
+        .reduceRight((a, i) => {
+            const iRand = randomRInt(0, i);
+            return i !== iRand ? (
+                swapped(i, iRand, a)
+            ) : a;
+        }, xs);
+
+    const test = () => knuthShuffle(
+        (`alpha beta gamma delta epsilon zeta
+          eta theta iota kappa lambda mu`)
+        .split(/\s+/)
+    );
+
+    // Non mutating version of swapped
+
+    // swapped :: Int -> Int -> [a] -> [a]
+    const swapped = (iFrom, iTo, xs) =>
+        xs.map(
+            (x, i) => iFrom !== i ? (
+                iTo !== i ? (
+                    x
+                ) : xs[iFrom]
+            ) : xs[iTo]
+        );
+
+    // GENERIC FUNCTIONS ----------------------------------
+
+    // enumFromTo :: Int -> Int -> [Int]
+    const enumFromTo = (m, n) =>
+        n >= m ? (
+            iterateUntil(x => x >= n, x => 1 + x, m)
+        ) : [];
+
+    // iterateUntil :: (a -> Bool) -> (a -> a) -> a -> [a]
+    const iterateUntil = (p, f, x) => {
+        let vs = [x],
+            h = x;
+        while (!p(h))(h = f(h), vs.push(h));
+        return vs;
+    };
+
+    // randomRInt :: Int -> Int -> Int
+    const randomRInt = (low, high) =>
+        low + Math.floor(
+            (Math.random() * ((high - low) + 1))
+        );
+
+    // zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
+    const zipWith = (f, xs, ys) =>
+        Array.from({
+            length: Math.min(xs.length, ys.length)
+        }, (_, i) => f(xs[i], ys[i], i));
+
+    // MAIN ---
+    return test();
+})();

Task/Knuth-shuffle/JavaScript/knuth-shuffle-5.js

@@ -0,0 +1,2 @@
+["mu", "theta", "beta", "eta", "delta", "epsilon",
+"kappa", "alpha", "gamma", "lambda", "zeta", "iota"]