Logo

Programming-Idioms

New implementation

Be concise.

Be useful.

All contributions dictatorially edited by webmasters to match personal tastes.

Please do not paste any copyright violating resource.

Please try to avoid dependencies to third-party libraries and frameworks.

Other implementations
#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 collection)
#include <algorithm>
#include <vector>
std::random_shuffle(my_collection.begin(), my_collection.end());
using System;
using System.Collections.Generic;
private static Random rng = new Random();  

public static void Shuffle<T>(this IList<T> list)  
{  
    int n = list.Count;  
    while (n > 1) {  
        n--;  
        int k = rng.Next(n + 1);  
        T value = list[k];  
        list[k] = list[n];  
        list[n] = value;  
    }  
}
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"
for i := len(x) - 1; i > 0; i-- {
	j := rand.Intn(i + 1)
	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]
}
import "math/rand"
y := make([]T, len(x))
perm := rand.Perm(len(x))
for i, v := range perm {
	y[v] = 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);
mutableList.shuffle()
val newList = list.shuffled()
function(list)
	for i = #list, 2, -1 do
		local j = math.random(i)
		list[i], list[j] = list[j], list[i]
	end
end
shuffled = {}
for i, v in ipairs(x) do
	local pos = math.random(1, #shuffled+1)
	table.insert(shuffled, pos, v)
end
@import GameplayKit;
x.shuffledArray
shuffle($x);
var Iter,rr: integer; 
[...]
  for Iter := 0 to high(List) do
    begin
      rr := random(high(List))+1;
      tmp := List[Iter];
      List[Iter] := List[rr];
      List[rr] := tmp;
    end;
use List::Util 'shuffle';
@shuffled = shuffle('a', 'b', 'c', 'd', 'e', 'f');
from random import shuffle
shuffle(x)
import random
random.shuffle(list)
x.shuffle
shuffled_list = x.shuffle
use rand::seq::SliceRandom;
use rand::thread_rng;
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 items = List(1, 2, 3, 4, 5)
val shuffledItems = Random.shuffle(items)
(shuffle x)
(define shuffle
  (lambda (list)
    (if (< (length list) 2) 
        list
        (let ((item (list-ref list (random (length list)))))
          (cons item (shuffle (remove item list)))))))
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