Concevez un générateur de nombres aléatoires où le i ème nombre a i% de chance de se produire pour tous 0 <i <14. 0 devrait avoir exactement 9% de chance de se produire. La graine pour le générateur doit être l'heure du système. Vous ne pouvez pas utiliser une fonction prédéfinie pour la génération de nombres aléatoires.

Fondamentalement, 1 a 1% de chance de se produire, 2 a 2% de chance et ainsi de suite jusqu'à 13 ayant 13% de chance de se produire. C'est le code-golf, donc le code le plus court l'emporte.

CJam, 14 octets

E,_T9t\]ze~es=

Testez-le ici.

Explication

E,   e# Push [0 1 2 ... 12 13].
_    e# Make a copy.
T9t\ e# Set the first element to 9. Swap with the original range.
]z   e# Wrap them in an array and transpose to get [[9 0] [1 1] [2 2] ... [13 13].
e~   e# Run-length decode to get `[0 0 0 0 0 0 0 0 0 1 2 2 3 3 3 ... 13 13 ... 13 13].
es=  e# Use the current timestamp as a cyclic index into this array.

Python 2, 54

import time
print((time.time()*1e4%800+1)**.5+1)//2%14

L'expression f(t) = ((8*t+1)**.5+1)//2transforme une distribution uniforme en une distribution entière triangulaire en mappant les intervalles

[0,1)  --> 1
[1,3)  --> 2
[3,6)  --> 3
[6,10) --> 4
...

Nous convertissons les millisecondes du temps en un flottant uniforme de 0 à 100 en faisant time.time()*1e4%100. En fait, nous faisons %800pour remplacer la multiplication par 8 dans l'étape de conversion. À la fin, 14 sont convertis en 0 en faisant %14.

Pyth - 14 octets

@+mZ9smRd14.d8

Génère un tableau avec la distribution spécifiée, puis choisissez-en un au hasard.

Essayez-le en ligne ici .

Dyalog APL , 20 octets

⊃(⌊.1×⊃⌽⎕TS)↓(/⍨⍳13)

⍳13entiers 1 à 13
(/⍨… )répliquer par lui-même, par exemple /⍨3est 3 3 3et /⍨2 3est 2 2 3 3 3
n↓ … supprimer n éléments (laisse la liste vide si n > longueur de la liste)
⎕TShorodatage du système par exemple 2015 11 1 13 28 56 834
⊃⌽dernier élément, c.-à-d. milliseconde actuelle 0–999
⌊.1×multiplier avec 0,1 et arrondir le
⊃premier élément, donne 0 si si les données sont vides

Traitement 3, 65 55 74 octets

long i=0,c=8,r=System.nanoTime()%100;for(;r>c;i++,c+=i);print(i);

Obtenez un nombre aléatoire de 0 à 99 (inclus). Si le nombre est 0-8, imprimer 0, si c'est 9 imprimer 1, si 10-11 imprimer 2, si 12-14 imprimer 3, etc ...

Personne ne l'a remarqué, mais le problème avec l'ancien code est que millis () renvoie la durée pendant laquelle l'application a été exécutée, ce qui donnerait des nombres très similaires lors des exécutions ultérieures du programme. Au moins maintenant, nous avons une nano précision!

PHP, 50 octets

<?for($t=microtime()*100;0<=$t-=++$i;)?><?=$i%14;

• microtimerenvoie l'heure sous la forme d'une chaîne comme "0,04993000 1446409253", lorsque je multiplie cela par 100, PHP contraint la chaîne à 0,04993000, résultat 4,993000. $tEst donc initialisé avec un nombre "aléatoire" dans[0,100)
• On soustrait 1, 2, 3, ... de $tjusqu'à ce qu'il atteigne 0
• Le résultat est le dernier nombre soustrait, modulo 14

Python3, 86 octets

simple:

import time;print(sum([[i]*i for i in range(1,14)],[0]*9)[int(str(time.time())[-2:])])

J - 28 caractères

Celui-ci était idiot.

{:({:1e3*6!:0'')$100{.#~i.14

6!:0''est l' Y M D h m sheure actuelle sous la forme d'une liste de 6 éléments, où les millisecondes sont représentées sous forme de fractions sur les secondes - pour les atteindre, nous n'avons d'autre choix que de multiplier les secondes ( {:) par 1e3. Pendant ce temps, #~i.14est une liste de zéro 0, un 1, deux 2, et ainsi de suite jusqu'à treize 13, et nous complétons cela à 100 éléments 100{..

J n'a pas d'indexation cyclique, il peut donc être tentant de prendre les millisecondes modulo 100 avant d'indexer la grande liste. Cependant, nous pouvons enregistrer deux caractères en utilisant $à la place pour étendre cycliquement la liste de 100 éléments au nombre de millisecondes que nous obtenons (de 0 à 60999 ) et prendre la dernière entrée à ce moment-là.

Pas qu'une liste d'éléments 60000 soit beaucoup de mémoire utilisée ou quoi que ce soit, cela ressemble à une surpuissance: P

JavaScript (ES6) 116

Ceci est une adaptation d'un RNG semé simple que j'ai utilisé à la place du RNG standard de javascript qui ne peut pas être semé (et qui n'est donc pas répétable)

R=(s=~new Date,p=[],i=0,j=9)=>{
while(p.push(i)<100)--j?0:j=++i;
return _=>(s=(1+Math.sin(s))*1e5,p[100*(s-~~s)|0])
};

// test

var rnd=R()

t=[0,0,0,0,0,0,0,0,0,0,0,0,0,0];
rgb='000,444,666,888,aaa,ddd,f0f,ff0,0ff,0ff,0f0,00f,f00,fff'.split`,`
.map(v=>(v=parseInt(v,16),[(v&15)*17,(v>>4&15)*17,(v>>8)*17]))

cnt=400*300
//for (i=0;i<cnt;i++)t[rnd()]++;

ctx = C.getContext("2d");
img=ctx.getImageData(0, 0, 400, 300)
for(p=0,y=0;y<300;y++)for(x=0;x<400;x++)
  v=rnd(),t[v]++,
  img.data[p++]=rgb[v][0],img.data[p++]=rgb[v][1],
  img.data[p++]=rgb[v][2],img.data[p++]=255
ctx.putImageData(img, 0, 0)

o=''
for(i=0;i<14;i++)
  t[i]/=cnt, o+=`<p><i>${i}</i><b style="width:${t[i]*300}%">,</b>${(t[i]*100).toFixed(2)}%</p>`;
G.innerHTML=o

#G { width: 400px; font-size: 12px; border: 1px solid #000;  }
p { margin: 0}
b { display: inline-block; font-size:80%; background: #08c; margin: 2px }
i { display: inline-block; width: 20px; text-align: right; padding: 0 4px }
#C { width: 400px; height: 300px; }

<div id=G></div>
<canvas id=C></canvas>

TI-BASIC, 18 octets

real(int(.5+2√(-4+50fPart(sub(getTime

100fPart(sub(getTimeobtient le résidu aléatoire entre 0 et 99. Le (n-1) ème nombre triangulaire est égal à (N^2+N)/2, donc l'inverse est égal à √(2y+1)-.5. Plancher ceci après un ajustement à la baisse de 9, et nous avons le résultat

Le seul problème est que pour les résidus inférieurs à 8, nous obtenons une racine carrée imaginaire. Nous prenons donc la partie réelle pour avoir la sortie de programme 0 à la place.

Perl 5, 51 octets

50 octets + 1 pour -Eau lieu de -e:

@_=(0)x 9;push@_,($_)x$_ for 0..13;say$_[time%100]