Pick random element: Difference between revisions
m
→{{header|EasyLang}}
(Pick random element in various BASIC dialents (BASIC256, True BASIC and Yabasic)) |
|||
(19 intermediate revisions by 14 users not shown) | |||
Line 6:
{{trans|Python}}
<
=={{header|8086 Assembly}}==
Line 12:
For brevity's sake, the implementations of the RNG and printing routines were left out; they can be provided if requested.
<
.stack 1024
Line 41:
mov ax,4C00h
int 21h ;exit program and return to MS-DOS
end start</
Line 54:
=={{header|ACL2}}==
<
(defun pick-random-element (xs state)
(mv-let (idx state)
(random$ (len xs) state)
(mv (nth idx xs) state)))</
=={{header|Action!}}==
<
DEFINE PTR="CARD"
PTR ARRAY a(7)
Line 80:
PrintE(a(index))
OD
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Pick_random_element.png Screenshot from Atari 8-bit computer]
Line 112:
resp. a list of consonants.
<
procedure Pick_Random_Element is
Line 141:
end loop;
Ada.Text_IO.New_Line;
end Pick_Random_Element;</
{{out}}
Line 147:
=={{header|Aime}}==
<
l_append(l, 'a');
Line 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 183:
print( ( PICKRANDOM days, newline ) )
)</
{{out}}
<pre>
Line 191:
=={{header|APL}}==
{{works with|Dyalog APL}}
<syntaxhighlight lang
{{out}}
<pre> pickRandom 'ABCDE'
Line 205:
=={{header|AppleScript}}==
<
{{out}}
<pre>"two"</pre>
Line 211:
=={{header|Arturo}}==
<
print sample fruit</
{{out}}
Line 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 240:
printf("%s\n",day_of_week[x])
exit(0)
}</
{{out}}
<pre>GAWK -f PICK_RANDOM_ELEMENT.AWK
Line 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 261:
element = RANDOM(6) + 1
PRINT "Chose ", element, ": ", words$[element]</
{{out}}
Line 272:
=={{header|Bash}}==
<
rand() {
Line 283:
}
echo "You feel like a $(rand_element pig donkey unicorn eagle) today"</
=={{header|BASIC}}==
Line 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 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 315 ⟶ 339:
60 END
100 DATA ALPHA, BRAVO, CHARLIE, DELTA, ECHO
110 DATA FOXTROT, GOLF, HOTEL, INDIA, JULIETT</
==={{header|True BASIC}}===
{{trans|QBasic}}
<
DIM foo(10)
FOR n = LBOUND(foo) TO UBOUND(foo)
Line 340 ⟶ 355:
!output
PRINT x, foo(x)
END</
==={{header|Yabasic}}===
<
a$(0)="Zero"
a$(1)="One"
Line 359 ⟶ 374:
randInt = int(ran(10))
print a$(randInt)
next i</
=={{header|Batch File}}==
Since there is no arrays in Batch File, I will use a 1-based pseudo-array.
<
setlocal enabledelayedexpansion
Line 379 ⟶ 393:
echo.!pseudo[%rndInt%]!
pause
exit /b</
{{Out|Sample Outputs}}
<pre>Delta
Line 394 ⟶ 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>
Line 408 ⟶ 422:
Both use BQN's system value <code>•rand</code>, which contains multiple functions for generating random values.
<
PR1 ← •rand.Range∘≠⊸⊑</
{{Out|Usage}}
<
67
PR1 5‿67‿7‿23
7</
=={{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 427 ⟶ 441:
=={{header|C}}==
<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdlib.h>
Line 444 ⟶ 458:
return 0;
}
</syntaxhighlight>
Output
<pre>
Line 481 ⟶ 495:
=={{header|C sharp}}==
<
using System.Collections.Generic;
Line 491 ⟶ 505:
Console.WriteLine("I picked element {0}", randomElement);
}
}</
=={{header|C++}}==
<
#include <random>
#include <vector>
Line 508 ⟶ 522:
<< " !\n" ;
return 0 ;
}</
=={{header|Ceylon}}==
<
DefaultRandom
Line 520 ⟶ 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}}==
<
return(a[array[T]$low(a) + random$next(array[T]$size(a))])
end random_element
Line 544 ⟶ 558:
stream$putl(po, random_element[string](arr))
end
end start_up</
{{out}}
<pre>qux
Line 554 ⟶ 568:
=={{header|COBOL}}==
{{works with|GNU Cobol}}
<
IDENTIFICATION DIVISION.
PROGRAM-ID. random-element.
Line 569 ⟶ 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 588 ⟶ 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 604 ⟶ 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 634 ⟶ 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}}==
<
(nth (random (length items)) items))
(random-choice '("a" "b" "c"))
;; => "a"</
=={{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 661 ⟶ 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 694 ⟶ 739:
call random_number(r)
write(*,*) a(int(r*size(a)) + 1)
end program</
=={{header|Free Pascal}}==
Line 700 ⟶ 745:
=={{header|FreeBASIC}}==
<
Dim a(0 To 9) As String = {"Zero", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine"}
Line 711 ⟶ 756:
Print a(randInt)
Next
Sleep</
Sample output :
Line 724 ⟶ 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 741 ⟶ 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 764 ⟶ 820:
rand.Seed(time.Now().UnixNano())
fmt.Println(list[rand.Intn(len(list))])
}</
=={{header|Groovy}}==
Solution:
<
def random = new Random();
Line 774 ⟶ 830:
def i = random.nextInt(list.size())
println "list[${i}] == ${list[i]}"
}</
{{out}}
Line 783 ⟶ 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 794 ⟶ 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}}==
<
use math::random;
use datetime;
Line 809 ⟶ 865:
fmt::printfln("{}", array[math::random::u32n(&r, len(array): u32)])!;
};</
=={{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}}==
Line 862 ⟶ 933:
to define one if an external source of entropy is available. In this entry, `/dev/urandom`
is used like so:
<
<
def prn:
if . == 1 then 0
Line 874 ⟶ 945:
# An illustration - 10 selections at random with replacement:
range(0;10) | ["a", "b", "c"] | .[length|prn]</
{{out}}
<pre>
Line 881 ⟶ 952:
=={{header|Julia}}==
<
rand(array)</
=={{header|K}}==
<
,"e"</
=={{header|Klingphix}}==
<
:pickran len rand * 1 + get ;
Line 897 ⟶ 968:
10 [drop pickran ?] for
" " input</
{{out}}
<pre>("nest", "list")
Line 911 ⟶ 982:
=={{header|Kotlin}}==
<
import java.util.Random
Line 940 ⟶ 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 957 ⟶ 1,028:
=={{header|Lasso}}==
<
my array = array('one', 'two', 3)
)
#myarray -> get(integer_random(#myarray -> size, 1))</
-> two
Line 967 ⟶ 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>
Line 998 ⟶ 1,069:
=={{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 1,025 ⟶ 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 1,044 ⟶ 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 1,061 ⟶ 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 1,083 ⟶ 1,154:
With an array:
<
let len = Array.length ary in
ary.(Random.int len)</
<pre>
Line 1,091 ⟶ 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 1,116 ⟶ 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.
<!--<
<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>
<!--</
=={{header|PHP}}==
<
$x = $arr[array_rand($arr)];</
=={{header|Picat}}==
<
% single element
Line 1,153 ⟶ 1,237:
% Pick a random element from a list L.
choice(List) = List[choice(List.length)], list(List) => true.</
{{out}}
Line 1,162 ⟶ 1,246:
This is a more structured output.
{{trans|Ada}}
<
_ = random2(),
Vowels = "aeiou",
Line 1,172 ⟶ 1,256:
: _ in 1..3] ,
println(RandWords),
nl.</
{{out}}
Line 1,179 ⟶ 1,263:
Get the random elements from a frequency table (converted to a "Roulette wheel").
<
go3 =>
_ = random2(),
Line 1,201 ⟶ 1,285:
Chars := Chars ++ [C : _ in 1..ceiling(10*F)]
end,
nl.</
{{out}}
Line 1,216 ⟶ 1,300:
=={{header|PicoLisp}}==
<
=={{header|PL/I}}==
<
('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j');
put ( t(10*random()) );</
{{out}}
<pre>
Line 1,230 ⟶ 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 1,282 ⟶ 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 1,288 ⟶ 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 1,298 ⟶ 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 1,304 ⟶ 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 1,321 ⟶ 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,332 ⟶ 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,347 ⟶ 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,355 ⟶ 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}}==
<
let pickRand = arr => {
Line 1,385 ⟶ 1,469:
}
Js.log(pickRand(fruits))</
{{out}}
<pre>$ bsc pickrand.res > pickrand.bs.js
Line 1,397 ⟶ 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,428 ⟶ 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,438 ⟶ 1,552:
Say word(wl,random(1,words(wl)))
</syntaxhighlight>
=={{header|Ring}}==
<
aList = "abcdefghij"
for i = 1 to 10
Line 1,449 ⟶ 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,472 ⟶ 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,497 ⟶ 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,512 ⟶ 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,532 ⟶ 1,659:
{{trans|Tcl}}
<
[seq (random nil (length seq))]))
@(bind x @(randelem #("a" "b" "c" "d")))</
=={{header|UNIX Shell}}==
{{works with|Bourne Again Shell}}
<
printf '%s\n' "${list[RANDOM%${#list[@]}]}"</
{{works with|Zsh}}
<
printf '%s\n' "$list[RANDOM%$#list+1]"</
=={{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,567 ⟶ 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,582 ⟶ 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,589 ⟶ 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,609 ⟶ 1,755:
=={{header|XBS}}==
<
log(Array[rnd(0,?Array-1)]);</
=={{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,651 ⟶ 1,797:
debug.warn("\n", .{});
}</
{{out}}
Line 1,667 ⟶ 1,813:
=={{header|zkl}}==
{{trans|XPL0}}
<
list[(0).random(list.len())]</
|