View source for Pick random element

{{task|Basic language learning}} [[Category:Randomness]]
Demonstrate how to pick a random element from a list.
<br><br>

=={{header|11l}}==
{{trans|Python}}

<syntaxhighlight lang="11l">print(random:choice([‘foo’, ‘bar’, ‘baz’]))</syntaxhighlight>

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

<syntaxhighlight lang="lisp">:set-state-ok t

(defun pick-random-element (xs state)
   (mv-let (idx state)
           (random$ (len xs) state)
      (mv (nth idx xs) state)))</syntaxhighlight>

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

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. 

<syntaxhighlight lang="ada">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;</syntaxhighlight>

{{out}}
<pre>horanohesuhodinahiru. desehonirosedisinelo, losihehederidonolahe?</pre>

=={{header|Aime}}==
<syntaxhighlight lang="aime">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');</syntaxhighlight>

=={{header|ALGOL 68}}==
{{works with|ALGOL 68G|Any - tested with release 2.8.win32}}
<syntaxhighlight lang="algol68"># 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 #


main: (

    []STRING days = ( "Sunday",   "Monday", "Tuesday", "Wednesday"
                    , "Thursday", "Friday", "Saturday"
                    );

    print( ( PICKRANDOM days, newline ) )

)</syntaxhighlight>
{{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}}==
App Inventor has the block '''pick a random item''' for selecting a random item from a list.<br>
[https://lh4.googleusercontent.com/-FaK4IeMmyI0/Uuv4G83dpYI/AAAAAAAAJ-E/3gzO5jUMwxE/s1600/Capture.PNG CLICK HERE TO VIEW THE BLOCKS AND ANDROID APP DISPLAY]

=={{header|AppleScript}}==
<syntaxhighlight lang="applescript">get some item of [1, "two", pi, "4", 5 > 4, 5 + 1, Sunday]</syntaxhighlight>
{{out}}
<pre>"two"</pre>

=={{header|Arturo}}==

<syntaxhighlight lang="rebol">fruit: ["apple" "banana" "pineapple" "apricot" "watermelon"]

print sample fruit</syntaxhighlight>

{{out}}

<pre>pineapple</pre>

=={{header|AutoHotkey}}==
; True Arrays
{{works with|AutoHotkey_L}}
<syntaxhighlight lang="ahk">list := ["abc", "def", "gh", "ijklmnop", "hello", "world"]
Random, randint, 1, % list.MaxIndex()
MsgBox % List[randint]</syntaxhighlight>
; Pseudo-Arrays
{{works with|AutoHotkey_Basic}}
<syntaxhighlight lang="autohotkey">list := "abc,def,gh,ijklmnop,hello,world"
StringSplit list, list, `,
Random, randint, 1, %list0%
MsgBox % List%randint%</syntaxhighlight>

=={{header|AWK}}==
<syntaxhighlight lang="awk"># 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)
}</syntaxhighlight>
{{out}}
<pre>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</pre>

=={{header|BaCon}}==
This is simply an application of a ranged random number used as an array index. '''BaCon''' has no built in random element selector.

<syntaxhighlight lang="freebasic">' 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]</syntaxhighlight>

{{out}}
<pre>prompt$ ./pick-random-element
Chose 2: Beta
prompt$ ./pick-random-element
Chose 1: Alpha
prompt$ ./pick-random-element
Chose 5: Epsilon</pre>

=={{header|Bash}}==
<syntaxhighlight lang="bash"># 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"</syntaxhighlight>

=={{header|BASIC}}==
{{works with|QBasic}}
{{works with|PowerBASIC}}

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

<syntaxhighlight lang="qbasic">'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)</syntaxhighlight>

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}}===
<syntaxhighlight lang="qbasic">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</syntaxhighlight>

==={{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.
<syntaxhighlight lang="dos">@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</syntaxhighlight>
{{Out|Sample Outputs}}
<pre>Delta
Press any key to continue . . .

Gamma
Press any key to continue . . .

Epsilon
Press any key to continue . . .

Gamma
Press any key to continue . . .</pre>

=={{header|BBC BASIC}}==
<syntaxhighlight lang="bbcbasic">      DIM list$(5)
      list$() = "The", "five", "boxing", "wizards", "jump", "quickly"
      chosen% = RND(6)
      PRINT "Item " ; chosen% " was chosen which is '" list$(chosen%-1) "'"</syntaxhighlight>
{{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}}==

<syntaxhighlight lang="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.

=={{header|C}}==

<syntaxhighlight lang="c">
#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;
}
</syntaxhighlight>
Output
<pre>
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
</pre>

=={{header|C sharp}}==
<syntaxhighlight lang="csharp">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);
  }
}</syntaxhighlight>

=={{header|C++}}==
<syntaxhighlight lang="cpp">#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 ;
}</syntaxhighlight>

=={{header|Ceylon}}==
<syntaxhighlight lang="ceylon">import ceylon.random {

	DefaultRandom
}

shared void run() {
    value random = DefaultRandom();
    value element = random.nextElement([1, 2, 3, 4, 5, 6]);
    print(element);
}</syntaxhighlight>

=={{header|Clojure}}==
<syntaxhighlight lang="clojure">(rand-nth coll)</syntaxhighlight>

where <code>coll</code> is some sequential collection. Equivalent to:

<syntaxhighlight lang="clojure">(nth coll (rand-int (count coll)))</syntaxhighlight>

=={{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}}
<syntaxhighlight lang="cobol">       >>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.</syntaxhighlight>

=={{header|CoffeeScript}}==
<syntaxhighlight lang="coffeescript">array = [1,2,3]
console.log array[Math.floor(Math.random() * array.length)]</syntaxhighlight>

=={{header|Common Lisp}}==
<syntaxhighlight lang="lisp">(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*))</syntaxhighlight>

{{out}}
<pre>FIVE 
THREE 
ONE</pre>

=={{header|Crystal}}==
<syntaxhighlight lang="ruby">
puts [1, 2, 3, 4, 5].sample(1)
</syntaxhighlight>

=={{header|D}}==
<syntaxhighlight lang="d">import std.stdio, std.random;

void main() {
    const items = ["foo", "bar", "baz"];
    items[uniform(0, $)].writeln;
}</syntaxhighlight>

=={{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}}==
See [[#Pascal / Delphi / Free Pascal]].

=={{header|Déjà Vu}}==
<syntaxhighlight lang="dejavu">!print choose [ "one" "two" "chicken" ]</syntaxhighlight>

=={{header|EasyLang}}==

<syntaxhighlight>
ar$[] = [ "spring" "summer" "autumn" "winter" ]
print ar$[randint len ar$[]]
</syntaxhighlight>

=={{header|EchoLisp}}==
<syntaxhighlight lang="lisp">
(define (pick-random list)
    (list-ref list (random (length list))))
(pick-random (iota 1000)) → 667
(pick-random (iota 1000)) → 179
</syntaxhighlight>

=={{header|Elena}}==
ELENA 6.x :
<syntaxhighlight lang="elena">import extensions;
 
extension listOp
{
    randomItem()
        = self[randomGenerator.nextInt(self.Length)];
}
 
public program()
{
    var item := new int[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
 
    console.printLine("I picked element ",item.randomItem())
}</syntaxhighlight>

=={{header|Elixir}}==
{{works with|Elixir|1.2}}
<syntaxhighlight lang="elixir">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]</syntaxhighlight>

=={{header|Emacs Lisp}}==
<syntaxhighlight lang="lisp">(defun random-choice (items)
  (nth (random (length items)) 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}}==
<syntaxhighlight lang="erlang">% 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).
</syntaxhighlight>

=={{header|Euphoria}}==
<syntaxhighlight lang="euphoria">constant s = {'a', 'b', 'c'}
puts(1,s[rand($)])</syntaxhighlight>

=={{header|F_Sharp|F#}}==
<syntaxhighlight lang="fsharp">let list = ["a"; "b"; "c"; "d"; "e"]
let rand = new System.Random()
printfn "%s" list.[rand.Next(list.Length)]</syntaxhighlight>

=={{header|Factor}}==
<syntaxhighlight lang="factor">( scratchpad ) { "a" "b" "c" "d" "e" "f" } random .
"a"</syntaxhighlight>

=={{header|Falcon}}==
<syntaxhighlight lang="falcon">
lst = [1, 3, 5, 8, 10]
> randomPick(lst)
</syntaxhighlight>

=={{header|Fortran}}==
{{works with|Fortran|90 and later}}
<syntaxhighlight lang="fortran">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</syntaxhighlight>

=={{header|Free Pascal}}==
See [[#Pascal / Delphi / Free Pascal]].

=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">' 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</syntaxhighlight>

Sample output :
{{out}}
<pre>
Zero
Seven
Three
Nine
Three
</pre>

=={{header|Frink}}==
<syntaxhighlight lang="frink">a = ["one", "two", "three"]
println[random[a]]</syntaxhighlight>

=={{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 !']'''
<syntaxhighlight lang="gambas">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 </syntaxhighlight>
Output:
<pre>
May
</pre>

=={{header|GAP}}==
<syntaxhighlight lang="gap">a := [2, 9, 4, 7, 5, 3];
Random(a);</syntaxhighlight>

This works with many GAP objects, for instance groups:

<syntaxhighlight lang="gap">Random(SymmetricGroup(20));

(1,4,8,2)(3,12)(5,14,10,18,17,7,16)(9,13)(11,15,20,19)</syntaxhighlight>

=={{header|Go}}==
<syntaxhighlight lang="go">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))])
}</syntaxhighlight>

=={{header|Groovy}}==
Solution:
<syntaxhighlight lang="groovy">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]}"
}</syntaxhighlight>

{{out}}
<pre>list[3] == 450
list[2] == 1
list[5] == 78
list[3] == 450</pre>

Alternate Solution:
<syntaxhighlight lang="groovy">
[25, 30, 1, 450, 3, 78].sort{new Random()}?.take(1)[0]
</syntaxhighlight>

=={{header|GW-BASIC}}==
<syntaxhighlight lang="gwbasic">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)</syntaxhighlight>
{{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:

<syntaxhighlight lang="haskell">import System.Random (randomRIO)

pick :: [a] -> IO a
pick xs = fmap (xs !!) $ randomRIO (0, length xs - 1)

x <- pick [1, 2, 3]</syntaxhighlight>

Using the random-fu library:

<syntaxhighlight lang="haskell">import Data.Random
sample $ randomElement  [1, 2, 3]</syntaxhighlight>

For example:
<syntaxhighlight lang="haskell">do 
  x <- sample $ randomElement  [1, 2, 3]
  print x</syntaxhighlight>

=={{header|Icon}} and {{header|Unicon}}==
The unary operator '?' selects a random element from its argument which may be a string, list, table, or set.

<syntaxhighlight lang="icon">procedure main()
   L := [1,2,3]  # a list
   x := ?L       # random element
end</syntaxhighlight>

=={{Header|Insitux}}==

<syntaxhighlight lang="insitux">
(rand-pick (range 100))
</syntaxhighlight>

=={{header|J}}==
<syntaxhighlight lang="j">   ({~ ?@#) 'abcdef'
b</syntaxhighlight>

=={{header|Java}}==
<syntaxhighlight lang="java">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</syntaxhighlight>

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}}==
<syntaxhighlight lang="javascript">var array = [1,2,3];
return array[Math.floor(Math.random() * array.length)];</syntaxhighlight>

=={{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}}==
<syntaxhighlight lang="julia">array = [1,2,3]
rand(array)</syntaxhighlight>

=={{header|K}}==
<syntaxhighlight lang="k">  1?"abcdefg"
,"e"</syntaxhighlight>

=={{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}}==
<syntaxhighlight lang="scala">// 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)}")
}</syntaxhighlight>

Sample output:
{{out}}
<pre>
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]
</pre>

=={{header|LabVIEW}}==
{{VI snippet}}<br/>[[File:LabVIEW_Pick_random_element.png]]

=={{header|Lasso}}==
<syntaxhighlight lang="lasso">local(
	my array = array('one', 'two', 3)
)

#myarray -> get(integer_random(#myarray -> size, 1))</syntaxhighlight>

-> two

=={{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.
<syntaxhighlight lang="lb">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, " ")</syntaxhighlight>
 Selecting term 5 in the list, which was Peter

=={{header|LiveCode}}==
<syntaxhighlight lang="livecode">put "Apple,Banana,Peach,Apricot,Pear" into fruits
put item (random(the number of items of fruits)) of fruits</syntaxhighlight>

=={{header|Logo}}==
{{works with|UCB Logo}}
<syntaxhighlight lang="logo">pick [1 2 3]</syntaxhighlight>

=={{header|Lua}}==

<syntaxhighlight lang="lua">math.randomseed(os.time())
local a = {1,2,3}
print(a[math.random(1,#a)])</syntaxhighlight>

=={{header|Maple}}==
<syntaxhighlight lang="maple">a := [bear, giraffe, dog, rabbit, koala, lion, fox, deer, pony]:
randomNum := rand(1 ..numelems(a)):
a[randomNum()];</syntaxhighlight>

=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">RandomChoice[{a, b, c}]</syntaxhighlight>
{{out}}
<pre>c</pre>

=={{header|MATLAB}} / {{header|Octave}}==
In case list is a cell array:
<syntaxhighlight lang="matlab">        list = {'a','b','c'}; 
	list{ceil(rand(1)*length(list))}</syntaxhighlight>

If list is a vector:
<syntaxhighlight lang="matlab">        list = 1:1000; 
	list(ceil(rand(1)*length(list)))</syntaxhighlight>

=={{header|Maxima}}==
<syntaxhighlight lang="maxima">random_element(l):= part(l, 1+random(length(l)));
/*  (%i1) random_element(['a, 'b, 'c]);
    (%o1)                                  c
*/</syntaxhighlight>

=={{header|МК-61/52}}==
<syntaxhighlight lang="text">0 П0 1 П1 2 П2 3 П3 4 П4 5

^ СЧ * [x] ПE КИПE С/П</syntaxhighlight>

=={{header|Nanoquery}}==
<syntaxhighlight lang="nanoquery">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))]</syntaxhighlight>

{{out}}
<pre>12</pre>

=={{header|NetLogo}}==
<syntaxhighlight lang="netlogo">;; 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) )</syntaxhighlight>

=={{header|NetRexx}}==
<syntaxhighlight lang="netrexx">/* 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
</syntaxhighlight>

=={{header|NewLISP}}==
<syntaxhighlight lang="newlisp">
(define (pick-random-element R)
	(nth (rand (length R)) R))
</syntaxhighlight>
Example:
<pre>
(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))
</pre>

=={{header|Nim}}==
<syntaxhighlight lang="nim">import random
randomize()

let ls = @["foo", "bar", "baz"]
echo sample(ls)</syntaxhighlight>

=={{header|Objeck}}==
<syntaxhighlight lang="objeck">values := [1, 2, 3];
value := values[(Float->Random() * 100.0)->As(Int) % values->Size()];</syntaxhighlight>

=={{header|OCaml}}==
With a list:
<syntaxhighlight lang="ocaml">let list_rand lst =
  let len = List.length lst in
  List.nth lst (Random.int len)</syntaxhighlight>

<pre>
# list_rand [1;2;3;4;5] ;;
- : int = 3
</pre>

With an array:
<syntaxhighlight lang="ocaml">let array_rand ary =
  let len = Array.length ary in
  ary.(Random.int len)</syntaxhighlight>

<pre>
# array_rand [|1;2;3;4;5|] ;;
- : 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}}==

<syntaxhighlight lang="oforth">: pickRand(l)   l size rand l at ;</syntaxhighlight>

=={{header|Ol}}==
<syntaxhighlight lang="scheme">
(import (otus random!))

(define x '("Monday" "Tuesday" "Wednesday" "Thursday" "Friday" "Saturday" "Sunday"))
(print (list-ref x (rand! (length x))))
</syntaxhighlight>

=={{header|PARI/GP}}==
<syntaxhighlight lang="parigp">pick(v)=v[random(#v)+1]</syntaxhighlight>

=={{header|Pascal}} / {{header|Delphi}} / {{header|Free Pascal}}==
<syntaxhighlight lang="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.</syntaxhighlight>

=={{header|Perl}}==
<syntaxhighlight lang="perl">my @array = qw(a b c);
print $array[ rand @array ];</syntaxhighlight>

=={{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}}==
<syntaxhighlight lang="php">$arr = array('foo', 'bar', 'baz');
$x = $arr[array_rand($arr)];</syntaxhighlight>

=={{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}}==
<syntaxhighlight lang="picolisp">(get Lst (rand 1 (length Lst)))</syntaxhighlight>

=={{header|PL/I}}==
<syntaxhighlight lang="pli">   declare t(0:9) character (1) static initial
      ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j');
   put ( t(10*random()) );</syntaxhighlight>
{{out}}
<pre>
e
</pre>

=={{header|Powershell}}==
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}}

<syntaxhighlight lang="prolog">
?- random_member(M, [a, b, c, d, e, f, g, h, i, j]).
M = i.
</syntaxhighlight>

=={{header|PureBasic}}==
<syntaxhighlight lang="purebasic">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</syntaxhighlight>
{{out}}
<pre>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</pre>
===Easy version===
<syntaxhighlight lang="purebasic">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()</syntaxhighlight>
{{out}}
<pre>Source list:    One     Two     Three   Four    Five    Six     Seven   Eight   Nine    Ten
Random list:    One     Two     Seven   Nine    Ten     Seven   Three   Five    Ten     Nine</pre>

=={{header|Python}}==
<syntaxhighlight lang="python">>>> import random
>>> random.choice(['foo', 'bar', 'baz'])
'baz'</syntaxhighlight>

=={{header|Quackery}}==
<syntaxhighlight lang="quackery">  [ dup size random peek ]      is pick ( [ --> x )

  randomise
  ' [ 20 33 -15 7 0 ] pick echo cr
  ' pick pick echo</syntaxhighlight> <!-- just to make the point that data and code are not differentiated -->
{{out}}
<pre>
33
random
</pre>

=={{header|R}}==
<syntaxhighlight lang="rsplus"># 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"</syntaxhighlight>

=={{header|Racket}}==

<syntaxhighlight lang="racket">
#lang racket
(define (pick-item l)
  (list-ref l (random (length l))))
</syntaxhighlight>

=={{header|Raku}}==
(formerly Perl 6)
{{Works with|rakudo|2015-12-07}}
In a nutshell, picking an element from a list 
is implemented with a method conveniently called "pick":
<syntaxhighlight lang="raku" line>say (1, 2, 3).pick;</syntaxhighlight>

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)
<syntaxhighlight lang="raku" line>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</syntaxhighlight>

Selection without replacement: (pick a card from a deck)
<syntaxhighlight lang="raku" line># 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</syntaxhighlight>
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" line>@array[@array * rand]</syntaxhighlight>
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" line>say Bool.pick;  # returns either True or False</syntaxhighlight>

=={{header|Red}}==
<syntaxhighlight lang="red">>> random/only collect [repeat i 10 [keep i]]</syntaxhighlight>

=={{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}}==
===version 1===
This REXX example takes the Rosetta Code task very literally.

Also, the newly named elements have been incorporated into this table.
<syntaxhighlight lang="rexx">/*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. */</syntaxhighlight>
{{out|output}}
<pre>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</pre>

===version 2===
Slightly simplified:
<br><br>Note that this version doesn't work (receives a syntax error 12) with REXXes that have a 
<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). 
<syntaxhighlight lang="rexx">
/* 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)))    
</syntaxhighlight>

=={{header|Ring}}==
<syntaxhighlight lang="ring">
aList  = "abcdefghij"
for i = 1 to 10
    letter = random(9) + 1
    if letter > 0
       see aList[letter] + nl
    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}}==
<syntaxhighlight lang="ruby">
%w(north east south west).sample   # => "west"
(1..100).to_a.sample(2)            # => [17, 79]</syntaxhighlight>

=={{header|Run BASIC}}==
<syntaxhighlight lang="runbasic">list$  = "a,b,c,d,e,f,g,h,i,j"
letter = rnd(1) * 10
print "Selected letter:"; word$(list$,letter,",")</syntaxhighlight>

=={{header|Rust}}==
{{libheader|rand}}
<syntaxhighlight lang="rust">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());
}</syntaxhighlight>

=={{header|Scala}}==
{{libheader|Scala}}
<syntaxhighlight lang="scala">val a = (1 to 10).toList

println(scala.util.Random.shuffle(a).head)</syntaxhighlight>

=={{header|Seed7}}==
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i";

const proc: main is func
  begin
    writeln(rand([] ("foo", "bar", "baz")));
  end func;</syntaxhighlight>

=={{header|Sidef}}==
<syntaxhighlight lang="ruby">var arr = %w(north east south west);
say arr.rand;
say arr.rand(2).dump;</syntaxhighlight>
{{out}}
<pre>south
['west', 'south']</pre>

=={{header|Smalltalk}}==
<syntaxhighlight lang="smalltalk">x := #(1 2 3) atRandom.</syntaxhighlight>

=={{header|SuperCollider}}==
<syntaxhighlight lang="supercollider">[1, 2, 3].choose</syntaxhighlight>

=={{header|Swift}}==
<syntaxhighlight lang="swift">import Darwin

let myList = [1, 2, 4, 5, 62, 234, 1, -1]
print(myList[Int(arc4random_uniform(UInt32(myList.count)))])</syntaxhighlight>

=={{header|Tcl}}==
Random selection from a list is implemented by composing <code>lindex</code> 
(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:
<syntaxhighlight lang="tcl">proc randelem {list} {
    lindex $list [expr {int(rand()*[llength $list])}]
}
set x [randelem {1 2 3 4 5}]</syntaxhighlight>

=={{header|TUSCRIPT}}==
<syntaxhighlight lang="tuscript">$$ 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</syntaxhighlight>
{{out}}
<pre>
Selecting term 3  in the list, which was George
</pre>

=={{header|TXR}}==
{{trans|Tcl}}

<syntaxhighlight lang="txr">@(do (defun randelem (seq)
       [seq (random nil (length seq))]))
@(bind x @(randelem #("a" "b" "c" "d")))</syntaxhighlight>

=={{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}}==
<syntaxhighlight lang="ursa"># 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 console</syntaxhighlight>

=={{header|VBA}}==

<syntaxhighlight lang="vb">
Option 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 Function
</syntaxhighlight>

=={{header|VBScript}}==
<syntaxhighlight lang="vb">Function 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"))</syntaxhighlight>

{{Out}}
<pre>d</pre>

=={{header|Visual Basic .NET}}==
{{trans|C#}}
<syntaxhighlight lang="vbnet">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 Module</syntaxhighlight>

=={{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}}==
<syntaxhighlight lang="wren">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)])</syntaxhighlight>

{{out}}
Sample run:
<pre>
blue
red
pink
yellow
red
</pre>

=={{header|XBS}}==
<syntaxhighlight lang="xbs">set Array = ["Hello","World",1,2,3];
log(Array[rnd(0,?Array-1)]);</syntaxhighlight>

=={{header|XPL0}}==
<syntaxhighlight lang="xpl0">code Ran=1, Text=12;
int  List;
[List:= ["hydrogen", "helium", "lithium", "beryllium", "boron"];  \(Thanks REXX)
Text(0, List(Ran(5)));
]</syntaxhighlight>

=={{header|Zig}}==
This example uses the [http://www.pcg-random.org/ PCG] algorithm.

<syntaxhighlight lang="zig">const std = @import("std");

const debug = std.debug;
const rand = std.rand;
const time = std.time;

test "pick random element" {
    var pcg = rand.Pcg.init(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', '?', '!',
        '<', '>', '(', ')',
    };

    var i: usize = 0;
    while (i < 32) : (i += 1) {
        if (i % 4 == 0) {
            debug.warn("\n  ", .{});
        }
        debug.warn("'{c}', ", .{chars[pcg.random.int(usize) % chars.len]});
    }

    debug.warn("\n", .{});
}</syntaxhighlight>

{{out}}
<pre>Test [1/1] test "pick random element"...
  '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', 
All 1 tests passed.</pre>

=={{header|zkl}}==
{{trans|XPL0}}
<syntaxhighlight lang="zkl">list:=T("hydrogen", "helium", "lithium", "beryllium", "boron");
list[(0).random(list.len())]</syntaxhighlight>