Supponiamo di avere due dadi a sei facce. Rotola la coppia 100 volte, calcolando la somma di ciascuna coppia. Stampa il numero di volte in cui si è verificata ogni somma. Se una somma non è mai stata distribuita, è necessario includere uno zero o un modo per identificare che quella somma specifica non è mai stata erogata.

Esempio di output: [3, 3, 9, 11, 15, 15, 11, 15, 7, 8, 3]

Il numero di volte in cui è stata lanciata una somma è rappresentato nell'indice delle somme - 2

In questo esempio, una somma di due è stata lanciata 3 volte ([2-2]), una somma di tre 3 volte ([3-2]), una somma di quattro 9 volte ([4-2]) e così su. Non importa che i singoli tiri di dado arrivino a una somma (5 e 2 verrebbero conteggiati come la stessa somma di 6 e 1)

Gli output "brutti" vanno bene (un sacco di zeri finali, output extra, strani modi di rappresentare i dati, ecc.) Purché spieghi come devono essere letti i dati.

Gelatina , 13 12 byte

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

Un collegamento niladico. Il formato di output è un elenco di elenchi di [value, count].

(Zero rotoli significa che tale voce non è presente nell'output, ad es. Un'uscita di [[6, 12], [7, 74], [8, 14]]identificherebbe che sono state lanciate solo somme di sei, sette e otto.)

Provalo online!

Come?

³Ḥ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 byte

-7 byte grazie a @JonathanAllan
-1 byte grazie a @FelipeNardiBatista

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

Provalo online!

L'output ha due zeri iniziali

05AB1E , 21 19 byte

-2 byte grazie a @Emigna

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

Provalo 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 byte

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

Implementazione semplice. Se non viene mai raggiunta alcuna somma, 0viene omesso dall'elenco.

MATL , 17 byte

6H100I$Yrs!11:Q=s

L'output è un elenco di 11 numeri (alcuni dei quali probabilmente 0) separati da spazi, che indicano il numero di volte per ogni coppia da 2 a 12.

Provalo online!

Per confronto, il numero medio teorico di volte in cui ciascuna coppia apparirà in media può essere calcolato come 6:gtY+36/100*.

Se si aumenta il numero di lanci, i valori ottenuti si avvicinano a quelli teorici. Vedi ad esempio i valori ottenuti e teorici con 10000 rotoli.

CJam, 18 20 byte

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

Provalo online!

Perl 6 , 30 byte

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

(^6).pickè un numero casuale compreso tra zero e cinque. xx 100crea un elenco di cento elementi di tali numeri. xx 2produce due di questi elenchi. [Z+]comprime queste due liste con l'aggiunta, producendo un elenco di cento elementi di tiri da due dadi. Infine, bagmette quell'elenco in una borsa, che è una raccolta con molteplicità. Esempio di output REPL:

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

Ciò significa che 1, 9 e 0 si sono verificati quattro volte ciascuno, quattro si sono verificati quattordici volte, ecc. Dato che i "dadi" in questo codice producono un numero da 0-5, aggiungere due a ciascuno di questi numeri per ottenere una coppia di tiri produrrebbe dadi standard 1-6.

R , 45 37 byte

-7 byte grazie a Jarko Dubbledam

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

Restituisce un oggetto tabella di elementi e conteggi di ciascuno. Esclude tutti i valori che non si sono verificati.

Provalo online!

vecchia versione:

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

sample(6,200,T) campioni a 200 volte da 1:6 uniformemente con la sostituzione, quindi crea una matrice con 2 file, somma le colonne, quindi le ordina in ordine crescente e calcola le lunghezze delle corse. Omette qualsiasi somma di dadi non raggiunta.

Restituisce un rleoggetto, che stampa per impostazione predefinita nel seguente 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 ...

dove lengthssono i conteggi e le valuessomme dei dadi.

TIO Link

PHP, 53 byte

stampa un array associativo. la chiave è il risultato di due dadi e il valore è il conteggio di questi risultati

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

Provalo online!

JavaScript (ES6), 72 byte

Considerando che l'output "brutto" è consentito, di seguito verrà generato un array contenente il numero di volte in cui è stato ottenuto il punteggio di ogni 2-12, con 89 elementi aggiuntivi impostati su 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 byte

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

Provalo online!

Lancia i dadi e li immagazzina nei primi 11 punti dell'heap, quindi scorre l'heap stampando ogni contatore. Questo è uno dei primi usi registrati della parola chiave rand combinata con un operatore di assegnazione.

