View source for Generate random numbers without repeating a value

{{draft task}}

Many puzzle games such as the [[15 puzzle game]] need a way to randomize the order of the pieces. One way to do this is to create an array and fill it with random values, with each element's index in that array being its position. Unfortunately, most random number generators can produce the same value more than once, which in this case isn't what we want.


;Task:
Create a random number generator and have it output the numbers 1 through 20 (inclusive), in a random order. It cannot produce the same value more than once.

;Or:

Given the output of an existing random number generator that <i>does</i> produce repeated output, create a function that constrains the output to numbers 1 through 20 (inclusive), and no number is output more than once. (Technically it stops being "random" at that point, but that's beyond the scope of this task.) Try your best not to make the process take too long at runtime.

For the second version of the task, the random number generator itself need not be implemented; however you must specify its possible range of values before your constraint function is applied. (e.g "Assume the random number generator creates a value from 0 to 255, and values are allowed to repeat")

;Related Tasks
:* &nbsp; [[15_puzzle_solver|15 Puzzle Solver]]
:* &nbsp; [[16 Puzzle Game]]
:* &nbsp; [[Random numbers]]
<br><br>

=={{header|11l}}==
{{trans|Nim}}

<syntaxhighlight lang="11l">F generate(a, b)
   [Int] result
   V count = b - a + 1
   V generated = [0B] * count
   L
      V n = random:(a .. b)
      I !generated[n - a]
         generated[n - a] = 1B
         result.append(n)
         I --count == 0
            L.break
   R result

L 5
   print(generate(1, 20))</syntaxhighlight>

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

=={{header|Action!}}==
<syntaxhighlight lang="action!">PROC PrintTable(BYTE ARRAY tab BYTE size)
  BYTE i

  FOR i=0 TO size-1
  DO
    PrintF("%B ",tab(i))
  OD
  PutE() PutE()
RETURN

PROC KnuthShuffle(BYTE ARRAY tab BYTE size)
  BYTE i,j,tmp

  i=size-1
  WHILE i>0
  DO
    j=Rand(i)
    tmp=tab(i)
    tab(i)=tab(j)
    tab(j)=tmp
    i==-1
  OD
RETURN

PROC Main()
  DEFINE LEN="20"
  BYTE ARRAY tab(LEN)
  BYTE i

  FOR i=1 TO LEN
  DO
    tab(i-1)=i
  OD
  FOR i=1 TO 5
  DO
    KnuthShuffle(tab,LEN)
    PrintTable(tab,LEN)
  OD
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Generate_random_numbers_without_repeating_a_value.png Screenshot from Atari 8-bit computer]
<pre>
17 6 20 3 8 10 14 12 4 15 2 7 16 18 15 19 9 13 11

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

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

19 16 15 9 4 14 20 2 11 12 3 6 8 17 15 10 18 13 7

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

=={{header|Ada}}==
<syntaxhighlight lang="ada">
-- Generate the integers 1 .. 20 in random order
-- J. Carter     2023 Apr

with Ada.Numerics.Discrete_Random;
with Ada.Text_IO;

procedure Random_20 is
   subtype Desired_Value is Integer range 1 .. 20;
   
   package Desired_Random is new Ada.Numerics.Discrete_Random (Result_Subtype => Desired_Value);
   
   type Desired_List is array (Desired_Value) of Desired_Value;
   
   List : Desired_List;
   Gen  : Desired_Random.Generator;
   Idx  : Desired_Value;
begin -- Random_20
   Fill : for I in List'Range loop
      List (I) := I;
   end loop Fill;

   Desired_Random.Reset (Gen => Gen);
   
   Randomize : for I in List'Range loop
      Idx := Desired_Random.Random (Gen);
      
      Swap : declare
         Temp : Desired_Value := List (Idx);
      begin -- Swap
         List (Idx) := List (I);
         List (I) := Temp;
      end Swap;
   end loop Randomize;
   
   Print : for V of List loop
      Ada.Text_IO.Put (Item => V'Image);
   end loop Print;
   
   Ada.Text_IO.New_Line;
end Random_20;
</syntaxhighlight>
{{out}}
<pre>
 8 3 18 12 2 20 17 11 5 13 9 15 6 14 19 4 16 1 10 7
 17 1 7 10 8 9 6 11 19 20 2 15 13 14 12 4 16 18 3 5
</pre>

=={{header|ALGOL 68}}==
{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}
{{libheader|ALGOL 68-rows}}
This is vertually identical to the Algol 68 sample for the Knuth Shuffle Task.
<syntaxhighlight lang="algol68"># generate a set of 20 random integers without duplicates #
# same as the Knuth Shuffle sample, but with different display #

PR read "rows.incl.a68" PR # include array related utilities #

PROC between = (INT a, b)INT :
(
  ENTIER (random * ABS (b-a+1) + (a<b|a|b))
);
 
PROC knuth shuffle = (REF[]INT a)VOID:
(
  FOR i FROM LWB a TO UPB a DO
    INT j = between(LWB a, UPB a);
    INT t = a[i];
    a[i] := a[j];
    a[j] := t
  OD
);
main:(
  [20]INT a;
  FOR i FROM 1 TO 20 DO a[i] := i OD;
  knuth shuffle(a);
  SHOW a
)</syntaxhighlight>
{{out}}
<pre>
 17 6 11 5 7 15 18 8 4 3 10 13 9 2 12 1 19 14 20 16
</pre>

=={{header|AppleScript}}==
<syntaxhighlight lang="applescript">-- Return a script object containing: 1) a list of all the integers in the required range and
-- 2) a handler that returns one of them at random without repeating any previous choices.
-- Calls to the handler after all the numbers have been used just return 'missing value'.
on makeRNG(low, high)
    script RNG
        property indexShift : missing value
        property ints : {}
        
        on nextInt()
            try
                set n to some number of my ints
                set item (n + indexShift) of my ints to missing value
            on error number -1728
                set n to missing value
            end try
            return n
        end nextInt
    end script
    
    if (low > high) then set {low, high} to {high, low}
    set RNG's indexShift to 1 - low
    repeat with n from low to high
        set end of RNG's ints to n
    end repeat
    
    return RNG
