Suponha que você tenha dois dados de seis lados. Role o par 100 vezes, calculando a soma de cada par. Imprima o número de vezes que cada soma ocorreu. Se uma soma nunca foi rolada, você deve incluir um zero ou alguma maneira de identificar que essa soma específica nunca foi rolada.

Exemplo de saída: [3, 3, 9, 11, 15, 15, 11, 15, 7, 8, 3]

O número de vezes que uma soma foi rolada é representado no índice de somas - 2

Neste exemplo, uma soma de dois foi rolada 3 vezes ([2-2]), uma soma de três três vezes ([3-2]), uma soma de quatro 9 vezes ([4-2]) e, portanto, em. Não importa que os dados individuais cheguem a uma soma (5 e 2 seriam contados como a mesma soma que 6 e 1)

As saídas "feias" são boas (montes de zeros à direita, saídas extras, maneiras estranhas de representar dados etc.), desde que você explique como os dados devem ser lidos.

Geléia , 13 12 bytes

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

Um link niládico. Formato de saída é uma lista de listas de [value, count].

(Rolagens zero significa que nenhuma entrada está presente na saída - por exemplo, uma saída [[6, 12], [7, 74], [8, 14]]identificaria que apenas somas de seis, sete e oito foram roladas.)

Experimente online!

Quão?

³Ḥ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 graças a @JonathanAllan
-1 byte graças a @FelipeNardiBatista

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

Experimente online!

A saída possui dois zeros à esquerda

05AB1E , 21 19 bytes

-2 bytes graças a @Emigna

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

Experimente online!

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]

Implementação direta. Se alguma soma nunca for alcançada, esta 0será omitida da lista.

MATL , 17 bytes

6H100I$Yrs!11:Q=s

Saída é uma lista de 11 números (alguns deles possivelmente 0) separados por espaços, indicando o número de vezes para cada par de 2 a 12.

Experimente online!

Para comparação, o número médio teórico de vezes que cada par aparecerá em média pode ser calculado como 6:gtY+36/100*.

Se o número de jogadas for aumentado, os valores obtidos se aproximam dos teóricos. Veja, por exemplo, os valores teóricos e obtidos com 10000 rolos.

CJam, 18 20 bytes

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

Experimente online!

Perl 6 , 30 bytes

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

(^6).pické um número aleatório de zero a cinco. xx 100faz uma lista de cem elementos desses números. xx 2produz duas dessas listas. [Z+]fecha essas duas listas com adição, produzindo uma lista de cem elementos de rolos de dois dados. Finalmente,bag coloca essa lista em uma sacola, que é uma coleção com multiplicidade. Exemplo de saída REPL:

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

Isso significa que 1, 9 e 0 ocorreram quatro vezes cada, quatro ocorreram catorze vezes, etc. Como os "dados" neste código produzem um número de 0 a 5, adicione dois a cada um desses números para obter os rolos um par de dados 1-6 padrão produziriam.

R , 45 bytes 37

-7 bytes graças a Jarko Dubbledam

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

Retorna um objeto de tabela de elementos e contagens de cada um. Exclui quaisquer valores que não ocorreram.

Experimente online!

versão antiga:

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

sample(6,200,T) amostras 200 vezes de 1:6 uniforme da substituição, cria uma matriz com 2 linhas, soma as colunas, as classifica em ordem crescente e calcula os comprimentos das execuções. Omite qualquer soma de dados que não seja atingida.

Retorna um rleobjeto, que é impresso por padrão no seguinte 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 ...

onde lengthsestão as contagens e as valuessomas dos dados.

Link TIO

PHP, 53 bytes

imprime uma matriz associativa. A chave é resultado de dois dados e o valor é a contagem desses resultados.

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

Experimente online!

JavaScript (ES6), 72 bytes

Visto que a saída "feia" é permitida, a seguir será exibida uma matriz contendo o número de vezes que cada pontuação de 2 a 12 foi rolada, com 89 elementos adicionais definidos como 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

Experimente online!

