Entwerfen Sie einen Zufallszahlengenerator, bei dem die i-te Zahl für alle 0 <i <14 eine Wahrscheinlichkeit von i% hat. 0 sollte eine Wahrscheinlichkeit von genau 9% haben. Der Startwert für den Generator sollte die Systemzeit sein. Sie können keine vordefinierte Funktion zur Erzeugung von Zufallszahlen verwenden.

Grundsätzlich hat 1 eine Eintrittswahrscheinlichkeit von 1%, 2 eine Eintrittswahrscheinlichkeit von 2% usw. Bis zu 13 haben eine Eintrittswahrscheinlichkeit von 13%. Dies ist Code-Golf, also gewinnt der kürzeste Code.

CJam, 14 Bytes

E,_T9t\]ze~es=

Testen Sie es hier.

Erläuterung

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

Der Ausdruck f(t) = ((8*t+1)**.5+1)//2wandelt eine gleichmäßige Verteilung in eine dreieckige Ganzzahlverteilung um, indem die Intervalle abgebildet werden

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

Wir konvertieren dabei die Millisekunden-Ziffern der Zeit in einen einheitlichen Gleitkommawert von 0 bis 100 time.time()*1e4%100. Tatsächlich %800ersetzen wir im Konvertierungsschritt das Multiplizieren durch 8. Am Ende werden 14er durch Handeln in Nullen umgewandelt %14.

Pyth - 14 Bytes

@+mZ9smRd14.d8

Erzeugt ein Array mit der angegebenen Verteilung und wählt dann ein zufälliges aus.

Probieren Sie es hier online aus .

Dyalog APL , 20 Bytes

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

⍳13Ganzzahlen 1 bis 13
(/⍨… )replizieren von selbst, z. B. /⍨3ist 3 3 3und /⍨2 3ist 2 2 3 3 3
n↓ … n Elemente löschen (leere Liste, wenn n > Länge der Liste)
⎕TSSystemzeitstempel zB 2015 11 1 13 28 56 834
⊃⌽letztes Element, dh aktuelle Millisekunde 0–999
⌊.1×multiplizieren mit 0.1 und abrunden des
⊃ersten Elements ergibt 0, wenn die Daten leer sind

Verarbeitung von 3, 65 55 74 Bytes

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

Holen Sie sich eine Zufallszahl von 0 bis 99 (einschließlich). Wenn die Zahl 0-8 ist, drucken Sie 0, wenn es 9 ist, drucken Sie 1, wenn 10-11 drucken Sie 2, wenn 12-14 drucken Sie 3 usw.

Niemand hat es bemerkt, aber das Problem mit dem alten Code ist, dass millis () die Zeit zurückgibt, die die Anwendung ausgeführt wurde, was bei nachfolgenden Programmläufen sehr ähnliche Zahlen ergeben würde. Zumindest haben wir jetzt Nano-Präzision!

PHP, 50 Bytes

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

• microtimeGibt die Zeit als Zeichenfolge wie "0.04993000 1446409253" zurück. Wenn ich dies mit 100 multipliziere, erzwingt PHP die Zeichenfolge in 0.04993000, Ergebnis 4.993000. So $twird mit einer „Zufallszahl“ initialisiert in[0,100)
• Wir subtrahieren 1, 2, 3, ... von $tbis es 0 erreicht
• Das Ergebnis ist die letzte subtrahierte Zahl, Modulo 14

Python3, 86 Bytes

einfach:

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

J - 28 char

Dieser war dumm.

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

6!:0''ist die aktuelle Y M D h m sZeit als Liste mit 6 Elementen, in der Millisekunden als Brüche in Sekunden dargestellt werden. Um sie zu erreichen, müssen wir nur die Sekunden ( {:) mit multiplizieren 1e3. In der Zwischenzeit gibt #~i.14es eine Liste mit null Nullen, einer 1, zwei 2s usw. bis zu dreizehn 13s, und wir füllen diese mit 100 Elementen auf 100{..

J hat keine zyklische Indizierung, daher ist es möglicherweise verlockend, das Millisekunden-Modulo 100 zu verwenden, bevor die große Liste indiziert wird. Wir können jedoch zwei Zeichen speichern, indem wir $stattdessen die Liste mit 100 Elementen zyklisch auf die Millisekunden erweitern, die wir erhalten (zwischen 0 und 60999 ), und dann den letzten Eintrag vornehmen .

Nicht dass eine 60000-Elementliste eine Menge Speicherplatz oder irgendetwas anderes ist, es fühlt sich einfach wie ein Overkill an: P.

JavaScript (ES6) 116

Dies ist eine Adaption eines einfachen gesetzten RNG, das ich anstelle des Standard-RNG von Javascript verwendet habe, das nicht ausgesät werden kann (und daher nicht wiederholbar ist).

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 Bytes

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

100fPart(sub(getTimeerhält den zufälligen Rest zwischen 0 und 99. Die (n-1) -te Dreieckszahl ist gleich (N^2+N)/2, also ist die Umkehrung gleich √(2y+1)-.5. Stellen Sie dies auf den Boden, nachdem Sie es um 9 nach unten eingestellt haben, und wir haben das Ergebnis

Das einzige Problem ist, dass wir für Reste unter 8 eine imaginäre Quadratwurzel erhalten. Wir nehmen also den Realteil, um stattdessen die Programmausgabe 0 zu haben.

Perl 5, 51 Bytes

50 Bytes + 1 für -Eanstelle von -e:

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