end makeRNG

on task()
    set low to 1
    set high to 20
    set generator to makeRNG(low, high)
    set output to {}
    repeat (high - low + 1) times
        set end of output to generator's nextInt()
    end repeat
    return output
end task

task()</syntaxhighlight>

{{output}}
<syntaxhighlight lang="applescript">{16, 9, 12, 6, 17, 10, 1, 5, 3, 2, 7, 20, 14, 18, 19, 11, 15, 13, 8, 4}</syntaxhighlight>

=={{header|Arturo}}==

<syntaxhighlight lang="rebol">generateUniqueRandoms: function [][
    result: new []

    while [20 > size result][
        rand: sample 1..20
        if not? in? rand result ->
            'result ++ rand
    ]
    return result
]

loop 3 'x [
    print generateUniqueRandoms
]</syntaxhighlight>

{{out}}

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

=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f GENERATE_RANDOM_NUMBERS_WITHOUT_REPEATING_A_VALUE.AWK
BEGIN {
    limit = 20
    srand()
    printf("range 1-%d:",limit)
    while (count < limit) {
      n = sprintf("%d",int(rand()*limit)+1)
      if (!(n in arr)) {
        printf(" %d",n)
        arr[n] = ""
        count++
      }
    }
    printf("\n")
    exit(0)
}
</syntaxhighlight>
{{out}}
<pre>
range 1-20: 16 18 15 4 13 6 11 2 1 20 14 3 7 19 17 12 10 9 5 8
</pre>

=={{header|BASIC}}==
==={{header|BASIC256}}===
{{trans|FreeBASIC}}
<syntaxhighlight lang="basic256">arraybase 1
for num = 1 to 5
	call pRand()
next num
end

subroutine pRand()
	dim randCheck(21)
	nr = 1
	do
		aleat = int(rand * 20) + 1
		if randCheck[aleat] = 1 then
			continue do
		else
			randCheck[aleat] = 1
			print aleat; " ";
		end if
		for n = 1 to randCheck[?]
			if randCheck[nr] then nr += 1
		next n
	until nr = 21
	print
end subroutine</syntaxhighlight>

==={{header|QBasic}}===
{{trans|FreeBASIC}}
<syntaxhighlight lang="qbasic">DECLARE SUB pRand ()

RANDOMIZE TIMER
FOR num = 1 TO 5
    pRand
NEXT num
END

SUB pRand
    DIM randCheck(1 TO 21)
    nr = 1
    DO
        aleat = INT(RND * 20) + 1
        IF randCheck(aleat) <> 1 THEN
            randCheck(aleat) = 1
            PRINT aleat;
        END IF
        
        FOR n = 1 TO UBOUND(randCheck)
            IF randCheck(nr) = 1 THEN nr = nr + 1
        NEXT n
    LOOP UNTIL nr = 21
    PRINT
END SUB</syntaxhighlight>

=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
Creates a "TRandomizer" object which makes it easy to setup and use multiple non repeating randomizers. Since the objects are independent, each one can have different parameters. 

<syntaxhighlight lang="Delphi">

{Create randomize object to make it easier to use}

type TRandomizer = class(TObject)
 private
  FSize: integer;
  procedure SetSize(const Value: integer);
 protected
  procedure Randomize;
 public
  Numbers: array of Integer;
  constructor Create;
  property Size: integer read FSize write SetSize;
 end;

{ TRandomizer }

constructor TRandomizer.Create;
begin
Size:=20;
end;

procedure TRandomizer.Randomize;
var I,Inx1,Inx2,T: integer;
begin
for I:=1 to 100 do
	begin
	Inx1:=Random(Length(Numbers));
	Inx2:=Random(Length(Numbers));
	T:=Numbers[Inx1];
	Numbers[Inx1]:=Numbers[Inx2];
	Numbers[Inx2]:=T;
	end;

end;

procedure TRandomizer.SetSize(const Value: integer);
var I: integer;
begin
if FSize<>Value then
	begin
	FSize:=Value;
	SetLength(Numbers,FSize);
	for I:=0 to FSize-1 do Numbers[I]:=I+1;
	Randomize;
	end;
