Supongamos que tienes dos dados de seis caras. Tira el par 100 veces, calculando la suma de cada par. Imprima el número de veces que ocurrió cada suma. Si nunca se realizó una suma, debe incluir un cero o alguna forma de identificar que esa suma en particular nunca se realizó.

Ejemplo de salida: [3, 3, 9, 11, 15, 15, 11, 15, 7, 8, 3]

El número de veces que se lanzó una suma se representa en el índice de sumas: 2

En este ejemplo, una suma de dos fue lanzada 3 veces ([2-2]), una suma de tres 3 veces ([3-2]), una suma de cuatro 9 veces ([4-2]), y así en. No importa que los dados individuales lleguen a una suma (5 y 2 se contarán como la misma suma que 6 y 1)

Las salidas "feas" están bien (cargas de ceros finales, salidas adicionales, formas extrañas de representar datos, etc.) siempre que explique cómo deben leerse los datos.

Jalea , 13 12 bytes

³Ḥ6ẋX€+2/ṢŒr

Un enlace niládico. El formato de salida es una lista de listas de [value, count].

(Cero tiradas significa que no hay tal entrada presente en la salida; por ejemplo, una salida de [[6, 12], [7, 74], [8, 14]]identificaría que solo se rodaron sumas de seis, siete y ocho).

Pruébalo en línea!

¿Cómo?

³Ḥ6ẋX€+2/ṢŒr - Main link: no arguments
³            - 100
 Ḥ           - double = 200
  6          - 6
   ẋ         - repeat -> [6,6,6...,6], length 200
    X€       - random integer from [1,z] for €ach (where z=6 every time)
       2/    - pairwise reduce with:
      +      -   addition (i.e. add up each two)
         Ṣ   - sort
          Œr - run-length encode (list of [value, length] for each run of equal values)

Python 2 , 84 77 76 bytes

-7 bytes gracias a @JonathanAllan
-1 byte gracias a @FelipeNardiBatista

from random import*
a=[0]*13
exec'a[%s]+=1;'%('+randint(1,6)'*2)*100
print a

Pruébalo en línea!

La salida tiene dos ceros a la izquierda

05AB1E , 21 19 bytes

-2 bytes gracias a @Emigna

TÝÌтF6Lã.RO¸ì}{γ€g<

Pruébalo en línea!

TÝÌтF6Lã.RO¸ì}{γ€g<
TÝÌ                   Range from 2 to 12
   тF                 100 times do:
     6L                 Range from 1 to 6
       ã                Cartesian product (creates all possible pairs of 1 and 6)
        .RO             Choose random pair and sum
           ¸ì           Prepend result to initial list
             }        end loop
              {γ€g<   Sort, split on consecutive elements, count and decrement

Mathematica, 50 bytes

r:=RandomInteger@5
Last/@Tally@Sort@Table[r+r,100]

Implementación directa. Si nunca se alcanza una suma, 0se omite de la lista.

MATL , 17 bytes

6H100I$Yrs!11:Q=s

La salida es una lista de 11 números (algunos de ellos posiblemente 0) separados por espacios, que indican el número de veces para cada par de 2 a 12.

Pruébalo en línea!

A modo de comparación, la cantidad promedio teórica de veces que cada par aparecerá en promedio se puede calcular como 6:gtY+36/100*.

Si se aumenta el número de rollos, los valores obtenidos se aproximan a los teóricos. Ver por ejemplo los valores obtenidos y teóricos con 10000 rollos.

CJam, 18 20 bytes

100{;6mr6mr+))}%$e``

Pruébalo en línea!

Perl 6 , 30 bytes

bag [Z+] (^6).pick xx 100 xx 2

(^6).pickes un número aleatorio de cero a cinco. xx 100hace una lista de cien elementos de tales números. xx 2produce dos de esas listas. [Z+]comprime esas dos listas con suma, produciendo una lista de cien elementos de tiradas de dos dados. Finalmente, bagpone esa lista en una bolsa, que es una colección con multiplicidad. Ejemplo de salida REPL:

bag(1(4), 9(4), 0(4), 4(14), 5(18), 3(9), 10(2), 6(19), 7(13), 2(3), 8(10))

Eso significa que 1, 9 y 0 ocurrieron cuatro veces cada uno, cuatro ocurrieron catorce veces, etc. Dado que los "dados" en este código producen un número del 0 al 5, agregue dos a cada uno de estos números para obtener un par de tiradas. se producirían de 1 a 6 dados estándar.

