Parce qu'il n'y a pas assez de défis simples de code-golf :

Créez un programme ou une fonction éventuellement sans nom qui, étant donné (par tout moyen) un entier 1 ≤ N ≤ 10000, génère la valeur True de votre langue avec une probabilité pseudo-aléatoire de 1 / N, False sinon.

Veuillez noter que l'exigence de dénomination a été supprimée. N'hésitez pas à modifier les réponses et les scores en conséquence.

Certaines langues utilisent 1 (ou -1) et 0 pour Vrai et Faux, c'est bien aussi.

Exemple:

Exemples de tests d'entrée:

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

Ie donné 4; il renvoie Vrai avec 25% de chances et Faux avec 75% de chances.

Modèles MediaWiki avec ParserFunctions , 48 octets

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

Pyth, 3 octets

!OQ

Essayez-le en ligne

Inversion simple du choix aléatoire de 0 à l'entrée

De manière amusante en Pyth, il n'est pas possible de créer une fonction qui le fasse sans, $car les fonctions Pyth sont automatiquement mémorisées.

CJam, 5 octets

Je dois être rapide avec ceux-ci ...

rimr!

Testez-le ici.

Explication

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, 4 octets utilisant des jetons d'un octet

not(int(Ansrand

Détermine si la partie entière de l'entrée multipliée par un nombre aléatoire dans [0,1) est zéro. Ansrand<1fonctionne également.

MATL, 5 octets

Trois versions différentes de celui-ci, toutes de longueur 5.

iYr1=

qui prend une entrée ( i), génère un entier aléatoire entre 1 et ce nombre ( Yr), et voit s'il est égal à 1 ( 1=). Alternativement,

li/r>

faire un 1 ( l, une solution de contournement car il y a un bug avec faire 1ien ce moment), prendre une entrée ( i), diviser pour obtenir 1 / N ( /), faire un nombre aléatoire entre 0 et 1 ( r), et voir si l'aléatoire le nombre est inférieur à 1 / N. Ou,

ir*1<

take et input ( i), et multipliez par un nombre aléatoire entre 0 et 1 ( r*), et voyez si le résultat est inférieur à 1 ( 1<).

Dans Matlab, pas MATL, vous pouvez faire cette fonction anonyme

@(n)n*rand<1

pour 12 octets, qui est utilisé en faisant ans(5), par exemple.

JavaScript ES6, 15 octets

-5 octets grâce à Downgoat.

x=>1>new Date%x

Basé sur (utilisations) de la technique de cette réponse.

Julia, 17 16 15 octets

n->2>rand(1:n)

Il s'agit d'une fonction qui génère un entier aléatoire compris entre 1 et net teste s'il est inférieur à 2. Il y aura 1 / n chance que cela se produise, et donc 1 / n chance de revenir true.

1 octet enregistré grâce à Thomas Kwa!

Microscript II , 3 octets

NR!

Lit un entier n, génère un entier aléatoire entre 0et n-1(inclus), puis applique une négation booléenne à cette valeur.

Candy , 2 octets

Hn

H signifie Heisen-double

n signifie pas

Le 'n' est passé avec le drapeau -i comme entrée numérique. Les valeurs laissées sur la pile sont imprimées à la sortie.

"Forme longue:

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

Sérieusement, 3 octets

,JY

0 est falsey et 1 est véridique. Essayez-le en ligne

Explication:

,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 octets

code

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

Il génère un nombre à partir d'une distribution uniforme (0 à 1) et devrait être évalué à 1 / n vrai des temps.

Japt, 6 octets

1>U*Mr

Essayez-le en ligne!

Mrest équivalent à JS Math.random. Le reste est assez évident. Je pourrais probablement ajouter une fonction numérique qui génère un flottant aléatoire entre 0 et le nombre. Dans ce cas, deux octets seront enregistrés:

1>Ur    // Doesn't currently work

Version alternative:

1>Ð %U

Ðest équivalent à new Date(, et l'objet Date, lorsqu'on lui demande de convertir en nombre, devient l'horodatage actuel en millisecondes. Ainsi, cela est entièrement aléatoire, à moins qu'il ne soit exécuté plusieurs fois par ms.

Marbelous , 21 octets

}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

J'ai pris 0pour falsey et 1pour être honnête, bien qu'il n'y ait aucune vraie raison pour que voir Marbelous n'a pas vraiment de si. Plus Marbelousy serait sorti {0pour vrai et {>pour faux. Cela ressemblerait à ceci:

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

Mais je ne suis pas sûr que ce soit valable.

APL, 6 3 octets

+=?

Il s'agit d'un train de fonctions qui prend un entier et renvoie 1 ou 0 (vrai / faux d'APL). Nous générons un entier aléatoire de 1 à l'entrée en utilisant ?, puis vérifions si l'entrée est égale à cet entier. Cela se traduit par une chance 1 / entrée de vrai.

Sauvegardé 3 octets grâce à Thomas Kwa!

PlatyPar , 3 octets

#?!

#?obtient un nombre aléatoire [0,n)où nest entré. !retourne truesi le nombre avant 0, sinon il retourne false.

En utilisant des fonctionnalités plus récentes qui ont été implémentées (mais malheureusement pour moi non engagées) avant que cette question ne soit posée, je peux la réduire à 2 avec ~! Try it online !

Java, 43 octets

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

C, 24 octets

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

> <>, 27 + 3 pour -v = 30 octets

Voici une solution non uniforme du tout où je modifie N la somme de 15876 choix aléatoires de 0 ou 1:

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

N doit être entré sur la pile avec le drapeau -v, la sortie est 0 pour falsey et 1 pour truey.

Une solution beaucoup plus intelligente et uniforme qui fonctionne à la place pour 1/2 ^ N:

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

Pour une entrée 3, vous avez 1/8 de chances d'obtenir 1 et 7/8 d'obtenir 0.

Explication:

J'ajoute autant xque nécessaire sur la 4ème ligne et je les entoure de directions afin qu'il n'y ait que deux voies de sortie x: la sortie falsey ou la suivante x. Je tombex va dans la bonne direction, la dernière route vers la sortie véridique.

Par exemple, pour N = 5, l'espace de code final est le suivant:

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

Mathematica, 18 16 octets

#RandomReal[]<1&

Solution basique. L'annulé Functioncrée un nombre aléatoire dans [0, 1), le multiplie par son argument et vérifie s'il est toujours inférieur à 1.

Python, 42 octets

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

Edit : Suppression de la time.time()réponse en raison de la distribution.

TeaScript , 3 octets

!N×

Essayez-le ici.

Explication

 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

Octo Guacamole flou, 10 octets

^-!_[0]1.|

Explication:

^-!_[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 octets

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

Ce code crée une plage de 0 à mais excluant l'entrée *. Il est alors pickun au hasard et !renvoie True lorsqu'il reçoit a 0.

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

Cela prend l'entrée *et la multiplie par un nombre aléatoire, 0..^1puis renvoie True si elle était inférieure à 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 octets

Code:

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

peut-être (+ P) est une fonction qui réussit avec la probabilité P et échoue avec la probabilité 1-P

Exemple:

p(4).
false

p(4).
false

p(4).
true

PowerShell, 25 octets

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

La Get-Randomfonction lorsqu'il est administré un -Maparamètre ximum nrenvoie une valeur de la gamme [0,n). Nous tirons parti de cela en soustrayant 1 de notre entrée $args[0], nous sommes donc correctement indexés à zéro et obtenons une valeur aléatoire. Précisément 1/nle temps, cette valeur sera 0, donc quand nous booléen-pas avec !elle reviendra True. Les autres fois reviendront False.

J, 3 octets

0=?

Il s'agit d'une fourche monadique qui prend un argument à droite. De même pour APL,? génère un entier aléatoire; cependant, les tableaux J sont basés sur zéro. Nous comparons donc à 0 au lieu de l'entrée.

Minkolang 0,14 , 7 octets

1nH1=N.

Essayez-le ici.

Explication

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 octets

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

Lit à npartir de la ligne de commande, comme:

$ php probability.php 4

Sorties ( falseest convertie en une chaîne vide en PHP) ou 1(dans le cas de true).

C #, 56 45 octets

Merci à pinkfloydx33 c'est 45 maintenant.

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

Ancien 56 octets

Génère un entier positif aléatoire supérieur ou égal à 0 et inférieur à net vérifie s'il est inférieur à 1et renvoie le résultat de la comparaison.

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

Scratch , 63 octets

Essayez-le en ligne!
Image: Code Scratchblocks :

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