June 2018 Update

Task/Knuth-shuffle/BASIC/knuth-shuffle-2.basic

@@ -1,14 +1,13 @@
- 10 RAND
- 20 LET A$=""
- 30 FOR I=1 TO 26
- 40 LET A$=A$+CHR$ (37+I)
- 50 NEXT I
- 60 PRINT A$
- 70 FOR I=26 TO 2 STEP -1
- 80 LET J=1+INT (RND*I)
- 90 LET T$=A$(I)
-100 LET A$(I)=A$(J)
-110 LET A$(J)=T$
-120 PRINT AT 0,I-1;CHR$ (CODE A$(I)+128)
-130 PRINT AT 0,J-1;CHR$ (CODE A$(J)+128)
-140 NEXT I
+ 100 :
+ 110  REM  KNUTH SHUFFLE
+ 120 :
+ 130  DIM A(25)
+ 140  FOR I = 1 TO 25
+ 150 A(I) = I: PRINT A(I);" ";: NEXT I
+ 160  PRINT : PRINT
+ 170  FOR I = 25 TO 2 STEP  - 1
+ 180 J =  INT ( RND (1) * I + 1)
+ 190 T = A(I):A(I) = A(J):A(J) = T: NEXT I
+ 200  FOR I = 1 TO 25
+ 210  PRINT A(I);" ";: NEXT I
+ 220  END

Task/Knuth-shuffle/BASIC/knuth-shuffle-3.basic

@@ -0,0 +1,14 @@
+ 10 RAND
+ 20 LET A$=""
+ 30 FOR I=1 TO 26
+ 40 LET A$=A$+CHR$ (37+I)
+ 50 NEXT I
+ 60 PRINT A$
+ 70 FOR I=26 TO 2 STEP -1
+ 80 LET J=1+INT (RND*I)
+ 90 LET T$=A$(I)
+100 LET A$(I)=A$(J)
+110 LET A$(J)=T$
+120 PRINT AT 0,I-1;CHR$ (CODE A$(I)+128)
+130 PRINT AT 0,J-1;CHR$ (CODE A$(J)+128)
+140 NEXT I

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

@@ -1,38 +1,46 @@
-(lst => {
+(() => {
 
     // knuthShuffle :: [a] -> [a]
-    let knuthShuffle = lst =>
-        range(0, lst.length - 1)
+    const knuthShuffle = xs =>
+        enumFromTo(0, xs.length - 1)
         .reduceRight((a, i) => {
-            let iRand = i ? randomInteger(0, i) : 0,
+            const
+                iRand =  randomRInt(0, i),
                 tmp = a[iRand];
-
-            return iRand !== i ?  (
+            return iRand !== i ? (
                 a[iRand] = a[i],
                 a[i] = tmp,
                 a
             ) : a;
-        }, lst),
+        }, xs);
 
-        // randomInteger :: Int -> Int -> Int
-        randomInteger = (low, high) =>
+    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))
-        ),
+        );
 
-        // range :: Int -> Int -> Maybe Int -> [Int]
-        range = (m, n, step) => {
-            let d = (step || 1) * (n >= m ? 1 : -1);
-
-            return Array.from({
-                length: Math.floor((n - m) / d) + 1
-            }, (_, i) => m + (i * d));
-        };
-
-
-    return knuthShuffle(lst);
-
-})(
-    'alpha beta gamma delta epsilon zeta eta theta iota kappa lambda mu'
-    .split(' ')
-  );
+    return test();
+})();

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

