이 과제는 다소 간단합니다.
양수 (0을 포함하지 않음)의 배열이 제공되며이 배열에서 임의의 요소를 선택해야합니다.
그러나 비틀기는 다음과 같습니다
. 요소를 선택할 확률은 정수의 값에 따라 달라집니다. 즉 정수가 커질수록 선택 될 확률도 높아집니다!
배열이 제공됩니다 [4, 1, 5].
(4)를 선택하는 확률이 동일하다 어레이의 모든 요소들의 합에 의해 나누어 4 이 경우 4 / ( 4 + 1 + 5 ) = 4 / 10 =40%.
1을 선택할 확률은 1 / 10또는 10%입니다.
양의 정수로 구성된 배열입니다.
메서드를 사용하는 경우 선택한 정수를 반환하거나로 직접 인쇄하십시오 stdout.
답변:
x`X
봐, 유니 코드 없음!
설명:
x`X
` Make monad from dyad and use same left and right arguments
x Repeat each element of the left argument (implicit) list its respective number of times in the right argument list
X Random element
OsmR
@Jakube 덕분에 다소 특이한 접근 방식으로 1 바이트를 절약했습니다.
Osm*]
OsmR-전체 프로그램.
R-오른쪽지도 ...
m-... 맵 사용. 기본적으로 [[4,4,4,4], [1], [5,5,5,5,5]] 목록이 생성됩니다.
-... 크레딧이 Jakube에갑니다!
s-평평하게합니다.
O-^의 임의 원소 암시 적으로 표시합니다.
Osm *]-전체 프로그램.
m-입력을 매핑합니다.
]-현재 요소 d는 줄 바꿈; [디].
*-d 번 반복.
s-평평하게합니다.
O-랜덤 요소. 결과를 암시 적으로 인쇄합니다.
OsmL또는OsmR
d, d범위 ... 천재에 매핑 !
q~_]ze~mR
온라인 데모 . 이것은 stdin에서 CJam 배열 형식으로 입력을 받고 선택된 요소를 stdout에 인쇄하는 전체 프로그램입니다.
q~ e# Read and parse input
_]z e# Copy and transpose
e~ e# Run-length decode
mR e# Select random element uniformly
@Brad Gilbert b2gills 덕분에 1 바이트를 절약했습니다.
{bag(@_ Zxx@_).pick}이것은 1 개의리스트 인수를 취합니다. xx연산자를 사용하여이 목록의 사본 2 개를 압축합니다 . 따라서 @_ Zxx@_, 우리 x는 요소 가 제시 되는 목록을 얻 x습니다. 그런 다음 Bag개체에 컬렉션에 표시되는 횟수와 함께 개체를 저장하는 컬렉션 인에 강제 변환됩니다 . 마지막으로을 사용하여이 컬렉션에서 임의의 요소를 선택합니다.이 요소 pick는 개수를 고려하여 The Right Thing ™을 수행합니다.
{bag(@_ Z=>@_).pick}
{bag(@_ Zxx@_).pick}
lambda A:choices(A,A)[0]
from random import*예, 내장되어 있습니다. 다른 A인은 choices(A, A)선택 사항입니다 weights인수입니다.
tY"1Zr
MATL Online 에서 사용해보십시오 !
t % Implicit input. Duplicate
Y" % Run-length decoding
1Zr % Randomly take one value with uniform distribution. Implicitly display
a->{int r=0,x=-1;for(int i:a)r-=i;for(r*=Math.random();r<1;)r+=a[++x];return a[x];}for(r*=Math.random();;)필요한지 또는 필요한 것이 모두 인지 이해하려고합니다 r*=Math.random().
for(;;)루프가 없으면 for(int i:a)...컴파일러를 만족시키기 위해 두 번째 (절대로 도달하지 않은) return 문이 필요합니다 . 3 바이트 더 깁니다.
for(int i:a)과 같습니다 foreach. 나는 같은 문제가 있었지만 for계속 반복 되는 것을 사용했다 . 당신의 새로운 대답은 저를 흥미롭게합니다. 나는 당신의 생각을 약간 시도하고 싶을 것입니다.
7 바이트는 유효하지 않습니다. 하루나 이틀 안에 컴퓨터로 돌아 오면 이전 편집으로 되돌릴 것입니다.
?@+/{#~
:( 배열에서 임의의 요소를 선택하는 것은 비용이 많이 듭니다.
8 바이트
#~{~1?+/
9 바이트
(1?+/){#~
?@+/{#~
? Choose random number in range
+/ Sum of the array
{ Select that element from
#~ The elements duplicated as many times as their value
?@+/이다 (?@+)/; 나는 당신이 그것을 다시 8까지
a=>a.sort((a,b)=>b-a)[Math.random()**2*a.length|0]
이것이 어떻게 작동하는지 분명히 알 수 있지만 어쨌든 여기서 설명하겠습니다. 정수를 내림차순으로 정렬 한 다음 베타 분포 (1 / 2,1)를 사용하여 무작위로 하나를 선택합니다 .
($args[0]|%{,$_*$_})|Random$args[0]리터럴 배열로 입력 을받습니다. 각 요소를 순환 |%{...}하고 각각의 반복은 새로운 배열 구축 ,$_의 $_대한 예 - 요소 4이 배열을 생성한다 @(4,4,4,4). 그런 다음 해당 배열 요소가 파이프되어 Get-Random(의사) 동일한 확률로 요소 중 하나를 뽑아냅니다. 예를 들어, @(4,1,5)이것이 우리에게 @(4,4,4,4,1,5,5,5,5,5)확률 요구 사항을 만족시키기 때문에.
a=>{int i=-1,r=new Random().Next(a.Sum());while(r>=0)r-=a[++i];return a[i];}추가 18 바이트 using System.Linq;
Nevay 덕분에 11 바이트가 절약되었습니다 .Nevay는 임의의 숫자 구현이 훨씬 간결합니다 ( int대신double ).
a=>{
int i=-1,
r=new Random().Next(a.Sum());
while(r>=0)
r-=a[++i];
return a[i];
}r0과 요소의 합 사이 의 난수 를 가져옵니다. 그런 다음 각 반복에서에서 현재 요소를 뺍니다 r. 경우 r미만이며 0,이 요소를 반환합니다. 아이디어는 배열의 숫자가 클수록 난수의 부분이 더 많다는 것입니다.
a=>{int i=-1,r=new Random().Next(a.Sum());for(;r>=0;)r-=a[++i];return a[i];}
@a=map{($_)x$_}@ARGV;$a[rand@a]
This assumes the input to be command line arguments. Note that it may run out of memory if the numbers are large.
Ｆ⪪θ;ＦＩι⊞υι‽υ
Try it online! Link is to verbose version of code. Since Charcoal tries to be too clever, I'm having to use semicolon-delimited input for the array. Explanation:
θ Input variable as string
⪪ ; Split on semicolons
Ｆ Loop i over each string
Ｉι Cast i to integer
Ｆ Repeat that many times
⊞υι Push i to (originally empty) list
‽υ Random selection from list
Implicitly print
import System.Random
f l|m<-[x<$[1..x]|x<-l]>>=id=randomRIO(0,length m-1)>>=print.(m!!)-7 bytes thanks to @Justin Mariner
a=>a.find(m=>(n-=m)<0,n=Math.random()*eval(a.join`+`))f=
a=>a.find(m=>(n-=m)<0,n=Math.random()*eval(a.join`+`))
console.log(f([4,1,5]))eval(a.join`+`) instead of reduce.
[].find(m=>(n-=m)<0,n=Math.random()*eval(a.join+)) and call with input::[].find(...)
import System.Random
f l=randomRIO(0,sum l-1)>>=pure.((l>>= \n->n<$[1..n])!!)Try it online! Usage example: f [1,99] probably yields 99.
f takes a list of integers l and returns the randomly selected integer as IO Int.l>>= \n->n<$[1..n] constructs a list with each element n repeated n times.randomRIO(0,sum l-1) yields an integer in the range from 0 to the length of the list of repeated elements, which is exactly the sum of all elements, minus one to avoid a out of bound exception.Bonus: 85 byte point-free version
import System.Random
(>>=).randomRIO.(,)0.pred.sum<*>(pure.).(!!).(>>= \n->n<$[1..n])for n in $@;{ printf $n\\n%.s `seq $n`;}|shuf|sed qTakes space-separated or newline-separated input in one argument or multiple arguments.
Validate the random frequencies with a more complicated test case.
import java.util.*;a->{List l=new Stack();for(int i:a)for(int j=i;j-->0;Collections.shuffle(l))l.add(i);return l.get(0);}-1 byte thanks to @Nevay.
Uses a similar approach as @ErikTheOutgolfer's Jelly answer, by adding n times the item n to the list, and then select one randomly from that list.
Explanation:
import java.util.*; // Required import for List, Stack and Collections
a->{ // Method with integer-array parameter and integer return-type
List l=new Stack(); // Create a List
for(int i:a) // Loop (1) over the input array
for(int j=i;j-->0; // Inner loop (2) from `i` down to 0
Collections.shuffle(l))
// and shuffle the List randomly after every iteration
l.add(i); // Add `i` that many times to List `l`
// End of inner loop (2) (implicit / single-line body)
// End of loop (1) (implicit / single-line body)
return l.get(0); // And then return the first item of the list
} // End of method#shuffle call into the for loop to save 1 byte for(int j=i;j-->0;Collections.shuffle(l))l.add(i);.
/⍨⌷⍨1?+/
/⍨, n copies of n for each n in the argument.⌷⍨, at the index of1?, a random value between 1 and+/, the sum of the argumentApproach inspired by Erik the Outgolfer's Jelly answer. Relies on ⎕IO being 0 instead of 1, which is the default for GNU APL (sort of +5 bytes for ⎕IO←0).
-3, -2 bytes thanks to @Zacharý
∇ function form
∇f R
S[?⍴S←∊0 0⍉R∘.⍴R]∇
Anonymous lambda form
{S[?⍴S←∊0 0⍉⍵∘.⍴⍵]}
For the explanation, I will use ⍵ to represent the argument passed to the function, but it is equivalent to R in the ∇ form.
⍵∘.⍴⍵ computes the outer product on the list using the reshape (⍴) operator. Effectively, this creates a table (like a multiplication table) but instead of multiplying, it repeats the element in the column a number of times equal to the element in the row. For the example given in the question, this is:
4 4 4 4 1 1 1 1 5 5 5 5
4 1 5
4 4 4 4 4 1 1 1 1 1 5 5 5 5 5
0 0⍉⍵∘.⍴⍵ transposes the matrix and returns just the main diagonal. This gives us just the parts where the row and column in ⍵∘.⍴⍵ were the same i.e. we repeated the number a number of times equal to its value. For the example, this is:
4 4 4 4 1 5 5 5 5 5
∊ turns its argument into a list. Using the transpose (⍉) operator, we got a vector containing 3 vectors. Enlist (∊) turns it into a single vector containing all the elements.
S←... assigns this new vector to vector S. ⍴S gives us the length of that list. ? is the random operator, so ?⍴S gives us a random number between 0 and the length of the list (exclusive) (this is why it relies on ⎕IO being 0; otherwise it's between 1 and the length, inclusive). S[...] returns the element at the given index.
Q, since you never use it. And IIRC you can remove the newline before the del (little triangle-thing marking the end of the function.)
<IO> <IO>⍉ to get the main diagonal was even a thing!
@(a)datasample(repelem(n,n),1)
This assumes MATLAB R2015a or newer and with the Statistics & Machine Learning toolbox installed.
See the explanation below for how repelem is used. The difference between this shorter one and the one below is that the S&ML toolbox includes the function datasample which can be used to take one or more elements from an array at random (with uniform probability) which allows an anonymous function to be used, stripping away the input/disp calls.
n=input('');a=repelem(n,n);disp(a(randi(nnz(a))))
This code assumes that MATLAB R2015a or newer is used as that is when the repelem function was introduced. repelem is a function which takes two parameters, the first is an array of numbers to be replicated, and the second is an array of how many times the corresponding element should be replicated. Essentially the function performs run-length decoding by providing the number and the run-length.
By providing the same input to both inputs of repelem we end up with an array which consists of n times more of element n if that makes sense. If you provided [1 2 3] you would get [1 2 2 3 3 3]. If you provided [1 2 4 2] you would get [1 2 2 4 4 4 4 2 2]. By doing this it means that if we select an element with uniform probability (randi(m) gives a random integer from 1 to m with uniform probability), each element n has an n times higher probability of being selected. In the first example of [1 2 3], 1 would have a 1/6 chance, 2 would have a 2/6 chance and 3 would have a 3/6 chance.
As a side note, because repelem is not available yet for Octave, I can't give a TIO link. Additionally because Octave can't be used there is a big character penalty as input() and disp() need to be used as an anonymous function is not possible. If Octave supported repelem, the following could be used:
@(n)a(randi(nnz(a=repelem(n,n))))
That would have saved 16 bytes, but it was not to be.