end;

{------------------------------------------------------------------------------}

procedure ShowRandomNumbers(Memo: TMemo);
var RD: TRandomizer;
var S: string;
var I,J: integer;
begin
RD:=TRandomizer.Create;
try
RD.Size:=20;
for J:=1 to 5 do
	begin
	RD.Randomize;
	S:='[';
	for I:=0 to High(RD.Numbers) do
	   S:=S+Format('%3D',[RD.Numbers[I]]);
	S:=S+']';
	Memo.Lines.Add(S);
	end;
finally RD.Free; end;
end;


</syntaxhighlight>
{{out}}
<pre>
[ 20 12  9 19  2  8 16 14 10  4 11  6 18  5  7  1 17  3 15 13]
[  7 12 20 13  4 19  8  3 17  5  2  6  9  1 15 11 18 16 10 14]
[ 19 12  7 20  6 16  1 10 13 15  4  2  8  9  3 17 11 18 14  5]
[ 18 13 12 20  8  2  3 10  4 16 19  1  7  5 11 15  9  6 17 14]
[ 17 20 19  3  6 10 12  9  5 16 18  7  8 13  4 15  1 11 14  2]
</pre>


=={{header|EasyLang}}==
<syntaxhighlight>
proc shuffle . a[] .
   for i = len a[] downto 2
      r = randint i
      swap a[r] a[i]
   .
.
for i to 20
   arr[] &= i
.
shuffle arr[]
print arr[]
</syntaxhighlight>
{{out}}
<pre>
[ 18 12 19 10 11 4 2 3 6 20 8 16 15 9 7 17 1 14 5 13 ]
</pre>

