Pick random element

Demonstrate how to pick a random element from a list.

11l

Translation of: Python

print(random:choice([‘foo’, ‘bar’, ‘baz’]))

The easiest way to pick a random element from a list is to use a random number generator's output as an index into an array. Care must be taken not to index out of bounds. If the array's size is a power of 2, then index = RNG output & (array size - 1) will ensure that the array is not indexed out of bounds while maintaining the randomness of the selection. Otherwise, you will have to manually check the RNG output against the array's size and roll again if the RNG output is larger.

For brevity's sake, the implementations of the RNG and printing routines were left out; they can be provided if requested.

    .model small
    .stack 1024

    .data
TestList byte 00h,05h,10h,15h,20h,25h,30h,35h

    .code
	
start:
	mov ax,@data
	mov ds,ax
	
	mov ax,@code
	mov es,ax

	call seedXorshift32				;seeds the xorshift rng using the computer's date and time
	
	call doXorshift32
	mov ax,word ptr [ds:xorshift32_state_lo]	;retrieve the rng output
	and al,00000111b				;constrain the rng to values 0-7
	
	mov bx,offset TestList
	XLAT						;translate AL according to [DS:BX]
	
	call PrintHex					;display AL to the terminal
	

	mov ax,4C00h
	int 21h						;exit program and return to MS-DOS
        end start

Output:

(After four runs of the program)

ACL2

:set-state-ok t

(defun pick-random-element (xs state)
   (mv-let (idx state)
           (random$ (len xs) state)
      (mv (nth idx xs) state)))

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

Output:

Screenshot from Atari 8-bit computer

Thursday
Tuesday
Friday
Friday
Saturday
Tuesday
Monday
Saturday
Sunday
Wednesday
Monday
Friday
Wednesday
Saturday
Friday
Thursday
Saturday
Saturday
Wednesday
Wednesday

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.

with Ada.Text_IO, Ada.Numerics.Float_Random;

procedure Pick_Random_Element is

   package Rnd renames Ada.Numerics.Float_Random;
   Gen: Rnd.Generator; -- used globally

   type Char_Arr is array (Natural range <>) of Character;

   function Pick_Random(A: Char_Arr) return Character is
      -- Chooses one of the characters of A (uniformly distributed)
   begin
      return A(A'First + Natural(Rnd.Random(Gen) * Float(A'Last)));
   end Pick_Random;

   Vowels    : Char_Arr := ('a', 'e', 'i', 'o', 'u');
   Consonants: Char_Arr := ('t', 'n', 's', 'h', 'r', 'd', 'l');
   Specials  : Char_Arr := (',', '.', '?', '!');

begin
   Rnd.Reset(Gen);
   for J in 1 .. 3 loop
      for I in 1 .. 10 loop
         Ada.Text_IO.Put(Pick_Random(Consonants));
         Ada.Text_IO.Put(Pick_Random(Vowels));
      end loop;
      Ada.Text_IO.Put(Pick_Random(Specials) & " ");
   end loop;
   Ada.Text_IO.New_Line;
end Pick_Random_Element;

Output:

horanohesuhodinahiru. desehonirosedisinelo, losihehederidonolahe?

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');

ALGOL 68

Works with: ALGOL 68G version Any - tested with release 2.8.win32

BEGIN # pick a random element from an array of strings #

    OP PICKRANDOM = ( []STRING list )STRING:
    BEGIN

        INT number of elements = ( UPB list - LWB list ) + 1;
        INT random element     =
            ENTIER ( next random * ( number of elements ) );

        list[ LWB list + random element ]
    END; # PICKRANDOM #
    # can define additional operators for other types of array #


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

        print( ( PICKRANDOM days, newline ) )
    END
END

Output:

Thursday

APL

Works with: Dyalog APL

pickRandom ← (?≢)⊃⊢

Output:

      pickRandom 'ABCDE'
E
      pickRandom 'ABCDE'
D
      pickRandom 'ABCDE'
A

App Inventor

App Inventor has the block pick a random item for selecting a random item from a list.
CLICK HERE TO VIEW THE BLOCKS AND ANDROID APP DISPLAY

AppleScript

