간단한 코드 골프 문제가 충분하지 않기 때문에 :

정수 1 ≤ N ≤ 10000을 지정하고 의사 난수 확률 1 / N으로 언어의 True 값을 출력하고 그렇지 않은 경우 False 인 선택적으로 명명되지 않은 프로그램 또는 함수를 만듭니다.

이름 지정 요구 사항이 제거되었습니다. 이에 따라 답변과 점수를 자유롭게 편집하십시오.

일부 언어는 True 및 False에 1 (또는 -1)과 0을 사용합니다.

예:

입력 테스트 예 :

4 -> True
4 -> False
4 -> False
4 -> False
4 -> False
4 -> True
4 -> False
4 -> False

즉, 4가 주어진다; 25 % 확률로 True를, 75 % 확률로 False를 반환합니다.

48 바이트의 ParserFunctions가 포함 된 MediaWiki 템플릿

{{#ifexpr:1>{{#time:U}} mod {{{n}}}|true|false}}

Pyth, 3 바이트

!OQ

온라인으로 사용해보십시오

0에서 입력으로 무작위 선택의 간단한 반전

Pyth에서는 Pyth $기능이 자동으로 메모되므로이 기능 을 수행하지 않으면 기능을 수행 할 수 없습니다 .

CJam, 5 바이트

이걸로 빨리 가야 해 ...

rimr!

여기에서 테스트하십시오.

설명

ri e# Read input and convert to integer N.
mr e# Get a uniformly random value in [0 1 ... N-1].
!  e# Logical NOT, turns 0 into 1 and everything else into 0.

TI-BASIC, 1 바이트 토큰을 사용하는 4 바이트

not(int(Ansrand

입력의 정수 부분에 [0,1)의 난수가 0인지 여부를 결정합니다. Ansrand<1작동합니다.

MATL, 5 바이트

이 버전의 세 가지 버전, 모두 길이 5.

iYr1=

입력 ( i) 을 취하여 1과 해당 숫자 ( Yr) 사이의 임의의 정수를 생성하고 1 ( 1=) 과 같은지 확인합니다 . 또는

li/r>

1 ( l, 1i순간에 버그가 있기 때문에 해결 방법 ), 입력 ( i), 1 / N ( /)으로 나누기 , 0과 1 ( r) 사이의 난수를 만들고 난수가 있는지 확인하십시오. 숫자가 1 / N보다 작습니다. 또는,

ir*1<

을 입력하고 ( i) 0과 1 ( r*) 사이의 난수를 곱한 다음 결과가 1 ( 1<) 보다 작은 지 확인하십시오 .

MATL이 아닌 Matlab에서이 익명 함수를 수행 할 수 있습니다.

@(n)n*rand<1

ans(5)예를 들어 12 바이트에 대해 사용됩니다 .

자바 스크립트 ES6, 15 바이트

Downgoat 덕분에 -5 바이트

x=>1>new Date%x

이 답변의 기술을 기반으로 사용합니다 .

줄리아, 17 16 15 바이트

n->2>rand(1:n)

이것은 1과 1 사이의 임의의 정수를 생성하는 함수입니다 n 그것이 2보다 작은 지 여부를 테스트 입니다.이 일이 발생할 확률은 1 / n이며 따라서 1 / n이 돌아올 확률이 true있습니다.

Thomas Kwa 덕분에 1 바이트를 절약했습니다!

마이크로 스크립트 II , 3 바이트

NR!

integer를 읽고 and (포함) n사이의 임의 의 정수 를 생성 한 다음 부울 부정을 해당 값에 적용합니다.0n-1

사탕 , 2 바이트

Hn

H 는 Heisen-double의 약자

엔 은 아닙니다

'n'은 숫자 입력으로 -i 플래그와 함께 전달됩니다. 스택에 남은 값은 종료시 인쇄됩니다.

"긴"형태 :

rand   # number between 0 and pop()
not    # cast to int, invert non-zero to zero, and zero to one

정말 3 바이트

,JY

0거짓과 1진실입니다.온라인으로 사용해보십시오

설명:

,JY
,    get input
 J   push a random integer in range(0, input) ([0, ..., input-1])
  Y  logical not: push 0 if truthy else 1  

R, 30 22 바이트

암호

cat(runif(1)<1/scan())          #new
f=function(N)cat(runif(1)<1/N)  #old

균일 분포 (0-1)에서 숫자를 생성하며 횟수의 true 1 / n으로 평가해야합니다.

apt, 6 바이트

1>U*Mr

온라인으로 사용해보십시오!

MrJS와 동일합니다 Math.random. 나머지는 꽤 분명합니다. 아마도 0과 숫자 사이에 임의의 부동 소수점을 생성하는 숫자 함수를 추가 할 수 있습니다. 이 경우 두 바이트가 저장됩니다.

1>Ur    // Doesn't currently work

대체 버전 :

1>Ð %U

Ð는에 해당 new Date(하며 Date 객체는 숫자로 변환하도록 요청 될 때 현재 타임 스탬프 (밀리 초)가됩니다. 따라서 이것은 ms 당 여러 번 실행되지 않는 한 전적으로 무작위입니다.

놀라운 , 21 바이트

}0    # takes one input n
--    # decrements n
??    # random value from range 0..n (inclusive)
=0?0  # push right if not equal to 0, fall through otherwise | convert to zero
++    # increment | no-op
{0//  # output | push left

Marbelous가 실제로 if를 가지고 있지 않다는 것을 볼 이유가 없지만 0허위와 진실로 취 했습니다 1. {0진실과 {>거짓 을 위해 더 많은 Marbelousy가 출력 될 것이다 . 이것은 다음과 같습니다

}0
--
??
=0{>
{0

그러나 그것이 확실하지 않습니다.

APL, 6 3 바이트

+=?

이것은 정수를 취하고 1 또는 0 (APL의 참 / 거짓)을 반환하는 함수 트레인입니다. 를 사용하여 1에서 입력까지 임의의 정수를 생성 한 ?다음 입력이 해당 정수와 같은지 확인하십시오. 그 결과 1 / 입력 기회가 참이됩니다.

Thomas Kwa 덕분에 3 바이트를 절약했습니다!

PlatyPar , 3 바이트

#?!

#? gets a random number [0,n) where n is input. ! returns true if the number before it is 0, else it returns false.

Using more recent features that were implemented (but unfortunately for me not committed) before this question was asked I can get it down to 2 with ~! Try it online!

Java, 43 bytes

boolean b(int a){return a*Math.random()<1;}

C, 24 bytes

f(n){return!(rand()%n);}

><>, 27 + 3 for -v = 30 bytes

Here is a not-uniform-at-all solution where I mod N the sum of 15876 random picks of 0 or 1 :

0"~":*>:?vr%0=n;
1-$1+$^-1x

N must be input on the stack with -v flag, output is 0 for falsey and 1 for truthy.

A much smarter and uniform solution that work for 1/2^N instead :

4{:?!v1-}:">"$2p:"x"$3p:"^"$4p1+:">"$3p1+!
   ^1<
0n;
1n;>
 

For an input 3 you've got 1/8 chances of getting 1 and 7/8 of getting 0.

Explanation :

I append as much x as needed on the 4th line and surround them with directions so there is only two ways out of the x: either the falsey output or the next x. If all x go in the right direction, the last one will route to the truthy output.

For example for N=5, the final codespace is the following :

4{:?!v1-}:">"$2p:"x"$3p:"^"$4p1+:">"$3p1+!
   ^1<
0n; > > > > >
1n;>x>x>x>x>x>
    ^ ^ ^ ^ ^

Mathematica, 18 16 bytes

#RandomReal[]<1&

Basic solution. The unnamed Function creates a random number in [0, 1), multiplies it by its argument, and checks if it is still less than 1.

Python, 42 bytes

import random
lambda n:1>random.random()*n

Edit: Removed the time.time() answer because of the distribution.

TeaScript, 3 bytes

!N×

Try it here.

Explanation

 N  maps to Math.rand which is a utility function that returns an integer
    between `arg1` and `arg2` or `0` and `arg1` if only one argument is
    provided.
  × is expanded to `(x)`, where `x` is initialised with the value provided
    in the input boxes; × represents byte '\xd7'
!   negate the result, 0 results in true, anything else false

Fuzzy Octo Guacamole, 10 bytes

^-!_[0]1.|

Explanation:

^-!_[0]1.|

^          # Get input.
 -         # Decrement, so we can append <ToS> zeros and a 1 to the stack.
  !        # Set loop counter.
   _       # Pop, since we are done with the input.
    [      # Start loop
     0     # Push 0
      ]    # End for loop. We have pushed input-1 0s to the stack.
       1   # Push a single 1 to the stack.
        .  # Switch stacks
         | # Pick a random item from the inactive stack, which has n-1 falsy items and 1 truthy item, so the truthy probability is 1/n.
           # (implicit output)

Perl 6,  10  8 bytes

!(^*).pick
#  ^- The * is the argument

This code creates a Range from 0 up-to but excluding the input *. It then picks one at random and the ! returns True when it receives a 0.

1>*.rand
# ^- The * is the argument

This takes the input * and multiplies it by a random Num from 0..^1 then returns True if it was smaller than 1.

# store it in a lexical code variable for ease of use
my &code = 1>*.rand;

die "never dies here" unless code 1;

for ^8 { say code 4 }

False
True
False
False
False
True
False
False

Prolog (SWI), 24 bytes

Code:

p(N):-X is 1/N,maybe(X).

maybe(+P) is a function which succeeds with probability P and fails with probability 1-P

Example:

p(4).
false

p(4).
false

p(4).
true

PowerShell, 25 Bytes

!(Random -ma($args[0]--))

The Get-Random function when given a -Maximum parameter n returns a value from the range [0,n). We leverage that by subtracting 1 from our input $args[0], so we're properly zero-indexed, and get a random value. Precisely 1/nth of the time, this value will be 0, so when we Boolean-not it with ! it will return True. The other times will return False.

J, 3 bytes

0=?

This is a monadic fork that takes an argument on the right. Similarly to APL, ? generates a random integer; however, J arrays are zero-based. So we compare to 0 instead of to the input.

Minkolang 0.14, 7 bytes

1nH1=N.

Try it here.

Explanation

1          Pushes 1
 n         Takes number from input
  H        Pops b,a and pushes a random integer between a and b, inclusive
   1=      1 if equal to 1, 0 otherwise
     N.    Output as number and stop.

PHP, 22 bytes

<?=2>rand(1,$argv[1]);

Reads n from command line, like:

$ php probability.php 4

Outputs (false is cast to an empty string in PHP) or 1 (in case of true).

C#, 56 45 bytes

Thanks to, pinkfloydx33 it's 45 now.

bool b(int n){return new Random().Next(n)<1;}

Old 56 bytes

Generates random positive integer bigger or equal to 0 and smaller than n and checks if it's smaller than 1 and return comparison result.

bool a(int n){Random r=new Random();return r.Next(n)<1;}

Scratch, 63 bytes

Try it online!
Picture:

Scratchblocks code:

when gf clicked
ask[]and wait
say<(pick random(1)to(answer))=[1