Rola os dados e os armazena nos 11 primeiros pontos da pilha, depois itera através da pilha, imprimindo cada contador. Esse é um dos primeiros usos registrados da palavra-chave rand combinada com um operador de atribuição.

Vale ressaltar que algumas modificações podem ser feitas para gerar um histograma dos rolos.

Infelizmente, ele deve ser executado a partir do intérprete offline .

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

Tentei algo mais difícil do que Jelly.

Explicação:

1. Defina a função que retorna um número aleatório entre 1 e 6, inclusive.
2. Defina a função anonimamente e deixe y seja a variável com a soma do rolo.
3. atualize o local apropriado na lista adicionando 1.
4. se tivermos 100 rolos, pare. Caso contrário, chame a si mesmo novamente, passando para você e para a lista atualizada.
5. retorne a matriz atualizada.

Deve ser chamado como p.(p,[0,0,0,0,0,0,0,0,0,0,0,0,0]). Irá emitir um aviso, mas retornará a matriz desejada com 13 elementos, os 2 primeiros devem ser ignorados.

Java 8, 104 bytes

Um lambda retornando um int[]de frequências. Atribuir a Supplier<int[]>.

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

Experimente Online

Lambda ungolfed

() -> {
    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

Solução:

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

Exemplo:

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

Explicação:

Jogue um dado 100?6, jogue-o novamente e adicione os vetores. Em seguida, veja onde cada resultado corresponde ao intervalo de 0 a 10 e, em seguida, resuma todas as verdades de 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:

'Golfe' é principalmente trocar qpalavras - chave pelos kequivalentes, a saber, eache til.

QBIC , 45 bytes

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

Explicação:

[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

Apresenta dados como uma tabela com a coluna esquerda representando a soma e a direita representando o número de ocorrências.

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

Postagem anterior:

APL, 36 31 bytes

5 bytes salvos graças a @ Adám

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

Explicação

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

Experimente online ou assista no playground de peixes !

O formato de saída feio é uma sequência de números separados por novas linhas, onde o n º número diz quantas vezes a soma era n - é feio, porque ele imprime para sempre, para todos os inteiros positivos n , embora a maioria das linhas será 0. ( O link TIO é modificado para parar após n = 12, ao custo de 5 bytes.)

O playground de peixes é bastante lento - leva cerca de três minutos e meio para imprimir até n = 12 na velocidade máxima -, então você pode modificá-lo para rolar 10 pares de dados em vez de 100, alterando o aa*na 5ª linha para a  (isto é, aseguido por dois espaços).

Os dados aleatórios são feitos por este bit:

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

Eles xmudam a direção do peixe aleatoriamente. Supondo que seja implementado com probabilidades iguais, fica claro que o resultado do rolo de matriz é uma distribuição uniforme por simetria.

Uma vez que o peixe tenha jogado 100 pares de dados, ele conta quantas vezes a soma foi n com esse bit (desembrulhado para maior clareza e começando no canto superior esquerdo):

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

Mantemos n na frente da pilha e usamos o registrador para contar o número de vezes que n aparece.

Javascript 85 75 caracteres

Obrigado Shaggy!

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

História

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

Experimente online!

Formato de saída:

<sum> <# rolls>

Para somas com zero rolos, a coluna de rolos está em branco.

PHP, 65 bytes

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

imprime um líder 0_e, em seguida, as ocorrências de 2 a 12, seguidas de um sublinhado cada.
Corra com -nrou experimente online .

K (oK) , 24 22 bytes

Solução:

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

Experimente online!

Explicação:

k'porta' da minha qsolução. A avaliação ocorre da direita para a esquerda, portanto, colchetes ao redor do 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

Editar% s:

• -2 bytes alternando a esquerda para cada um e ambos para a esquerda + virar para a direita

Pitão, 21 bytes

V100aY,O6O6)VTlfqsTNY

Produz cada etapa na criação dos rolos e, em seguida, gera a frequência de cada soma de 0 a 10 em uma linha 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;}

Experimente online!

Explicações

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;
}