Vale la pena notare che è possibile apportare alcune modifiche per produrre un istogramma dei rulli.

Purtroppo deve essere eseguito dall'interprete 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

Elisir, 157 118 byte

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

Ho provato qualcosa di più duro di Jelly.

Spiegazione:

1. Definire la funzione che restituisce un numero casuale compreso tra 1 e 6 inclusi.
2. Definire la funzione in forma anonima e lasciare che ysia la variabile con la somma del roll.
3. aggiorna il posto appropriato nell'elenco aggiungendo 1.
4. se siamo in 100, esci. Altrimenti chiama di nuovo te stesso passando in te stesso e l'elenco aggiornato.
5. restituisce l'array aggiornato.

Dovrebbe essere chiamato come p.(p,[0,0,0,0,0,0,0,0,0,0,0,0,0]). Emetterà un avviso, ma restituirà l'array desiderato con 13 elementi, i primi 2 dovrebbero essere ignorati.

Java 8, 104 byte

Un lambda che restituisce una int[]delle frequenze. Assegna a Supplier<int[]>.

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

Provalo 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 byte

Soluzione:

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

Esempio:

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

Spiegazione:

Lancia un dado 100?6, tira di nuovo un dado e aggiungi i vettori insieme. Quindi vedi dove ogni risultato corrisponde all'intervallo 0..10, quindi riassumi tutte le verità in ogni elenco:

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

Appunti:

"Giocare a golf" è principalmente scambiare qparole chiave per gli kequivalenti, vale a dire eache til.

QBIC , 45 byte

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

Spiegazione:

[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 byte

,∘≢⌸+/?100 2⍴6

Presenta i dati come una tabella con la colonna di sinistra che rappresenta la somma e la destra che rappresenta il numero di occorrenze.

spiegato

        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

Messaggio precedente:

APL, 36 31 byte

5 byte salvati grazie a @ Adám

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

Spiegazione

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

Come 11⍴⍉⌽ffunziona

⍝ ⌽ - 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 byte

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

Provalo online o guardalo nel parco giochi per pesci !

Il formato di output brutto è una sequenza di numeri separati da nuove righe, dove il n -esimo numero dice quante volte la somma è stata n - è brutto perché la stampa per sempre, per tutti gli interi positivi n , anche se la maggior parte delle linee saranno 0. ( Il collegamento TIO viene modificato per arrestarsi dopo n = 12, al costo di 5 byte.)

Il parco giochi per pesci è abbastanza lento - ci vogliono circa tre minuti e mezzo per stampare fino a n = 12 alla massima velocità - quindi potresti volerlo modificare per tirare 10 coppie di dadi invece di 100 cambiando il aa*nella 5a riga in a  (cioè aseguito da due spazi).

I tiri di dado casuali sono fatti da questo bit:

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

Il x s cambiano la direzione del pesce in modo casuale. Supponendo che sia implementato con le stesse probabilità, è chiaro che il risultato del tiro di dado è una distribuzione uniforme per simmetria.

Una volta che il pesce ha lanciato 100 coppie di dadi, conta quante volte è stata la somma n con questo bit (da scartare per chiarezza e iniziando in alto a sinistra):

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

Manteniamo n in primo piano e utilizziamo il registro per contare il numero di volte n appare.

Javascript 85 75 caratteri

Grazie Shaggy!

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

Storia

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 byte

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

Provalo online!

Formato di output:

<sum> <# rolls>

Per le somme con zero rotoli, la colonna dei rotoli è vuota.

PHP, 65 byte

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

stampa un inizio 0_e quindi le occorrenze da 2 a 12, seguite da una sottolineatura ciascuna.
Corri con -nro provalo online .

K (oK) , 24 22 byte

Soluzione:

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

Provalo online!

Spiegazione:

k"porta" della mia qsoluzione. La valutazione avviene da destra a sinistra, quindi tra parentesi attorno a 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

modifiche:

• -2 byte che cambiano ciascuno a sinistra per ciascuno di entrambi, e ciascuno a sinistra + capovolgi per ciascuno di destra

Pyth, 21 byte

V100aY,O6O6)VTlfqsTNY

Emette ogni passaggio nella creazione dei rulli, quindi emette la frequenza di ogni somma 0 - 10 su una riga separata.

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 byte

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

Provalo online!

spiegazioni

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