R , 45 37 bytes

-7 bytes gracias a Jarko Dubbledam

s=sample;table(s(6,100,T)+s(6,100,T))

Devuelve una tabla objeto de elementos y recuentos de cada uno. Excluye los valores que no ocurrieron.

Pruébalo en línea!

versión antigua:

rle(sort(colSums(matrix(sample(6,200,T),2))))

sample(6,200,T)muestra 200 veces de manera 1:6uniforme con reemplazo, luego forma una matriz con 2 filas, suma las columnas, luego las ordena en orden ascendente y calcula las longitudes de las corridas. Omite cualquier suma de dados que no se alcance.

Devuelve un rleobjeto, que imprime de forma predeterminada en el siguiente formato:

Run Length Encoding
  lengths: int [1:11] 5 6 8 12 12 20 12 11 4 7 ...
  values : num [1:11] 2 3 4 5 6 7 8 9 10 11 ...

¿Dónde lengthsestán los recuentos y las valuessumas de dados?

Enlace TIO

PHP, 53 bytes

imprime una matriz asociativa. la clave es el resultado de dos dados y el valor es el recuento de estos resultados

for(;$i++<100;)$r[rand(1,6)+rand(1,6)]++;print_r($r);

Pruébalo en línea!

JavaScript (ES6), 72 bytes

Al ver que se permite la salida "fea", lo siguiente generará una matriz que contiene el número de veces que se obtuvo cada puntaje de 2-12, con 89 elementos adicionales establecidos en 0.

_=>(a=Array(100).fill(0)).map(_=>a[g()+g()]++,g=_=>Math.random()*6|0)&&a

f=
_=>(a=Array(100).fill(0)).map(_=>a[g()+g()]++,g=_=>Math.random()*6|0)&&a
o.innerText=f()

<pre id=o>

SILOS , 99 bytes

i=100
lbla
x=rand*6+rand*6
a=get x
a+1
set x a
i-1
if i a
lblb
c=get b
printInt c
b+1
d=11-b
if d b

Pruébalo en línea!

Tira los dados y los almacena en los primeros 11 puntos del montón, luego solo itera a través del montón imprimiendo cada contador. Este es uno de los primeros usos registrados de la palabra clave rand combinada con un operador de asignación.

Vale la pena señalar que se pueden hacer algunas modificaciones para generar un histograma de los rollos.

Lamentablemente, debe ejecutarse desde el intérprete fuera de línea .

i=4000
lbla
x=rand*6+rand*6
a=get x
a+1
set x a
i-1
if i a
canvas 1100 1000 Output
lblb
c=get b
printInt c
d=c*1
y=1000-d
x=b*100
newObj 0 100 d
moveObj b x y
b+1
d=11-b
if d b
wait 10000

Elixir, 157 118 bytes

l=&Enum.random(1..&1)
p=fn(o,s)->y=l.(6)+l.(6)
s=List.update_at(s,y,&(&1+1))
if Enum.sum(s)<100 do s=o.(o,s) end
s end

Intenté algo más duro que Jelly.

Explicación:

1. Defina la función que devuelve un número aleatorio entre 1 y 6 inclusive.
2. Defina la función de forma anónima y deje que ysea ​​la variable con la suma total.
3. actualice el lugar apropiado en la lista agregando 1.
4. si tenemos 100 rollos, déjalo. De lo contrario, llama a ti mismo de nuevo pasando en ti y la lista actualizada.
5. Devuelve la matriz actualizada.

Debería llamarse como p.(p,[0,0,0,0,0,0,0,0,0,0,0,0,0]). Aparecerá una advertencia, pero devolverá la matriz deseada con 13 elementos, los 2 primeros deben ignorarse.

Java 8, 104 bytes

Una lambda que devuelve una int[]de frecuencias. Asignar a Supplier<int[]>.

()->{int o[]=new int[11],i=0;while(i++<100)o[(int)(Math.random()*6)+(int)(Math.random()*6)]++;return o;}

Pruébalo en línea

Lambda sin golf

() -> {
    int
        o[] = new int[11],
        i = 0
    ;
    while (i++ < 100)
        o[(int) (Math.random() * 6) + (int) (Math.random() * 6)]++;
    return o;
}

