Pick random element
Demonstrate how to pick a random element from a list.
You are encouraged to solve this task according to the task description, using any language you may know.
print(random:choice([‘foo’, ‘bar’, ‘baz’]))The easiest way to pick a random element from a list is to use a random number generator's output as an index into an array. Care must be taken not to index out of bounds. If the array's size is a power of 2, then index = RNG output & (array size - 1) will ensure that the array is not indexed out of bounds while maintaining the randomness of the selection. Otherwise, you will have to manually check the RNG output against the array's size and roll again if the RNG output is larger.
For brevity's sake, the implementations of the RNG and printing routines were left out; they can be provided if requested.
.model small
.stack 1024
.data
TestList byte 00h,05h,10h,15h,20h,25h,30h,35h
.code
start:
mov ax,@data
mov ds,ax
mov ax,@code
mov es,ax
call seedXorshift32 ;seeds the xorshift rng using the computer's date and time
call doXorshift32
mov ax,word ptr [ds:xorshift32_state_lo] ;retrieve the rng output
and al,00000111b ;constrain the rng to values 0-7
mov bx,offset TestList
XLAT ;translate AL according to [DS:BX]
call PrintHex ;display AL to the terminal
mov ax,4C00h
int 21h ;exit program and return to MS-DOS
end start
- Output:
(After four runs of the program)
05 20 15 30
:set-state-ok t
(defun pick-random-element (xs state)
(mv-let (idx state)
(random$ (len xs) state)
(mv (nth idx xs) state)))
PROC Main()
DEFINE PTR="CARD"
PTR ARRAY a(7)
BYTE i,index
a(0)="Monday"
a(1)="Tuesday"
a(2)="Wednesday"
a(3)="Thursday"
a(4)="Friday"
a(5)="Saturday"
a(6)="Sunday"
FOR i=1 TO 20
DO
index=Rand(7)
PrintE(a(index))
OD
RETURN- Output:
Screenshot from Atari 8-bit computer
Thursday Tuesday Friday Friday Saturday Tuesday Monday Saturday Sunday Wednesday Monday Friday Wednesday Saturday Friday Thursday Saturday Saturday Wednesday Wednesday
The following program generates three 20-letter words. Each vowel and each consonant is picked randomly from a list of vowels resp. a list of consonants.
with Ada.Text_IO, Ada.Numerics.Float_Random;
procedure Pick_Random_Element is
package Rnd renames Ada.Numerics.Float_Random;
Gen: Rnd.Generator; -- used globally
type Char_Arr is array (Natural range <>) of Character;
function Pick_Random(A: Char_Arr) return Character is
-- Chooses one of the characters of A (uniformly distributed)
begin
return A(A'First + Natural(Rnd.Random(Gen) * Float(A'Last)));
end Pick_Random;
Vowels : Char_Arr := ('a', 'e', 'i', 'o', 'u');
Consonants: Char_Arr := ('t', 'n', 's', 'h', 'r', 'd', 'l');
Specials : Char_Arr := (',', '.', '?', '!');
begin
Rnd.Reset(Gen);
for J in 1 .. 3 loop
for I in 1 .. 10 loop
Ada.Text_IO.Put(Pick_Random(Consonants));
Ada.Text_IO.Put(Pick_Random(Vowels));
end loop;
Ada.Text_IO.Put(Pick_Random(Specials) & " ");
end loop;
Ada.Text_IO.New_Line;
end Pick_Random_Element;
- Output:
horanohesuhodinahiru. desehonirosedisinelo, losihehederidonolahe?
list l;
l_append(l, 'a');
l_append(l, 'b');
l_append(l, 'c');
l_append(l, 'd');
l_append(l, 'e');
l_append(l, 'f');
o_byte(l[drand(5)]);
o_byte('\n');BEGIN # pick a random element from an array of strings #
OP PICKRANDOM = ( []STRING list )STRING:
BEGIN
INT number of elements = ( UPB list - LWB list ) + 1;
INT random element =
ENTIER ( next random * ( number of elements ) );
list[ LWB list + random element ]
END; # PICKRANDOM #
# can define additional operators for other types of array #
BEGIN
[]STRING days = ( "Sunday", "Monday", "Tuesday", "Wednesday"
, "Thursday", "Friday", "Saturday"
);
print( ( PICKRANDOM days, newline ) )
END
END- Output:
Thursday
pickRandom ← (?≢)⊃⊢
- Output:
pickRandom 'ABCDE'
E
pickRandom 'ABCDE'
D
pickRandom 'ABCDE'
A
App Inventor has the block pick a random item for selecting a random item from a list.
CLICK HERE TO VIEW THE BLOCKS AND ANDROID APP DISPLAY
get some item of [1, "two", pi, "4", 5 > 4, 5 + 1, Sunday]
- Output:
"two"
(import std.Random)
(print (random:choice ["foo" "bar" "baz"]))- Output:
baz
fruit: ["apple" "banana" "pineapple" "apricot" "watermelon"]
print sample fruit
- Output:
pineapple
- True Arrays
list := ["abc", "def", "gh", "ijklmnop", "hello", "world"]
Random, randint, 1, % list.MaxIndex()
MsgBox % List[randint]
- Pseudo-Arrays
list := "abc,def,gh,ijklmnop,hello,world"
StringSplit list, list, `,
Random, randint, 1, %list0%
MsgBox % List%randint%
# syntax: GAWK -f PICK_RANDOM_ELEMENT.AWK
BEGIN {
n = split("Monday,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday",day_of_week,",")
srand()
x = int(n*rand()) + 1
printf("%s\n",day_of_week[x])
exit(0)
}
- Output:
GAWK -f PICK_RANDOM_ELEMENT.AWK Sunday GAWK -f PICK_RANDOM_ELEMENT.AWK Monday GAWK -f PICK_RANDOM_ELEMENT.AWK Wednesday GAWK -f PICK_RANDOM_ELEMENT.AWK Tuesday
This is simply an application of a ranged random number used as an array index. BaCon has no built in random element selector.
' Pick random element
OPTION BASE 1
DECLARE words$[6]
FOR i = 1 TO 6 : READ words$[i] : NEXT
DATA "Alpha", "Beta", "Gamma", "Delta", "Epsilon", "Zeta"
element = RANDOM(6) + 1
PRINT "Chose ", element, ": ", words$[element]
- Output:
prompt$ ./pick-random-element Chose 2: Beta prompt$ ./pick-random-element Chose 1: Alpha prompt$ ./pick-random-element Chose 5: Epsilon
# borrowed from github.com/search?q=bashnative
rand() {
printf $(( $1 * RANDOM / 32767 ))
}
rand_element () {
local -a th=("$@")
unset th[0]
printf $'%s\n' "${th[$(($(rand "${#th[*]}")+1))]}"
}
echo "You feel like a $(rand_element pig donkey unicorn eagle) today"
Note the use of LBOUND and UBOUND. This is only necessary for arrays where the lower and upper limits aren't known. In this example, we know they are 0 and 10 respectively, and could have hard-coded those numbers. (For that matter, the "random selection" line could've just been entered as x = INT(RND * 11).)
'setup
DIM foo(10) AS LONG
DIM n AS LONG, x AS LONG
FOR n = LBOUND(foo) TO UBOUND(foo)
foo(n) = INT(RND*99999)
NEXT
RANDOMIZE TIMER
'random selection
x = INT(RND * ((UBOUND(foo) - LBOUND(foo)) + 1))
'output
PRINT x, foo(x)
See also: Liberty BASIC, PureBasic, Run BASIC
This is the same as the Commodore BASIC solution, except the Commodore timer variable TI is just a regular variable in Applesoft and gets set to a 16-bit random seed value. This is a number which is continually counted up while waiting for a keypress.
10 DIM A$(9)
20 FOR I = 0 TO 9: READ A$(I): NEXT
25 TI = PEEK(78) + PEEK(79)*256
30 X = RND ( - TI): REM 'PLANT A RANDOM SEED'
40 X = INT ( RND (1) * 10)
50 PRINT A$(X)
60 END
100 DATAALPHA, BRAVO, CHARLIE, DELTA, ECHO
110 DATAFOXTROT, GOLF, HOTEL, INDIA, JULIETT
dim a$ = {"Zero", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine"}
for i = 1 to 5
randInt = int(rand * 10)
print a$[randInt]
next iThe Commodore BASIC solution works without any changes.
10 DIM A$(9)
20 FOR I=0 TO 9 : READ A$(I) : NEXT
30 X = RND(-TI) : REM 'PLANT A RANDOM SEED'
40 X = INT(RND(1)*10)
50 PRINT A$(X)
60 END
100 DATA ALPHA, BRAVO, CHARLIE, DELTA, ECHO
110 DATA FOXTROT, GOLF, HOTEL, INDIA, JULIETT
!setup
DIM foo(10)
FOR n = LBOUND(foo) TO UBOUND(foo)
LET foo(n) = INT(RND*99999)
NEXT n
RANDOMIZE
!random selection
LET x = INT(RND*((UBOUND(foo)-LBOUND(foo))+1))
!output
PRINT x, foo(x)
END
dim a$(9)
a$(0)="Zero"
a$(1)="One"
a$(2)="Two"
a$(3)="Three"
a$(4)="Four"
a$(5)="Five"
a$(6)="Six"
a$(7)="Seven"
a$(8)="Eight"
a$(9)="Nine"
for i = 1 to 5
randInt = int(ran(10))
print a$(randInt)
next iSince there is no arrays in Batch File, I will use a 1-based pseudo-array.
@echo off
setlocal enabledelayedexpansion
::Initializing the pseudo-array...
set "pseudo=Alpha Beta Gamma Delta Epsilon"
set cnt=0 & for %%P in (!pseudo!) do (
set /a cnt+=1
set "pseudo[!cnt!]=%%P"
)
::Do the random thing...
set /a rndInt=%random% %% cnt +1
::Print the element corresponding to rndint...
echo.!pseudo[%rndInt%]!
pause
exit /b
- Sample Outputs:
Delta Press any key to continue . . . Gamma Press any key to continue . . . Epsilon Press any key to continue . . . Gamma Press any key to continue . . .
DIM list$(5)
list$() = "The", "five", "boxing", "wizards", "jump", "quickly"
chosen% = RND(6)
PRINT "Item " ; chosen% " was chosen which is '" list$(chosen%-1) "'"
- Output:
Item 4 was chosen which is 'wizards'
PR1 is a tacit translation of PR.
Both use BQN's system value •rand, which contains multiple functions for generating random values.
PR ← {𝕩⊑˜•rand.Range ≠𝕩}
PR1 ← •rand.Range∘≠⊸⊑
- Usage:
PR 5‿67‿7‿23
67
PR1 5‿67‿7‿23
7
blsq ) "ABCDEFG"123456 0 6rn-]!!
'G123456 is the random seed. In order to pick another element you have to change the random seed.
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main(){
char array[] = { 'a', 'b', 'c','d','e','f','g','h','i','j' };
int i;
time_t t;
srand((unsigned)time(&t));
for(i=0;i<30;i++){
printf("%c\n", array[rand()%10]);
}
return 0;
}
Output
a e f h b d g a b f a i b d d g j a f e a e g e i d j a f e a
using System;
using System.Collections.Generic;
class RandomElementPicker {
static void Main() {
var list = new List<int>(new[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
var rng = new Random();
var randomElement = list[rng.Next(list.Count)];
Console.WriteLine("I picked element {0}", randomElement);
}
}
#include <iostream>
#include <random>
#include <vector>
int main( ) {
std::vector<int> numbers { 11 , 88 , -5 , 13 , 4 , 121 , 77 , 2 } ;
std::random_device seed ;
// generator
std::mt19937 engine( seed( ) ) ;
// number distribution
std::uniform_int_distribution<int> choose( 0 , numbers.size( ) - 1 ) ;
std::cout << "random element picked : " << numbers[ choose( engine ) ]
<< " !\n" ;
return 0 ;
}
import ceylon.random {
DefaultRandom
}
shared void run() {
value random = DefaultRandom();
value element = random.nextElement([1, 2, 3, 4, 5, 6]);
print(element);
}
(rand-nth coll)
where coll is some sequential collection. Equivalent to:
(nth coll (rand-int (count coll)))
random_element = proc [T: type] (a: array[T]) returns (T)
return(a[array[T]$low(a) + random$next(array[T]$size(a))])
end random_element
start_up = proc ()
po: stream := stream$primary_output()
d: date := now()
random$seed(d.second + 60*(d.minute + 60*d.hour))
arr: array[string] := array[string]$["foo", "bar", "baz", "qux"]
for i: int in int$from_to(1,5) do
stream$putl(po, random_element[string](arr))
end
end start_up- Output:
qux foo qux bar foo
>>SOURCE FREE
IDENTIFICATION DIVISION.
PROGRAM-ID. random-element.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 nums-area VALUE "123456789".
03 nums PIC 9 OCCURS 9 TIMES.
01 random-idx PIC 9 COMP.
PROCEDURE DIVISION.
COMPUTE random-idx = FUNCTION RANDOM(FUNCTION CURRENT-DATE (9:7)) * 9 + 1
DISPLAY nums (random-idx)
.
END PROGRAM random-element.
array = [1,2,3]
console.log array[Math.floor(Math.random() * array.length)]
(defvar *list* '(one two three four five))
(print (nth (random (length *list*)) *list*))
(print (nth (random (length *list*)) *list*))
(print (nth (random (length *list*)) *list*))
- Output:
FIVE THREE ONE
["foo" "bar" "baz"]mR
puts [1, 2, 3, 4, 5].sample(1)
import std.stdio, std.random;
void main() {
const items = ["foo", "bar", "baz"];
items[uniform(0, $)].writeln;
}
import 'dart:math';
void main() {
final array = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'];
int i;
for (i = 1; i < 30; i++) {
var intValue = Random().nextInt(i) % 10;
print(array[intValue]);
}
}
!print choose [ "one" "two" "chicken" ]# PRN in range(0,n)
create or replace function prn(n) as trunc(random() * n)::BIGINT;
create or replace function list_random(lst) as
lst[ 1 + prn(length(lst)) ] ;
## Example:
select histogram( r )
from (select list_random( [1,2,3] ) as r from range(0,1000) _(n));
- Output:
┌───────────────────────┐
│ histogram(r) │
│ map(integer, ubigint) │
├───────────────────────┤
│ {1=322, 2=333, 3=345} │
└───────────────────────┘
ar$[] = [ "spring" "summer" "autumn" "winter" ]
print ar$[random 1 len ar$[] ]- Output:
summer
(define (pick-random list)
(list-ref list (random (length list))))
(pick-random (iota 1000)) → 667
(pick-random (iota 1000)) → 179
ELENA 6.x :
import extensions;
extension listOp
{
randomItem()
= self[Random.nextInt(self.Length)];
}
public program()
{
auto item := new int[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
Console.printLine("I picked element ",item.randomItem())
}iex(1)> list = Enum.to_list(1..20)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
iex(2)> Enum.random(list)
19
iex(3)> Enum.take_random(list,4)
[19, 20, 7, 15]
(defun random-choice (items)
(nth (random (length items)) items))
(random-choice '("a" "b" "c"))
;; => "a"
alternate version
(seq-random-elt (list 1 2 3 4))
(seq-random-elt (list "a" "b" "c" "d"))
- Output:
(seq-random-elt (list 1 2 3 4)) 3 (seq-random-elt (list "a" "b" "c" "d")) "d" ;; Note that seq-random-elt can be applied to a string, and it will ;; return the ascii value of one letter in the string: (seq-random-elt "kangaroo") 97 ;; In the above case, 97 is the ascii value of the character a.
for each int i in range(5)
writeLine(random(text["Dee", "do", "de", "de"]))
end- Output:
do de do de Dee
% Implemented by Arjun Sunel
-module(pick_random).
-export([main/0]).
main() ->
List =[1,2,3,4,5],
Index = rand:uniform(length(List)),
lists:nth(Index,List).
constant s = {'a', 'b', 'c'}
puts(1,s[rand($)])let list = ["a"; "b"; "c"; "d"; "e"]
let rand = new System.Random()
printfn "%s" list.[rand.Next(list.Length)]
( scratchpad ) { "a" "b" "c" "d" "e" "f" } random .
"a"
lst = [1, 3, 5, 8, 10]
> randomPick(lst)program pick_random
implicit none
integer :: i
integer :: a(10) = (/ (i, i = 1, 10) /)
real :: r
call random_seed
call random_number(r)
write(*,*) a(int(r*size(a)) + 1)
end program
' FB 1.05.0 Win64
Dim a(0 To 9) As String = {"Zero", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine"}
Randomize
Dim randInt As Integer
For i As Integer = 1 To 5
randInt = Int(Rnd * 10)
Print a(randInt)
Next
Sleep
Sample output :
- Output:
Zero Seven Three Nine Three
a = ["one", "two", "three"]
println[random[a]]random
mda(0) = {0,1,2,3,4,5,6,7,8,9}
print mda(rnd(10)-1)
HandleEventsYou can run this code. Copy the code, click this link, paste it in and press 'Run !'
Public Sub Main()
Dim sList As String[] = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
Print sList[Rand(0, 11)]
End
Output:
May
a := [2, 9, 4, 7, 5, 3];
Random(a);
This works with many GAP objects, for instance groups:
Random(SymmetricGroup(20));
(1,4,8,2)(3,12)(5,14,10,18,17,7,16)(9,13)(11,15,20,19)
package main
import (
"fmt"
"math/rand"
"time"
)
var list = []string{"bleen", "fuligin", "garrow", "grue", "hooloovoo"}
func main() {
rand.Seed(time.Now().UnixNano())
fmt.Println(list[rand.Intn(len(list))])
}
["foo" "bar" "baz"].,rand=
Solution:
def list = [25, 30, 1, 450, 3, 78]
def random = new Random();
(0..3).each {
def i = random.nextInt(list.size())
println "list[${i}] == ${list[i]}"
}
- Output:
list[3] == 450 list[2] == 1 list[5] == 78 list[3] == 450
Alternate Solution:
[25, 30, 1, 450, 3, 78].sort{new Random()}?.take(1)[0]
10 RANDOMIZE TIMER : REM set random number seed to something arbitrary
20 DIM ARR(10) : REM initialise array
30 FOR I = 1 TO 10
40 ARR(I) = I*I : REM squares of the integers is OK as a demo
50 NEXT I
60 C = 1 + INT(RND*10) : REM get a random index from 1 to 10 inclusive
70 PRINT ARR(C)
- Output:
81
use fmt;
use math::random;
use datetime;
export fn main() void = {
const array = ["one", "two", "three", "four", "five"];
const seed = datetime::now();
const seed = datetime::nsec(&seed);
let r = math::random::init(seed: u32);
fmt::printfln("{}", array[math::random::u32n(&r, len(array): u32)])!;
};
Creating a custom function:
import System.Random (randomRIO)
pick :: [a] -> IO a
pick xs = fmap (xs !!) $ randomRIO (0, length xs - 1)
x <- pick [1, 2, 3]
Using the random-fu library:
import Data.Random
sample $ randomElement [1, 2, 3]
For example:
do
x <- sample $ randomElement [1, 2, 3]
print x
The unary operator '?' selects a random element from its argument which may be a string, list, table, or set.
(rand-pick (range 100)) ({~ ?@#) 'abcdef'
b
import java.util.Random;
...
int[] array = {1,2,3};
return array[new Random().nextInt(array.length)]; // if done multiple times, the Random object should be re-used
For a List object rather than an array, substitute list.get(...) for array[...]. If preserving the order of the List isn't important, you could call Collections.shuffle(list); and then list.get(0);. You would need to shuffle each time unless you removed the item from the list.
var array = [1,2,3];
return array[Math.floor(Math.random() * array.length)];
DEFINE pick_random == dup size rand swap rem at.
(* initialize random number generator *)
time 89 * clock + srand
["zero" "one" "two" "three" "four" "five" "six" "seven" "eight" "nine" "ten" "eleven" "twelve"]
pick_random.Works with gojq, the Go implementation of jq
Neither jq nor gojq currently has a built-in PRNG, but it is quite straightforward to define one if an external source of entropy is available. In this entry, `/dev/urandom` is used like so:
< /dev/urandom tr -cd '0-9' | fold -w 1 | jq -MRcnr -f program.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;
# An illustration - 10 selections at random with replacement:
range(0;10) | ["a", "b", "c"] | .[length|prn]- Output:
bcbabacbbc
array = [1,2,3]
rand(array)
1?"abcdefg"
,"e"
include ..\Utilitys.tlhy
:pickran len rand * 1 + get ;
( 1 3.1415 "Hello world" ( "nest" "list" ) )
10 [drop pickran ?] for
" " input- Output:
("nest", "list")
3.1415
("nest", "list")
Hello world
1
Hello world
3.1415
("nest", "list")
1
3.1415
// version 1.2.10
import java.util.Random
/**
* Extension function on any list that will return a random element from index 0
* to the last index
*/
fun <E> List<E>.getRandomElement() = this[Random().nextInt(this.size)]
/**
* Extension function on any list that will return a list of unique random picks
* from the list. If the specified number of elements you want is larger than the
* number of elements in the list it returns null
*/
fun <E> List<E>.getRandomElements(numberOfElements: Int): List<E>? {
if (numberOfElements > this.size) {
return null
}
return this.shuffled().take(numberOfElements)
}
fun main(args: Array<String>) {
val list = listOf(1, 16, 3, 7, 17, 24, 34, 23, 11, 2)
println("The list consists of the following numbers:\n${list}")
// notice we can call our extension functions as if they were regular member functions of List
println("\nA randomly selected element from the list is ${list.getRandomElement()}")
println("\nA random sequence of 5 elements from the list is ${list.getRandomElements(5)}")
}
Sample output:
- Output:
The list consists of the following numbers: [1, 16, 3, 7, 17, 24, 34, 23, 11, 2] A randomly selected element from the list is 11 A random sequence of 5 elements from the list is [17, 24, 23, 16, 3]
This image is a VI Snippet, an executable image of LabVIEW code. The LabVIEW version is shown on the top-right hand corner. You can download it, then drag-and-drop it onto the LabVIEW block diagram from a file browser, and it will appear as runnable, editable code.
local(
my array = array('one', 'two', 3)
)
#myarray -> get(integer_random(#myarray -> size, 1))
-> two
The natural way to hold an array of text is in a space- or comma-delimited string, although an array could be used.
list$ ="John Paul George Ringo Peter Paul Mary Obama Putin"
wantedTerm =int( 10 *rnd( 1))
print "Selecting term "; wantedTerm; " in the list, which was "; word$( list$, wantedTerm, " ")Selecting term 5 in the list, which was Peter
put "Apple,Banana,Peach,Apricot,Pear" into fruits
put item (random(the number of items of fruits)) of fruitspick [1 2 3]math.randomseed(os.time())
local a = {1,2,3}
print(a[math.random(1,#a)])
a := [bear, giraffe, dog, rabbit, koala, lion, fox, deer, pony]:
randomNum := rand(1 ..numelems(a)):
a[randomNum()];
RandomChoice[{a, b, c}]
- Output:
c
In case list is a cell array:
list = {'a','b','c'};
list{ceil(rand(1)*length(list))}
If list is a vector:
list = 1:1000;
list(ceil(rand(1)*length(list)))
random_element(l):= part(l, 1+random(length(l)));
/* (%i1) random_element(['a, 'b, 'c]);
(%o1) c
*/
0 П0 1 П1 2 П2 3 П3 4 П4 5
^ СЧ * [x] ПE КИПE С/П
import Nanoquery.Util
list = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}
println list[new(Random).getInt(len(list))]- Output:
12
;; from list containnig only literals and literal constants
user-message one-of [ 1 3 "rooster" blue ]
;; from list containing variables and reporters
user-message one-of (list (red + 2) turtles (patch 0 0) )/* NetRexx */
options replace format comments java crossref savelog symbols nobinary
iArray = [ 1, 2, 3, 4, 5 ] -- a traditional array
iList = Arrays.asList(iArray) -- a Java Collection "List" object
iWords = '1 2 3 4 5' -- a list as a string of space delimited words
v1 = iArray[Random().nextInt(iArray.length)]
v2 = iList.get(Random().nextInt(iList.size()))
v3 = iWords.word(Random().nextInt(iWords.words()) + 1) -- the index for word() starts at one
say v1 v2 v3
(define (pick-random-element R)
(nth (rand (length R)) R))
Example:
(setq X '("alpha" "beta" "gamma" "delta" "epsilon"))
(println (pick-random-element X))
(println (pick-random-element X))
(println (pick-random-element X))
(println (pick-random-element X))
import random
randomize()
let ls = @["foo", "bar", "baz"]
echo sample(ls)
[5 6 7 8 9] | get (random int ..<($in | length))values := [1, 2, 3];
value := values[(Float->Random() * 100.0)->As(Int) % values->Size()];With a list:
let list_rand lst =
let len = List.length lst in
List.nth lst (Random.int len)
# list_rand [1;2;3;4;5] ;; - : int = 3
With an array:
let array_rand ary =
let len = Array.length ary in
ary.(Random.int len)
# array_rand [|1;2;3;4;5|] ;; - : int = 3
package main
import "core:fmt"
import "core:math/rand"
main :: proc() {
list := []string{"foo", "bar", "baz"}
rand_index := rand.int_max(len(list))
fmt.println(list[rand_index])
}
: pickRand(l) l size rand l at ;(import (otus random!))
(define x '("Monday" "Tuesday" "Wednesday" "Thursday" "Friday" "Saturday" "Sunday"))
(print (list-ref x (rand! (length x))))
pick(v)=v[random(#v)+1]Pascal / Delphi / Free Pascal
Program PickRandomElement (output);
const
s: array [1..5] of string = ('1234', 'ABCDE', 'Charlie', 'XB56ds', 'lala');
begin
randomize;
writeln(s[low(s) + random(length(s))]);
end.
begin
var a := Arr('cat','dog','wolf','zebra');
a.RandomElement.Print
end.
my @array = qw(a b c);
print $array[ rand @array ];
You can randomly pick an integer, float, string, [nested] subsequence, or anything else, just as easily from a mixed list as from a single-type list.
with javascript_semantics constant s = {1,2.5,"three",{4,{"4 as well"}}} pp(s[rand(length(s))])
$arr = array('foo', 'bar', 'baz');
$x = $arr[array_rand($arr)];
go =>
% single element
println(choice=choice(10)), % single element
% From a list of numbers
L = 1..10,
println([choice(L) : _ in 1..10]),
% From a string
S = "pickrandomelement",
println([choice(S) : _ in 1..10]),
nl.
% Pick a random number from 1..N
choice(N) = random(1,N), integer(N) => true.
% Pick a random element from a list L.
choice(List) = List[choice(List.length)], list(List) => true.- Output:
choice = 4 [7,8,6,4,6,7,3,10,2,3] ekcealmnei
This is a more structured output.
go2 =>
_ = random2(),
Vowels = "aeiou",
Consonants = "tnshrdl",
Specials = ",.?!",
RandWords = [( [[Consonants.choice()] ++ [Vowels.choice()] : _ in 1..10]
++ [Specials.choice()]
).flatten()
: _ in 1..3] ,
println(RandWords),
nl.- Output:
[dodidosisahuhiretesi,,loledohusoluhusululu?,tunuridunoheditonudu!]
Get the random elements from a frequency table (converted to a "Roulette wheel").
% Pick according to a frequency table
go3 =>
_ = random2(),
Max = 17,
S = letter_freq_wheel(),
foreach(_ in 1..10)
println([choice(S) : _ in 1..1+choice(Max)])
end,
nl.
% Frequencies of letters converted to a "roulette wheel".
letter_freq_wheel = Chars =>
Freq =
[ [e,12.02],[t,9.10],[a,8.12],[o,7.68],[i,7.31],[n,6.95],[s,6.28],
[r,6.02],[h,5.92],[d,4.32],[l,3.98],[u,2.88],[c,2.71],[m,2.61],
[f,2.30],[y,2.11],[w,2.09],[g,2.03],[p,1.82],[b,1.49],[v,1.11],
[k,0.69],[x,0.17],[q,0.11],[j,0.10],[z,0.07]
],
Chars = [],
foreach([C,F] in Freq)
Chars := Chars ++ [C : _ in 1..ceiling(10*F)]
end,
nl.- Output:
ihvuotpswieecanrv gnelhlutnopytoss aentkttnenb cnyawephc nsioetohasedd yapaeofyt setmtoorwloiar nsssrkcfgnpadtifln rrlwree nawmtnie
(get Lst (rand 1 (length Lst))) declare t(0:9) character (1) static initial
('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j');
put ( t(10*random()) );- Output:
e
local ordinals = {"first", "second", "third", "fourth", "fifth", "sixth"}
for _ = 1, 6 do
print(ordinals[math.random(1, #ordinals)])
end
- Output:
Sample run:
sixth fifth first fourth second sixth
Powershell has Get-Random Cmdlet which one of its overload is to select randomly from a given list
1..100 | Get-Random -Count 3
?- random_member(M, [a, b, c, d, e, f, g, h, i, j]).
M = i.
Procedure.s pickRandomElement(List source.s())
Protected x = ListSize(source())
If x > 0
SelectElement(source(), Random(x - 1)) ;element numbering is zero - based
ProcedureReturn source()
EndIf
EndProcedure
;initialize list elements
DataSection
elements:
Data.s "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten"
EndDataSection
#elementCount = 10
NewList item.s()
Restore elements
Define i
For i = 1 To #elementCount
AddElement(item())
Read.s item()
Next
If OpenConsole()
Print("Source list: ")
ForEach item()
Print(item() + " ")
Next
PrintN(#CRLF$)
Print("Random picks from list: ")
For i = 1 To 10
Print(pickRandomElement(item()) + " ")
Next
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()
CloseConsole()
EndIf
- Output:
Source list: One Two Three Four Five Six Seven Eight Nine Ten Random picks from list: Seven Nine Two Six Four Four Nine Three Six Two
Easy version
OpenConsole()
a$="One" +#TAB$+ "Two" +#TAB$+ "Three" +#TAB$+ "Four" +#TAB$+ "Five" +#TAB$+
"Six" +#TAB$+ "Seven"+#TAB$+ "Eight" +#TAB$+ "Nine" +#TAB$+ "Ten" +#TAB$
Print("Source list: "+#TAB$+a$+#CRLF$+"Random list: "+#TAB$)
For i=1 To CountString(a$,#TAB$)
Print(StringField(a$,Random(CountString(a$,#TAB$),1),#TAB$)+#TAB$)
Next
Input()
- Output:
Source list: One Two Three Four Five Six Seven Eight Nine Ten Random list: One Two Seven Nine Ten Seven Three Five Ten Nine
>>> import random
>>> random.choice(['foo', 'bar', 'baz'])
'baz'
[ dup size random peek ] is pick ( [ --> x )
randomise
' [ 20 33 -15 7 0 ] pick echo cr
' pick pick echo- Output:
33 random
# a vector (letters are builtin)
letters
# [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s"
# [20] "t" "u" "v" "w" "x" "y" "z"
# picking one element
sample(letters, 1)
# [1] "n"
# picking some elements with repetition, and concatenating to get a word
paste(sample(letters, 10, rep=T), collapse="")
# [1] "episxgcgmt"
#lang racket
(define (pick-item l)
(list-ref l (random (length l))))
(formerly Perl 6)
In a nutshell, picking an element from a list is implemented with a method conveniently called "pick":
say (1, 2, 3).pick;
There are various ways of doing something similar, though. Raku has actually two methods (with associated functional forms) to return random elements depending on whether you are doing selection with or without replacement.
Selection with replacement: (roll of a die)
say (1..6).roll; # return 1 random value in the range 1 through 6
say (1..6).roll(3); # return a list of 3 random values in the range 1 through 6
say (1..6).roll(*)[^100]; # return first 100 values from a lazy infinite list of random values in the range 1 through 6
Selection without replacement: (pick a card from a deck)
# define the deck
my @deck = <2 3 4 5 6 7 8 9 J Q K A> X~ <♠ ♣ ♥ ♦>;
say @deck.pick; # Pick a card
say @deck.pick(5); # Draw 5
say @deck.pick(*); # Get a shuffled deck
Or you can always use the normal rand built-in to generate a subscript (which automatically truncates any fractional part):
@array[@array * rand]
However, the pick and roll methods (not to be confused with the pick-and-roll method in basketball) are more general insofar as they may be used on any enumerable type:
say Bool.pick; # returns either True or False
Rebol [
title: "Rosetta code: Pick random element"
file: %Pick_random_element.r3
url: https://rosettacode.org/wiki/Pick_random_element
]
elements: [
"Hydrogen_H" "Helium_He" "Lithium_Li" "Beryllium_Be"
"Boron_B" "Carbon_C" "Nitrogen_N" "Oxygen_O"
"Fluorine_F" "Neon_Ne" "Sodium_Na" "Magnesium_Mg"
"Aluminium_Al" "Silicon_Si" "Phosphorus_P" "Sulfur_S"
"Chlorine_Cl" "Argon_Ar" "Potassium_K" "Calcium_Ca"
"Scandium_Sc" "Titanium_Ti" "Vanadium_V" "Chromium_Cr"
"Manganese_Mn" "Iron_Fe" "Cobalt_Co" "Nickel_Ni"
"Copper_Cu" "Zinc_Zn" "Gallium_Ga" "Germanium_Ge"
"Arsenic_As" "Selenium_Se" "Bromine_Br" "Krypton_Kr"
"Rubidium_Rb" "Strontium_Sr" "Yttrium_Y" "Zirconium_Zr"
"Niobium_Nb" "Molybdenum_Mo" "Technetium_Tc" "Ruthenium_Ru"
"Rhodium_Rh" "Palladium_Pd" "Silver_Ag" "Cadmium_Cd"
"Indium_In" "Tin_Sn" "Antimony_Sb" "Tellurium_Te"
"Iodine_I" "Xenon_Xe" "Caesium_Cs" "Barium_Ba"
"Lanthanum_La" "Cerium_Ce" "Praseodymium_Pr" "Neodymium_Nd"
"Promethium_Pm" "Samarium_Sm" "Europium_Eu" "Gadolinium_Gd"
"Terbium_Tb" "Dysprosium_Dy" "Holmium_Ho" "Erbium_Er"
"Thulium_Tm" "Ytterbium_Yb" "Lutetium_Lu" "Hafnium_Hf"
"Tantalum_Ta" "Tungsten_W" "Rhenium_Re" "Osmium_Os"
"Iridium_Ir" "Platinum_Pt" "Gold_Au" "Mercury_Hg"
"Thallium_Tl" "Lead_Pb" "Bismuth_Bi" "Polonium_Po"
"Astatine_At" "Radon_Rn" "Francium_Fr" "Radium_Ra"
"Actinium_Ac" "Thorium_Th" "Protactinium_Pa" "Uranium_U"
"Neptunium_Np" "Plutonium_Pu" "Americium_Am" "Curium_Cm"
"Berkelium_Bk" "Californium_Cf" "Einsteinium_Es" "Fermium_Fm"
"Mendelevium_Md" "Nobelium_No" "Lawrencium_Lr" "Rutherfordium_Rf"
"Dubnium_Db" "Seaborgium_Sg" "Bohrium_Bh" "Hassium_Hs"
"Meitnerium_Mt" "Darmstadtium_Ds" "Roentgenium_Rg" "Copernicium_Cn"
"Nihonium_Nh" "Flerovium_Fl" "Moscovium_Mc" "Livermorium_Lv"
"Tennessine_Ts" "Oganesson_Og" "Ununbium_Uub" "Ununtrium_Uut"
"Ununquadium_Uuq"
]
either all [
block? args: system/script/args
not empty? args
][
label: "Specified"
try/with [
entry: pick elements args: to integer! first args
][
print ["Invalid script argument:" as-red args]
print ["Script expects number from 1 to" length? elements]
quit
]
unless entry [
print ["Element" as-red args "hasn't been discovered yet"]
quit
]
][
label: "Random"
entry: random/only elements
]
set [name symbol] split entry #"_"
print [label "element:" as-green name "-" as-yellow symbol]
- Output:
c:\Rebol-RosettaCode\tasks>rebol3 Pick_random_element.r3 foo Invalid script argument: foo Script expects number from 1 to 121 c:\Rebol-RosettaCode\tasks>rebol3 Pick_random_element.r3 123 Element 123 hasn't been discovered yet c:\Rebol-RosettaCode\tasks>rebol3 Pick_random_element.r3 32 Specified element: Germanium - Ge c:\Rebol-RosettaCode\tasks>rebol3 Pick_random_element.r3 Random element: Seaborgium - Sg
>> random/only collect [repeat i 10 [keep i]]
let fruits = ["apple", "banana", "coconut", "orange", "lychee"]
let pickRand = arr => {
let len = Js.Array.length(arr)
let i = Js.Math.random_int(0, len)
arr[i]
}
Js.log(pickRand(fruits))- Output:
$ bsc pickrand.res > pickrand.bs.js $ node pickrand.bs.js lychee
version 1
This REXX example takes the Rosetta Code task very literally.
Also, the newly named elements have been incorporated into this table.
/*REXX program picks a random element from a list (tongue in cheek, a visual pun).*/
l= "Hydrogen_H Helium_He Lithium_Li Beryllium_Be Boron_B"
l=l "Carbon_C Nitrogen_N Oxygen_O Fluorine_F Neon_Ne Sodium_Na"
l=l "Magnesium_Mg Aluminium_Al Silicon_Si Phosphorus_P Sulfur_S"
l=l "Chlorine_Cl Argon_Ar Potassium_K Calcium_Ca Scandium_Sc"
l=l "Titanium_Ti Vanadium_V Chromium_Cr Manganese_Mn Iron_Fe"
l=l "Cobalt_Co Nickel_Ni Copper_Cu Zinc_Zn Gallium_Ga"
l=l "Germanium_Ge Arsenic_As Selenium_Se Bromine_Br Krypton_Kr"
l=l "Rubidium_Rb Strontium_Sr Yttrium_Y Zirconium_Zr Niobium_Nb"
l=l "Molybdenum_Mo Technetium_Tc Ruthenium_Ru Rhodium_Rh"
l=l "Palladium_Pd Silver_Ag Cadmium_Cd Indium_In Tin_Sn"
l=l "Antimony_Sb Tellurium_Te Iodine_I Xenon_Xe Caesium_Cs"
l=l "Barium_Ba Lanthanum_La Cerium_Ce Praseodymium_Pr"
l=l "Neodymium_Nd Promethium_Pm Samarium_Sm Europium_Eu"
l=l "Gadolinium_Gd Terbium_Tb Dysprosium_Dy Holmium_Ho Erbium_Er"
l=l "Thulium_Tm Ytterbium_Yb Lutetium_Lu Hafnium_Hf Tantalum_Ta"
l=l "Tungsten_W Rhenium_Re Osmium_Os Iridium_Ir Platinum_Pt"
l=l "Gold_Au Mercury_Hg Thallium_Tl Lead_Pb Bismuth_Bi"
l=l "Polonium_Po Astatine_At Radon_Rn Francium_Fr Radium_Ra"
l=l "Actinium_Ac Thorium_Th Protactinium_Pa Uranium_U"
l=l "Neptunium_Np Plutonium_Pu Americium_Am Curium_Cm"
l=l "Berkelium_Bk Californium_Cf Einsteinium_Es Fermium_Fm"
l=l "Mendelevium_Md Nobelium_No Lawrencium_Lr Rutherfordium_Rf"
l=l "Dubnium_Db Seaborgium_Sg Bohrium_Bh Hassium_Hs Meitnerium_Mt"
l=l "Darmstadtium_Ds Roentgenium_Rg Copernicium_Cn Nihonium_Nh"
l=l "Flerovium_Fl Moscovium_Mc Livermorium_Lv Tennessine_Ts"
l=l "Oganesson_Og Ununbium_Uub Ununtrium_Uut Ununquadium_Uuq"
n=words(l) /* Number of known elements */
/*----- You can't trust atoms, -----*/
/*----- they make everything up. -----*/
Parse Arg pick /* atomic number specified */
If pick>n Then Do
Say 'Element' pick 'hasn''t been discovered by now'
Exit
End
take=pick
If pick='' Then
take=random(1,n)
item=word(l,take) /*pick the specified or random element */
Parse Var item name '_' symbol
If pick='' Then
which='Random'
Else
which='Specified'
Say which 'element: ' take name '('symbol')' /*stick a fork in it, we're all done. */
- output:
E:\>rexx pez Random element: 100 Fermium (Fm) E:\>rexx pez 8 Specified element: 8 Oxygen (O) E:\>rexx pez 133 Element 133 hasn't been discovered by now
version 2
Slightly simplified:
Note that this version doesn't work (receives a syntax error 12) with REXXes that have a
smaller limit of the total length of a clause, in particular PC/REXX and Personal REXX
which have a limit of 1,000 characters).
/* REXX ***************************************************************
* 18.10.2012 Walter Pachl Not only the list of elements shortened:-)
**********************************************************************/
wl='hydrogen helium lithium beryllium boron carbon nitrogen oxygen',
'fluorine neon sodium magnesium aluminum silicon phosphorous sulfur',
'...',
'meitnerium darmstadtium roentgenium copernicium Ununtrium'
Say word(wl,random(1,words(wl)))
aList = "abcdefghij"
for i = 1 to 10
letter = random(9) + 1
if letter > 0
see aList[letter] + nl
ok
next≪ DUP SIZE RAND * CEIL GET ≫ ‘RANDGET’ STO
{ Alpha Beta Gamma Delta } RANDGET
{ Alpha Beta Gamma Delta } RANDGET
{ Alpha Beta Gamma Delta } RANDGET
- Output:
3: ‘Delta’ 2: ‘Alpha’ 1: ‘Beta’
%w(north east south west).sample # => "west"
(1..100).to_a.sample(2) # => [17, 79]
list$ = "a,b,c,d,e,f,g,h,i,j"
letter = rnd(1) * 10
print "Selected letter:"; word$(list$,letter,",")extern crate rand;
use rand::Rng;
fn main() {
let array = [5,1,2,5,6,7,8,1,2,4,5];
let mut rng = rand::thread_rng();
println!("{}", rng.choose(&array).unwrap());
}
val a = (1 to 10).toList
println(scala.util.Random.shuffle(a).head)
; for Chicken Scheme
(import (chicken random))
(define (pick_random x)
(list-ref x (pseudo-random-integer (length x)))
)$ include "seed7_05.s7i";
const proc: main is func
begin
writeln(rand([] ("foo", "bar", "baz")));
end func;var arr = %w(north east south west);
say arr.rand;
say arr.rand(2).dump;- Output:
south ['west', 'south']
x := #(1 2 3) atRandom.[1, 2, 3].chooseimport Darwin
let myList = [1, 2, 4, 5, 62, 234, 1, -1]
print(myList[Int(arc4random_uniform(UInt32(myList.count)))])Random selection from a list is implemented by composing lindex
(for selection of an item from a list) and the pattern for generating an integral random number from the range .
It's simpler to use when wrapped up as a helper procedure:
proc randelem {list} {
lindex $list [expr {int(rand()*[llength $list])}]
}
set x [randelem {1 2 3 4 5}]The use of the upvar command allows using lists in place, instead of copying the list. The expr expression solver has access to math commands such as srand() and rand(). The clock command has access to the system clock, useful for timing and seeding the rng. A search of the results can avoid duplicate random selections.
# seed rng
set seed [expr { srand([clock clicks]) }]
# return a list of random selections of items from a list
proc random_items { item_list {n 1} {dups no} } {
# use item_list in place as items
upvar 1 $item_list items
set result {}
set max [llength $items]
if { $n > $max} {set n $max}
set count 0
while { $count < $n } {
# random integer index 0..len-1
set idx [expr { int(rand() * $max)} ]
# pick item
set item [lindex $items $idx]
# check for dups
if {$dups eq no} {
set srch [lsearch $result $item]
if {$srch > -1} { continue }
}
lappend result $item
incr count
}
return $result
}
# randomize a list in place
proc randomize {item_list} {
upvar 1 $item_list items
set len [llength $items]
set items [random_items items $len]
}
# return a new shuffled list
proc shuffle {items} {
set len [llength $items]
return [random_items items $len]
}
# test cases
set animals {
dog cat bird ant fish
horse pig cow snake mouse
whale worm bug spider deer
bee bear human gecko octopus
}
# 1 item default
set guess [random_items animals]
puts stdout "guess: $guess \n"
# in place shuffle
randomize animals
# list of 4 random items, no dups
set A [random_items animals 4]
set B [random_items animals 5]
set C [random_items animals 6]
set dashline [string repeat "-" 30]
foreach a {$A $B $C} {
puts stdout $dashline
puts stdout "${a}"
}
puts stdout $dashline- Output:
guess: mouse ----------------------------- spider deer dog octopus ----------------------------- whale bird deer bug cat ----------------------------- bug bee fish deer horse human -----------------------------
$$ MODE TUSCRIPT
list="John'Paul'George'Ringo'Peter'Paul'Mary'Obama'Putin"
sizeList=SIZE(list)
selectedNr=RANDOM_NUMBERS (1,sizeList,1)
selectedItem=SELECT(list,#selectednr)
PRINT "Selecting term ",selectedNr," in the list, which was ",selectedItem- Output:
Selecting term 3 in the list, which was George
@(do (defun randelem (seq)
[seq (random nil (length seq))]))
@(bind x @(randelem #("a" "b" "c" "d")))list=(these are some words)
printf '%s\n' "${list[RANDOM%${#list[@]}]}"list=(these are some words)
printf '%s\n' "$list[RANDOM%$#list+1]"
⊡⌊×⚂⧻."abcdefg"# generate a stream (ursa equivalent of a list)
decl string<> str
append "these" "are" "some" "values" str
decl ursa.util.random r
out str<(r.getint (size str))> endl consoleOption Explicit
Sub Main_Pick_Random_Element()
Debug.Print Pick_Random_Element(Array(1, 2, 3, 4, 5, #11/24/2017#, "azerty"))
End Sub
Function Pick_Random_Element(myArray)
Randomize Timer
Pick_Random_Element = myArray(Int((Rnd * (UBound(myArray) - LBound(myArray) + 1) + LBound(myArray))))
End FunctionFunction pick_random(arr)
Set objRandom = CreateObject("System.Random")
pick_random = arr(objRandom.Next_2(0,UBound(arr)+1))
End Function
WScript.Echo pick_random(Array("a","b","c","d","e","f"))- Output:
d
Module Program
Sub Main()
Dim list As New List(Of Integer)({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
Dim rng As New Random()
Dim randomElement = list(rng.Next(list.Count)) ' Upper bound is exclusive.
Console.WriteLine("I picked element {0}", randomElement)
End Sub
End Moduleimport rand
fn main() {
list := ["friends", "peace", "people", "happiness", "hello", "world"]
for index in 1..list.len + 1 {
println(index.str() + ": " + list[rand.intn(list.len)!])
}
}- Output:
Sample of random output:
1: peace 2: happiness 3: hello 4: friends 5: peace 6: people
import "random" for Random
var rand = Random.new()
var colors = ["red", "green", "blue", "yellow", "pink"]
for (i in 0..4) System.print(colors[rand.int(colors.count)])- Output:
Sample run:
blue red pink yellow red
set Array = ["Hello","World",1,2,3];
log(Array[rnd(0,?Array-1)]);code Ran=1, Text=12;
int List;
[List:= ["hydrogen", "helium", "lithium", "beryllium", "boron"]; \(Thanks REXX)
Text(0, List(Ran(5)));
]!ys-0
defn main(items='apple banana cherry date elderberry fig grape'):
fruits =: items:words
say: fruits:rand-nth- Output:
$ ys pick-random-element.ys grape
import "std/random.zc"
fn main() {
let rng = Random::new();
let planets = ["Earth", "Venus", "Mercury", "Mars", "Jupiter"];
// Permits repeats.
for _ in 0..5 {
let r = rng.next_int_range(0, 4);
println "{planets[r]}";
}
}- Output:
Sample output:
Mercury Jupiter Mercury Mars Venus
This example uses the PCG algorithm.
const std = @import("std");
const debug = std.debug;
const rand = std.Random;
const time = std.time;
pub fn main() void {
var pcg = rand.Pcg.init(@intCast(time.milliTimestamp()));
const chars = [_]u8{
'A', 'B', 'C', 'D',
'E', 'F', 'G', 'H',
'I', 'J', 'K', 'L',
'M', 'N', 'O', 'P',
'Q', 'R', 'S', 'T',
'U', 'V', 'W', 'X',
'Y', 'Z', '?', '!',
'<', '>', '(', ')',
};
for(0..32) |i| {
if (i % 4 == 0) {
debug.print("\n ", .{});
}
debug.print("'{c}', ", .{chars[pcg.random().uintLessThan(usize, chars.len)]});
}
debug.print("\n", .{});
}- Output:
'N', 'Q', 'H', '?',
'D', '>', 'Q', 'G',
'U', 'H', 'W', 'U',
'N', '(', 'E', 'K',
'Y', 'V', 'W', 'S',
'U', 'V', 'H', '<',
'Z', 'O', 'C', 'D',
'Y', 'J', '?', 'L',
list:=T("hydrogen", "helium", "lithium", "beryllium", "boron");
list[(0).random(list.len())]