=={{header|F_Sharp|F#}}==
<syntaxhighlight lang="fsharp">
// Generate random numbers without repeating a value. Nigel Galloway: August 27th., 2021
MathNet.Numerics.Combinatorics.GeneratePermutation 20|>Array.map((+)1)|>Array.iter(printf "%d "); printfn ""
</syntaxhighlight>
{{out}}
<pre>
12 7 17 8 10 13 16 19 20 14 18 5 9 11 3 4 1 15 6 2
</pre>

=={{header|Factor}}==
Generating a random permutation of 1..20:
{{works with|Factor|0.99 2021-06-02}}
<syntaxhighlight lang="factor">USING: kernel math.combinatorics math.ranges prettyprint random
sequences ;

: random-permutation ( seq -- newseq )
    [ length dup nPk random ] keep permutation ;

20 [1,b] random-permutation .</syntaxhighlight>
{{out}}
<pre>
{ 7 10 12 9 5 8 20 14 18 4 13 3 17 16 19 6 15 1 2 11 }
</pre>
Shuffling 1..20:
{{works with|Factor|0.99 2021-06-02}}
<syntaxhighlight lang="factor">USING: math.ranges prettyprint random vectors ;

20 [1,b] >vector randomize .</syntaxhighlight>
{{out}}
<pre>
V{ 20 7 8 17 18 1 15 13 12 10 3 14 19 2 5 9 16 11 6 4 }
</pre>
Sampling 20 elements from 1..20:
{{works with|Factor|0.99 2021-06-02}}
<syntaxhighlight lang="factor">USING: math.ranges prettyprint random ;

20 [1,b] 20 sample .</syntaxhighlight>
{{out}}
<pre>
{ 12 3 16 13 1 9 8 11 5 19 15 18 17 20 10 4 7 14 6 2 }
</pre>


=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">Sub pRand
    Dim As Integer randCheck(20), nr = 1
    Do
        Dim As Integer aleat = Int(Rnd * 20) + 1
        If randCheck(aleat) = 1 Then
            Continue Do
        Else
            randCheck(aleat) = 1
            Print aleat;
        End If
        For n As Integer = 1 To Ubound(randCheck)
            If randCheck(nr) = 1 Then nr += 1
        Next n
    Loop Until nr = 21
    Print
End Sub

Randomize Timer
For num As Integer = 1 To 5
    pRand()
Next num
Sleep</syntaxhighlight>
{{out}}
<pre>
7 11 16 13 14 6 20 2 1 10 17 18 9 12 4 8 15 19 5 3
9 6 18 16 3 14 1 8 11 2 7 20 4 13 19 12 17 5 15 10
11 19 15 6 10 17 13 8 18 2 12 14 16 5 4 1 3 9 7 20
5 18 13 8 4 15 16 12 7 6 1 19 2 17 9 14 10 20 3 11
19 5 4 9 12 11 8 14 6 13 3 1 7 2 16 18 10 17 20 15
</pre>


=={{header|Go}}==
{{trans|Nim}}
This uses Go's 'native' random number generator which internally uses a custom algorithm attributed to D P Mitchell and J A Reeds and can generate non-negative random integers in the 64-bit range. 
<syntaxhighlight lang="go">package main

import (
    "fmt"
    "log"
    "math/rand"
    "time"
)

// Generates and prints all numbers within an inclusive range whose endpoints are
// non-negative 64-bit integers. The numbers are generated in random order with
// any repetitions being ignored.
func generate(from, to int64) {
    if to < from || from < 0 {
        log.Fatal("Invalid range.")
    }
    span := to - from + 1
    generated := make([]bool, span) // all false by default, zero indexing
    count := span
    for count > 0 {
        n := from + rand.Int63n(span) // upper endpoint is exclusive
        if !generated[n-from] {
            generated[n-from] = true
            fmt.Printf("%2d ", n)
            count--
        }
    }
    fmt.Println()
}

func main() {
    rand.Seed(time.Now().UnixNano())

    // generate 5 sets say
    for i := 1; i <= 5; i++ {
        generate(1, 20)
    }
}</syntaxhighlight>

{{out}}
Sample run:
<pre>
16  7  5 11 10 12  1 19  9  2  4 14  6 18 17  8 20  3 13 15 
10  3  5  7 14  9 20  6 11  8 13 18  1 17 15 12  4  2 16 19 
12 14 16 11 15  2  8 13  3 19  6 17 18  4 10  5 20  1  7  9 
 4 11  9 17 14 16  2  7  6  1 12 20  8 15  5 13 10 18 19  3 
19 13  9  7  5 12 11 17  1  3 16  4 15 14 20  8  6 18  2 10 
</pre>
<br>
Alternatively and far more efficiently, we can simply create a list of the required numbers and randomly shuffle them. Go has a standard library function for this which uses the Fisher-Yates (aka Knuth) shuffle.
<syntaxhighlight lang="go">package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    rand.Seed(time.Now().UnixNano())
    numbers := make([]int, 20)
    for i := 0; i < 20; i++ {
        numbers[i] = i + 1
    }
    for i := 1; i <= 5; i++ {
        rand.Shuffle(20, func(i, j int) {
            numbers[i], numbers[j] = numbers[j], numbers[i]
        })
        s := fmt.Sprintf("%2d ", numbers)
        fmt.Println(s[1 : len(s)-2])
    }
}</syntaxhighlight>

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

=={{header|Haskell}}==
<syntaxhighlight lang="haskell">import Data.List (sortBy)
import Data.Ord (comparing)
import System.Random (newStdGen, randomRs)

--------------------- IN RANDOM ORDER --------------------

inRandomOrder :: [a] -> IO [a]
inRandomOrder xs =
  fmap fst . sortBy (comparing snd) . zip xs
    <$> (randomRs (0, 1) <$> newStdGen :: IO [Double])

--------------------------- TEST -------------------------
main :: IO ()
main =
  inRandomOrder [1 .. 20]
    >>= print</syntaxhighlight>
{{Out}}
For example:
<pre>[16,1,3,9,8,20,12,18,11,19,2,14,5,6,13,15,17,10,7,4]</pre>

=={{header|J}}==
<syntaxhighlight lang="j">>: ?~ 20</syntaxhighlight>

=={{header|Java}}==
<syntaxhighlight lang="java">
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Random;
import java.util.Set;
</syntaxhighlight>
<syntaxhighlight lang="java">
int[] randomList() {
    /* 'Set' allows only unique values */
    /* 'LinkedHashSet' will preserve the input order */
    Set<Integer> set = new LinkedHashSet<>();
    Random random = new Random();
    while (set.size() < 20)
        set.add(random.nextInt(1, 21));
    int[] values = new int[set.size()];
    /* 'Set' does not have a 'get' method */
    Iterator<Integer> iterator = set.iterator();
    int index = 0;
    while (iterator.hasNext())
        values[index++] = iterator.next();
    return values;
}
</syntaxhighlight>
<pre>
8, 3, 2, 17, 11, 4, 6, 15, 20, 9, 14, 10, 5, 19, 18, 7, 12, 13, 1, 16
</pre>
<pre>
6, 7, 20, 14, 1, 2, 10, 5, 13, 8, 4, 12, 16, 15, 17, 11, 18, 3, 19, 9
</pre>
<br />
<syntaxhighlight lang="java">import java.util.*;

public class RandomShuffle {
    public static void main(String[] args) {
        Random rand = new Random();
        List<Integer> list = new ArrayList<>();
        for (int j = 1; j <= 20; ++j)
            list.add(j);
        Collections.shuffle(list, rand);
        System.out.println(list);
    }
}</syntaxhighlight>

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

=={{header|JavaScript}}==
<syntaxhighlight lang="javascript">(() => {
    "use strict";

    // ---------- NON-REPEATING RANDOM NUMBERS -----------

    // main :: IO ()
    const main = () =>
        sortOn(Math.random)(
            enumFromTo(1)(20)
        );


    // --------------------- GENERIC ---------------------

    // comparing :: (a -> b) -> (a -> a -> Ordering)
    const comparing = f =>
        // The ordering of f(x) and f(y) as a value
        // drawn from {-1, 0, 1}, representing {LT, EQ, GT}.
        x => y => {
            const
                a = f(x),
                b = f(y);

            return a < b ? -1 : (a > b ? 1 : 0);
        };


    // enumFromTo :: Int -> Int -> [Int]
    const enumFromTo = m =>
        n => Array.from({
            length: 1 + n - m
        }, (_, i) => m + i);


    // sortBy :: (a -> a -> Ordering) -> [a] -> [a]
    const sortBy = f =>
        // A copy of xs sorted by the comparator function f.
        xs => xs.slice()
        .sort((a, b) => f(a)(b));


    // sortOn :: Ord b => (a -> b) -> [a] -> [a]
    const sortOn = f =>
        // Equivalent to sortBy(comparing(f)), but with f(x)
        // evaluated only once for each x in xs.
        // ('Schwartzian' decorate-sort-undecorate).
        xs => sortBy(
            comparing(x => x[0])
        )(
            xs.map(x => [f(x), x])
        )
        .map(x => x[1]);

    // MAIN ---
    return JSON.stringify(main());
})();</syntaxhighlight>
{{Out}}
For example:
<pre>[6,9,8,16,5,15,19,7,13,12,4,20,1,2,18,11,14,17,10,3]</pre>

=={{header|jq}}==
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''

In this entry, an external source of entropy is used to define a jq
filter, `knuthShuffle`, so that the specific task can then be accomplished using the expression:
<syntaxhighlight lang="jq">[range(1;21)] | knuthShuffle</syntaxhighlight>

In the following, a bash or bash-like scripting environment is assumed, and the jq command is assumed to be "jq".
<syntaxhighlight lang="sh">
< /dev/urandom tr -cd '0-9' | fold -w 1 | jq -MRcnr -f program.jq
</syntaxhighlight>
'''program.jq'''
<syntaxhighlight lang="jq"># Output: a prn in range(0;$n) where $n is `.`
def prn:
  if . == 1 then 0
  else . as $n
  | ([1, (($n-1)|tostring|length)]|max) as $w
  | [limit($w; inputs)] | join("") | tonumber
  | if . < $n then . else ($n | prn) end
  end;

def knuthShuffle:
  length as $n
  | if $n <= 1 then .
    else {i: $n, a: .}
    | until(.i ==  0;
        .i += -1
        | (.i + 1 | prn) as $j
        | .a[.i] as $t
        | .a[.i] = .a[$j]
        | .a[$j] = $t)
    | .a 
    end;

# The task:
[range(1;21)] | knuthShuffle</syntaxhighlight>
{{out}}
<pre>
4
11
3
8
1
9
16
6
5
7
12
17
15
19
10
20
18
2
13
14
</pre>

=={{header|Julia}}==
Julia's Random module contains a function called `shuffle([rng=GLOBAL_RNG,] v::AbstractArray)` which constructs a randomly permuted copy of v.
<syntaxhighlight lang="julia">using Random
Random.seed!(1234567)

# 1. built in

@show shuffle(1:20)

# 2. from standard random generator rand()

myshuffle(urn::AbstractVector) =
    map(length(urn):-1:1) do len
        ball = urn[ceil(Int, rand() * len)]
        urn = setdiff(urn, ball)
        ball
    end

@show myshuffle(1:20);</syntaxhighlight>{{out}}
<pre>
shuffle(1:20) = [4, 17, 15, 14, 11, 5, 18, 6, 7, 8, 16, 3, 20, 13, 12, 19, 2, 10, 1, 9]
myshuffle(1:20) = [5, 10, 19, 3, 15, 13, 18, 1, 6, 8, 2, 11, 4, 20, 17, 14, 9, 16, 7, 12]
</pre>

=={{header|Mathematica}} / {{header|Wolfram Language}}== 
<syntaxhighlight lang="mathematica">RandomSample[Range@20]</syntaxhighlight>

{{out}}<pre>
{14,4,2,6,20,11,17,13,16,18,15,19,12,10,1,8,3,7,5,9}
</pre>

=={{header|Nim}}==
{{trans|Wren}}
Nim standard module <code>random</code> provides a PRNG based on xoroshiro128+ algorithm whose period is 2^128 − 1. It also provides the <code>shuffle</code> procedure to shuffle an array or a sequence using Knuth algorithm.

Here, we have defined a procedure which accepts a slice <code>a..b</code> as argument and returns a shuffled sequence of values from a to b. It uses the same algorithm as in Wren solution, i.e. a list to keep track of generated values.

<syntaxhighlight lang="nim">import random

randomize()

proc generate(s: Slice[int]): seq[int] =
  assert s.a <= s.b
  var count = s.b - s.a + 1
  var generated = newSeq[bool](count) # Initialized to false.
  while count != 0:
    let n = rand(s)
    if not generated[n - s.a]:
      generated[n - s.a] = true
      result.add n
      dec count

for i in 1..5:
  echo generate(1..20)</syntaxhighlight>

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

=={{header|Perl}}==
Just shuffle...
<syntaxhighlight lang="perl">#!/usr/bin/perl

use strict; # https://rosettacode.org/wiki/Generate_random_numbers_without_repeating_a_value
use warnings;
use List::Util qw( shuffle );

print "@{[ shuffle 1 .. 20 ]}\n" for 1 .. 5;</syntaxhighlight>
{{out}}
<pre>
9 15 11 14 17 10 13 1 2 7 19 3 6 12 4 16 8 5 18 20
20 17 18 6 1 19 14 10 2 7 4 12 8 15 3 16 9 11 5 13
4 3 9 15 6 20 14 8 18 5 19 17 1 10 11 16 12 2 13 7
17 9 3 15 1 20 7 19 13 8 11 10 6 5 4 14 12 18 16 2
13 1 5 18 12 11 3 14 10 9 19 4 20 16 8 6 17 2 7 15
</pre>


=={{header|Phix}}==
Trival use of standard builtins. Progressively filtering the output of rand(20) would gain nothing except wasted cycles. Normally I would use "with javascript_semantics", or equivalently just "with js", to explicitly specify/verify the code can be run on both the desktop ''and'' in a web browser, however here that somehow seems like overkill.
<!--<syntaxhighlight lang="phix">(phixonline)-->
 <span style="color: #0000FF;">?</span><span style="color: #7060A8;">shuffle</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">20</span><span style="color: #0000FF;">))</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
{13,6,8,1,9,19,5,18,2,12,11,20,4,17,10,3,15,7,14,16}
</pre>

=={{header|Python}}==
===Version 1===
<syntaxhighlight lang="python">
import random

print(random.sample(range(1, 21), 20))
</syntaxhighlight>
{{out}}
<pre>
[14, 15, 3, 18, 4, 11, 16, 10, 12, 20, 13, 1, 6, 7, 2, 17, 5, 9, 19, 8]
</pre>

===Version 2===
<syntaxhighlight lang="python">
import random as r

def GenerateRandomSet(n: int) -> list:
    set_ = list(range(1, n+1))
    r.shuffle(set_)
    return set_
</syntaxhighlight>

=={{header|Quackery}}==

As a dialogue in the Quackery shell.

<pre>Welcome to Quackery.

Enter "leave" to leave the shell.

/O> [] 20 times [ i^ 1+ join ]
... shuffle 
... echo
... 
[ 7 6 9 5 13 11 15 17 19 2 14 20 12 4 8 1 3 18 10 16 ]
Stack empty.

/O> leave
... 

Auf wiedersehen.
</pre>

=={{header|R}}==
R makes this so easy that it feels like you've missed the point.
<syntaxhighlight lang="rsplus">sample(20)</syntaxhighlight>

=={{header|Raku}}==
Raku has three distinct "random" functions built in. rand() for when you want some fraction between 0 and 1. roll() when you want to select elements from a collection with replacement (rolls of a die). And pick() for when you want to select some elements from a collection ''without'' replacement. (pick a card, any card, or two cards or 10 cards...). If you want to select ''all'' the elements in random order, just pick 'whatever'. Here we'll pick all from 1 to 20, 5 times using the repetition operator.

Pick random elements ''without'' replacement
<syntaxhighlight lang="raku" line>.put for (1..20).pick(*) xx 5</syntaxhighlight>
{{out|Sample output}}
<pre>20 4 5 7 15 19 2 16 8 6 3 12 14 13 10 18 9 17 1 11
4 5 18 10 13 3 1 11 6 2 19 8 12 7 16 17 14 20 15 9
14 8 15 11 17 4 3 10 18 7 16 13 1 20 12 9 6 5 19 2
7 5 15 11 12 18 17 3 20 6 13 19 14 2 16 10 4 9 8 1
19 12 4 7 3 20 13 17 5 8 6 15 10 18 1 11 2 14 16 9</pre>

Pick random elements ''with'' replacement
<syntaxhighlight lang="raku" line>.put for (1..20).roll(20) xx 5</syntaxhighlight>
{{out|Sample output}}
<pre>16 20 15 17 13 4 19 1 3 8 4 12 13 4 4 5 14 17 10 14
12 6 8 8 9 6 2 4 16 8 4 3 14 8 19 20 5 12 7 15
20 4 20 16 14 6 15 15 16 18 5 19 20 3 14 11 2 7 13 12
3 19 11 13 9 4 5 11 2 20 16 17 14 18 12 10 4 1 13 2
17 20 12 17 19 4 20 20 14 8 2 19 2 12 18 14 4 14 10 8</pre>

=={{header|REXX}}==
The REXX solution to this task is performed in essentially three parts:
<br>: Part 1. &nbsp; &nbsp; (The DO ''i'' &nbsp; ...) &nbsp; build a list of sequential integers.
<br>: Part 2. &nbsp; &nbsp; (The DO ''r'' &nbsp; ...) &nbsp; build an array of random integers, using the list as a selection template.
<br>: Part 3. &nbsp; &nbsp; (The DO ''o'' &nbsp; ...) &nbsp; display a grid of the random integers with title and formatting. 

With the method/algorithm used herein, &nbsp; there are &nbsp; no &nbsp; random numbers being discarded &nbsp; (due to possible 
<br>duplicates) &nbsp; because there cannot &nbsp; ''be'' &nbsp; any duplicates. 
<syntaxhighlight lang="rexx">/*REXX program generates & displays a list of random integers (1 ──► N) with no repeats.*/
parse arg n cols seed .                          /*obtain optional argument from the CL.*/
if    n=='' |    n==","  then    n= 20           /*Not specified?  Then use the default.*/
if cols=='' | cols==","  then cols= 10           /* "      "         "   "   "     "    */
if datatype(seed, 'W')   then call random ,,seed /*Specified?      Then use the seed.   */
w= 6
                     title= ' random integers  (1 ──► '   n")  with no repeats"
say ' index │'center(title,   1 + cols*(w+1)     )         /*display the output title.  */
say '───────┼'center(""   ,   1 + cols*(w+1), '─')         /*   "     "     "  separator*/
a=
        do i=1  for n;      a= a  i              /*create a list of possible integers.  */
        end   /*i*/                              /*step through the (random) integers.  */
pool= n
        do r=1  for n;      ?= random(1, pool)   /*obtain a random integer from the list*/
        @.r= word(a, ?);    a= delword(a, ?, 1)  /*obtain random integer; del from pool.*/
        pool= pool - 1                           /*diminish size of the allowable pool. */
        end   /*r*/                              /*step through the (random) integers.  */
$=;                                     idx= 1
        do o=1  for n;      x= @.o               /*obtain a random integer from random @*/
        $= $  right( x, w)                       /*add an integer to the output list.   */
        if o//cols\==0  then iterate             /*have we populated a line of output?  */
        say center(idx, 7)'│'  substr($, 2); $=  /*display what we have so far  (cols). */
        idx= idx + cols                          /*bump the  index  count for the output*/
        end   /*j*/

if $\==''  then say center(idx, 7)"│"  substr($, 2)     /*possible show residual output.*/
say '───────┴'center(""  ,   1 + cols*(w+1), '─');  say
exit 0                                           /*stick a fork in it,  we're all done. */</syntaxhighlight>
{{out|output|text=&nbsp; when using the default inputs:}}
<pre>
 index │             random integers  (1 ──►  20)  with no repeats
───────┼───────────────────────────────────────────────────────────────────────
   1   │     20      7      5     12     11      6     19      8      4     10
  11   │      9     17     15     13      1     16      3     18     14      2
───────┴───────────────────────────────────────────────────────────────────────
</pre>
=={{header|Ring}}==
<syntaxhighlight lang="ring">
see "working..." + nl
decimals(3)
time1 = clock()
for num = 1 to 5
    pRand()
next

time2 = clock()
time3 = time2/1000 - time1/1000
see "Elapsed time = " + time3 + " s" + nl
see "done..." + nl

func pRand
     randCheck = list(20)
     while true
           rnd = random(19)+1
           if randCheck[rnd] = 1
              loop
           else
              randCheck[rnd] = 1
              see "" + rnd + " "
           ok  
           nr = 1
           for n = 1 to len(randCheck)
               if randCheck[nr] = 1
                  nr++
               ok
           next
           if nr = 21
              see nl
              exit
           ok   
     end
</syntaxhighlight>
{{out}}
<pre>
working...
6 11 16 19 10 15 3 1 8 7 2 9 20 5 4 14 12 13 17 18 
7 20 2 15 8 5 9 13 17 19 1 6 4 16 11 18 3 12 10 14 
5 19 12 3 1 10 15 7 9 17 18 4 20 13 2 11 8 14 16 6 
11 10 17 1 5 19 15 4 18 9 20 12 13 6 3 2 7 8 16 14 
2 14 15 6 19 20 3 17 5 1 8 13 4 18 7 9 10 16 11 12 
Elapsed time = 0.008 s
done...
</pre>

=={{header|RPL}}==
'''Stand-alone implementation'''
 ≪ 0 → n r 
   ≪ 1 n '''FOR''' j j '''NEXT'''                        <span style="color:grey">@ fill stack with 1, 2,..n</span>
      1 n '''START''' 
         n 1 - RAND * CEIL 1 + 'r' STO 
         r ROLL SWAP r ROLLD                  <span style="color:grey">@ swap 2 stack levels randomly, n times</span>
         n ROLL 
     '''NEXT''' 
     n →LIST
 ≫ ≫ '<span style="color:blue">SHUFFLE</span>' STO
'''Using Knuth shuffle'''

<code>KNUTH</code> is defined at [[Knuth shuffle#RPL|Knuth shuffle]]
 ≪ { } 
    1 ROT '''FOR''' j j + '''NEXT''' 
    <span style="color:blue">KNUTH  </span>
 ≫ '<span style="color:blue">SHUFFLE</span>' STO

 20 <span style="color:blue">SHUFFLE</span>
{{out}}
<pre>
1: { 3 13 14 1 7 10 4 9 12 11 16 15 18 17 20 6 19 8 2 5 }
</pre>

=={{header|Ruby}}==
<syntaxhighlight lang="ruby">nums = (1..20).to_a
5.times{ puts nums.shuffle.join(" ") }</syntaxhighlight>
{{out}}
<pre>2 9 19 12 7 18 17 13 5 6 20 10 14 4 1 8 11 15 3 16
18 6 9 5 17 14 2 13 7 16 4 11 15 10 3 8 12 19 1 20
2 16 7 12 3 10 13 17 20 18 11 14 5 15 1 19 9 6 4 8
10 14 5 15 8 1 7 12 16 6 18 4 9 3 11 20 19 17 13 2
2 16 13 12 6 18 14 4 15 7 9 10 8 11 19 5 17 1 3 20
</pre>

=={{header|Rust}}==
<syntaxhighlight lang="rust">// [dependencies]
// rand = "0.7.2"

fn main() {
    use rand::seq::SliceRandom;
    use rand::thread_rng;
    let mut rng = thread_rng();
    let mut v: Vec<u32> = (1..=20).collect();
    v.shuffle(&mut rng);
    println!("{:?}", v);
}</syntaxhighlight>

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

=={{header|Sidef}}==
{{trans|Ruby}}
<syntaxhighlight lang="ruby">var nums = (1..20).to_a
5.times{ say nums.shuffle.join(" ") }</syntaxhighlight>

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

=={{header|Swift}}==
<syntaxhighlight lang="swift">var array = Array(1...20)
array.shuffle()
print(array)</syntaxhighlight>

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

=={{header|V (Vlang)}}==
{{trans|go}}
<syntaxhighlight lang="v (vlang)">import rand
import rand.seed

fn generate(from i64, to i64) {
    if to < from || from < 0 {
        println("Invalid range.")
    }
    span := int(to - from + 1)
    mut generated := []bool{len: span} // all false by default, zero indexing
    mut count := span
    for count > 0 {
        n := from + rand.i64n(span) or {0} // upper endpoint is exclusive
        if !generated[n-from] {
            generated[n-from] = true
            print("${n} ")
            count--
        }
    }
    println('')
}

fn main(){
    rand.seed(seed.time_seed_array(2))
    // generate 5 sets say
    for i := 1; i <= 5; i++ {
        generate(1, 20)
    }
}</syntaxhighlight>
{{out}}
<pre>Same as Go entry</pre>

Alternatively and far more efficiently, we can simply create a list of the required numbers and randomly shuffle them. Vlang has a standard library function for this which uses the Fisher-Yates (aka Knuth) shuffle.
<syntaxhighlight lang="vlang">import rand
import rand.seed

fn main(){
    rand.seed(seed.time_seed_array(2))
    mut numbers := []int{len:20, init:it+1}
    // generate 5 sets say
    for i := 1; i <= 5; i++ {
        rand.shuffle<int>(mut numbers, rand.ShuffleConfigStruct{})?
        s := "${numbers:2} "
        println(s[1 .. s.len-2])
    }
}</syntaxhighlight>

{{out}}
<pre>
Same as go entry
</pre>

=={{header|Wren}}==
{{libheader|Wren-fmt}}
This uses Wren's 'native' pseudo-random number generator which internally uses WELL512a and can generate random integers in the 32-bit range. 
<syntaxhighlight lang="wren">import "random" for Random
import "./fmt" for Fmt

var rand = Random.new()

// Generates and prints all numbers within an inclusive range whose endpoints are 32 bit integers.
// The numbers are generated in random order with any repetitions being ignored. 
var generate = Fn.new { |r|    
    var generated = List.filled(r.to - r.from + 1, false) // zero indexing
    while (generated.any { |g| !g }) { 
        var n = rand.int(r.from, r.to + 1) // upper endpoint is exclusive
        if (!generated[n - r.from]) {      
            generated[n - r.from] = true
            Fmt.write("$2d ", n)
        }
    }
    System.print()
}

// generate 5 sets say
for (i in 1..5) generate.call(1..20)</syntaxhighlight>

{{out}}
Sample run:
<pre>
 4 16 10  5  1  2  9 19  7 12 15 11 18  3 13 17 20 14  6  8 
16  1  9 11  8 10 19  5  4  6 17 20 12 15  3  7 14 18  2 13 
 5 15 13  1 17 19 16  2  7 12 18  8 14  6 20  9 10 11  3  4 
 9  6 20 16  2 14 19  1  7 18 11 12  4 15  5 17  3  8 10 13 
16  1  8 14  5 19  3  4 18 12 20  2 10  6 13 11  7 15  9 17 
</pre>
<br>
Alternatively and far more efficiently, we can simply create a list of the required numbers and randomly shuffle them. Wren has a built-in function for this which uses the Fisher-Yates (aka Knuth) shuffle.
<syntaxhighlight lang="wren">import "random" for Random
import "./fmt" for Fmt

var rand = Random.new()
var numbers = (1..20).toList
for (i in 1..5) {
    rand.shuffle(numbers)
    Fmt.print("$2d", numbers)
}</syntaxhighlight>

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

=={{header|XPL0}}==
<syntaxhighlight lang="xpl0">int Set, R;
[Set:= 0;
repeat  R:= Ran(20);
        if (Set & 1<<R) = 0 then
            [Set:= Set ! 1<<R;
            IntOut(0, R+1);  ChOut(0, ^ )];
until   Set = $F_FFFF;
]</syntaxhighlight>

{{out}}
Example outputs:
<pre>
14 5 1 20 18 16 2 3 19 6 4 13 7 11 17 10 8 12 15 9 
18 19 8 11 9 6 5 4 12 2 3 1 16 15 14 7 20 13 10 17 
5 11 17 19 2 14 20 18 9 16 1 15 4 8 12 10 13 6 7 3 
17 11 13 20 3 7 8 9 19 5 4 18 15 14 16 12 1 2 6 10 
</pre>