Knuth shuffle: Difference between revisions

{{task|Classic CS problems and programs}}

 

 

=={{header|360 Assembly}}==

{{trans|BBC BASIC}}

* Knuth shuffle 02/11/2015

KNUTHSH CSECT

YREGS

END KNUTHSH

{{out}}

<pre>

</pre>

 

 

=={{header|ACL2}}==

 

(defun array-swap (name array i j)

array

(1- (first (dimensions name array)))

 

=={{header|Ada}}==

This implementation is a generic shuffle routine, able to shuffle an array of any type.

type Element_Type is private;

type Array_Type is array (Positive range <>) of Element_Type;

 

procedure Generic_Shuffle (List : in out Array_Type) is

List(K) := T;

end loop;

An example using Generic_Shuffle.

with Generic_Shuffle;

 

Ada.Text_IO.Put(Integer'Image(Integer_List(I)));

end loop;

 

=={{header|Aime}}==

The shuffle function works on any type (the lists are heterogenous).

shuffle(list l)

{

integer i;

 

if (i) {

i -= 1;

while (i) {

i -= 1;

}

}

 

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G}}

(

ENTIER (random * ABS (b-a+1) + (a<b|a|b))

a[j] := t

OD

[20]INT a;

FOR i FROM 1 TO 20 DO a[i] := i OD;

knuth shuffle(a);

print(a)

 

=={{header|AppleScript}}==

 

set array to {}

end repeat

 

Example:

 

=={{header|AutoHotkey}}==

ahk forum: [http://www.autohotkey.com/forum/viewtopic.php?t=44657&postdays=0&postorder=asc&start=133 discussion]

MsgBox % shuffle("1,2,3,4,5,6,7,8,9")

 

s .= "," . a%A_Index%

Return SubStr(s,2) ; drop leading comma

 

=={{header|AutoIt}}==

Dim $a[10]

ConsoleWrite('array before permutation:' & @CRLF)

Next

EndFunc

 

{{out}}

This example shows how to shuffle such arrays.

The elements can be integers, floating-point numbers, or strings.

function shuffle(array, len, i, j, t) {

for (i = len; i > 1; i--) {

for (i = 1; i < len; i++) printf "%s ", array[i]

printf "%s\n", array[len]

 

=={{header|BASIC}}==

 

DIM cards(51) AS INTEGER

PRINT LTRIM$(STR$(cards(L0))); " ";

NEXT

 

{{out}}

</pre>

 

DIM pack%(cards%)

FOR I% = 1 TO cards%

PRINT pack%(I%);

NEXT I%

 

I provide a <tt>shuffle()</tt> function. It can only shuffle an array of numbers. It fails if the array has more than 32768 elements. It always shuffles the array named <tt>shuffle[]</tt>; the array is not a function parameter because <tt>bc</tt> passes arrays by copying.

 

This code requires a <tt>bc</tt> with long names; the test program also requires a <tt>bc</tt> with the <tt>print</tt> statement.

{{works with|OpenBSD bc}}

scale = 0

 

trash = shuffle(10)

"Shuffled array: "; trash = print_array(10)

{{out}}

<pre>Original array: 11, 22, 33, 44, 55, 66, 77, 88, 99, 110

Shuffled array: 66, 44, 11, 55, 33, 77, 110, 22, 88, 99</pre>

 

=={{header|Brat}}==

(a.length - 1).to 1 { i |

random_index = random(0, i)

}

 

 

=={{header|C}}==

This shuffles any "object"; it imitates <tt>qsort</tt> in the syntax.

#include <string.h>

 

}

free(temp);

Alternatively, using Durstenfeld's method (swapping selected item and last item in each iteration instead of literally shifting everything), and macro'd function declaration/definition:

#include <stdlib.h>

 

printf(" %d", x[i]);

return 0;

 

=={{header|C++}}==

'''Compiler:''' [[g++]] (version 4.3.2 20081105 (Red Hat 4.3.2-7))

#include <algorithm>

#include <iterator>

template<typename RandomAccessIterator>

void knuthShuffle(RandomAccessIterator begin, RandomAccessIterator end) {

for(unsigned int n = end - begin - 1; n >= 1; --n) {

unsigned int k = rand() % (n + 1);

}

}

The standard library provides this in the form of <code>std::random_shuffle</code>.

#include <vector>

 

std::random_shuffle(array, array + 9); // shuffle C-style array

std::random_shuffle(vec.begin(), vec.end()); // shuffle STL container

 

=={{header|Clojure}}==

(reduce (fn [v i] (let [r (rand-int i)]

This works by generating a sequence of end-indices from n-1 to 1, then reducing that sequence (starting with the original vector) through a function that, given a vector and end-index, performs a swap between the end-index and some random index less than the end-index.

 

 

 

=={{header|CMake}}==

# stores the result in a list.

function(shuffle var)

endforeach(i)

set("${var}" ${answer} PARENT_SCOPE)

 

message(STATUS "${result}")

# One possible output:

 

=={{header|CoffeeScript}}==

{{trans|JavaScript}}

n = a.length

while n > 1

 

for key, val of counts

{{out}}

<pre>

 

=={{header|Common Lisp}}==

(loop for i from (length sequence) downto 2

do (rotatef (elt sequence (random i))

(elt sequence (1- i))))

This operates on arbitrary sequences, but will be inefficient applied to a list as opposed to a vector. Dispatching on type, and using an intermediate vector to hold the contents of list can make both cases more efficient (since the array specific case can use <code>aref</code> rather than <code>elt</code>):

(etypecase sequence

(list (nshuffle-list sequence))

do (rotatef (aref array (random i))

(aref array (1- i)))

 

=={{header|D}}==

===Standard Version===

A variant of the Knuth shuffle is in the D standard library Phobos:

import std.stdio, std.random;

 

a.randomShuffle;

a.writeln;

{{out}}

<pre>[8, 9, 3, 1, 7, 5, 4, 6, 2]</pre>

===One Implementation===

This shuffles any collection that supports random access, length and swapping of items:

 

void knuthShuffle(Range)(Range r)

a.knuthShuffle;

a.writeln;

 

=={{header|Delphi}}==

 

=={{header|DWScript}}==

var

i, j, tmp : Integer;

tmp:=a[i]; a[i]:=a[j]; a[j]:=tmp;

end;

 

=={{header|E}}==

for bound in (2..(array.size())).descending() {

def i := random.nextInt(bound)

array[i] := t

}

# value: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].diverge()

 

? shuffle(arr, entropy)

? arr

 

=={{header|EchoLisp}}==

Remark- The native '''shuffle''' function implementation in EchoLisp has been replaced by this one.

Thx Rosetta Code.

'(adrien 🎸 alexandre 🚂 antoine 🍼 ben 📚 georges 📷 julie 🎥 marine 🐼 nathalie 🍕 ))

→ (antoine 🎥 🚂 marine adrien nathalie 🍼 🍕 ben 🐼 julie 📷 📚 🎸 alexandre georges)

 

=={{header|Eiffel}}==

class

APPLICATION

end

 

{{out}}

<pre>

Shuffeld: 1 5 3 4 7 6 2

</pre>

 

=={{header|Elena}}==

{

}

 

=={{header|Elixir}}==

{{trans|Erlang}}

def shuffle( inputs ) do

n = length( inputs )

defp random_move( n, {inputs, acc} ) do

{List.delete( inputs, item ), [item | acc]}

end

end

 

seq = Enum.to_list( 0..19 )

IO.inspect Knuth.shuffle( seq )

Enum.reduce(1..100000, Map.new, fn _,acc ->

k = Knuth.shuffle(seq)

end)

 

{{out}}

 

=={{header|Erlang}}==

-module( knuth_shuffle ).

 

Item = lists:nth( random:uniform(N), Inputs ),

{lists:delete(Item, Inputs), [Item | Acc]}.

{{out}}

<pre>

 

=={{header|ERRE}}==

 

CONST CARDS%=52

PRINT

END PROGRAM

 

=={{header|Euphoria}}==

{{trans|BASIC}}

cards = repeat(0,52)

integer card,temp

for i = 1 to 52 do

printf(1,"%d ",cards[i])

 

=={{header|Factor}}==

There is a <code>randomize</code> word already in the standard library. Implementation:

dup length [ dup 1 > ]

[ [ iota random ] [ 1 - ] bi [ pick exchange ] keep ]

 

=={{header|Fantom}}==

{

static Void knuthShuffle (List array)

echo (b)

}

 

=={{header|Forth}}==

 

: shuffle ( deck size -- )

create deck 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ,

 

 

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

implicit none

 

end subroutine Shuffle

 

=={{header|Frink}}==

The built-in method <CODE><I>array</I>.shuffle[]</CODE> implements the Fisher-Yates-Knuth shuffle algorithm:

a = [1,2,3]

a.shuffle[]

 

=={{header|FunL}}==

res = array( a )

n = a.length()

res(i), res(r) = res(r), res(i)

 

=={{header|GAP}}==

ShuffleAlt := function(a)

local i, j, n, t;

# One may also call the built-in random generator on the symmetric group :

Random(SymmetricGroup(10));

 

=={{header|Go}}==

 

import (

}

fmt.Println(a)

To shuffle any type:

 

import (

shuffle(a)

fmt.Println(a)

{{out|Example output}} (of either program)

<pre>

=={{header|Groovy}}==

Solution:

if (list == null || list.empty) return list

def r = new Random()

}

list

Test:

println list

println shuffle(list)

println shuffle(list)

{{out}}

<pre>[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

 

=={{header|Haskell}}==

 

 

replaceAt :: Int -> a -> [a] -> [a]

 

swapElems :: (Int, Int) -> [a] -> [a]

 

knuthShuffle :: [a] -> IO [a]

<pre>*Main> knuthShuffle ['a'..'k']

"bhjdgfciake"

[(0,10),(8,18),(2,12),(3,13),(9,19),(4,14),(7,17),(1,11),(6,16),(5,15)]</pre>

Function for showing intermediate results:

knuthShuffleProcess =

{{out}} Detailed example:

<pre>*Main> knuthShuffleProcess ['a'..'k']

"iebjhkcgfad"</pre>

An imperative implementation using arrays and the <code>ST</code> monad:

import Data.STRef

import Control.Monad

where len = length list

newAry :: (Int, Int) -> [a] -> ST s (STArray s Int a)

 

=={{header|Icon}} and {{header|Unicon}}==

The <tt>shuffle</tt> method used here can shuffle lists, record fields, and strings:

show(shuffle([3,1,4,1,5,9,2,6,3]))

show(shuffle("this is a string"))

every writes(!A," ")

write()

{{out}}

<pre>->ks

-></pre>

Note that the gloriously succinct 'standard' Icon shuffle:

every !A :=: ?A

is subtly biased.

 

=={{header|Inform 6}}==

 

 

=={{header|J}}==

The input array is transformed to a rectangular array of indexes. By doing this all kinds of arrays can serve as input (see examples below). The process is imitated by using using a fold, swapping elements in a restricted part of this index-array in each fold step.

 

Example of a transformed input:

0 0 0 0 0 0

1 1 0 0 0 0

4 3 0 0 0 0

5 0 0 0 0 0

The last row is the index-array that has to be shuffled. The other rows have valid indexes in the first two columns. The second column has a randomized value <= value first column.

 

The index-swapping is done by the part:

Finally, the shuffled indexes select elements from the original array.

Alternatively, instead of creating a rectangular array, the swapping indices and the original data can be individually boxed.

 

 

With this approach, the data structure with the swapping indices and the original data could look like this:

+---+-+---+---+-+-----+

|4 2|3|2 1|1 0|0|abcde|

Note that we have the original data here, instead of indices to select all of its items. Note also that we have only a single value in a box where an item is being "swapped" with itself (this is required by J's cycle operation (<code>C.</code>)).

 

The resulting definition looks like this:

Note that here we did not wind up with a list of indices which we used to permute the original data set. That data set is permuted directly. However, it is in a box and we do have to remove it from that box.

 

Permuting the data directly, instead of permuting indices, has performance implications when the items being swapped are large, but see the note at the end of this entry for J for how you would do this operation in a "real" J program.

 

1 1 1

1 0 0

 

11 2 3

11 2 3

0 11 2

 

1 2 3

+--+---+----+---+

|aA|bbB|cC%$|dD@|

+--+----+---+---+

|aA|cC%$|dD@|bbB|

In J the shuffling of an arbitrary array can easily be implemented by the phrase

( ref http://www.jsoftware.com/jwiki/JPhrases/RandomNumbers ):

Applied on the former examples:

8 7 13 6 10 11 5 9 12

 

+----+---+--+---+

|cC%$|bbB|aA|dD@|

 

=={{header|Java}}==

 

public static final Random gen = new Random();

array[k] = temp;

}

 

=={{header|JavaScript}}==

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)

arr[i] = temp;

}

for (var key in res) {

print(key + "\t" + res[key]);

Results in:

<pre>1,2,3 16619

3,2,1 16596</pre>

 

 

(* Take the size of the array (without destroying it) *)

dup dup size

(* Generate a list of as many random numbers *)

[rand] [rem] enconcat map

(* Zip the two lists *)

swap zip

(* Sort according to the new index number *)

[small] [] [uncons unswonsd [first >] split [swons] dip2]

[enconcat] binrec

(* Delete the new index number *)

Using knuth-shuffle (file shuffle.joy):

[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20]

Command line:

: <tt>joy shuffle.joy</tt>

[12 6 8 4 14 18 7 15 1 0 11 13 5 10 16 2 19 17 9 20 3]

</pre>

 

=={{header|Julia}}==

j = rand(r, 1:i)

end

end

 

 

{{out}}

 

=={{header|Kotlin}}==

internal val gen = java.util.Random()

}

require(s.toSortedSet() == ia.toSet())

}

{{out}}

<pre>xdhsvtnumjgbywiqoapcelkrfz

[[File:Knuth_shuffle_diagram.png|200px]]

 

 

=={{header|Lasso}}==

fail_if(

#p1 < 1 or #p2 < 1 or

}

 

{{out}}

<pre>staticarray(9, 5, 6, 1, 10, 8, 3, 4, 2, 7)</pre>

 

=={{header|Liberty BASIC}}==

UpperBound = 9

Dim array(UpperBound)

For i = 0 To UpperBound

Print array(i)

 

=={{header|Logo}}==

localmake "t item :i :a

setitem :i :a item :j :a

make "a {1 2 3 4 5 6 7 8 9 10}

shuffle :a

Lhogho does not have a setitem, and also does things more 'function'ally.

local "res

make "res []

make "a ( list 1 2 3 4 5 6 7 8 9 10 )

make "a shuffle :a

 

=={{header|Lua}}==

local k = math.random(n)

t[n], t[k] = t[k], t[n]

end

return t

end

math.randomseed( os.time() )

a = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

table.shuffle(a)

 

=={{header|M4}}==

define(`randSeed',141592653)

define(`rand_t',`eval(randSeed^(randSeed>>13))')

show(`b')

shuffle(`b')

{{out}}

<pre>

</pre>

 

Usage of built-in function:

Custom function:

Module[{indices = {}, allindices = Range[Length[input]]},

Do[

];

input[[indices]]

Example:

 

=={{header|MATLAB}}==

Because this shuffle is done using rounds of operations on subsets of decreasing size, this is not an algorithm that can be vectorized using built-in MATLAB functions. So, we have to go old-school, no fancy MATLAB trickery.

 

for i = (numel(list):-1:2)

list([j i]) = list([i j]);

end

There is an alternate way to do this that is not a true Knuth Shuffle, but operates with the same spirit.

This alternate version produces the same output, saves some space,

and can be implemented in-line without the need to encapsulate it

in a function call like the Knuth Shuffle.

list = list( randperm(numel(list)) );

 

=={{header|Maxima}}==

 

=={{header|Modula-3}}==

 

IMPORT IO, Fmt, Random;

END;

IO.Put("\n");

{{out}}

<pre>

 

=={{header|MUMPS}}==

Set list="",n=0

Set ii="" For Set ii=$Order(items(ii)) Quit:ii="" Do

Queen of Spades

King of Diamonds

 

=={{header|Nemerle}}==

{

def rnd = Random();

arr[i] <-> arr[(rnd.Next(i, arr.Length))];

arr

 

=={{header|NetRexx}}==

===version 1===

options replace format comments java crossref savelog symbols nobinary

 

say

 

{{out}}

<pre>

 

===version 2===

* 08.01.2014 Walter Pachl modified to show state development a la Rexx

*--------------------------------------------------------------------*/

method showHand(deck = ArrayList,tag=REXX) public static binary

say tag ArrayList(deck.subList(0,deck.size)).toString

{{out}}

<pre>In [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

 

=={{header|Nim}}==

randomize()

 

swap(x[i], x[j])

 

shuffle(x)

 

=={{header|Objective-C}}==

 

@interface NSMutableArray (KnuthShuffle)

}

return 0;

{{out}}

<pre>

 

=={{header|OCaml}}==

for n = Array.length arr - 1 downto 1 do

let k = Random.int (n + 1) in

arr.(n) <- arr.(k);

arr.(k) <- temp

 

=={{header|Oforth}}==

Returns a new list

 

| s i l |

self asListBuffer ->l

self size dup ->s 1- loop: i [ s i - rand i + i l swapValues ]

 

=={{header|Oz}}==

proc {Shuffle Arr}

Low = {Array.low Arr}

{Show {Array.toRecord unit X}}

{Shuffle X}

 

=={{header|PARI/GP}}==

forstep(n=#v,2,-1,

my(i=random(n)+1,t=v[i]);

};

 

 

=={{header|Pascal}}==

 

const

DisplayList(a);

end;

{{out}}

<pre> -5 -4 -3 -2 -1 0 1 2 3 4 5

 

=={{header|Perl}}==

my @a = @_;

foreach my $n (1 .. $#a) {

}

return @a;

 

=={{header|Phix}}==

{{out}}

Before: {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52}

After: {42,4,48,28,11,3,52,51,22,2,49,38,25,33,27,35,18,44,5,7,21,13,36,29,43,6,9,31,10,30,20,16,46,34,8,17,14,45,37,24,32,41,50,15,39,40,47,23,1,12,26,19}

 

=={{header|PHP}}==

function yates_shuffle($arr){

$shuffled = Array();

list($arr[$i], $arr[$rnd]) = array($arr[$rnd], $arr[$i]);

}

 

=={{header|PicoLisp}}==

 

=={{header|PL/I}}==

===version 1===

declare (i, j, temp) fixed binary;

do i = lbound(T,1) to hbound(T,1);

j = min(random() * 12, 11);

temp = T(j); T(j) = T(i); T(i) = temp;

 

===version 2===

/*--------------------------------------------------------------------

* 07.01.2014 Walter Pachl translated from REXX version 2

Put Edit(txt,(t(k) do k=1 To n))(Skip,a(7),10(f(3)));

End;

{{out}}

<pre>In 1 2 3 4 5 6 7 8 9 10

=={{header|PowerShell}}==

{{works with|PowerShell|3}}

{{works with|PowerShell|2}} <!-- Get-Random didn't exist in PowerShell 1 -->

$c = $a.Clone() # make copy to avoid clobbering $a

1..($c.Length - 1) | ForEach-Object {

}

$c[-1] # last value

This yields the values one by one instead of returning the array as a whole, so the rest of the pipeline can work on the values while shuffling is still in progress.

 

=={{header|PureBasic}}==

 

Procedure KnuthShuffle(Array a(1))

 

KnuthShuffle(a())

{{out}}

<pre>shuffled: 1,8,6,0,5,9,2,4,7,3</pre>

Python's standard library function <code>[http://docs.python.org/library/random.html#random.shuffle random.shuffle]</code> uses this algorithm and so should normally be used.

The function below is very similar:

 

def knuth_shuffle(x):

x = list(range(10))

knuth_shuffle(x)

{{out}}

<pre>

shuffled: [5, 1, 6, 0, 8, 4, 2, 3, 9, 7]

</pre>

 

See also, the built-in function 'sample'.

{

pool <- seq_len(n)

}

a

{

a <- seq_len(n)

fisheryatesshuffle(6) # e.g. 1 3 6 2 4 5

x <- c("foo", "bar", "baz", "quux")

 

=={{header|Racket}}==

 

 

(define (swap! vec i j)

(vector->list (knuth-shuffle (list->vector x)))

(begin (for ([i (in-range (sub1 (vector-length x)) 0 -1)])

(swap! x i r))

x)))

 

 

=={{header|REBOL}}==

Title: "Fisher-Yates"

Purpose: {Fisher-Yates shuffling algorithm}

]

b

 

=={{header|REXX}}==

===version 0, card pips===

say '══════════════════ getting a new deck out of the box ···'

do j =1 for length(suit)

end /*k*/

end /*j*/

call show

say; say '══════════════════ shuffling' cards "cards ···"

end /*s*/

call show

'''output'''

<pre>

 

===version 1, card names===

say '══════════════════ getting a new deck out of the box ···'

do j =1 for words(suit)

end /*k*/

end /*j*/

 

say; say '══════════════════ shuffling' cards "cards ···"

 

do s=cards by -1 to 2; ?=random(1,s); _=@.?; @.?=@.s; @.s=_

call show

end /*m*/

'''output'''

══════════════════ getting a new deck out of the box ···

 

 

===version 2===

* 05.01.2014 Walter Pachl

* borrow one improvement from version 1

Do k=1 To n; ol=ol right(a.k,2); End

Say ol

{{out}}

<pre>In 1 2 3 4 5 6 7 8 9 10

 

=={{header|Ring}}==

next

 

 

=={{header|Ruby}}==

{{trans|Tcl}}

def knuth_shuffle!

j = length

end

 

results in

<pre>[1, 2, 3] => 16572

[3, 1, 2] => 16838

[3, 2, 1] => 16633</pre>

def knuth_shuffle!

(length - 1).downto(1) do |i|

self

end

 

=={{header|Run BASIC}}==

for i = 1 to 52 ' make deck

cards(i) = i

if i mod 18 = 0 then print

next

 

=={{header|Rust}}==

 

extern crate rand;

knuth_shuffle(&mut v);

println!("after: {:?}", v);

 

=={{header|Scala}}==

for (i <- 1 until a.size reverse) {

val j = util.Random nextInt (i + 1)

}

a

 

=={{header|Scheme}}==

A functional version, using lists (inefficient), somewhat unusual in reversing the entire initial sublist on each pass instead of just swapping:

(import (rnrs base (6))

(srfi :27 random-bits))

(let

((li-prime (semireverse li (random-integer (length li)))))

 

A mutable version, using vectors (efficient):

(import (rnrs base (6))

(srfi :27 random-bits))

((j (random-integer i)))

(vector-swap! vec (- i 1) j)))

 

=={{header|Scratch}}==

 

=={{header|Seed7}}==

 

const type: intArray is array integer;

end for;

writeln;

 

{{out}}

</pre>

 

 

 

}

 

{{out}}

<pre>

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

implemented (GNU Smalltalk version 3.0.4); so here it is an implementation"

SequenceableCollection extend [

]

]

Testing

|c|

c := OrderedCollection new.

c addAll: #( 1 2 3 4 5 6 7 8 9 ).

Shuffler Knuth: c.

 

=={{header|SNOBOL4}}==

-include 'Random.sno'

 

shuffle(a)

output = a2s(a)

{{out}}

<pre>1 2 3 4 5 6 7 8 9 10 ->

2 10 4 9 1 5 6 8 7 3</pre>

 

=={{header|Swift}}==

 

'''Simple version (any Swift version):''' Extend Array with shuffle methods; using arc4random_uniform from C stdlib:

 

 

extension Array {

print([1, 2, 3, 4, 5, 6, 7, 8, 9, 10].shuffle())

// Swift 1.x:

 

{{out}}

'''Generic version (any Swift version):''' While the above code is generic in that it works with arrays of any element type, we can use generic global functions to define shuffling for any mutable collection with random-access index type which is far more generic than the above code:

 

 

func shuffleInPlace<T: MutableCollectionType where T.Index: RandomAccessIndexType>(inout collection: T) {

print(shuffle([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))

// Swift 1.x:

 

{{out}}

{{works with|Swift | 2.0 }} While the above solutions work with Swift 2.0 as they are, we can use Swift 2.0's Protocol Oriented Programming features to add shuffling methods to any mutable collection that has a random-access index:

 

 

// Define a protocol for shuffling:

{ /* Implementation provided by Shufflable protocol extension */ }

 

 

{{out}}

 

=={{header|Tcl}}==

set j [llength $lst]

for {set i 0} {$j > 1} {incr i;incr j -1} {

5 2 1 4 3

% knuth_shuffle {tom dick harry peter paul mary}

As a test of skewing (an indicator of a poor implementation) this code was used:

foreach val [knuth_shuffle {1 2 3 4 5}] pos {pos0 pos1 pos2 pos3 pos4} {

incr tots($pos) $val

tots(pos2) = 299701

tots(pos3) = 299830

 

=={{header|TI-83 BASIC}}==

:DelVar D

:Return

 

=={{header|TUSCRIPT}}==

oldnumbers=newnumbers="",range=20

LOOP nr=1,#range

ENDLOOP

 

{{out}}

<pre>

 

=={{header|uBasic/4tH}}==

FOR L = 0 TO 51

@(L) = L

END

 

{{out}}

<pre>before:

after:

19 4 49 9 27 35 50 11 2 29 22 48 33 15 17 42 47 28 41 18 34 21 30 39 3 8 23 12 36 26 0 46 7 44 13 14 16 40 10 25 31 32 51 24 20 38 45 6 43 1 5 37</pre>

=={{header|UNIX Shell}}==

{{works with|ksh93}}

{{works with|pdksh}}

function shuffle {

integer i j t

set -A array 11 22 33 44 55 66 77 88 99 110

shuffle

 

=={{header|Ursala}}==

This function works on lists of any type and length, including character strings.

test program:

 

{{out}}

<pre>'keacfjlbdigh'</pre>

 

=={{header|VBScript}}==

;Implementation

function shuffle( a )

dim i

a = b

b = tmp

;Invocation

a = array( 1,2,3,4,5,6,7,8,9)

wscript.echo "before: ", join( a, ", " )

wscript.echo "after: ", join( a, ", " )

shuffle a

{{out}}

<pre>

 

The output will be inserted in current edit buffer.

#90 = Time_Tick // seed for random number generator

#99 = 20 // number of items in the array

#93 = 0x7fffffff % 48271

#90 = (48271 * (#90 % #92) - #93 * (#90 / #92)) & 0x7fffffff

{{out}}

<pre>Before:

After:

9 13 8 18 10 1 17 15 0 16 14 19 3 2 7 11 6 4 5 12 </pre>

 

=={{header|zkl}}==

Two versions, imperative and functional, same results.

xs has to be a mutable list.

xs

}

<pre>

var ns=(1).pump(10,List).copy() // [1..10] made mutable