# Idiom #10 Shuffle a list

Generate a random permutation of the elements of list x

``````var Iter,rr: integer;
[...]
for Iter := 0 to high(x) do
begin
rr := random(high(x))+1;
tmp := x[Iter];
x[Iter] := x[rr];
x[rr] := tmp;
end;``````
``````#include <stdlib.h>
#include <time.h>``````
``````srand(time(NULL));
for (int i = 0; i < N-1; ++i)
{
int j = rand() % (N-i) + i;
int temp = x[i];
x[i] = x[j];
x[j] = temp;
}``````
``(shuffle x)``
``````#include <algorithm>
#include <vector>``````
``std::random_shuffle(x.begin(), x.end());``
``````using System;
using System.Collections.Generic;``````
``````private static Random rng = new Random();

public static void Shuffle<T>(this IList<T> x)
{
int n = x.Count;
while (n > 1) {
n--;
int k = rng.Next(n + 1);
T value = x[k];
x[k] = x[n];
x[n] = value;
}
}``````
``````using System;
using System.Collections.Generic;
using System.Linq;``````
``````public static IEnumerable<T> Shuffle<T>(this IEnumerable<T> input)
=> input.OrderBy(_ => Guid.NewGuid());
``````
``import std.random;``
``randomShuffle(x);``
``var shuffled = x.toList()..shuffle();``
``x.shuffle();``
``y = Enum.shuffle x``
``[Y||{_,Y} <- lists:sort([ {rand:uniform(), N} || N <- X])].``
``````module M_shuffle
contains
function scramble( number_of_values ) result(array)
integer,intent(in)    :: number_of_values
integer,allocatable   :: array(:)
array=[(i,i=1,number_of_values)]
n=1; m=number_of_values
do k=1,2
do i=1,m
call random_number(u)
j = n + FLOOR((m+1-n)*u)
itemp=array(j); array(j)=array(i); array(i)=itemp
enddo
enddo
end function scramble
end module M_shuffle
:
use M_shuffle, only : scramble
newlist=list(scramble(size(list))
``````
``import "math/rand"``
``````rand.Shuffle(len(x), func(i, j int) {
x[i], x[j] = x[j], x[i]
})``````
``import "math/rand"``
``````y := make([]T, len(x))
perm := rand.Perm(len(x))
for i, v := range perm {
y[v] = x[i]
}``````
``import "math/rand"``
``````for i := len(x) - 1; i > 0; i-- {
j := rand.Intn(i + 1)
x[i], x[j] = x[j], x[i]
}``````
``import "math/rand"``
``````func shuffle[T any](x []T) {
rand.Shuffle(len(x), func(i, j int) {
x[i], x[j] = x[j], x[i]
})
}``````
``import "math/rand"``
``````for i := range x {
j := rand.Intn(i + 1)
x[i], x[j] = x[j], x[i]
}``````
``x.shuffle()``
``````shuffle x = if length x < 2 then return x else do
i <- System.Random.randomRIO (0, length(x)-1)
r <- shuffle (take i x ++ drop (i+1) x)
return (x!!i : r)
``````
``````for (var i = x.length - 1; i > 0; i--) {
var j = Math.floor(Math.random() * (i + 1));
var temp = x[j];
x[j] = x[i];
x[i] = temp;
}``````
``import java.util.Collections;``
``Collections.shuffle(x);``
``x.shuffle()``
``val y = x.shuffled()``
``````(let ((end (length x)))
(loop for i from 0 below end
do (rotatef (aref x i)
(aref x (+ i (random (- end i)))))))
``````
``````shuffled = {}
for i, v in ipairs(x) do
local pos = math.random(1, #shuffled+1)
table.insert(shuffled, pos, v)
end``````
``````function(x)
for i = #x, 2, -1 do
local j = math.random(i)
x[i], x[j] = x[j], x[i]
end
end
``````
``@import GameplayKit;``
``x.shuffledArray``
``shuffle(\$x);``
``use List::Util 'shuffle';``
``@shuffled = shuffle(@x);``
``from random import shuffle``
``shuffle(x)``
``import random``
``random.shuffle(x)``
``y = x.shuffle``
``````use rand::seq::SliceRandom;
``````let mut rng = thread_rng();
x.shuffle(&mut rng);``````
``````extern crate rand;
use rand::{Rng, StdRng};``````
``````let mut rng = StdRng::new().unwrap();
rng.shuffle(&mut x);``````
``import scala.util.Random``
``val shuffled = Random.shuffle(x)``
``````(define shuffle
(lambda (x)
(if (< (length x) 2)
list
(let ((item (list-ref list (random (length x)))))
(cons item (shuffle (remove item x)))))))``````
``(shuffle x)``
``x shuffled.``
``````Function Shuffle(Of T)(collection As IEnumerable(Of T)) As List(Of T)
Dim r As Random = New Random()
Shuffle = collection.OrderBy(Function(a) r.Next()).ToList()
End Function``````

programming-idioms.org