Soma de 100 rolos de dois dados de seis lados

14

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.

MuffinDevil
fonte
2
Você quer dizer "imprimir o número de vezes que cada par ocorreu" ou "imprimir o número de vezes que cada soma ocorreu"?
Esolanging Fruit
1
Se uma soma específica nunca aparecer, será necessário que exista um 0na lista ou pode ser omitido?
Greg Martin
1
Os diferentes valores precisam ser consistentemente identificáveis ​​ou apenas as contagens são suficientes?
Jonathan Allan
1
Se a saída é apenas o número de vezes que cada combinação de pares ocorre, por que precisamos somar o valor de cada rolo? O que devemos fazer com esse total? O que você quer dizer com "feio"?
Shaggy
1
extra outputmas ainda não podemos produzir uma lista infinita de números aleatórios e dizer que ela aparece aleatoriamente em algum lugar, certo? Essa é uma brecha padrão Iirc.
24517 Stephen

Respostas:

5

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)
Jonathan Allan
fonte
4

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

ovs
fonte
golfed to 76 bytes TIO
Felipe Nardi Batista
3

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
kalsowerus
fonte
TÝÌтF6Lã.RO¸ì}{γ€g<economiza 2 bytes.
Emigna
@ Emigna, não esperava que o loop fosse mais curto, obrigado!
precisa saber é o seguinte
2

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.

Greg Martin
fonte
2

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.

Luis Mendo
fonte
2

CJam, 18 20 bytes

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

Experimente online!

Esolanging Fruit
fonte
Ele gera um formato feio - o número de vezes que cada rolo ocorreu é representado como o comprimento dos segmentos contínuos.
Esolanging Fruit
@ JonathanAllan Tudo bem, tudo bem então. e` leva apenas dois bytes.
Esolanging Fruit
2

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.

Sean
fonte
Uau. Perl 6 é uma força a ser reconhecida.
Jakob
No entanto, "Se uma soma nunca foi rolada, você deve incluir um zero ou alguma maneira de identificar que essa soma específica nunca foi rolada". Não parece que a solução da bolsa satisfaça isso.
Jakob
Se um número específico não foi rolado, essa situação pode ser identificada pela ausência do número na sacola.
23417 Sean
2

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

Giuseppe
fonte
1

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!

Jörg Hülsermann
fonte
If a sum was never rolled, you must include a zero or some way to identify that that particular sum was never rolled.
Titus
1

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>

Shaggy
fonte
Você não está desperdiçando um byte para torná-lo 100 elementos em vez de 99 ou 20 ou apenas 12?
Rohan Jhunjhunwala
@RohanJhunjhunwala, o desafio exige 100 jogadas dos dois dados.
Salsicha
Ah, eu pensei que estavam apenas inicializando uma matriz de 100 elementos para armazenar os rolos.
Rohan Jhunjhunwala
1

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. insira a descrição da imagem aqui

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
Rohan Jhunjhunwala
fonte
1

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.

SalmonKiller
fonte
1

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;
}
Jakob
fonte
1

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.

rua
fonte
0

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
steenbergh
fonte
0

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
Uriel
fonte
Salve alguns bytes combinando as instruções e tornando o operando tácito:(11⍴⍉⌽f)[⍋11⍴⍉f←,∘⍴⌸+/?100 2⍴6]
Adám 28/05
Desculpe, editei minha sugestão enquanto você a incorporava. Observe o operando tácito.
Adám
No entanto, o OP permite qualquer formato de saída inequívoco, portanto ,∘⍴⌸+/?100 2⍴6deve ser suficiente, pois lista as somas que ocorrem (indicando quais não estão lá) e suas frequências (portanto, nenhuma classificação é necessária).
Adám
0

> <> , 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.

Não é uma árvore
fonte
0

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)
Steve Bennett
fonte
Manteve o significado para lhe dar algumas economias para isso; aqui está uma versão de 75 byte muito rapidamente golfed da sua solução: a=[];for(i=100;i--;)a[o=(f=_=>Math.random()*6|0)()+f()]=(a[o]|0)+1;alert(a). (Nota: neste caso, o IIFE não poupa nem os custos de quaisquer bytes, mas há momentos em que você pode economizar um byte ou 2, por isso é útil para tê-lo em seu "golfbag".)
Shaggy
Oh, incrível, obrigado. Truques úteis lá! Tão interessante que |0é a solução de golfe para "Math.floor ()" e também para "converter indefinido em 0".
Steve Bennett
0

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.

Xcali
fonte
0

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 .

Titus
fonte
0

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
rua
fonte
0

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
Dave
fonte
0

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;
}
Olivier Grégoire
fonte