Generate random numbers without repeating a value: Difference between revisions
Generate random numbers without repeating a value (view source)
Revision as of 18:58, 19 April 2024
, 28 days agoAdded Easylang
(→{{header|JavaScript}}: Added a version in JavaScript) |
(Added Easylang) |
||
| (22 intermediate revisions by 12 users not shown) | |||
Line 22:
{{trans|Nim}}
<
[Int] result
V count = b - a + 1
Line 36:
L 5
print(generate(1, 20))</
{{out}}
Line 48:
=={{header|Action!}}==
<
BYTE i
Line 86:
PrintTable(tab,LEN)
OD
RETURN</
{{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]
Line 99:
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>
Line 105 ⟶ 154:
{{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 #
Line 129 ⟶ 178:
knuth shuffle(a);
SHOW a
)</
{{out}}
<pre>
Line 136 ⟶ 185:
=={{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'.
Line 175 ⟶ 224:
end task
task()</
{{output}}
<
=={{header|Arturo}}==
<
result: new []
Line 195 ⟶ 244:
loop 3 'x [
print generateUniqueRandoms
]</
{{out}}
Line 204 ⟶ 253:
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f GENERATE_RANDOM_NUMBERS_WITHOUT_REPEATING_A_VALUE.AWK
BEGIN {
Line 221 ⟶ 270:
exit(0)
}
</syntaxhighlight>
{{out}}
<pre>
Line 230 ⟶ 279:
==={{header|BASIC256}}===
{{trans|FreeBASIC}}
<
for num = 1 to 5
call pRand()
Line 252 ⟶ 301:
until nr = 21
print
end subroutine</
==={{header|QBasic}}===
{{trans|FreeBASIC}}
<
RANDOMIZE TIMER
Line 279 ⟶ 328:
LOOP UNTIL nr = 21
PRINT
END SUB</
=={{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#}}==
<
// 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>
Line 294 ⟶ 450:
Generating a random permutation of 1..20:
{{works with|Factor|0.99 2021-06-02}}
<
sequences ;
Line 300 ⟶ 456:
[ length dup nPk random ] keep permutation ;
20 [1,b] random-permutation .</
{{out}}
<pre>
Line 307 ⟶ 463:
Shuffling 1..20:
{{works with|Factor|0.99 2021-06-02}}
<
20 [1,b] >vector randomize .</
{{out}}
<pre>
Line 316 ⟶ 472:
Sampling 20 elements from 1..20:
{{works with|Factor|0.99 2021-06-02}}
<
20 [1,b] 20 sample .</
{{out}}
<pre>
Line 326 ⟶ 482:
=={{header|FreeBASIC}}==
<
Dim As Integer randCheck(20), nr = 1
Do
Line 347 ⟶ 503:
pRand()
Next num
Sleep</
{{out}}
<pre>
Line 361 ⟶ 517:
{{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 (
Line 398 ⟶ 554:
generate(1, 20)
}
}</
{{out}}
Line 411 ⟶ 567:
<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 (
Line 432 ⟶ 588:
fmt.Println(s[1 : len(s)-2])
}
}</
{{out}}
Line 444 ⟶ 600:
=={{header|Haskell}}==
<
import Data.Ord (comparing)
import System.Random (
--------------------- 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]
>>=
{{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
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 {
Line 473 ⟶ 665:
System.out.println(list);
}
}</
{{out}}
Line 479 ⟶ 671:
[19, 15, 10, 6, 17, 13, 14, 9, 2, 20, 3, 18, 8, 16, 7, 12, 1, 4, 5, 11]
</pre>
=={{header|JavaScript}}==
<
"use strict";
Line 537 ⟶ 728:
// MAIN ---
return JSON.stringify(main());
})();</
{{Out}}
For example:
Line 548 ⟶ 739:
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".
<syntaxhighlight lang="sh">
< /dev/urandom tr -cd '0-9' | fold -w 1 | jq -MRcnr -f program.jq
</syntaxhighlight>
'''program.jq'''
<
def prn:
if . == 1 then 0
Line 578 ⟶ 769:
# The task:
[range(1;21)] | knuthShuffle</
{{out}}
<pre>
Line 604 ⟶ 795:
=={{header|Julia}}==
Julia's Random module contains a function called `
<
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>
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
{{out}}<pre>
Line 624 ⟶ 831:
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()
Line 640 ⟶ 847:
for i in 1..5:
echo generate(1..20)</
{{out}}
Line 651 ⟶ 858:
=={{header|Perl}}==
Just shuffle...
<
use strict; # https://rosettacode.org/wiki/Generate_random_numbers_without_repeating_a_value
Line 657 ⟶ 864:
use List::Util qw( shuffle );
print "@{[ shuffle 1 .. 20 ]}\n" for 1 .. 5;</
{{out}}
<pre>
Line 670 ⟶ 877:
=={{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>
Line 679 ⟶ 886:
=={{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}}==
Line 708 ⟶ 930:
=={{header|R}}==
R makes this so easy that it feels like you've missed the point.
<syntaxhighlight lang
=={{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
Line 720 ⟶ 943:
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}}==
Line 729 ⟶ 961:
With the method/algorithm used herein, there are no random numbers being discarded (due to possible
<br>duplicates) because there cannot ''be'' 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.*/
Line 756 ⟶ 988:
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. */</
{{out|output|text= when using the default inputs:}}
<pre>
Line 766 ⟶ 998:
</pre>
=={{header|Ring}}==
<
see "working..." + nl
decimals(3)
Line 800 ⟶ 1,032:
ok
end
</syntaxhighlight>
{{out}}
<pre>
Line 811 ⟶ 1,043:
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}}==
<
5.times{ puts nums.shuffle.join(" ") }</
{{out}}
<pre>2 9 19 12 7 18 17 13 5 6 20 10 14 4 1 8 11 15 3 16
Line 823 ⟶ 1,080:
2 16 13 12 6 18 14 4 15 7 9 10 8 11 19 5 17 1 3 20
</pre>
=={{header|Rust}}==
<
// rand = "0.7.2"
Line 834 ⟶ 1,092:
v.shuffle(&mut rng);
println!("{:?}", v);
}</
{{out}}
Line 843 ⟶ 1,101:
=={{header|Sidef}}==
{{trans|Ruby}}
<
5.times{ say nums.shuffle.join(" ") }</
{{out}}
Line 856 ⟶ 1,114:
=={{header|Swift}}==
<
array.shuffle()
print(array)</
{{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>
Line 868 ⟶ 1,179:
{{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
var rand = Random.new()
Line 888 ⟶ 1,199:
// generate 5 sets say
for (i in 1..5) generate.call(1..20)</
{{out}}
Line 901 ⟶ 1,212:
<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
var rand = Random.new()
Line 909 ⟶ 1,220:
rand.shuffle(numbers)
Fmt.print("$2d", numbers)
}</
{{out}}
Line 921 ⟶ 1,232:
=={{header|XPL0}}==
<
[Set:= 0;
repeat R:= Ran(20);
Line 928 ⟶ 1,239:
IntOut(0, R+1); ChOut(0, ^ )];
until Set = $F_FFFF;
]</
{{out}}
| |||