Pick random element: Difference between revisions
added Falcon |
added Elixir |
||
Line 259: | Line 259: | ||
=={{header|Déjà Vu}}== |
=={{header|Déjà Vu}}== |
||
<lang dejavu>!print choose [ "one" "two" "chicken" ]</lang> |
<lang dejavu>!print choose [ "one" "two" "chicken" ]</lang> |
||
=={{header|Elixir}}== |
|||
<lang elixir> |
|||
defmodule Random do |
|||
def init() do |
|||
:random.seed(:erlang.now()) |
|||
end |
|||
def pick_element(list) do |
|||
Enum.at(list, :random.uniform(Enum.count(list)) - 1) |
|||
end |
|||
end |
|||
Random.init() |
|||
IO.puts Random.pick_element(1..20) |
|||
</lang> |
|||
=={{header|Erlang}}== |
=={{header|Erlang}}== |
Revision as of 08:20, 1 August 2014
![Task](http://static.miraheze.org/rosettacodewiki/thumb/b/ba/Rcode-button-task-crushed.png/64px-Rcode-button-task-crushed.png)
You are encouraged to solve this task according to the task description, using any language you may know.
Demonstrate how to pick a random element from a list.
ACL2
<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)))</lang>
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.
<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;</lang>
Sample Output:
horanohesuhodinahiru. desehonirosedisinelo, losihehederidonolahe?
Aime
<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_query(l, drand(5))); o_byte('\n');</lang>
ALGOL 68
<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 ) )
)</lang>
- Output:
Thursday
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
AutoHotkey
- True Arrays
<lang AHK>list := ["abc", "def", "gh", "ijklmnop", "hello", "world"] Random, randint, 1, % list.MaxIndex() MsgBox % List[randint]</lang>
- Pseudo-Arrays
<lang AutoHotkey>list := "abc,def,gh,ijklmnop,hello,world" StringSplit list, list, `, Random, randint, 1, %list0% MsgBox % List%randint%</lang>
Bash
<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"</lang>
BASIC
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)
.)
<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)</lang>
See also: Liberty BASIC, PureBasic, Run BASIC
BBC BASIC
<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) "'"</lang>
Output:
Item 4 was chosen which is 'wizards'
Burlesque
<lang burlesque> blsq ) "ABCDEFG"123456 0 6rn-]!! 'G </lang>
123456 is the random seed. In order to pick another element you have to change the random seed.
C
<lang C>#include <stdio.h>
- include <stdlib.h>
- include <time.h>
int main(){
char array[] = { 'a', 'b', 'c' };
srand( time( 0 ) );
printf( "%c\n", array[ rand() % 3 ] );
return 0;
}</lang>
C++
<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 ;
}</lang>
C#
<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); }
}</lang>
Clojure
<lang Clojure>(rand-nth coll)</lang>
where coll
is some sequential collection. Equivalent to:
<lang Clojure>(nth coll (rand-int (count coll)))</lang>
COBOL
<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.</lang>
CoffeeScript
<lang coffeescript>array = [1,2,3] console.log array[Math.floor(Math.random() * array.length)]</lang>
Common Lisp
<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*))</lang>
Output:
FIVE THREE ONE
D
<lang d>import std.stdio, std.random;
void main() {
const items = ["foo", "bar", "baz"]; items[uniform(0, $)].writeln;
}</lang>
Déjà Vu
<lang dejavu>!print choose [ "one" "two" "chicken" ]</lang>
Elixir
<lang elixir> defmodule Random do
def init() do :random.seed(:erlang.now()) end def pick_element(list) do Enum.at(list, :random.uniform(Enum.count(list)) - 1) end
end
Random.init() IO.puts Random.pick_element(1..20) </lang>
Erlang
<lang erlang>% Implemented by Arjun Sunel -module(pick_random). -export([main/0]).
main() -> List =[1,2,3,4,5], Index = random:uniform(length(List)), lists:nth(Index,List). </lang>
Euphoria
<lang euphoria>constant s = {'a', 'b', 'c'} puts(1,s[rand($)])</lang>
Factor
<lang factor>( scratchpad ) { "a" "b" "c" "d" "e" "f" } random . "a"</lang>
Falcon
<lang falcon> lst = [1, 3, 5, 8, 10] > randomPick(lst) </lang>
F#
<lang fsharp>let list = ["a"; "b"; "c"; "d"; "e"] let rand = new System.Random() printfn "%s" x.[rand.Next(list.Length)]</lang>
GAP
<lang gap>a := [2, 9, 4, 7, 5, 3]; Random(a);</lang>
Go
<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))])
}</lang>
Groovy
Solution: <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]}"
}</lang>
Output:
list[3] == 450 list[2] == 1 list[5] == 78 list[3] == 450
Haskell
Creating a custom function:
<lang haskell>import Random (randomRIO)
pick :: [a] -> IO a pick xs = randomRIO (0, length xs - 1) >>= return . (xs !!)
x <- pick [1 2 3]</lang>
Using the random-extras library:
<lang haskell>import Data.Random import Data.Random.Source.DevRandom import Data.Random.Extras
x <- runRVar (choice [1 2 3]) DevRandom</lang>
Icon and Unicon
The unary operator '?' selects a random element from its argument which may be a string, list, table, or set.
<lang Icon>procedure main()
L := [1,2,3] # a list x := ?L # random element
end</lang>
J
<lang j> ({~ ?@#) 'abcdef' b</lang>
Java
<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</lang>
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 remove
d the item from the list.
JavaScript
<lang javascript>var array = [1,2,3]; return array[Math.floor(Math.random() * array.length)];</lang>
Julia
<lang julia>array = [1,2,3] array[rand(1:length(array))]</lang>
K
<lang K> 1?"abcdefg" ,"e"</lang>
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
<lang Lasso>local( my array = array('one', 'two', 3) )
- myarray -> get(integer_random(#myarray -> size, 1))</lang>
-> 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. <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, " ")</lang>
Selecting term 5 in the list, which was Peter
Logo
<lang logo>pick [1 2 3]</lang>
Lua
<lang lua>math.randomseed(os.time()) local a = {1,2,3} print(a[math.random(1,#a)])</lang>
Mathematica
<lang Mathematica>RandomChoice[{a, b, c}] ->c</lang>
MATLAB / Octave
In case list is a cell array: <lang Matlab> list = {'a','b','c'}; list{ceil(rand(1)*length(list))}</lang>
If list is a vector: <lang Matlab> list = 1:1000; list(ceil(rand(1)*length(list)))</lang>
Maxima
<lang Maxima>random_element(l):= part(l, 1+random(length(l))); /* (%i1) random_element(['a, 'b, 'c]);
(%o1) c
- /</lang>
МК-61/52
<lang>0 П0 1 П1 2 П2 3 П3 4 П4 5
^ СЧ * [x] ПE КИПE С/П</lang>
NetLogo
<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) )</lang>
NetRexx
<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 </lang>
Nimrod
<lang nimrod>import math randomize()
proc random[T](a: openarray[T]): T =
a[random(a.low..a.len)]
let ls = @["foo", "bar", "baz"] echo ls.random()
var xs: array[10..14, string] for i in 10..14:
xs[i] = "foo: " & $i
echo xs.random()</lang>
Objeck
<lang objeck>values := [1, 2, 3]; value := values[(Float->Random() * 100.0)->As(Int) % values->Size()];</lang>
OCaml
With a list: <lang ocaml>let list_rand lst =
let len = List.length lst in List.nth lst (Random.int len)</lang>
# list_rand [1;2;3;4;5] ;; - : int = 3
With an array: <lang ocaml>let array_rand ary =
let len = Array.length ary in ary.(Random.int len)</lang>
# array_rand [|1;2;3;4;5|] ;; - : int = 3
PARI/GP
<lang parigp>pick(v)=v[random(#v)+1]</lang>
Pascal
<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.</lang>
Perl
<lang perl>my @array = qw(a b c); print $array[ rand @array ];</lang>
Perl 6
In a nutshell, picking an element from a list is implemented with a method conveniently called "pick": <lang Perl 6>say (1, 2, 3).pick;</lang>
There are various ways of doing something similar, though. Perl 6 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) <lang perl6>(1..6).roll; # return 1 random value in the range 1 through 6 (1..6).roll(3); # return a list of 3 random values in the range 1 through 6 (1..6).roll(*); # return a lazy infinite list of random values in the range 1 through 6</lang>
Selection without replacement: (pick a card from a deck) <lang perl6># define the deck constant deck = 2..9, <J Q K A> X~ <♠ ♣ ♥ ♦>; deck.pick; # Pick a card deck.pick(5); # Draw 5 deck.pick(*); # Get a shuffled deck</lang> Or you can always use the normal rand built-in to generate a subscript (which automatically truncates any fractional part): <lang perl6>@array[@array * rand]</lang> 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: <lang perl6>say Bool.pick; # returns either True or False</lang>
PHP
<lang php>$arr = array('foo', 'bar', 'baz'); $x = $arr[array_rand($arr)];</lang>
PicoLisp
<lang PicoLisp>(get Lst (rand 1 (length Lst)))</lang>
PL/I
<lang pli> declare t(0:9) character (1) static initial
('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'); put ( t(10*random()) );</lang>
output:
e
Prolog
<lang prolog> ?- random_member(M, [a, b, c, d, e, f, g, h, i, j]). M = i. </lang>
PureBasic
<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</lang> Sample 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
Python
<lang python>>>> import random >>> random.choice(['foo', 'bar', 'baz']) 'baz'</lang>
R
<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"</lang>
Racket
<lang Racket>
- lang racket
(define (pick-item l)
(list-ref l (random (length l))))
</lang>
REXX
version 1
This REXX example takes the task very literally. <lang rexx>/*REXX program to pick a random element from a list (tongue in cheek). */
_= 'hydrogen helium lithium beryllium boron carbon nitrogen oxygen' _=_ 'fluorine neon sodium magnesium aluminum silicon phosphorous sulfur' _=_ 'chlorine argon potassium calcium scandium titanium vanadium chromium' _=_ 'manganese iron cobalt nickel copper zinc gallium germanium arsenic' _=_ 'selenium bromine krypton rubidium strontium yttrium zirconium' _=_ 'niobium molybdenum technetium ruthenium rhodium palladium silver' _=_ 'cadmium indium tin antimony tellurium iodine xenon cesium barium' _=_ 'lanthanum cerium praseodymium neodymium promethium samarium europium' _=_ 'gadolinium terbium dysprosium holmium erbium thulium ytterbium' _=_ 'lutetium hafnium tantalum tungsten rhenium osmium irdium platinum' _=_ 'gold mercury thallium lead bismuth polonium astatine radon francium' _=_ 'radium actinium thorium protactinium uranium neptunium plutonium' _=_ 'americium curium berkelium californium einsteinum fermium mendelevium' _=_ 'nobelium lawrencium rutherfordium dubnium seaborgium bohrium hassium' _=_ 'meitnerium darmstadtium roentgenium copernicium Ununtrium'
w=words(_) say 'random element =' word(_,random(1,w))
/*stick a fork in it, we're done.*/</lang>
output
random element = ytterbium
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).
<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))) </lang>
Ruby
<lang ruby>irb(main):001:0> %w(north east south west).sample => "west" irb(main):002:0> (1..100).to_a.sample(2) => [17, 79]</lang>
<lang ruby>irb(main):001:0> %w(north east south west).choice => "south"</lang>
Run BASIC
<lang runbasic>list$ = "a,b,c,d,e,f,g,h,i,j" letter = rnd(1) * 10 print "Selected letter:"; word$(list$,letter,",")</lang>
Scala
<lang Scala>val a = (1 to 10).toList
println(scala.util.Random.shuffle(a).head)</lang>
Seed7
<lang seed7>$ include "seed7_05.s7i";
const proc: main is func
begin writeln(rand([] ("foo", "bar", "baz"))); end func;</lang>
Smalltalk
<lang smalltalk>x := #(1 2 3) atRandom.</lang>
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 . It's simpler to use when wrapped up as a helper procedure:
<lang tcl>proc randelem {list} {
lindex $list [expr {int(rand()*[llength $list])}]
} set x [randelem {1 2 3 4 5}]</lang>
TXR
<lang txr>@(do (defun randelem (seq)
[seq (random nil (length seq))]))
@(bind x @(randelem #("a" "b" "c" "d")))</lang>
TUSCRIPT
<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</lang> Output:
Selecting term 3 in the list, which was George
XPL0
<lang XPL0>code Ran=1, Text=12; int List; [List:= ["hydrogen", "helium", "lithium", "beryllium", "boron"]; \(Thanks REXX) Text(0, List(Ran(5))); ]</lang>
zkl
<lang zkl>list:=T("hydrogen", "helium", "lithium", "beryllium", "boron"); list[(0).random(list.len())]</lang>
- Programming Tasks
- Basic language learning
- ACL2
- Ada
- Aime
- ALGOL 68
- App Inventor
- AutoHotkey
- Bash
- BASIC
- BBC BASIC
- Burlesque
- C
- C++
- C sharp
- Clojure
- COBOL
- CoffeeScript
- Common Lisp
- D
- Déjà Vu
- Elixir
- Erlang
- Euphoria
- Factor
- Falcon
- F Sharp
- GAP
- Go
- Groovy
- Haskell
- Icon
- Unicon
- J
- Java
- JavaScript
- Julia
- K
- LabVIEW
- Lasso
- Liberty BASIC
- Logo
- Lua
- Mathematica
- MATLAB
- Octave
- Maxima
- МК-61/52
- NetLogo
- NetRexx
- Nimrod
- Objeck
- OCaml
- PARI/GP
- Pascal
- Perl
- Perl 6
- PHP
- PicoLisp
- PL/I
- Prolog
- PureBasic
- Python
- R
- Racket
- REXX
- Ruby
- Run BASIC
- Scala
- Scala Implementations
- Seed7
- Smalltalk
- Tcl
- TXR
- TUSCRIPT
- XPL0
- Zkl
- Randomness