Generate random numbers without repeating a value: Difference between revisions

{{trans|Nim}}

 

[Int] result

V count = b - a + 1

 

L 5

 

{{out}}

 

=={{header|Action!}}==

BYTE i

 

PrintTable(tab,LEN)

OD

{{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]

{{libheader|ALGOL 68-rows}}

This is vertually identical to the Algol 68 sample for the Knuth Shuffle Task.

# same as the Knuth Shuffle sample, but with different display #

 

knuth shuffle(a);

SHOW a

{{out}}

<pre>

 

=={{header|AppleScript}}==

-- 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'.

end task

 

 

{{output}}

 

=={{header|Arturo}}==

 

result: new []

 

loop 3 'x [

print generateUniqueRandoms

 

{{out}}

 

=={{header|AWK}}==

# syntax: GAWK -f GENERATE_RANDOM_NUMBERS_WITHOUT_REPEATING_A_VALUE.AWK

BEGIN {

exit(0)

}

{{out}}

<pre>

==={{header|BASIC256}}===

{{trans|FreeBASIC}}

for num = 1 to 5

call pRand()

until nr = 21

print

 

==={{header|QBasic}}===

{{trans|FreeBASIC}}

 

RANDOMIZE TIMER

LOOP UNTIL nr = 21

PRINT

 

=={{header|F_Sharp|F#}}==

// 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 ""

{{out}}

<pre>

Generating a random permutation of 1..20:

{{works with|Factor|0.99 2021-06-02}}

sequences ;

 

[ length dup nPk random ] keep permutation ;

 

{{out}}

<pre>

Shuffling 1..20:

{{works with|Factor|0.99 2021-06-02}}

 

{{out}}

<pre>

Sampling 20 elements from 1..20:

{{works with|Factor|0.99 2021-06-02}}

 

{{out}}

<pre>

 

=={{header|FreeBASIC}}==

Dim As Integer randCheck(20), nr = 1

Do

pRand()

Next num

{{out}}

<pre>

{{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.

 

import (

generate(1, 20)

}

 

{{out}}

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

 

import (

fmt.Println(s[1 : len(s)-2])

}

 

{{out}}

 

=={{header|Haskell}}==

import Data.Ord (comparing)

import System.Random (newStdGen, randomRs)

main =

inRandomOrder [1 .. 20]

{{Out}}

For example:

 

=={{header|Java}}==

 

public class RandomShuffle {

System.out.println(list);

}

 

{{out}}

 

=={{header|JavaScript}}==

"use strict";

 

// MAIN ---

return JSON.stringify(main());

{{Out}}

For example:

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:

 

In the following, a bash or bash-like scripting environment is assumed, and the jq command is assumed to be "jq".

< /dev/urandom tr -cd '0-9' | fold -w 1 | jq -MRcnr -f program.jq

'''program.jq'''

def prn:

if . == 1 then 0

 

# The task:

{{out}}

<pre>

=={{header|Julia}}==

Julia's Random module contains a function called `randperm(n::Integer)` which constructs a random permutation of integers from 1 to n.

@show randperm(20)

<pre>

randperm(20) = [20, 2, 5, 6, 18, 14, 12,4, 13, 7, 15, 3, 19, 17, 1, 9, 16, 11, 10]

</pre>

=={{header|Mathematica}} / {{header|Wolfram Language}}==

 

{{out}}<pre>

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.

 

 

randomize()

 

for i in 1..5:

 

{{out}}

=={{header|Perl}}==

Just shuffle...

 

use strict; # https://rosettacode.org/wiki/Generate_random_numbers_without_repeating_a_value

use List::Util qw( shuffle );

 

{{out}}

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

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

{{out}}

<pre>

 

=={{header|Python}}==

import random

 

print(random.sample(range(1, 21), 20))

 

=={{header|Quackery}}==

=={{header|R}}==

R makes this so easy that it feels like you've missed the point.

 

=={{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.

 

{{out|Sample output}}

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

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.

parse arg n cols seed . /*obtain optional argument from the CL.*/

if n=='' | n=="," then n= 20 /*Not specified? Then use the default.*/

if $\=='' then say center(idx, 7)"│" substr($, 2) /*possible show residual output.*/

say '───────┴'center("" , 1 + cols*(w+1), '─'); say

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

</pre>

=={{header|Ring}}==

see "working..." + nl

decimals(3)

ok

end

{{out}}

<pre>

 

=={{header|Ruby}}==

{{out}}

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

</pre>

=={{header|Rust}}==

// rand = "0.7.2"

 

v.shuffle(&mut rng);

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

 

{{out}}

=={{header|Sidef}}==

{{trans|Ruby}}

 

{{out}}

 

=={{header|Swift}}==

array.shuffle()

 

{{out}}

=={{header|Vlang}}==

{{trans|go}}

import rand.seed

 

generate(1, 20)

}

{{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.

import rand.seed

 

println(s[1 .. s.len-2])

}

 

{{out}}

{{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.

import "/fmt" for Fmt

 

 

// generate 5 sets say

 

{{out}}

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

import "/fmt" for Fmt

 

rand.shuffle(numbers)

Fmt.print("$2d", numbers)

 

{{out}}

 

=={{header|XPL0}}==

[Set:= 0;

repeat R:= Ran(20);

IntOut(0, R+1); ChOut(0, ^ )];

until Set = $F_FFFF;

 

{{out}}