q / kdb +, 31 28 25 bytes

Solución:

sum!:[11]=/:sum(2#100)?'6

Ejemplo:

q)sum!:[11]=/:sum(2#100)?'6
1 3 5 11 16 21 16 9 8 9 1i

Explicación:

Tira un dado 100?6, tira un dado de nuevo y suma los vectores. Luego vea donde cada resultado coincide con el rango 0..10, luego resuma todas las verdades en cada lista:

sum til[11]=/:sum(2#100)?'6 / ungolfed solution
                 (2#100)    / 2 take 100, gives list (100;100)
                        ?'6 / performs rand on each left-each right, so 100 & 6, 100 & 6
              sum           / add the lists together
    til[11]                 / the range 0..10
           =/:              / apply 'equals?' to each right on left list
sum                         / sum up the results, e.g. how many 1s, 2s, 3s.. 12s

Notas:

'Golf' es en su mayoría intercambiando qpalabras clave por los kequivalentes, a saber, eachy til.

QBIC , 45 bytes

[100|h=_r1,6|+_r1,6|-2┘g(h)=g(h)+1][0,z|?g(b)

Explicación:

[100|         FOR a = 1 to 100
h=_r1,6|       set h to a random value between 1-6
 +_r1,6|       + another rnd(1,6) (2, 3 ... 11, 12)
 -2            - 2 (index: 0 ... 10
┘             Syntactic linebreak
g(h)          When using array parenthesis on an undefined array,
              it is interpreted as an array with 10 indexes of all zeroes.           
    =         Of array g, set the value of index h (0 ... 11)
      g(h)+1  to one higher (all indices start out as 0)
              Note that we need to track 11 values. Fortunately, QBasic'set
              empty, 10-sized array has 11 indices, because of base 0 / base 1 ambiguity.
]             NEXT set of dice
[0,z|         FOR b = 0 to 10
?g(b)           PRINT the tracker array

APL, 14 bytes

,∘≢⌸+/?100 2⍴6

Presenta los datos como una tabla con la columna izquierda que representa la suma y la derecha que representa el número de ocurrencias.

Explicado

        100 2⍴6  ⍝ create an 2×100 array of 6
       ?         ⍝ roll for each cell from 1 to 6
     +/          ⍝ sum every row
   ⌸            ⍝ for every unique sum
,∘≢              ⍝ get the sum and the number of indexes

Publicación anterior:

APL, 36 31 bytes

5 bytes guardados gracias a @ Adám

(11⍴⍉⌽f)[⍋11⍴⍉f←,∘≢⌸+/?100 2⍴6]

Explicación

f←,∘≢⌸+/?100 2⍴6
          100 2⍴6    ⍝ create an 2×100 array of 6
         ?           ⍝ roll for each cell from 1 to 6
       +/            ⍝ sum every row
     ⌸              ⍝ for every unique sum
  ,∘≢                ⍝ get the sum and the number of indexes

(11⍴⍉⌽f)[⍋11⍴⍉f]  ⍝ ⍋x returns the indexes of the sorted x in the current x  
                     ⍝ x[y] find the yth elements of x
                     ⍝ x[⍋y] reorders x the same way that would be required to sort y

            11⍴⍉f   ⍝ the column of sums - see below
 11⍴⍉⌽f            ⍝ the column of counts - see below

Como 11⍴⍉⌽ffunciona

⍝ ⌽ - Reverses the array
⍝ ⍉ - Transposes the array

  ⍝   f
 9 14   ⍝ Sum - Occurences
 4  9
 7 17
 8 18
 6 15
 5  7
10  3
11  5
 3  6
 2  2
12  4

  ⍝   ⍉f
 9 4  7  8  6 5 10 11 3 2 12  ⍝ Sum
14 9 17 18 15 7  3  5 6 2  4  ⍝ Occurences

  ⍝   ⍉⌽f
14 9 17 18 15 7  3  5 6 2  4  ⍝ Occurences
 9 4  7  8  6 5 10 11 3 2 12  ⍝ Sum

> <> , 93 bytes

00[0[v
v 1\v/4
v 2xxx5
v 3/^\6
>l2(?^+]laa*=?v0[
  /&1+&\ v1&0]<
=?/ :?!\}>:@@:@
oa&0n&}< ^+1

¡Pruébelo en línea o mírelo en el área de juegos para peces !

El formato de salida fea es una secuencia de números separados por saltos de línea, en el que el n º Número dice cuántas veces la suma era n - es feo porque imprime siempre, para todos los enteros positivos n , aunque la mayoría de las líneas será 0. ( El enlace TIO se modifica para detenerse después de n = 12, a un costo de 5 bytes).

El área de juegos para peces es bastante lenta: toma aproximadamente tres minutos y medio imprimir hasta n = 12 a la velocidad máxima, por lo que es posible que desee modificarlo para lanzar 10 pares de dados en lugar de 100 cambiando el aa*en la quinta línea a a  (es decir,a seguido de dos espacios).

Las tiradas de dados al azar se realizan por este bit:

1\v/4
2xxx5
3/^\6

Los xs cambian la dirección del pez al azar. Suponiendo que se implemente con las mismas probabilidades, está claro que el resultado del dado es una distribución uniforme por simetría.

Una vez que el pez ha lanzado 100 pares de dados, cuenta cuántas veces la suma fue n con este bit (sin envolver para mayor claridad y comenzando en la parte superior izquierda):

v       /&1+&\
>:@@:@=?/ :?!\}
^   +1oa&0n&}<

Mantenemos n al frente de la pila y usamos el registro para contar la cantidad de veces que aparece n .

Javascript 85 75 caracteres

Gracias Shaggy!

a=[]
for(i=100;i--;)a[o=(f=_=>Math.random()*6|0)()+f()]=(a[o‌​]|0)+1
alert(a)

Historia

85

a={}
f=_=>Math.random()*6
for(i=0;i++<100;)a[o=-~f()-~f()]=(a[o]||0)+1
console.log(a)

Perl 5 , 64 bytes

map$s{2+int(rand 6)+int rand 6}++,1..100;say"$_ $s{$_}"for 2..12

Pruébalo en línea!

Formato de salida:

<sum> <# rolls>

Para sumas con cero rollos, la columna de rollos está en blanco.

PHP, 65 bytes

while($i++<100)${rand(1,6)+rand(1,6)}++;for(;++$k<13;)echo+$$k,_;

imprime un inicio 0_y luego las ocurrencias de 2 a 12, seguido de un guión bajo cada uno.
Ejecutar -nro probarlo en línea .

K (oK) , 24 22 bytes

Solución:

+/(!11)=/:+/(2#100)?'6

Pruébalo en línea!

Explicación:

k'puerto' de mi qsolución. La evaluación ocurre de derecha a izquierda, por lo tanto, los corchetes alrededor del til ( !)

+/(!11)=/:+/(2#100)?'6 / the solution
            (2#100)    / the list (100;100)
                   ?'6 / take 6 from each left/each right (roll the dice twice)
           +/          / sum rolls together
  (!11)                / til, performs range of 0..n-1, thus 0..10
       =/:             / equals each right (bucket the sum of the rolls)
+/                     / sum up to get counts per result

Ediciones:

• -2 bytes que cambian cada uno a la izquierda para cada uno, y el cada uno a la izquierda + voltear para cada uno a la derecha

Pyth, 21 bytes

V100aY,O6O6)VTlfqsTNY

Emite cada paso en la creación de los rollos, luego emite la frecuencia de cada suma 0-10 en una línea separada.

V100aY,O6O6)VTlfqsTNY Full program, no input, outputs to stdout
V100                  For N from 0 to 100
    a ,O6O6           Append a pair of random ints below 6
     Y                To a list Y, initialized to the empty list
           )          Then
            VT        For N from 0 to 10
              f     Y Print Y filtered to only include pairs
                q  N  For which N is equal to
                 sT   The sum of the pair

Java (OpenJDK 8) , 95 bytes

a->{int r[]=new int[11],i=0,d=0;for(;i++<200;)r[d+=Math.random()*6]+=i%2<1?1-(d=0):0;return r;}

Pruébalo en línea!

Explicaciones

a->{
  int r[] = new int[11],     // Rolls or result
      i   = 0,               // Iteration
      d   = 0;               // Dice accumulator
  for (;i++<200;)
    r[d+=Math.random()*6] += // Accumulate a new die and start an addition
     i % 2 < 1               // Accumulate up to two dice
       ? 1 - (d = 0)         // If we're at 2 dice, reset the accumulator and add 1
       : 0;                  // If we only have one die, add 0
  return r;
}