En el webcomic Darths & Droids , Pete, que interpreta a R2-D2 en la campaña ficticia de rol en la que se basa el cómic, una vez afirma (advertencia: posibles spoilers en el cómic vinculado) que, con el Orbe Perdido de Phanastacoria armado hasta su sonda de choque, ahora puede repartir una friolera de 1048576d4de daños (El GM no ha confirmado ni negado esto). Dado que debería ser razonablemente obvio que casi nadie tendrá la paciencia para tirar tantos dados, escriba un programa de computadora para que lo haga por él, generando el valor total obtenido de manera razonable formato. Las entradas se clasificarán según el tamaño del programa (programa más corto, por número de bytes, victorias), en general y por idioma, con lazos de tiempo de ejecución. La respuesta puede ser un programa completo o una definición de función.

Puntuaciones por idioma

Pyth

Maltysen - 8 bytes *

Jakube - 10 bytes

APL

Alex A - 10 bytes

CJam

Optimizador - 11 bytes

J

--ıʇǝɥʇuʎs - 12 bytes **

Clip10

Ypnypn - 12 bytes **

K

JohnE - 13 bytes

Ti-84 BÁSICO

SuperJedi224 - 17 bytes *

R

MickyT - 23 bytes

OCTAVE / MATLAB

Oebele - 24 bytes

PARI / GP

Charles - 25 bytes **

Wolfram / Mathematica

LegionMammal978 - 27 bytes

Perl

Nutki - 29 bytes

AsciiThenAnsii - 34 bytes

Rubí

Haegin - 32 bytes **

ConfusedMr_C - 51 bytes **

Commodore Basic

Marca - 37 bytes **

PHP

Ismael Miguel - 38 bytes

VBA

Sean Cheshire - 40 bytes **

Potencia Shell

Nacht - 41 bytes **

Javascript

Ralph Marshall - 41 bytes

edc65 - 54 bytes (Requiere la funcionalidad ES6 no disponible en todos los navegadores).

Lua

críptico - 51 bytes

Java

RobAu - 52 bytes **

Geobits - 65 bytes

C

Functino - 57 bytes

Pitón

CarpetPython - 58 bytes

Postgre / SQL

Andrew - 59 bytes **

Rápido

Skrundz - 69 bytes

GoatInTheMachine - 81 bytes

Haskell

Zeta - 73 bytes **

ActionScript

Brian - 75 bytes **

> <>

ConfusedMr_C - 76 bytes

VAMOS

Kristoffer Sall-Storgaard - 78 bytes

C#

Brandon - 91 bytes **

Andrew - 105 bytes

Ewan - 148 bytes

Rasguño

SuperJedi224 - 102 bytes

C ++

Michelfrancis Bustillos - 154 bytes

Políglotas

Ismael Miguel (Javascript / ActionScript2) - 67 bytes

Top 10 en general

Maltysen
Alex A
Jakube
Optimizador
ɐɔıʇǝɥʇuʎs / Ypnypn (orden incierta)
JohnE
SuperJedi224
MickyT
Oebele

Programado marcado ** Todavía no he podido probar correctamente

Pyth - 9 8 bytes

Utiliza un método simple y obvio de suma de randint. Me tomó un minuto darme cuenta de que 1048576era 2^20, ahora me siento realmente estúpido. Gracias a @Jakube por salvarme un byte al señalar 2^20 = 4^10.

smhO4^4T

El tiempo de ejecución es horrible, aún no ha terminado en mi computadora, por lo que no tiene sentido ejecutarlo en línea, así que aquí está el 2^10: Pruébelo en línea aquí .

s        Summation
 m       Map
  h      Incr (accounts for 0-indexed randint)
   O4    Randint 4
  ^4T    Four raised to ten

Perl - 48 44 37 39 34 bytes

$-+=rand(4)+1for(1..2**20);print$-

Imprime la suma sin una nueva línea final.
Ahorró 4 bytes sustituyendo 2**20(gracias Maltysen) y eliminando comillas alrededor de la impresión.
Ahorré otros 7 bytes al reorganizar el código (¡gracias Thaylon!)
Perdí 2 bytes porque mi código anterior generó 0-4 (debería ser 1-4).
Una vez más, ahorré 5 bytes gracias a Caek y nutki.

