Diseñe un generador de números aleatorios donde el i-ésimo número tenga un% de probabilidad de ocurrir para todos 0 <i <14. 0 debería tener exactamente un 9% de probabilidad de ocurrir. La semilla para el generador debe ser la hora del sistema. No puede usar una función predefinida para la generación de números aleatorios.

Básicamente 1 tiene 1% de probabilidad de ocurrir, 2 tiene 2% de probabilidad y así sucesivamente hasta 13 con 13% de probabilidad de ocurrir. Este es el código de golf, por lo que gana el código más corto.

CJam, 14 bytes

E,_T9t\]ze~es=

Pruébalo aquí.

Explicación

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.

Pitón 2, 54

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

La expresión f(t) = ((8*t+1)**.5+1)//2transforma una distribución uniforme en una distribución entera triangular al mapear los intervalos

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

Convertimos los dígitos de milisegundos del tiempo a un flotador uniforme de 0 a 100 haciendo time.time()*1e4%100. En realidad, lo hacemos %800para reemplazar la multiplicación por 8 en el paso de conversión. Al final, 14 se convierten en 0 haciendo %14.

Pyth - 14 bytes

@+mZ9smRd14.d8

Genera una matriz con la distribución especificada, luego elige una aleatoria.

Pruébelo en línea aquí .

Dyalog APL , 20 bytes

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

⍳13enteros 1 a 13
(/⍨... )replicarse por sí mismo, por ejemplo, /⍨3es 3 3 3y /⍨2 3es 2 2 3 3 3
n↓ ... soltar n elementos (deja la lista vacía si n > longitud de la lista)
⎕TSmarca de tiempo del sistema, por ejemplo, 2015 11 1 13 28 56 834
⊃⌽último elemento, es decir, milisegundos actuales 0–999
⌊.1×multiplicar con 0.1 y redondear hacia abajo el
⊃primer elemento, da 0 si los datos están vacíos

Procesamiento 3, 65 55 74 bytes

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

Obtenga un número aleatorio del 0 al 99 (inclusive). Si el número es 0-8, imprime 0, si es 9 imprime 1, si 10-11 imprime 2, si 12-14 imprime 3, etc.

Nadie lo notó, pero el problema con el código anterior es que millis () devuelve la cantidad de tiempo que la aplicación ha estado ejecutándose, lo que daría números muy similares en ejecuciones posteriores del programa. ¡Al menos ahora tenemos nano precisión!

PHP, 50 bytes

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

• microtimedevuelve el tiempo como una cadena como "0.04993000 1446409253", cuando multiplico esto por 100, PHP coacciona la cadena a 0.04993000, resultado 4.993000. Entonces $tse inicializa con un número "aleatorio" en[0,100)
• Restamos 1, 2, 3, ... $thasta que llegue a 0
• El resultado es el último número restado, módulo 14

Python3, 86 bytes

sencillo:

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

J - 28 char

Este era tonto.

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

6!:0''es el Y M D h m stiempo actual como una lista de 6 elementos, donde los milisegundos se representan como fracciones en los segundos; para obtenerlos, no tenemos más remedio que multiplicar los segundos ( {:) por 1e3. Mientras tanto, #~i.14es una lista de cero 0s, uno 1, dos 2s, y así sucesivamente hasta trece 13s, y lo completamos con 100 elementos 100{..

J no tiene indexación cíclica, por lo que puede ser tentador tomar el módulo 100 de milisegundos antes de indexar la lista grande. Sin embargo, podemos guardar dos caracteres al usar $para extender cíclicamente la lista de 100 elementos a la cantidad de milisegundos que obtengamos (de 0 a 60999 ) y tomar la última entrada.

No es que una lista de 60000 elementos sea una gran cantidad de memoria utilizada ni nada, simplemente se siente como una exageración: P

JavaScript (ES6) 116

Esta es una adaptación de un RNG sin semillas simple que he usado en lugar del RNG estándar de javascript que no se puede sembrar (y por lo tanto no es repetible)

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(getTime obtiene el residuo aleatorio entre 0 y 99. El número triangular (n-1) es igual a (N^2+N)/2 , por lo que el inverso es igual a √(2y+1)-.5. Piso esto después de ajustar hacia abajo por 9, y tenemos el resultado

El único problema es que para residuos de menos de 8, obtenemos una raíz cuadrada imaginaria. Entonces, tomamos la parte real para que el programa produzca 0 en su lugar.

Perl 5, 51 bytes

50 bytes + 1 para en -Elugar de -e:

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