@@ -1,56 +1,61 @@
-(lst => {
+(() => {
 
     // knuthShuffle :: [a] -> [a]
-    function knuthShuffle(lst) {
-        let lng = lst.length;
+    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);
 
-        return lng ? range(0, lng - 1)
-            .reduceRight((a, i) => {
-                let iRand = i > 0 ? randomInteger(0, i) : 0;
+    const test = () => knuthShuffle(
+        (`alpha beta gamma delta epsilon zeta
+          eta theta iota kappa lambda mu`)
+        .split(/\s+/)
+    );
 
-                return i !== iRand ? swapped(a, i, iRand) : a;
-            }, lst) : [];
+    // 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;
     };
 
-
-    // A non-mutating variant of swapped():
-
-    // swapped :: [a] -> Int -> Int -> [a]
-    let swapped = (lst, iFrom, iTo) => {
-            let [iLow, iHigh] = iTo > iFrom ? (
-                    [iFrom, iTo]
-            ) : [iTo, iFrom];
-
-            return iLow !== iHigh ? (
-                    [].concat(
-                        (iLow > 0 ? lst.slice(0, iLow) : []), // pre
-                        lst[iHigh],                           // DOWN
-                        lst.slice(iLow + 1, iHigh),           // mid
-                        lst[iLow],                            // UP
-                        lst.slice(iHigh + 1)                  // post
-                    )
-                ) : lst.slice(0) // (unchanged copy)
-        },
-
-        // randomInteger :: Int -> Int -> Int
-        randomInteger = (low, high) =>
+    // randomRInt :: Int -> Int -> Int
+    const randomRInt = (low, high) =>
         low + Math.floor(
             (Math.random() * ((high - low) + 1))
-        ),
+        );
 
-        // range :: Int -> Int -> Maybe Int -> [Int]
-        range = (m, n, step) => {
-            let d = (step || 1) * (n >= m ? 1 : -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));
 
-            return Array.from({
-                length: Math.floor((n - m) / d) + 1
-            }, (_, i) => m + (i * d));
-        };
-
-
-    return knuthShuffle(lst);
-
-})(
-    'alpha beta gamma delta epsilon zeta eta theta iota kappa lambda mu'
-    .split(' ')
-);
+    // MAIN ---
+    return test();
+})();

Task/Knuth-shuffle/Julia/knuth-shuffle.julia

@@ -0,0 +1,11 @@
+function knuthshuffle!(r::AbstractRNG, v::AbstractVector)
+    for i in length(v):-1:2
+        j = rand(r, 1:i)
+        v[i], v[j] = v[j], v[i]
+    end
+    return v
+end
+knuthshuffle!(v::AbstractVector) = knuthshuffle!(Base.Random.GLOBAL_RNG, v)
+
+v = collect(1:20)
+println("# v = $v\n   -> ", knuthshuffle!(v))

Task/Knuth-shuffle/PicoLisp/knuth-shuffle.l

@@ -1,7 +1,11 @@
-(de shuffle (Lst)
-   (make
-      (for (N (length Lst) (gt0 N))
-         (setq Lst
-            (conc
-               (cut (rand 0 (dec 'N)) 'Lst)
-               (prog (link (car Lst)) (cdr Lst)) ) ) ) ) )
+(seed (in "/dev/urandom" (rd 8)))
+
+(de knuth (Lst)
+   (for (N (length Lst) (>= N 2) (dec N))
+      (let I (rand 1 N)
+         (xchg (nth Lst N) (nth Lst I)) ) ) )
+
+(let L (range 1 15)
+   (println 'before L)
+   (knuth L)
+   (println 'after L) )

Task/Knuth-shuffle/Ring/knuth-shuffle.ring

@@ -1,16 +1,31 @@
-a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-shuffle(a)
-for n = 1 to len(a)
-    see "" + a[n] + " "
-next
+# Project : Knuth shuffle
+# Date    : 2017/11/08
+# Author : Gal Zsolt [~ CalmoSoft ~]
+# Email   : <calmosoft@gmail.com>
 
-func shuffle t
-     n = len(t)
-     while n > 1
-           k = random(n-1)+1
-           temp = t[n]
-           t[n] = t[k]
-           t[k] = temp
-           n = n - 1
-     end
-     return t
+items = list(52)
+for n = 1 to len(items)
+      items[n] = n
+next
+knuth(items)
+showarray(items)
+
+func knuth(items)
+       for i = len(items) to 1 step -1
+            j = random(i-1) + 1
+            if i != j
+               temp = items[i]
+               items[i] = items[j]
+               items[j] = temp
+            ok
+       next
+
+func showarray(vect)
+       see "["
+       svect = ""
+       for n = 1 to len(vect)
+           svect = svect + vect[n] + " "
+       next
+       svect = left(svect, len(svect) - 1)
+       see svect
+       see "]" + nl

Task/Knuth-shuffle/Stata/knuth-shuffle.stata

@@ -0,0 +1,15 @@
+mata
+function shuffle(a) {
+	n = length(a)
+	r = runiformint(1,1,1,1..n)
+	for (i=n; i>=2; i--) {
+		j = r[i]
+		x = a[i]
+		a[i] = a[j]
+		a[j] = x
+	}
+	return(a)
+}
+
+shuffle(1..10)
+end