Código no escrito, correctamente escrito:

my $s = 0
$s += int( rand(4) + 1 ) for (1 .. 2**20);
print "$s";

APL, 11 10 bytes

+/?4⍴⍨2*20

Esto solo toma la suma de una matriz de 2 ²⁰ = 1048576 enteros aleatorios entre 1 y 4.

+/           ⍝ Reduce by summing a
  ?          ⍝ random integer
   4⍴⍨       ⍝ array with values between 1 and 4
      2*20   ⍝ of length 2^20

Puede comparar esto en TryAPL imprimiendo la marca de tiempo antes y después. Tarda unos 0.02 segundos.

¡Ahorré un byte gracias a marinus y FUZxxl!

Ti-84 Basic, 17 bytes

Huella total: tamaño del encabezado del programa = 17 bytes

Tiempo de ejecución: Desconocido, estimado en 5-6 horas en función del rendimiento para un número menor de rollos (así que, básicamente, no es muy bueno)

Σ (randInt (1,4), A, 1,2 ^ 20

R, 32 24 23 21 bytes

Editar: se deshizo de la as.integerdivisión entera y la usó %/%. Acelera un poco.

Gracias a Alex A por la sugerencia de muestra ... y Giuseppe por eliminar el r=

sum(sample(4,2^20,T))

Probado con

i = s = 0
repeat {
i = i + 1
print(sum(sample(4,2^20,r=T)))
s = s + system.time(sum(sample(4,2^20,r=T)))[3]
if (i == 10) break
}
print (s/10)

Salidas

[1] 2621936
[1] 2620047
[1] 2621004
[1] 2621783
[1] 2621149
[1] 2619777
[1] 2620428
[1] 2621840
[1] 2621458
[1] 2620680
elapsed 
   0.029 

Para velocidad pura, lo siguiente se completa en microsegundos. Sin embargo, no estoy seguro de tener mi lógica correcta. Los resultados parecen consistentes con el método aleatorio. Es una pena que sea más larga.

sum(rmultinom(1,2^20,rep(1,4))*1:4)

Aquí hay una carrera de tiempo que hice en mi máquina

system.time(for(i in 1:1000000)sum(rmultinom(1,2^20,rep(1,4))*1:4))
                   user                  system                 elapsed 
7.330000000000040927262 0.000000000000000000000 7.370000000000345607987 

Python 2, 58 bytes

Obtenemos 1048576 caracteres aleatorios del sistema operativo, tomamos 2 bits de cada uno y los sumamos. El uso de la osbiblioteca parece ahorrar algunos caracteres sobre el uso de la randombiblioteca.

import os
print sum(1+ord(c)%4 for c in os.urandom(1<<20))

Esto toma alrededor de 0.2 segundos en mi PC.

CJam, 12 11 bytes

YK#_{4mr+}*

Esto es bastante directo:

YK                  e# Y is 2, K is 20
  #                 e# 2 to the power 20
   _                e# Copy this 2 to the power 20. The first one acts as a base value
    {    }*         e# Run this code block 2 to the power 20 times
     4mr            e# Get a random int from 0 to 3. 0 to 3 works because we already have
                    e# 2 to the power 20 as base value for summation.
        +           e# Add it to the current sum (initially 2 to the power 20)

¡Pero la belleza de esto es que también es realmente rápido! En mi máquina (y usando el compilador de Java ) toma un promedio de 70 milisegundos.

La versión en línea tarda alrededor de 1.7 segundos en mi máquina.

Actualización : 1 byte guardado gracias a DocMax

JavaScript (ES6), 54 bytes

Tiempo promedio <100 mseg. Ejecute el fragmento para probar (en Firefox)

// This is the answer
f=t=>(i=>{for(t=i;i--;)t+=Math.random()*4|0})(1<<20)|t

// This is the test
test();

function test(){
  var time = ~new Date;
  var tot = f();
  time -= ~new Date;
  
  Out.innerHTML = "Tot: " + tot + " in msec: " + time + "\n" + Out.innerHTML;
}

<button onclick="test()">Repeat test</button><br>
<pre id=Out></pre>

Explicación

Sin un paquete estadístico incorporado, en Javascript la forma más corta de obtener la suma de 1 millón de números aleatorios es llamar al azar () por un millón de veces. Tan simplemente

f=()=>{
   var t = 0, r, i
   for (i=1<<20; i--; ) 
   {
      r = Math.random()*4 // random number between 0 and 3.9999999
      r = r + 1 // range 1 ... 4.999999
      r = r | 0 // truncate to int, so range 1 ... 4
      t = t+r
   }
   return t
}

Ahora, agregar 1 por un millón de veces es exactamente lo mismo que agregar 1 millón, o incluso mejor, comenzar la suma con 1 millón y luego agregar el resto:

f=()=>{
   var t, r, i
   for (t = i = 1<<20; i--; ) 
   {
      r = Math.random()*4 // random number between 0 and 3.9999999
      r = r | 0 // truncate to int, so range 0 ... 3
      t = t+r
   }
   return t
}

Luego golf, suelte la variable temporal r y suelte la declaración de variables locales. tes un parámetro, ya que se necesita uno para acortar la declaración de f. ies global (cosa mala)

f=t=>{
   for(t=i=1<<20;i--;) 
      t+=Math.random()*4|0
   return t
}

Luego, encuentre una manera de evitar el 'retorno' utilizando una función interna sin nombre. Como efecto secundario, obtenemos otro parámetro para que no se usen globales

f=t=>(
  (i=>{ // start inner function body
     for(t=i;i--;)t=t+Math.random()*4|0 // assign t without returning it
   })(1<<20) // value assigned to parameter i
  | t // the inner function returns 'undefined', binary ored with t gives t again
) // and these open/close bracket can be removed too

Perl, 29

Genera una tabla de la longitud requerida.

print~~map{0..rand 4}1..2**20

J (12 bytes, aproximadamente 9.8 milisegundos)

+/>:?4$~2^20

Sospecho que esto es en su mayoría limitado por el ancho de banda de la memoria: ni siquiera puedo lograr que maximice un solo núcleo ...

Puede probar esto con el siguiente código:

   timeit =: 13 : '(1000 * >./ ($/x) 6!:2"0 1 y)'
   4 20 timeit '+/>:?4$~2^20'
9.90059

Esto lo ejecuta en 4 grupos de 20 pistas, y devuelve el número de milisegundos del tiempo promedio en el grupo más rápido. Un intérprete se puede encontrar aquí .

Pyth, 10 bytes

u+GhO4^4TZ

Esto tiene un poco más de bytes que la solución Pyth de @ Maltysen. Pero se ejecuta en 8,5 segundos en mi computadora portátil, mientras que la solución de @ Maltysen no produjo ninguna solución en 20 minutos de tiempo de ejecución.

Pero todavía es un poco lento para el compilador en línea.

Explicación

u     ^4TZ   start with G = 0, for H in 0, ... 4^10-1:
                G = 
 +GhO4              G + (rand_int(4) + 1)
             result is printed implicitly 

Java, 65

Como tenemos puntajes listados por idioma, ¿por qué no incluir Java en la mezcla? Aquí no hay mucho para jugar al golf, solo un simple bucle, pero pude exprimir un par de mi intento inicial:

int f(){int i=1<<20,s=i;while(i-->0)s+=Math.random()*4;return s;}

Matlab, 24

¡Primera presentación!

sum(randi([1,4],1,2^20))

Tenía la esperanza de hacer uso de randi ([1,4], 1024), que proporciona una matriz de 1048576 elementos, pero luego necesitaba una suma doble, que requiere más caracteres que este.

Con respecto a la velocidad de carrera mencionada en la pregunta, timeitme dice que el tiempo de ejecución es de aproximadamente 0.031 segundos. Entonces, casi al instante.

Haskell, 73 bytes

import System.Random
f=fmap sum.(sequence.replicate(2^20))$randomRIO(1,4)

Uso:

$ ghci sourcefile.hs
ghci> f
2622130

C #: 105 bytes

using System.Linq;class C{int D(){var a=new System.Random();return new int[1<<20].Sum(i=>a.Next(1,5));}}

PHP 38 37 bytes

Esto utiliza una idea muy simple: sumarlos todos.

Además, he notado que 1048576está 10000000000000000000en binario, equivalente a 1<<20.

Aquí está el código:

while($i++<1<<20)$v+=rand(1,4);echo$v

Prueba en tu navegador (con MUY PEQUEÑOS cambios):

$i=$v=0;while($i++<1<<20)$v+=rand(1,4);printf($v);

//'patch' to make a TRUE polyglot, to work in JS

if('\0'=="\0")//this will be false in PHP, true in JS
{
  //rand function, takes 2 parameters
  function rand($m,$n){
    return ((Math.random()*($n-$m+1))+$m)>>0;
    
    /*
     *returns an integer number between $m and $n
     *example run, with rand(4,9):
     *(Math.random()*(9-4+1))+4
     *
     *if you run Math.random()*(9-4+1),
     *it will returns numbers between 0 and 5 (9-4+1=6, but Math.random() never returns 1)
     *but the minimum is 4, so, we add it in the end
     *this results in numbers between 0+4 and 4+5
     *
     */
    
  }
  
  //for this purpose, this is enough
  function printf($s){
    document.write($s);
  }
}


/*
 *Changes:
 *
 *- instead of echo, use printf
 *    printf outputs a formatted string in php
 *    if I used echo instead, PHP would complain
 *- set an initial value on $i and $v
 *    this avoids errors in Javascript
 *
 */


$i=$v=0;while($i++<1<<20)$v+=rand(1,4);printf($v);

Todos los cambios en el código se explican en los comentarios.

Mathematica, 30 27 bytes

Tr[RandomInteger[3,2^20]+1]

Mathematica tiene nombres de funciones bastante largos ...

C, 57 bytes

main(a,b){for(b=a=1<<20;a--;b+=rand()%4);printf("%d",b);}

Este código funciona ... una vez. Si alguna vez necesita tirar esos dados nuevamente, deberá colocarlos srand(time(0))allí, agregando 14 bytes.

PostgreSQL, 59 bytes

select sum(ceil(random()*4)) from generate_series(1,1<<20);

Admitiré el ligero problema que random()podría, en teoría, producir exactamente cero, en cuyo caso la tirada del dado sería cero.

Ruby, 32 bytes

(1..2**20).inject{|x|x-~rand(4)}

En una forma más legible:

(1..2**20).inject(0) do |x|
  x + rand(4) + 1
end

Crea un rango de 1 a 1048576 y luego itera sobre el bloque muchas veces. Cada vez que se ejecuta el bloque, el valor de la iteración anterior se pasa como x(inicialmente 0, el valor predeterminado para inject). Cada iteración calcula un número aleatorio entre 0 y 3 (inclusive), agrega uno, por lo que simula tirar un d4 y lo agrega al total.

En mi máquina es bastante rápido ejecutar ( 0.25 real, 0.22 user, 0.02 sys).

Si tiene instalado Ruby, puede ejecutarlo ruby -e 'p (1..2**20).inject{|x|x+rand(4)+1}'( pes necesario para ver el resultado cuando se ejecuta de esta manera, omítalo si no le importa o simplemente ejecútelo dentro de IRB donde el resultado se imprime en la pantalla para ti). Lo he probado en Ruby 2.1.6.

Gracias a histocrat por el truco poco retorcido que reemplaza x + rand(4) + 1con x-~rand(4).

PARI / GP, 25 bytes

Realmente, no hay necesidad de jugar golf aquí: esta es la forma directa de hacer el cálculo en GP. Se ejecuta en 90 milisegundos en mi máquina. Alzando el +1ahorra unos 20 milisegundos.

sum(i=1,2^20,random(4)+1)

Solo por diversión: si uno estuviera optimizando el rendimiento en PARI,

inline long sum32d4(void) {
  long n = rand64();
  // Note: __builtin_popcountll could replace hamming_word if using gcc
  return hamming_word(n) + hamming_word(n & 0xAAAAAAAAAAAAAAAALL);
}

long sum1048576d4(void) {
  long total = 0;
  int i;
  for(i=0; i<32768; i++) total += sum32d4();
  return total;
}

tiene un recuento total de operaciones muy pequeño: si xorgens necesita ~ 27 ciclos por palabra de 64 bits (¿alguien puede verificar esto?), entonces un procesador con POPCNT debería tomar solo alrededor de 0.5 ciclos / bit, o unos pocos cientos de microsegundos para el final número.

Esto debería tener un rendimiento cercano al óptimo en el peor de los casos entre los métodos que usan números aleatorios de calidad similar o superior. Debería ser posible aumentar considerablemente la velocidad promedio combinando casos, tal vez un millón de rollos a la vez, y seleccionando (esencialmente) codificación aritmética .

Javascript, 55 53 50 47 41 bytes

for(a=i=1<<20;i--;)a+=(Math.random()*4)|0

No me di cuenta de que los números no aleatorios eran un irritante conocido, por lo que creo que debería publicar una solución real. No significaba falta de respeto.

Comentario: como lo señalaron otros arriba, puede omitir el +1 en cada rollo comenzando con el número de rollos en su respuesta, y al no tener que escribir a = 0, i = 1 << 20 ahorra dos bytes, y otros 2 porque no agregas +1 a cada rollo. La función parseInt hace lo mismo que Math.floor pero es 2 caracteres más corta.

Clip 10 , 12 bytes

r+`m[)r4}#WT

         #4T    .- 4^10 = 1048576             -.
   m[   }       .- that many...               -.
     )r4        .-          ...random numbers -.
r+`             .- sum                        -.

Se tarda aproximadamente 0,6 segundos en ejecutarse en mi máquina.

Go, 78 bytes

Golfed

import."math/rand";func r()(o int){for i:=2<<19;i>=0;i--{o+=Intn(4)+1};return}

Sigo trabajando en eso

Ejecute en línea aquí http://play.golang.org/p/pCliUpu9Eq

Go, 87 bytes

Solución ingenua

import"math/rand";func r(){o,n:=0,2<<19;for i:=0;i<n;i++{o+=rand.Intn(4)};println(o+n)}

Corre en línea aquí: http://play.golang.org/p/gwP5Os7_Sq

Debido a la forma en que funciona el área de juegos Go, debe cambiar manualmente la semilla (el tiempo siempre es el mismo)

Commodore Basic, 37 bytes

1F┌I=1TO2↑20:C=C+INT(R/(1)*4+1):N─:?C

Sustituciones de PETSCII: ─= SHIFT+E, /= SHIFT+N, ┌=SHIFT+O

Tiempo de ejecución estimado basado en carreras con recuentos de dados más bajos: 4.25 horas.

Es tentador intentar jugar golf de dos bytes haciendo Cun número entero, obteniendo redondeo implícito de los números aleatorios. Sin embargo, el rango de enteros en Commodore Basic es -32678 a 32767 - no es suficiente, cuando la respuesta mediana es 2621440.

PowerShell, 41 37 bytes

1..1mb|%{(get-random)%4+1}|measure -s

Tomó mi máquina 2 minutos 40 segundos

Ruby, 51 47 caracteres

x=[];(2**20).times{x<<rand(4)+1};p x.inject(:+)

Miré todas las respuestas antes de hacer esto, y la sum(2**20 times {randInt(4)})estrategia realmente sobresalió, así que usé eso.

> <>, 76 caracteres

012a*&>2*&1v
|.!33&^?&:-<
3.v < >-:v >
   vxv1v^<;3
  1234    n+
  >>>> >?!^^

No estoy seguro de si funciona, porque mi navegador falló cuando intenté probarlo, pero aquí está el intérprete en línea.

Rápido, 64 bytes

Nada inteligente, jugar al golf en Swift es difícil ...

func r()->Int{var x=0;for _ in 0..<(2<<19) {x+=Int(arc4random()%4)+1;};return x;}

Versión 2 (demasiado tarde)

var x=0;for _ in 0..<(2<<19){x+=Int(arc4random()%4)+1;};print(x)

Java (Java 8) - 52

int f(){return new Random().ints(1<<20,1,5).sum();}