Pick random element: Difference between revisions

{{trans|Python}}

 

 

=={{header|8086 Assembly}}==

 

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

.stack 1024

 

mov ax,4C00h

int 21h ;exit program and return to MS-DOS

 

=={{header|ACL2}}==

 

 

(defun pick-random-element (xs state)

(mv-let (idx state)

(random$ (len xs) state)

 

=={{header|Action!}}==

DEFINE PTR="CARD"

PTR ARRAY a(7)

PrintE(a(index))

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Pick_random_element.png Screenshot from Atari 8-bit computer]

resp. a list of consonants.

 

 

procedure Pick_Random_Element is

end loop;

Ada.Text_IO.New_Line;

 

{{out}}

 

=={{header|Aime}}==

 

l_append(l, 'a');

 

o_byte(l[drand(5)]);

 

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release 2.8.win32}}

 

OP PICKRANDOM = ( []STRING list )STRING:

print( ( PICKRANDOM days, newline ) )

 

{{out}}

<pre>

=={{header|APL}}==

{{works with|Dyalog APL}}

{{out}}

<pre> pickRandom 'ABCDE'

 

=={{header|AppleScript}}==

{{out}}

<pre>"two"</pre>

=={{header|Arturo}}==

 

 

 

{{out}}

; True Arrays

{{works with|AutoHotkey_L}}

Random, randint, 1, % list.MaxIndex()

; Pseudo-Arrays

{{works with|AutoHotkey_Basic}}

