Pick random element: Difference between revisions
m
→{{header|EasyLang}}
Drkameleon (talk | contribs) (Added Arturo implementation) |
|||
(38 intermediate revisions by 29 users not shown) | |||
Line 6:
{{trans|Python}}
<
=={{header|8086 Assembly}}==
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 <code>index = RNG output & (array size - 1)</code> 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.
<syntaxhighlight lang="asm"> .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</syntaxhighlight>
{{out}} (After four runs of the program)
<pre>
05
20
15
30
</pre>
=={{header|ACL2}}==
<
(defun pick-random-element (xs state)
(mv-let (idx state)
(random$ (len xs) state)
(mv (nth idx xs) state)))</
=={{header|Action!}}==
<syntaxhighlight lang="action!">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</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Pick_random_element.png Screenshot from Atari 8-bit computer]
<pre>
Thursday
Tuesday
Friday
Friday
Saturday
Tuesday
Monday
Saturday
Sunday
Wednesday
Monday
Friday
Wednesday
Saturday
Friday
Thursday
Saturday
Saturday
Wednesday
Wednesday
</pre>
=={{header|Ada}}==
Line 23 ⟶ 112:
resp. a list of consonants.
<
procedure Pick_Random_Element is
Line 52 ⟶ 141:
end loop;
Ada.Text_IO.New_Line;
end Pick_Random_Element;</
{{out}}
Line 58 ⟶ 147:
=={{header|Aime}}==
<
l_append(l, 'a');
Line 68 ⟶ 157:
o_byte(l[drand(5)]);
o_byte('\n');</
=={{header|ALGOL 68}}==
{{works with|ALGOL 68G|Any - tested with release 2.8.win32}}
<
OP PICKRANDOM = ( []STRING list )STRING:
Line 94 ⟶ 183:
print( ( PICKRANDOM days, newline ) )
)</
{{out}}
<pre>
Thursday
</pre>
=={{header|APL}}==
{{works with|Dyalog APL}}
<syntaxhighlight lang="apl">pickRandom ← (?≢)⊃⊢</syntaxhighlight>
{{out}}
<pre> pickRandom 'ABCDE'
E
pickRandom 'ABCDE'
D
pickRandom 'ABCDE'
A</pre>
=={{header|App Inventor}}==
Line 105 ⟶ 205:
=={{header|AppleScript}}==
<
{{out}}
<pre>"two"</pre>
Line 111 ⟶ 211:
=={{header|Arturo}}==
<
print sample fruit</
{{out}}
Line 122 ⟶ 222:
; True Arrays
{{works with|AutoHotkey_L}}
<
Random, randint, 1, % list.MaxIndex()
MsgBox % List[randint]</
; Pseudo-Arrays
{{works with|AutoHotkey_Basic}}
<
StringSplit list, list, `,
Random, randint, 1, %list0%
MsgBox % List%randint%</
=={{header|AWK}}==
<
BEGIN {
n = split("Monday,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday",day_of_week,",")
Line 140 ⟶ 240:
printf("%s\n",day_of_week[x])
exit(0)
}</
{{out}}
<pre>GAWK -f PICK_RANDOM_ELEMENT.AWK
Line 154 ⟶ 254:
This is simply an application of a ranged random number used as an array index. '''BaCon''' has no built in random element selector.
<
OPTION BASE 1
DECLARE words$[6]
Line 161 ⟶ 261:
element = RANDOM(6) + 1
PRINT "Chose ", element, ": ", words$[element]</
{{out}}
Line 172 ⟶ 272:
=={{header|Bash}}==
<
rand() {
Line 183 ⟶ 283:
}
echo "You feel like a $(rand_element pig donkey unicorn eagle) today"</
=={{header|BASIC}}==
Line 191 ⟶ 291:
Note the use of <code>LBOUND</code> and <code>UBOUND</code>. 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 <code>x = INT(RND * 11)</code>.)
<
DIM foo(10) AS LONG
DIM n AS LONG, x AS LONG
Line 203 ⟶ 303:
'output
PRINT x, foo(x)</
See also: [[#Liberty BASIC|Liberty BASIC]], [[#PureBasic|PureBasic]], [[#Run BASIC|Run BASIC]]
==={{header|Applesoft BASIC}}===
This is the same as the [[#Commodore_BASIC|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.
<syntaxhighlight lang="qbasic"> 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
</syntaxhighlight>
==={{header|BASIC256}}===
<syntaxhighlight lang="basic256">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 i</syntaxhighlight>
==={{header|Chipmunk Basic}}===
{{works with|Chipmunk Basic|3.6.4}}
The [[#Commodore BASIC|Commodore BASIC]] solution works without any changes.
==={{header|Commodore BASIC}}===
<
20 FOR I=0 TO 9 : READ A$(I) : NEXT
30 X = RND(-TI) : REM 'PLANT A RANDOM SEED'
Line 215 ⟶ 339:
60 END
100 DATA ALPHA, BRAVO, CHARLIE, DELTA, ECHO
110 DATA FOXTROT, GOLF, HOTEL, INDIA, JULIETT</
==={{header|True BASIC}}===
{{trans|QBasic}}
<syntaxhighlight lang="qbasic">!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</syntaxhighlight>
==={{header|Yabasic}}===
<syntaxhighlight lang="yabasic">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 i</syntaxhighlight>
=={{header|Batch File}}==
Since there is no arrays in Batch File, I will use a 1-based pseudo-array.
<
setlocal enabledelayedexpansion
Line 234 ⟶ 393:
echo.!pseudo[%rndInt%]!
pause
exit /b</
{{Out|Sample Outputs}}
<pre>Delta
Line 249 ⟶ 408:
=={{header|BBC BASIC}}==
<
list$() = "The", "five", "boxing", "wizards", "jump", "quickly"
chosen% = RND(6)
PRINT "Item " ; chosen% " was chosen which is '" list$(chosen%-1) "'"</
{{out}}
<pre>
Item 4 was chosen which is 'wizards'
</pre>
=={{header|BQN}}==
<code>PR1</code> is a tacit translation of <code>PR</code>.
Both use BQN's system value <code>•rand</code>, which contains multiple functions for generating random values.
<syntaxhighlight lang="bqn">PR ← {𝕩⊑˜•rand.Range ≠𝕩}
PR1 ← •rand.Range∘≠⊸⊑</syntaxhighlight>
{{Out|Usage}}
<syntaxhighlight lang="bqn"> PR 5‿67‿7‿23
67
PR1 5‿67‿7‿23
7</syntaxhighlight>
=={{header|Burlesque}}==
<
blsq ) "ABCDEFG"123456 0 6rn-]!!
'G
</syntaxhighlight>
''123456'' is the random seed. In order to pick another element you have to change the random seed.
Line 269 ⟶ 441:
=={{header|C}}==
<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdlib.h>
Line 286 ⟶ 458:
return 0;
}
</syntaxhighlight>
Output
<pre>
Line 323 ⟶ 495:
=={{header|C sharp}}==
<
using System.Collections.Generic;
Line 333 ⟶ 505:
Console.WriteLine("I picked element {0}", randomElement);
}
}</
=={{header|C++}}==
<
#include <random>
#include <vector>
Line 350 ⟶ 522:
<< " !\n" ;
return 0 ;
}</
=={{header|Ceylon}}==
<
DefaultRandom
Line 362 ⟶ 534:
value element = random.nextElement([1, 2, 3, 4, 5, 6]);
print(element);
}</
=={{header|Clojure}}==
<syntaxhighlight lang
where <code>coll</code> is some sequential collection. Equivalent to:
<
=={{header|CLU}}==
<syntaxhighlight lang="clu">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</syntaxhighlight>
{{out}}
<pre>qux
foo
qux
bar
foo</pre>
=={{header|COBOL}}==
{{works with|GNU Cobol}}
<
IDENTIFICATION DIVISION.
PROGRAM-ID. random-element.
Line 388 ⟶ 583:
DISPLAY nums (random-idx)
.
END PROGRAM random-element.</
=={{header|CoffeeScript}}==
<
console.log array[Math.floor(Math.random() * array.length)]</
=={{header|Common Lisp}}==
<
(print (nth (random (length *list*)) *list*))
(print (nth (random (length *list*)) *list*))
(print (nth (random (length *list*)) *list*))</
{{out}}
Line 407 ⟶ 602:
=={{header|Crystal}}==
<syntaxhighlight lang="ruby">
puts [1, 2, 3, 4, 5].sample(1)
</syntaxhighlight>
=={{header|D}}==
<
void main() {
const items = ["foo", "bar", "baz"];
items[uniform(0, $)].writeln;
}</
=={{header|Dart}}==
{{trans|C}}
<syntaxhighlight lang="dart">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]);
}
}</syntaxhighlight>
=={{header|Delphi}}==
Line 423 ⟶ 632:
=={{header|Déjà Vu}}==
<
=={{header|EasyLang}}==
<syntaxhighlight>
ar$[] = [ "spring" "summer" "autumn" "winter" ]
print ar$[randint len ar$[]]
</syntaxhighlight>
=={{header|EchoLisp}}==
<
(define (pick-random list)
(list-ref list (random (length list))))
(pick-random (iota 1000)) → 667
(pick-random (iota 1000)) → 179
</syntaxhighlight>
=={{header|Elena}}==
ELENA
<
extension listOp
{
randomItem()
= self[randomGenerator.
}
Line 453 ⟶ 664:
console.printLine("I picked element ",item.randomItem())
}</
=={{header|Elixir}}==
{{works with|Elixir|1.2}}
<
[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]</
=={{header|Emacs Lisp}}==
<syntaxhighlight lang="lisp">(defun random-choice (items)
(
(random-choice '("a" "b" "c"))
;; => "a"</syntaxhighlight>
=={{header|EMal}}==
<syntaxhighlight lang="emal">
for each int i in range(5)
writeLine(random(text["Dee", "do", "de", "de"]))
end
</syntaxhighlight>
{{out}}
<pre>
do
de
do
de
Dee
</pre>
=={{header|Erlang}}==
<
-module(pick_random).
-export([main/0]).
Line 484 ⟶ 706:
Index = rand:uniform(length(List)),
lists:nth(Index,List).
</syntaxhighlight>
=={{header|Euphoria}}==
<
puts(1,s[rand($)])</
=={{header|F_Sharp|F#}}==
<
let rand = new System.Random()
printfn "%s" list.[rand.Next(list.Length)]</
=={{header|Factor}}==
<
"a"</
=={{header|Falcon}}==
<
lst = [1, 3, 5, 8, 10]
> randomPick(lst)
</syntaxhighlight>
=={{header|Fortran}}==
{{works with|Fortran|90 and later}}
<
implicit none
Line 517 ⟶ 739:
call random_number(r)
write(*,*) a(int(r*size(a)) + 1)
end program</
=={{header|Free Pascal}}==
Line 523 ⟶ 745:
=={{header|FreeBASIC}}==
<
Dim a(0 To 9) As String = {"Zero", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine"}
Line 534 ⟶ 756:
Print a(randInt)
Next
Sleep</
Sample output :
Line 547 ⟶ 769:
=={{header|Frink}}==
<
println[random[a]]</
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
random
mda(0) = {0,1,2,3,4,5,6,7,8,9}
print mda(rnd(10)-1)
HandleEvents
</syntaxhighlight>
=={{header|Gambas}}==
'''[https://gambas-playground.proko.eu/ You can run this code. Copy the code, click this link, paste it in and press 'Run !']'''
<
Dim sList As String[] = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
Print sList[Rand(0, 11)]
End </
Output:
<pre>
Line 564 ⟶ 797:
=={{header|GAP}}==
<
Random(a);</
This works with many GAP objects, for instance groups:
<
(1,4,8,2)(3,12)(5,14,10,18,17,7,16)(9,13)(11,15,20,19)</
=={{header|Go}}==
<
import (
Line 587 ⟶ 820:
rand.Seed(time.Now().UnixNano())
fmt.Println(list[rand.Intn(len(list))])
}</
=={{header|Groovy}}==
Solution:
<
def random = new Random();
Line 597 ⟶ 830:
def i = random.nextInt(list.size())
println "list[${i}] == ${list[i]}"
}</
{{out}}
Line 606 ⟶ 839:
Alternate Solution:
<
[25, 30, 1, 450, 3, 78].sort{new Random()}?.take(1)[0]
</syntaxhighlight>
=={{header|GW-BASIC}}==
<
20 DIM ARR(10) : REM initialise array
30 FOR I = 1 TO 10
Line 617 ⟶ 850:
50 NEXT I
60 C = 1 + INT(RND*10) : REM get a random index from 1 to 10 inclusive
70 PRINT ARR(C)</
{{out}}<pre> 81</pre>
=={{header|Hare}}==
<syntaxhighlight lang="hare">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)])!;
};</syntaxhighlight>
=={{header|Haskell}}==
Creating a custom function:
<
pick :: [a] -> IO a
pick xs = fmap (xs !!) $ randomRIO (0, length xs - 1)
x <- pick [1, 2, 3]</
Using the random-fu library:
<
sample $ randomElement [1, 2, 3]</
For example:
<
x <- sample $ randomElement [1, 2, 3]
print x</
=={{header|Icon}} and {{header|Unicon}}==
The unary operator '?' selects a random element from its argument which may be a string, list, table, or set.
<
L := [1,2,3] # a list
x := ?L # random element
end</
=={{Header|Insitux}}==
<syntaxhighlight lang="insitux">
(rand-pick (range 100))
</syntaxhighlight>
=={{header|J}}==
<
b</
=={{header|Java}}==
<
...
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 <code>list.get(...)</code> for <code>array[...]</code>. If preserving the order of the List isn't important, you could call <code>Collections.shuffle(list);</code> and then <code>list.get(0);</code>. You would need to shuffle each time unless you <code>remove</code>d the item from the list.
=={{header|JavaScript}}==
<
return array[Math.floor(Math.random() * array.length)];</
=={{header|Joy}}==
<syntaxhighlight lang="joy">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.</syntaxhighlight>
=={{header|jq}}==
{{works with|jq}}
'''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:
<syntaxhighlight lang="sh">< /dev/urandom tr -cd '0-9' | fold -w 1 | jq -MRcnr -f program.jq</syntaxhighlight>
<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;
# An illustration - 10 selections at random with replacement:
range(0;10) | ["a", "b", "c"] | .[length|prn]</syntaxhighlight>
{{out}}
<pre>
bcbabacbbc
</pre>
=={{header|Julia}}==
<
rand(array)</
=={{header|K}}==
<
,"e"</
=={{header|Klingphix}}==
<syntaxhighlight lang="klingphix">include ..\Utilitys.tlhy
:pickran len rand * 1 + get ;
( 1 3.1415 "Hello world" ( "nest" "list" ) )
10 [drop pickran ?] for
" " input</syntaxhighlight>
{{out}}
<pre>("nest", "list")
3.1415
("nest", "list")
Hello world
1
Hello world
3.1415
("nest", "list")
1
3.1415</pre>
=={{header|Kotlin}}==
<
import java.util.Random
Line 702 ⟶ 1,011:
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:
Line 719 ⟶ 1,028:
=={{header|Lasso}}==
<
my array = array('one', 'two', 3)
)
#myarray -> get(integer_random(#myarray -> size, 1))</
-> two
Line 729 ⟶ 1,038:
=={{header|Liberty BASIC}}==
The natural way to hold an array of text is in a space- or comma-delimited string, although an array could be used.
<
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
=={{header|LiveCode}}==
<
put item (random(the number of items of fruits)) of fruits</
=={{header|Logo}}==
{{works with|UCB Logo}}
<syntaxhighlight lang
=={{header|Lua}}==
<
local a = {1,2,3}
print(a[math.random(1,#a)])</
=={{header|Maple}}==
<
randomNum := rand(1 ..numelems(a)):
a[randomNum()];</
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
{{out}}
<pre>c</pre>
=={{header|MATLAB}} / {{header|Octave}}==
In case list is a cell array:
<
list{ceil(rand(1)*length(list))}</
If list is a vector:
<
list(ceil(rand(1)*length(list)))</
=={{header|Maxima}}==
<
/* (%i1) random_element(['a, 'b, 'c]);
(%o1) c
*/</
=={{header|МК-61/52}}==
<syntaxhighlight lang="text">0 П0 1 П1 2 П2 3 П3 4 П4 5
^ СЧ * [x] ПE КИПE С/П</
=={{header|Nanoquery}}==
<
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))]</
{{out}}
Line 786 ⟶ 1,096:
=={{header|NetLogo}}==
<
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) )</
=={{header|NetRexx}}==
<
options replace format comments java crossref savelog symbols nobinary
Line 805 ⟶ 1,115:
say v1 v2 v3
</syntaxhighlight>
=={{header|NewLISP}}==
<syntaxhighlight lang="newlisp">
(define (pick-random-element R)
(nth (rand (length R)) R))
</syntaxhighlight>
Example:
<pre>
Line 822 ⟶ 1,132:
=={{header|Nim}}==
<
randomize()
let ls = @["foo", "bar", "baz"]
echo sample(ls)</
=={{header|Objeck}}==
<
value := values[(Float->Random() * 100.0)->As(Int) % values->Size()];</
=={{header|OCaml}}==
With a list:
<
let len = List.length lst in
List.nth lst (Random.int len)</
<pre>
Line 844 ⟶ 1,154:
With an array:
<
let len = Array.length ary in
ary.(Random.int len)</
<pre>
Line 852 ⟶ 1,162:
- : int = 3
</pre>
=={{header|Odin}}==
<syntaxhighlight lang="odin">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])
}</syntaxhighlight>
=={{header|Oforth}}==
<
=={{header|Ol}}==
<
(import (otus random!))
(define x '("Monday" "Tuesday" "Wednesday" "Thursday" "Friday" "Saturday" "Sunday"))
(print (list-ref x (rand! (length x))))
</syntaxhighlight>
=={{header|PARI/GP}}==
<
=={{header|Pascal}} / {{header|Delphi}} / {{header|Free Pascal}}==
<
const
Line 877 ⟶ 1,200:
randomize;
writeln(s[low(s) + random(length(s))]);
end.</
=={{header|Perl}}==
<
print $array[ rand @array ];</
=={{header|Phix}}==
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.
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2.5</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"three"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,{</span><span style="color: #008000;">"4 as well"</span><span style="color: #0000FF;">}}}</span>
<span style="color: #7060A8;">pp</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #7060A8;">rand</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">))])</span>
<!--</syntaxhighlight>-->
=={{header|PHP}}==
<
$x = $arr[array_rand($arr)];</
=={{header|Picat}}==
<syntaxhighlight lang="picat">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.</syntaxhighlight>
{{out}}
<pre>choice = 4
[7,8,6,4,6,7,3,10,2,3]
ekcealmnei</pre>
This is a more structured output.
{{trans|Ada}}
<syntaxhighlight lang="picat">go2 =>
_ = random2(),
Vowels = "aeiou",
Consonants = "tnshrdl",
Specials = ",.?!",
RandWords = [( [[Consonants.choice()] ++ [Vowels.choice()] : _ in 1..10]
++ [Specials.choice()]
).flatten()
: _ in 1..3] ,
println(RandWords),
nl.</syntaxhighlight>
{{out}}
<pre>[dodidosisahuhiretesi,,loledohusoluhusululu?,tunuridunoheditonudu!]</pre>
Get the random elements from a frequency table (converted to a "Roulette wheel").
<syntaxhighlight lang="picat">% 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.</syntaxhighlight>
{{out}}
<pre>ihvuotpswieecanrv
gnelhlutnopytoss
aentkttnenb
cnyawephc
nsioetohasedd
yapaeofyt
setmtoorwloiar
nsssrkcfgnpadtifln
rrlwree
nawmtnie</pre>
=={{header|PicoLisp}}==
<
=={{header|PL/I}}==
<
('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j');
put ( t(10*random()) );</
{{out}}
<pre>
Line 906 ⟶ 1,314:
Powershell has Get-Random Cmdlet which one of its overload is to select randomly from a given list
<syntaxhighlight lang="powershell">
1..100 | Get-Random -Count 3
</syntaxhighlight>
=={{header|Prolog}}==
{{works with|SWI-Prolog|6}}
<
?- random_member(M, [a, b, c, d, e, f, g, h, i, j]).
M = i.
</syntaxhighlight>
=={{header|PureBasic}}==
<
Protected x = ListSize(source())
Line 958 ⟶ 1,366:
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()
CloseConsole()
EndIf</
{{out}}
<pre>Source list: One Two Three Four Five Six Seven Eight Nine Ten
Line 964 ⟶ 1,372:
Random picks from list: Seven Nine Two Six Four Four Nine Three Six Two</pre>
===Easy version===
<
a$="One" +#TAB$+ "Two" +#TAB$+ "Three" +#TAB$+ "Four" +#TAB$+ "Five" +#TAB$+
Line 974 ⟶ 1,382:
Print(StringField(a$,Random(CountString(a$,#TAB$),1),#TAB$)+#TAB$)
Next
Input()</
{{out}}
<pre>Source list: One Two Three Four Five Six Seven Eight Nine Ten
Line 980 ⟶ 1,388:
=={{header|Python}}==
<
>>> random.choice(['foo', 'bar', 'baz'])
'baz'</
=={{header|Quackery}}==
<
randomise
' [ 20 33 -15 7 0 ] pick echo cr
' pick pick echo</
{{out}}
<pre>
Line 997 ⟶ 1,405:
=={{header|R}}==
<
letters
# [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s"
Line 1,008 ⟶ 1,416:
# picking some elements with repetition, and concatenating to get a word
paste(sample(letters, 10, rep=T), collapse="")
# [1] "episxgcgmt"</
=={{header|Racket}}==
<syntaxhighlight lang="racket">
#lang racket
(define (pick-item l)
(list-ref l (random (length l))))
</syntaxhighlight>
=={{header|Raku}}==
Line 1,023 ⟶ 1,431:
In a nutshell, picking an element from a list
is implemented with a method conveniently called "pick":
<syntaxhighlight lang="raku"
There are various ways of doing something similar, though.
Line 1,031 ⟶ 1,439:
Selection with replacement: (roll of a die)
<syntaxhighlight lang="raku"
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)
<syntaxhighlight lang="raku"
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 <tt>rand</tt> built-in
to generate a subscript (which automatically truncates any fractional part):
<syntaxhighlight lang="raku"
However, the <tt>pick</tt> and <tt>roll</tt> 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:
<syntaxhighlight lang="raku"
=={{header|Red}}==
<
=={{header|ReScript}}==
<syntaxhighlight lang="rescript">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))</syntaxhighlight>
{{out}}
<pre>$ bsc pickrand.res > pickrand.bs.js
$ node pickrand.bs.js
lychee
</pre>
=={{header|REXX}}==
Line 1,057 ⟶ 1,481:
Also, the newly named elements have been incorporated into this table.
<
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. */</syntaxhighlight>
{{out|output}}
<pre>E:\>rexx pez
E:\>rexx pez 8
Specified element: 8 Oxygen (O)
E:\>rexx pez 133
Element 133 hasn't been discovered by now</pre>
===version 2===
Line 1,088 ⟶ 1,542:
<br>smaller limit of the total length of a clause, in particular PC/REXX and Personal REXX
<br>which have a limit of 1,000 characters).
<
/* REXX ***************************************************************
* 18.10.2012 Walter Pachl Not only the list of elements shortened:-)
Line 1,098 ⟶ 1,552:
Say word(wl,random(1,words(wl)))
</syntaxhighlight>
=={{header|Ring}}==
<
aList = "abcdefghij"
for i = 1 to 10
Line 1,109 ⟶ 1,563:
ok
next
</syntaxhighlight>
=={{header|RPL}}==
≪ DUP SIZE RAND * CEIL GET ≫ ‘<span style="color:blue">RANDGET</span>’ STO
{ Alpha Beta Gamma Delta } <span style="color:blue">RANDGET</span>
{ Alpha Beta Gamma Delta } <span style="color:blue">RANDGET</span>
{ Alpha Beta Gamma Delta } <span style="color:blue">RANDGET</span>
{{out}}
<pre>
3: ‘Delta’
2: ‘Alpha’
1: ‘Beta’
</pre>
=={{header|Ruby}}==
<
%w(north east south west).sample # => "west"
(1..100).to_a.sample(2) # => [17, 79]</
=={{header|Run BASIC}}==
<
letter = rnd(1) * 10
print "Selected letter:"; word$(list$,letter,",")</
=={{header|Rust}}==
{{libheader|rand}}
<
use rand::Rng;
Line 1,132 ⟶ 1,599:
println!("{}", rng.choose(&array).unwrap());
}</
=={{header|Scala}}==
{{libheader|Scala}}
<
println(scala.util.Random.shuffle(a).head)</
=={{header|Seed7}}==
<
const proc: main is func
begin
writeln(rand([] ("foo", "bar", "baz")));
end func;</
=={{header|Sidef}}==
<
say arr.rand;
say arr.rand(2).dump;</
{{out}}
<pre>south
Line 1,157 ⟶ 1,624:
=={{header|Smalltalk}}==
<
=={{header|SuperCollider}}==
<syntaxhighlight lang
=={{header|Swift}}==
<
let myList = [1, 2, 4, 5, 62, 234, 1, -1]
print(myList[Int(arc4random_uniform(UInt32(myList.count)))])</
=={{header|Tcl}}==
Line 1,172 ⟶ 1,639:
(for selection of an item from a list) and the pattern for generating an integral random number from the range <math>[0,n)</math>.
It's simpler to use when wrapped up as a helper procedure:
<
lindex $list [expr {int(rand()*[llength $list])}]
}
set x [randelem {1 2 3 4 5}]</
=={{header|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</
{{out}}
<pre>
Line 1,192 ⟶ 1,659:
{{trans|Tcl}}
<
[seq (random nil (length seq))]))
@(bind x @(randelem #("a" "b" "c" "d")))</
=={{header|UNIX Shell}}==
{{works with|Bourne Again Shell}}
<syntaxhighlight lang="sh">list=(these are some words)
printf '%s\n' "${list[RANDOM%${#list[@]}]}"</syntaxhighlight>
{{works with|Zsh}}
<syntaxhighlight lang="sh">list=(these are some words)
printf '%s\n' "$list[RANDOM%$#list+1]"</syntaxhighlight>
=={{header|Ursa}}==
<
decl string<> str
append "these" "are" "some" "values" str
decl ursa.util.random r
out str<(r.getint (size str))> endl console</
=={{header|VBA}}==
<syntaxhighlight lang="vb">
Option Explicit
Line 1,217 ⟶ 1,694:
Pick_Random_Element = myArray(Int((Rnd * (UBound(myArray) - LBound(myArray) + 1) + LBound(myArray))))
End Function
</syntaxhighlight>
=={{header|VBScript}}==
<
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"))</
{{Out}}
Line 1,232 ⟶ 1,709:
=={{header|Visual Basic .NET}}==
{{trans|C#}}
<
Sub Main()
Dim list As New List(Of Integer)({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
Line 1,239 ⟶ 1,716:
Console.WriteLine("I picked element {0}", randomElement)
End Sub
End Module</
=={{header|V (Vlang)}}==
<syntaxhighlight lang="v (vlang)">import 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) or {}])}
}</syntaxhighlight>
{{out}}
Sample of random output:
<pre>
1: peace
2: happiness
3: hello
4: friends
5: peace
6: people
</pre>
=={{header|Wren}}==
<
var rand = Random.new()
var colors = ["red", "green", "blue", "yellow", "pink"]
for (i in 0..4) System.print(colors[rand.int(colors.count)])</
{{out}}
Line 1,257 ⟶ 1,753:
red
</pre>
=={{header|XBS}}==
<syntaxhighlight lang="xbs">set Array = ["Hello","World",1,2,3];
log(Array[rnd(0,?Array-1)]);</syntaxhighlight>
=={{header|XPL0}}==
<
int List;
[List:= ["hydrogen", "helium", "lithium", "beryllium", "boron"]; \(Thanks REXX)
Text(0, List(Ran(5)));
]</
=={{header|Zig}}==
This example uses the [http://www.pcg-random.org/ PCG] algorithm.
<
const debug = std.debug;
Line 1,297 ⟶ 1,797:
debug.warn("\n", .{});
}</
{{out}}
Line 1,313 ⟶ 1,813:
=={{header|zkl}}==
{{trans|XPL0}}
<
list[(0).random(list.len())]</
|