get some item of [1, "two", pi, "4", 5 > 4, 5 + 1, Sunday]

Output:

"two"

Arturo

fruit: ["apple" "banana" "pineapple" "apricot" "watermelon"]

print sample fruit

Output:

pineapple

AutoHotkey

True Arrays

Works with: AutoHotkey_L

list := ["abc", "def", "gh", "ijklmnop", "hello", "world"]
Random, randint, 1, % list.MaxIndex()
MsgBox % List[randint]

Pseudo-Arrays

Works with: AutoHotkey_Basic

list := "abc,def,gh,ijklmnop,hello,world"
StringSplit list, list, `,
Random, randint, 1, %list0%
MsgBox % List%randint%

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

Output:

GAWK -f PICK_RANDOM_ELEMENT.AWK
Sunday
GAWK -f PICK_RANDOM_ELEMENT.AWK
Monday
GAWK -f PICK_RANDOM_ELEMENT.AWK
Wednesday
GAWK -f PICK_RANDOM_ELEMENT.AWK
Tuesday

BaCon

This is simply an application of a ranged random number used as an array index. BaCon has no built in random element selector.

' Pick random element
OPTION BASE 1
DECLARE words$[6]
FOR i = 1 TO 6 : READ words$[i] : NEXT
DATA "Alpha", "Beta", "Gamma", "Delta", "Epsilon", "Zeta"

element = RANDOM(6) + 1
PRINT "Chose ", element, ": ", words$[element]

Output:

prompt$ ./pick-random-element
Chose 2: Beta
prompt$ ./pick-random-element
Chose 1: Alpha
prompt$ ./pick-random-element
Chose 5: Epsilon

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"

BASIC

Works with: QBasic

Works with: PowerBASIC

Note the use of LBOUND and UBOUND. This is only necessary for arrays where the lower and upper limits aren't known. In this example, we know they are 0 and 10 respectively, and could have hard-coded those numbers. (For that matter, the "random selection" line could've just been entered as x = INT(RND * 11).)

'setup
DIM foo(10) AS LONG
DIM n AS LONG, x AS LONG
FOR n = LBOUND(foo) TO UBOUND(foo)
    foo(n) = INT(RND*99999)
NEXT
RANDOMIZE TIMER

'random selection
x = INT(RND * ((UBOUND(foo) - LBOUND(foo)) + 1))

'output
PRINT x, foo(x)

See also: Liberty BASIC, PureBasic, Run BASIC

Applesoft BASIC

This is the same as the Commodore BASIC solution, except the Commodore timer variable TI is just a regular variable in Applesoft and gets set to a 16-bit random seed value. This is a number which is continually counted up while waiting for a keypress.

 10  DIM A$(9)
 20  FOR I = 0 TO 9: READ A$(I): NEXT 
25 TI = PEEK(78) + PEEK(79)*256
 30 X =  RND ( - TI): REM  'PLANT A RANDOM SEED'
 40 X =  INT ( RND (1) * 10)
 50  PRINT A$(X)
 60  END 
 100  DATAALPHA, BRAVO, CHARLIE, DELTA, ECHO
 110  DATAFOXTROT, GOLF, HOTEL, INDIA, JULIETT

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

Chipmunk Basic

Works with: Chipmunk Basic version 3.6.4

The Commodore BASIC solution works without any changes.

Commodore BASIC

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

True BASIC

Translation of: 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

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

Batch File

Since there is no arrays in Batch File, I will use a 1-based pseudo-array.

@echo off
setlocal enabledelayedexpansion

	::Initializing the pseudo-array...
set "pseudo=Alpha Beta Gamma Delta Epsilon"
set cnt=0 & for %%P in (!pseudo!) do (
	set /a cnt+=1
	set "pseudo[!cnt!]=%%P"
)
	::Do the random thing...
set /a rndInt=%random% %% cnt +1

	::Print the element corresponding to rndint...
echo.!pseudo[%rndInt%]!
pause
exit /b

Sample Outputs:

Delta
Press any key to continue . . .

Gamma
Press any key to continue . . .

Epsilon
Press any key to continue . . .

Gamma
Press any key to continue . . .

BBC BASIC

      DIM list$(5)
      list$() = "The", "five", "boxing", "wizards", "jump", "quickly"
      chosen% = RND(6)
      PRINT "Item " ; chosen% " was chosen which is '" list$(chosen%-1) "'"

Output:

Item 4 was chosen which is 'wizards'

BQN

PR1 is a tacit translation of PR.

Both use BQN's system value •rand, which contains multiple functions for generating random values.

PR ← {𝕩⊑˜•rand.Range ≠𝕩}
PR1 ← •rand.Range∘≠⊸⊑

Usage:

   PR 5‿67‿7‿23
67
   PR1 5‿67‿7‿23
7

Burlesque

blsq ) "ABCDEFG"123456 0 6rn-]!!
'G

123456 is the random seed. In order to pick another element you have to change the random seed.

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;
}

Output

a
e
f
h
b
d
g
a
b
f
a
i
b
d
d
g
j
a
f
e
a
e
g
e
i
d
j
a
f
e
a

C#

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);
  }
}

C++

#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 ;
}

Ceylon

import ceylon.random {

	DefaultRandom
}

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

Clojure

(rand-nth coll)

where coll is some sequential collection. Equivalent to:

(nth coll (rand-int (count coll)))

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

Output:

qux
foo
qux
bar
foo

COBOL

Works with: GNU 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.

CoffeeScript

array = [1,2,3]
console.log array[Math.floor(Math.random() * array.length)]

Common 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*))

Output:

FIVE 
THREE 
ONE

Crystal

puts [1, 2, 3, 4, 5].sample(1)

D

import std.stdio, std.random;

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

Dart

Translation of: C

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]);
  }
}

Delphi

See #Pascal / Delphi / Free Pascal.

Déjà Vu

!print choose [ "one" "two" "chicken" ]

DuckDB

Works with: DuckDB version V1.0

# PRN in range(0,n)
create or replace function prn(n) as trunc(random() * n)::BIGINT;

create or replace function list_random(lst) as
  lst[ 1 + prn(length(lst)) ] ;

## Example:
select histogram( r )
   from (select list_random( [1,2,3] ) as r from range(0,1000) _(n));

Output:

┌───────────────────────┐
│     histogram(r)      │
│ map(integer, ubigint) │
├───────────────────────┤
│ {1=322, 2=333, 3=345} │
└───────────────────────┘

EasyLang

ar$[] = [ "spring" "summer" "autumn" "winter" ]
print ar$[random len ar$[]]

EchoLisp

(define (pick-random list)
    (list-ref list (random (length list))))
(pick-random (iota 1000)) → 667
(pick-random (iota 1000)) → 179

Elena

ELENA 6.x :

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())
}

Elixir

Works with: Elixir version 1.2

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]

Emacs Lisp

(defun random-choice (items)
  (nth (random (length items)) items))

(random-choice '("a" "b" "c"))
;; => "a"

EMal

for each int i in range(5)
  writeLine(random(text["Dee", "do", "de", "de"]))
end

Output:

do
de
do
de
Dee

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

Euphoria

constant s = {'a', 'b', 'c'}
puts(1,s[rand($)])

F#

let list = ["a"; "b"; "c"; "d"; "e"]
let rand = new System.Random()
printfn "%s" list.[rand.Next(list.Length)]

Factor

( scratchpad ) { "a" "b" "c" "d" "e" "f" } random .
"a"

Falcon

lst = [1, 3, 5, 8, 10]
> randomPick(lst)

Fortran

Works with: Fortran version 90 and later

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

Free Pascal

See #Pascal / Delphi / Free Pascal.

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

Sample output :

Output:

Zero
Seven
Three
Nine
Three

Frink

a = ["one", "two", "three"]
println[random[a]]

FutureBasic

random

mda(0) = {0,1,2,3,4,5,6,7,8,9}

print mda(rnd(10)-1)

HandleEvents

Gambas

You can run this code. Copy the code, click this link, paste it in and press 'Run !'

Public Sub Main()
Dim sList As String[] = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]

Print sList[Rand(0, 11)]

End

Output:

May

GAP

a := [2, 9, 4, 7, 5, 3];
Random(a);

This works with many GAP objects, for instance groups:

Random(SymmetricGroup(20));

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

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))])
}

Groovy

Solution:

def list = [25, 30, 1, 450, 3, 78]
def random = new Random();

(0..3).each {
    def i = random.nextInt(list.size())
    println "list[${i}] == ${list[i]}"
}

Output:

list[3] == 450
list[2] == 1
list[5] == 78
list[3] == 450

Alternate Solution:

[25, 30, 1, 450, 3, 78].sort{new Random()}?.take(1)[0]

GW-BASIC

10 RANDOMIZE TIMER       :   REM set random number seed to something arbitrary
20 DIM ARR(10)           :   REM initialise array
30 FOR I = 1 TO 10
40 ARR(I) = I*I          :   REM squares of the integers is OK as a demo
50 NEXT I
60 C = 1 + INT(RND*10)   :   REM  get a random index from 1 to 10 inclusive
70 PRINT ARR(C)

Output:

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)])!;
};

Haskell

Creating a custom function:

import System.Random (randomRIO)

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

x <- pick [1, 2, 3]

Using the random-fu library:

import Data.Random
sample $ randomElement  [1, 2, 3]

For example:

do 
  x <- sample $ randomElement  [1, 2, 3]
  print x

Icon and Unicon

The unary operator '?' selects a random element from its argument which may be a string, list, table, or set.

procedure main()
   L := [1,2,3]  # a list
   x := ?L       # random element
end

Insitux

(rand-pick (range 100))

J

   ({~ ?@#) 'abcdef'
b

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

For a List object rather than an array, substitute list.get(...) for array[...]. If preserving the order of the List isn't important, you could call Collections.shuffle(list); and then list.get(0);. You would need to shuffle each time unless you removed the item from the list.

JavaScript

var array = [1,2,3];
return array[Math.floor(Math.random() * array.length)];

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.

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:

< /dev/urandom tr -cd '0-9' | fold -w 1 | jq -MRcnr -f program.jq

# Output: a prn in range(0;$n) where $n is `.`
def prn:
  if . == 1 then 0
  else . as $n
  | ([1, (($n-1)|tostring|length)]|max) as $w
  | [limit($w; inputs)] | join("") | tonumber
  | if . < $n then . else ($n | prn) end
  end;

# An illustration - 10 selections at random with replacement:
range(0;10) | ["a", "b", "c"] | .[length|prn]

Output:

bcbabacbbc

Julia

array = [1,2,3]
rand(array)

K

  1?"abcdefg"
,"e"

Klingphix

include ..\Utilitys.tlhy

:pickran len rand * 1 + get ;

( 1 3.1415 "Hello world" ( "nest" "list" ) )

10 [drop pickran ?] for

" " input

Output:

("nest", "list")
3.1415
("nest", "list")
Hello world
1
Hello world
3.1415
("nest", "list")
1
3.1415

Kotlin

// version 1.2.10

import java.util.Random

/**
 * Extension function on any list that will return a random element from index 0 
 * to the last index
 */
fun <E> List<E>.getRandomElement() = this[Random().nextInt(this.size)]

/**
 * Extension function on any list that will return a list of unique random picks
 * from the list. If the specified number of elements you want is larger than the
 * number of elements in the list it returns null
 */
fun <E> List<E>.getRandomElements(numberOfElements: Int): List<E>? {
    if (numberOfElements > this.size) {
        return null
    }
    return this.shuffled().take(numberOfElements)
}

fun main(args: Array<String>) { 
    val list = listOf(1, 16, 3, 7, 17, 24, 34, 23, 11, 2)
    println("The list consists of the following numbers:\n${list}")
 
    // notice we can call our extension functions as if they were regular member functions of List
    println("\nA randomly selected element from the list is ${list.getRandomElement()}")
    println("\nA random sequence of 5 elements from the list is ${list.getRandomElements(5)}")
}

Sample output:

Output:

The list consists of the following numbers:
[1, 16, 3, 7, 17, 24, 34, 23, 11, 2]

A randomly selected element from the list is 11

A random sequence of 5 elements from the list is [17, 24, 23, 16, 3]

LabVIEW

This image is a VI Snippet, an executable image of LabVIEW code. The LabVIEW version is shown on the top-right hand corner. You can download it, then drag-and-drop it onto the LabVIEW block diagram from a file browser, and it will appear as runnable, editable code.

Lasso

local(
	my array = array('one', 'two', 3)
)

#myarray -> get(integer_random(#myarray -> size, 1))

-> two

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.

list$ ="John Paul George Ringo Peter Paul Mary Obama Putin"
wantedTerm =int( 10 *rnd( 1))
print "Selecting term "; wantedTerm; " in the list, which was "; word$( list$, wantedTerm, " ")

Selecting term 5 in the list, which was Peter

LiveCode

put "Apple,Banana,Peach,Apricot,Pear" into fruits
put item (random(the number of items of fruits)) of fruits

Logo

Works with: UCB Logo

pick [1 2 3]

Lua

math.randomseed(os.time())
local a = {1,2,3}
print(a[math.random(1,#a)])

Maple

a := [bear, giraffe, dog, rabbit, koala, lion, fox, deer, pony]:
randomNum := rand(1 ..numelems(a)):
a[randomNum()];

Mathematica /Wolfram Language

RandomChoice[{a, b, c}]

Output:

MATLAB / Octave

In case list is a cell array:

        list = {'a','b','c'}; 
	list{ceil(rand(1)*length(list))}

If list is a vector:

        list = 1:1000; 
	list(ceil(rand(1)*length(list)))

Maxima

random_element(l):= part(l, 1+random(length(l)));
/*  (%i1) random_element(['a, 'b, 'c]);
    (%o1)                                  c
*/

МК-61/52

0 П0 1 П1 2 П2 3 П3 4 П4 5

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

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

Output:

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

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

NewLISP

(define (pick-random-element R)
	(nth (rand (length R)) R))

Example:

(setq X '("alpha" "beta" "gamma" "delta" "epsilon"))
(println (pick-random-element X))
(println (pick-random-element X))
(println (pick-random-element X))
(println (pick-random-element X))

Nim

import random
randomize()

let ls = @["foo", "bar", "baz"]
echo sample(ls)

Nu

Works with: Nushell version 0.96.1

[5 6 7 8 9] | get (random int ..<($in | length))

Objeck

values := [1, 2, 3];
value := values[(Float->Random() * 100.0)->As(Int) % values->Size()];

OCaml

With a list:

let list_rand lst =
  let len = List.length lst in
  List.nth lst (Random.int len)

# list_rand [1;2;3;4;5] ;;
- : int = 3

With an array:

let array_rand ary =
  let len = Array.length ary in
  ary.(Random.int len)

# array_rand [|1;2;3;4;5|] ;;
- : int = 3

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])
}

Oforth

: pickRand(l)   l size rand l at ;

Ol

(import (otus random!))

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

PARI/GP

pick(v)=v[random(#v)+1]

Pascal / Delphi / Free Pascal

Program PickRandomElement (output);

const
  s: array [1..5] of string = ('1234', 'ABCDE', 'Charlie', 'XB56ds', 'lala');

begin
  randomize;
  writeln(s[low(s) + random(length(s))]);
end.

PascalABC.NET

begin
  var a := Arr('cat','dog','wolf','zebra');
  a.RandomElement.Print
end.

Perl

my @array = qw(a b c);
print $array[ rand @array ];

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.

with javascript_semantics
constant s = {1,2.5,"three",{4,{"4 as well"}}}
pp(s[rand(length(s))])

PHP

$arr = array('foo', 'bar', 'baz');
$x = $arr[array_rand($arr)];

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.

Output:

choice = 4
[7,8,6,4,6,7,3,10,2,3]
ekcealmnei

This is a more structured output.

Translation of: Ada

go2 =>
   _ = random2(),
   Vowels     = "aeiou",
   Consonants = "tnshrdl",
   Specials  = ",.?!",
   RandWords = [( [[Consonants.choice()] ++ [Vowels.choice()] : _ in 1..10] 
                   ++ [Specials.choice()]
                ).flatten()
               : _ in 1..3] ,
   println(RandWords),
   nl.

Output:

[dodidosisahuhiretesi,,loledohusoluhusululu?,tunuridunoheditonudu!]

Get the random elements from a frequency table (converted to a "Roulette wheel").

% Pick according to a frequency table
go3 =>
  _ = random2(),
  Max = 17,
  S = letter_freq_wheel(), 
  foreach(_ in 1..10)
     println([choice(S) :   _ in 1..1+choice(Max)]) 
  end,
  nl.

% Frequencies of letters converted to a "roulette wheel".
letter_freq_wheel = Chars => 
  Freq =
   [ [e,12.02],[t,9.10],[a,8.12],[o,7.68],[i,7.31],[n,6.95],[s,6.28],
     [r,6.02],[h,5.92],[d,4.32],[l,3.98],[u,2.88],[c,2.71],[m,2.61],
     [f,2.30],[y,2.11],[w,2.09],[g,2.03],[p,1.82],[b,1.49],[v,1.11],
     [k,0.69],[x,0.17],[q,0.11],[j,0.10],[z,0.07]
  ],
  Chars = [],
  foreach([C,F] in Freq)
     Chars := Chars ++ [C : _ in 1..ceiling(10*F)]
  end,
  nl.

Output:

ihvuotpswieecanrv
gnelhlutnopytoss
aentkttnenb
cnyawephc
nsioetohasedd
yapaeofyt
setmtoorwloiar
nsssrkcfgnpadtifln
rrlwree
nawmtnie

PicoLisp

(get Lst (rand 1 (length Lst)))

PL/I

   declare t(0:9) character (1) static initial
      ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j');
   put ( t(10*random()) );

Output:

Powershell

Powershell has Get-Random Cmdlet which one of its overload is to select randomly from a given list

1..100 | Get-Random -Count 3

Prolog

Works with: SWI-Prolog version 6

?- random_member(M, [a, b, c, d, e, f, g, h, i, j]).
M = i.

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

Output:

Source list:  One Two Three Four Five Six Seven Eight Nine Ten

Random picks from list:  Seven Nine Two Six Four Four Nine Three Six Two

Easy version

OpenConsole()

a$="One" +#TAB$+ "Two"  +#TAB$+ "Three" +#TAB$+ "Four" +#TAB$+ "Five" +#TAB$+ 
   "Six" +#TAB$+ "Seven"+#TAB$+ "Eight" +#TAB$+ "Nine" +#TAB$+ "Ten"  +#TAB$

Print("Source list: "+#TAB$+a$+#CRLF$+"Random list: "+#TAB$)

For i=1 To CountString(a$,#TAB$)
  Print(StringField(a$,Random(CountString(a$,#TAB$),1),#TAB$)+#TAB$)
Next
Input()

Output:

Source list:    One     Two     Three   Four    Five    Six     Seven   Eight   Nine    Ten
Random list:    One     Two     Seven   Nine    Ten     Seven   Three   Five    Ten     Nine

Python

>>> import random
>>> random.choice(['foo', 'bar', 'baz'])
'baz'

Quackery

  [ dup size random peek ]      is pick ( [ --> x )

  randomise
  ' [ 20 33 -15 7 0 ] pick echo cr
  ' pick pick echo

Output:

33
random

R

# 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"

Racket

#lang racket
(define (pick-item l)
  (list-ref l (random (length l))))

Raku

(formerly Perl 6)

Works with: rakudo version 2015-12-07

In a nutshell, picking an element from a list is implemented with a method conveniently called "pick":

say (1, 2, 3).pick;

There are various ways of doing something similar, though. Raku has actually two methods (with associated functional forms) to return random elements depending on whether you are doing selection with or without replacement.

Selection with replacement: (roll of a die)

say (1..6).roll;          # return 1 random value in the range 1 through 6
say (1..6).roll(3);       # return a list of 3 random values in the range 1 through 6
say (1..6).roll(*)[^100]; # return first 100 values from a lazy infinite list of random values in the range 1 through 6

Selection without replacement: (pick a card from a deck)

# define the deck
my @deck = <2 3 4 5 6 7 8 9 J Q K A> X~ <♠ ♣ ♥ ♦>;
say @deck.pick;    # Pick a card
say @deck.pick(5); # Draw 5
say @deck.pick(*); # Get a shuffled deck

Or you can always use the normal rand built-in to generate a subscript (which automatically truncates any fractional part):

@array[@array * rand]

However, the pick and roll methods (not to be confused with the pick-and-roll method in basketball) are more general insofar as they may be used on any enumerable type:

say Bool.pick;  # returns either True or False

Red

>> random/only collect [repeat i 10 [keep i]]

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

Output:

$ bsc pickrand.res > pickrand.bs.js
$ node pickrand.bs.js
lychee

REXX

version 1

This REXX example takes the Rosetta Code task very literally.

Also, the newly named elements have been incorporated into this table.

/*REXX program picks a   random element   from a list   (tongue in cheek, a visual pun).*/
l=  "Hydrogen_H Helium_He Lithium_Li Beryllium_Be Boron_B"
l=l "Carbon_C Nitrogen_N Oxygen_O Fluorine_F Neon_Ne Sodium_Na"
l=l "Magnesium_Mg Aluminium_Al Silicon_Si Phosphorus_P Sulfur_S"
l=l "Chlorine_Cl Argon_Ar Potassium_K Calcium_Ca Scandium_Sc"
l=l "Titanium_Ti Vanadium_V Chromium_Cr Manganese_Mn Iron_Fe"
l=l "Cobalt_Co Nickel_Ni Copper_Cu Zinc_Zn Gallium_Ga"
l=l "Germanium_Ge Arsenic_As Selenium_Se Bromine_Br Krypton_Kr"
l=l "Rubidium_Rb Strontium_Sr Yttrium_Y Zirconium_Zr Niobium_Nb"
l=l "Molybdenum_Mo Technetium_Tc Ruthenium_Ru Rhodium_Rh"
l=l "Palladium_Pd Silver_Ag Cadmium_Cd Indium_In Tin_Sn"
l=l "Antimony_Sb Tellurium_Te Iodine_I Xenon_Xe Caesium_Cs"
l=l "Barium_Ba Lanthanum_La Cerium_Ce Praseodymium_Pr"
l=l "Neodymium_Nd Promethium_Pm Samarium_Sm Europium_Eu"
l=l "Gadolinium_Gd Terbium_Tb Dysprosium_Dy Holmium_Ho Erbium_Er"
l=l "Thulium_Tm Ytterbium_Yb Lutetium_Lu Hafnium_Hf Tantalum_Ta"
l=l "Tungsten_W Rhenium_Re Osmium_Os Iridium_Ir Platinum_Pt"
l=l "Gold_Au Mercury_Hg Thallium_Tl Lead_Pb Bismuth_Bi"
l=l "Polonium_Po Astatine_At Radon_Rn Francium_Fr Radium_Ra"
l=l "Actinium_Ac Thorium_Th Protactinium_Pa Uranium_U"
l=l "Neptunium_Np Plutonium_Pu Americium_Am Curium_Cm"
l=l "Berkelium_Bk Californium_Cf Einsteinium_Es Fermium_Fm"
l=l "Mendelevium_Md Nobelium_No Lawrencium_Lr Rutherfordium_Rf"
l=l "Dubnium_Db Seaborgium_Sg Bohrium_Bh Hassium_Hs Meitnerium_Mt"
l=l "Darmstadtium_Ds Roentgenium_Rg Copernicium_Cn Nihonium_Nh"
l=l "Flerovium_Fl Moscovium_Mc Livermorium_Lv Tennessine_Ts"
l=l "Oganesson_Og Ununbium_Uub Ununtrium_Uut Ununquadium_Uuq"
n=words(l)                       /* Number of known elements            */
                                 /*-----  You can't trust atoms,   -----*/
                                 /*-----  they make everything up. -----*/
Parse Arg pick                   /* atomic number specified             */
If pick>n Then Do
  Say 'Element' pick 'hasn''t been discovered by now'
  Exit
  End
take=pick
If pick='' Then
  take=random(1,n)

item=word(l,take)                /*pick the specified or random element */
Parse Var item name '_' symbol
If pick='' Then
  which='Random'
Else
  which='Specified'
Say which 'element: ' take name '('symbol')' /*stick a fork in it,  we're all done. */

output:

E:\>rexx pez
Random element:  100 Fermium (Fm)

E:\>rexx pez 8
Specified element:  8 Oxygen (O)

E:\>rexx pez 133
Element 133 hasn't been discovered by now

version 2

Slightly simplified:

Note that this version doesn't work (receives a syntax error 12) with REXXes that have a
smaller limit of the total length of a clause, in particular PC/REXX and Personal REXX
which have a limit of 1,000 characters).

/* REXX *************************************************************** 
* 18.10.2012 Walter Pachl Not only the list of elements shortened:-)
**********************************************************************/ 
wl='hydrogen helium lithium beryllium boron carbon nitrogen oxygen',    
   'fluorine neon sodium magnesium aluminum silicon phosphorous sulfur',   
   '...',                                                                  
   'meitnerium darmstadtium roentgenium copernicium Ununtrium'             
                                                                        
Say word(wl,random(1,words(wl)))

Ring

aList  = "abcdefghij"
for i = 1 to 10
    letter = random(9) + 1
    if letter > 0
       see aList[letter] + nl
    ok       
next

RPL

≪ DUP SIZE RAND * CEIL GET ≫ ‘RANDGET’ STO

{ Alpha Beta Gamma Delta } RANDGET
{ Alpha Beta Gamma Delta } RANDGET
{ Alpha Beta Gamma Delta } RANDGET

Output:

3: ‘Delta’
2: ‘Alpha’
1: ‘Beta’

Ruby

%w(north east south west).sample   # => "west"
(1..100).to_a.sample(2)            # => [17, 79]

Run BASIC

list$  = "a,b,c,d,e,f,g,h,i,j"
letter = rnd(1) * 10
print "Selected letter:"; word$(list$,letter,",")

Rust

Library: rand

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());
}

Scala

Library: Scala

val a = (1 to 10).toList

println(scala.util.Random.shuffle(a).head)

Seed7

$ include "seed7_05.s7i";

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

Sidef

var arr = %w(north east south west);
say arr.rand;
say arr.rand(2).dump;

Output:

south
['west', 'south']

Smalltalk

x := #(1 2 3) atRandom.

SuperCollider

[1, 2, 3].choose

Swift

import Darwin

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

Tcl

Random selection from a list is implemented by composing lindex (for selection of an item from a list) and the pattern for generating an integral random number from the range ${\displaystyle [0,n)}$ . It's simpler to use when wrapped up as a helper procedure:

proc randelem {list} {
    lindex $list [expr {int(rand()*[llength $list])}]
}
set x [randelem {1 2 3 4 5}]

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

Output:

Selecting term 3  in the list, which was George

TXR

Translation of: Tcl

@(do (defun randelem (seq)
       [seq (random nil (length seq))]))
@(bind x @(randelem #("a" "b" "c" "d")))

UNIX Shell

Works with: Bourne Again Shell

list=(these are some words)
printf '%s\n' "${list[RANDOM%${#list[@]}]}"

Works with: Zsh

list=(these are some words)
printf '%s\n' "$list[RANDOM%$#list+1]"

Uiua

⊡⌊×⚂⧻."abcdefg"

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

VBA

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

VBScript

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

Output:

Visual Basic .NET

Translation of: C#

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

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 {}])
    }
}

Output:

Sample of random output:

1: peace
2: happiness
3: hello
4: friends
5: peace
6: people

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

Output:

Sample run:

blue
red
pink
yellow
red

XBS

set Array = ["Hello","World",1,2,3];
log(Array[rnd(0,?Array-1)]);

XPL0

code Ran=1, Text=12;
int  List;
[List:= ["hydrogen", "helium", "lithium", "beryllium", "boron"];  \(Thanks REXX)
Text(0, List(Ran(5)));
]

Zig

This example uses the PCG algorithm.

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", .{});
}

Output:

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.

zkl

Translation of: XPL0

list:=T("hydrogen", "helium", "lithium", "beryllium", "boron");
list[(0).random(list.len())]