• Pascal

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;

• C

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;
}

• Clojure

(shuffle x)

• C++

std::random_shuffle(x.begin(), x.end());

• C#

public static IEnumerable<T> Shuffle<T>(this IEnumerable<T> input)
    => input.OrderBy(_ => Guid.NewGuid());

• C#

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;  
    }  
}

• D

randomShuffle(x);

• Dart

x.shuffle();

• Dart

var shuffled = x.toList()..shuffle();

• Elixir

y = Enum.shuffle x

• Erlang

[Y||{_,Y} <- lists:sort([ {rand:uniform(), N} || N <- X])].

• Fortran

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))

• Go

func shuffle[T any](x []T) {
	rand.Shuffle(len(x), func(i, j int) {
		x[i], x[j] = x[j], x[i]
	})
}

• Go

rand.Shuffle(len(x), func(i, j int) {
	x[i], x[j] = x[j], x[i]
})

• Go

for i := len(x) - 1; i > 0; i-- {
	j := rand.Intn(i + 1)
	x[i], x[j] = x[j], x[i]
}

• Go

for i := range x {
	j := rand.Intn(i + 1)
	x[i], x[j] = x[j], x[i]
}

• Go

y := make([]T, len(x))
perm := rand.Perm(len(x))
for i, v := range perm {
	y[v] = x[i]
}

• Groovy

x.shuffle()

• Haskell

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)

• JS

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;
}

• Java

Collections.shuffle(x);

• Java

shuffle(asList(x));

• Kotlin

x.shuffle()

• Kotlin

val y = x.shuffled()

• Lisp

(let ((end (length x)))
 (loop for i from 0 below end
       do (rotatef (aref x i)
                   (aref x (+ i (random (- end i)))))))

• Lua

function(x)
	for i = #x, 2, -1 do
		local j = math.random(i)
		x[i], x[j] = x[j], x[i]
	end
end

• Lua

shuffled = {}
for i, v in ipairs(x) do
	local pos = math.random(1, #shuffled+1)
	table.insert(shuffled, pos, v)
end

• Obj-C

x.shuffledArray

• PHP

shuffle($x);

• Perl

@shuffled = shuffle(@x);

• Python

random.shuffle(x)

• Python

shuffle(x)

• Ruby

y = x.shuffle

• Rust

let mut rng = thread_rng();
x.shuffle(&mut rng);

• Rust

let mut rng = StdRng::new().unwrap();
rng.shuffle(&mut x);

• Rust

pub fn shuffle<T>(vec: &mut [T]) {
    let n = vec.len();
    for i in 0..(n - 1) {
        let j = rand() % (n - i) + i;
        vec.swap(i, j);
    }
}

pub fn rand() -> usize {
    RandomState::new().build_hasher().finish() as usize
}

• Scala

val shuffled = Random.shuffle(x)

• Scheme

(shuffle x)

• Scheme

(define shuffle
  (lambda (x)
    (if (< (length x) 2) 
        list
        (let ((item (list-ref list (random (length x)))))
          (cons item (shuffle (remove item x)))))))

• Smalltalk

x shuffled.

• VB

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