StringSplit list, list, `,

Random, randint, 1, %list0%

 

=={{header|AWK}}==

BEGIN {

n = split("Monday,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday",day_of_week,",")

printf("%s\n",day_of_week[x])

exit(0)

{{out}}

<pre>GAWK -f PICK_RANDOM_ELEMENT.AWK

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]

 

element = RANDOM(6) + 1

 

{{out}}

 

=={{header|Bash}}==

 

rand() {

}

 

 

=={{header|BASIC}}==

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

 

'output

 

See also: [[#Liberty BASIC|Liberty BASIC]], [[#PureBasic|PureBasic]], [[#Run BASIC|Run BASIC]]

 

==={{header|Commodore BASIC}}===

20 FOR I=0 TO 9 : READ A$(I) : NEXT

30 X = RND(-TI) : REM 'PLANT A RANDOM SEED'

60 END

100 DATA ALPHA, BRAVO, CHARLIE, DELTA, ECHO

 

=={{header|Batch File}}==

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

setlocal enabledelayedexpansion

 

echo.!pseudo[%rndInt%]!

pause

{{Out|Sample Outputs}}

<pre>Delta

 

=={{header|BBC BASIC}}==

list$() = "The", "five", "boxing", "wizards", "jump", "quickly"

chosen% = RND(6)

{{out}}

<pre>

 

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

67

PR1 5‿67‿7‿23

 

=={{header|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.

=={{header|C}}==

 

#include <stdio.h>

#include <stdlib.h>

return 0;

}

Output

<pre>

 

=={{header|C sharp}}==

using System.Collections.Generic;

 

Console.WriteLine("I picked element {0}", randomElement);

}

 

=={{header|C++}}==

#include <random>

#include <vector>

<< " !\n" ;

return 0 ;

 

=={{header|Ceylon}}==

 

DefaultRandom

value element = random.nextElement([1, 2, 3, 4, 5, 6]);

print(element);

 

=={{header|Clojure}}==

 

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

stream$putl(po, random_element[string](arr))

end

{{out}}

<pre>qux

=={{header|COBOL}}==

{{works with|GNU Cobol}}

IDENTIFICATION DIVISION.

PROGRAM-ID. random-element.

DISPLAY nums (random-idx)

.

 

=={{header|CoffeeScript}}==

 

=={{header|Common Lisp}}==

 

(print (nth (random (length *list*)) *list*))

(print (nth (random (length *list*)) *list*))

 

{{out}}

 

=={{header|Crystal}}==

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

 

=={{header|D}}==

 

void main() {

const items = ["foo", "bar", "baz"];

items[uniform(0, $)].writeln;

 

=={{header|Delphi}}==

 

=={{header|Déjà Vu}}==

 

=={{header|EasyLang}}==

 

 

=={{header|EchoLisp}}==

(define (pick-random list)

(list-ref list (random (length list))))

(pick-random (iota 1000)) → 667

(pick-random (iota 1000)) → 179

 

=={{header|Elena}}==

extension listOp

{

randomItem()

}

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)

 

=={{header|Emacs Lisp}}==

(nth (random (length items)) items))

 

(random-choice '("a" "b" "c"))

 

=={{header|Erlang}}==

-module(pick_random).

-export([main/0]).

Index = rand:uniform(length(List)),

lists:nth(Index,List).

 

=={{header|Euphoria}}==

 

=={{header|F_Sharp|F#}}==

let rand = new System.Random()

 

=={{header|Factor}}==

 

=={{header|Falcon}}==

lst = [1, 3, 5, 8, 10]

> randomPick(lst)

 

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

implicit none

 

call random_number(r)

write(*,*) a(int(r*size(a)) + 1)

 

=={{header|Free Pascal}}==

 

=={{header|FreeBASIC}}==

 

Dim a(0 To 9) As String = {"Zero", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine"}

Print a(randInt)

Next

 

Sample output :

 

=={{header|Frink}}==

 

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

 

Output:

<pre>

 

=={{header|GAP}}==

 

This works with many GAP objects, for instance groups:

 

 

 

=={{header|Go}}==

 

import (

rand.Seed(time.Now().UnixNano())

fmt.Println(list[rand.Intn(len(list))])

 

=={{header|Groovy}}==

Solution:

def random = new Random();

 

def i = random.nextInt(list.size())

println "list[${i}] == ${list[i]}"

 

{{out}}

 

Alternate Solution:

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

 

=={{header|GW-BASIC}}==

20 DIM ARR(10) : REM initialise array

30 FOR I = 1 TO 10

50 NEXT I

60 C = 1 + INT(RND*10) : REM get a random index from 1 to 10 inclusive

{{out}}<pre> 81</pre>

 

=={{header|Haskell}}==

Creating a custom function:

 

 

pick :: [a] -> IO a

pick xs = fmap (xs !!) $ randomRIO (0, length xs - 1)

 

 

Using the random-fu library:

 

 

For example:

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

 

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

 

=={{header|J}}==

 

=={{header|Java}}==

...

int[] array = {1,2,3};

 

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

 

=={{header|jq}}==

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

 

# An illustration - 10 selections at random with replacement:

{{out}}

<pre>

 

=={{header|Julia}}==

 

=={{header|K}}==

 

=={{header|Klingphix}}==

 

:pickran len rand * 1 + get ;

10 [drop pickran ?] for

 

{{out}}

<pre>("nest", "list")

 

=={{header|Kotlin}}==

 

import java.util.Random

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:

 

=={{header|Lasso}}==

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

)

 

 

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

wantedTerm =int( 10 *rnd( 1))

Selecting term 5 in the list, which was Peter

 

=={{header|LiveCode}}==

 

=={{header|Logo}}==

{{works with|UCB Logo}}

 

=={{header|Lua}}==

 

local a = {1,2,3}

 

=={{header|Maple}}==

randomNum := rand(1 ..numelems(a)):

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

{{out}}

<pre>c</pre>

=={{header|MATLAB}} / {{header|Octave}}==

In case list is a cell array:

 

If list is a vector:

 

=={{header|Maxima}}==

/* (%i1) random_element(['a, 'b, 'c]);

(%o1) c

 

=={{header|МК-61/52}}==

 

 

=={{header|Nanoquery}}==

list = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}

 

{{out}}

 

=={{header|NetLogo}}==

user-message one-of [ 1 3 "rooster" blue ]

;; from list containing variables and reporters

 

=={{header|NetRexx}}==

options replace format comments java crossref savelog symbols nobinary

 

 

say v1 v2 v3

 

=={{header|NewLISP}}==

(define (pick-random-element R)

(nth (rand (length R)) R))

Example:

<pre>

 

=={{header|Nim}}==

randomize()

 

let ls = @["foo", "bar", "baz"]

 

=={{header|Objeck}}==

 

=={{header|OCaml}}==

With a list:

let len = List.length lst in

 

<pre>

 

With an array:

let len = Array.length ary in

 

<pre>

- : int = 3

</pre>

 

=={{header|Oforth}}==

 

 

=={{header|Ol}}==

(import (otus random!))

 

(define x '("Monday" "Tuesday" "Wednesday" "Thursday" "Friday" "Saturday" "Sunday"))

(print (list-ref x (rand! (length x))))

 

=={{header|PARI/GP}}==

 

=={{header|Pascal}} / {{header|Delphi}} / {{header|Free Pascal}}==

 

const

randomize;

writeln(s[low(s) + random(length(s))]);

 

=={{header|Perl}}==

 

=={{header|Phix}}==

 

=={{header|PHP}}==

 

=={{header|PicoLisp}}==

 

=={{header|PL/I}}==

('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j');

{{out}}

<pre>

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

 

1..100 | Get-Random -Count 3

 

=={{header|Prolog}}==

{{works with|SWI-Prolog|6}}

 

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

M = i.

 

=={{header|PureBasic}}==

Protected x = ListSize(source())

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

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

 

a$="One" +#TAB$+ "Two" +#TAB$+ "Three" +#TAB$+ "Four" +#TAB$+ "Five" +#TAB$+

Print(StringField(a$,Random(CountString(a$,#TAB$),1),#TAB$)+#TAB$)

Next

{{out}}

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

 

=={{header|Python}}==

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

 

=={{header|Quackery}}==

 

randomise

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

{{out}}

<pre>

 

=={{header|R}}==

letters

# [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s"

# picking some elements with repetition, and concatenating to get a word

paste(sample(letters, 10, rep=T), collapse="")

 

=={{header|Racket}}==

 

#lang racket

(define (pick-item l)

(list-ref l (random (length l))))

 

=={{header|Raku}}==

In a nutshell, picking an element from a list

is implemented with a method conveniently called "pick":

 

There are various ways of doing something similar, though.

 

Selection with replacement: (roll of a die)

say (1..6).roll(3); # return a list of 3 random values in the range 1 through 6

 

Selection without replacement: (pick a card from a 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

Or you can always use the normal <tt>rand</tt> built-in

to generate a subscript (which automatically truncates any fractional part):

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:

 

=={{header|Red}}==

 

=={{header|ReScript}}==

 

let pickRand = arr => {

}

 

{{out}}

<pre>$ bsc pickrand.res > pickrand.bs.js

 

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

 

 

 

===version 2===

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

Say word(wl,random(1,words(wl)))

 

=={{header|Ring}}==

aList = "abcdefghij"

for i = 1 to 10

ok

next

 

=={{header|Ruby}}==

%w(north east south west).sample # => "west"

 

=={{header|Run BASIC}}==

letter = rnd(1) * 10

 

=={{header|Rust}}==

{{libheader|rand}}

 

use rand::Rng;

println!("{}", rng.choose(&array).unwrap());

 

=={{header|Scala}}==

{{libheader|Scala}}

 

 

=={{header|Seed7}}==

 

const proc: main is func

begin

writeln(rand([] ("foo", "bar", "baz")));

 

=={{header|Sidef}}==

say arr.rand;

{{out}}

<pre>south

 

=={{header|Smalltalk}}==

 

=={{header|SuperCollider}}==

 

=={{header|Swift}}==

 

let myList = [1, 2, 4, 5, 62, 234, 1, -1]

 

=={{header|Tcl}}==

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

}

 

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

{{out}}

<pre>

{{trans|Tcl}}

 

[seq (random nil (length seq))]))

 

=={{header|UNIX Shell}}==

{{works with|Bourne Again Shell}}

 

{{works with|Zsh}}

 

 

=={{header|Ursa}}==

decl string<> str

append "these" "are" "some" "values" str

 

decl ursa.util.random r

 

=={{header|VBA}}==

 

Option Explicit

 

Pick_Random_Element = myArray(Int((Rnd * (UBound(myArray) - LBound(myArray) + 1) + LBound(myArray))))

End Function

 

=={{header|VBScript}}==

Set objRandom = CreateObject("System.Random")

pick_random = arr(objRandom.Next_2(0,UBound(arr)+1))

End Function

 

 

{{Out}}

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

Console.WriteLine("I picked element {0}", randomElement)

End Sub

 

=={{header|Wren}}==

 

var rand = Random.new()

var colors = ["red", "green", "blue", "yellow", "pink"]

 

{{out}}

 

=={{header|XBS}}==

 

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

 

debug.warn("\n", .{});

 

{{out}}

=={{header|zkl}}==

{{trans|XPL0}}