Supposons que vous ayez deux dés à six faces. Faites rouler la paire 100 fois, en calculant la somme de chaque paire. Imprimez le nombre de fois où chaque somme s'est produite. Si une somme n'a jamais été roulée, vous devez inclure un zéro ou un moyen d'identifier que cette somme particulière n'a jamais été roulée.

Exemple de sortie: [3, 3, 9, 11, 15, 15, 11, 15, 7, 8, 3]

Le nombre de fois qu'une somme a été roulée est représenté dans l'index des sommes - 2

Dans cet exemple, une somme de deux a été roulée 3 fois ([2-2]), une somme de trois 3 fois ([3-2]), une somme de quatre 9 fois ([4-2]), etc. sur. Peu importe les jets de dés individuels pour arriver à une somme (5 et 2 seraient comptés comme la même somme que 6 et 1)

Les sorties "laides" sont très bien (charges de zéros de fin, sortie supplémentaire, façons étranges de représenter les données, etc.) tant que vous expliquez comment les données doivent être lues.

Gelée , 13 12 octets

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

Un lien niladique. Le format de sortie est une liste de listes de [value, count].

(Zéro roll signifie qu'aucune entrée de ce type n'est présente dans la sortie - par exemple, une sortie de [[6, 12], [7, 74], [8, 14]]identifierait que seules des sommes de six, sept et huit ont été roulées.)

Essayez-le en ligne!

Comment?

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

-7 octets grâce à @JonathanAllan
-1 octet grâce à @FelipeNardiBatista

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

Essayez-le en ligne!

La sortie a deux zéros non significatifs

05AB1E , 21 19 octets

-2 octets grâce à @Emigna

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

Essayez-le en ligne!

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 octets

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

Mise en œuvre simple. Si aucune somme n'est jamais atteinte, le 0est omis de la liste.

MATL , 17 octets

6H100I$Yrs!11:Q=s

La sortie est une liste de 11 nombres (certains d'entre eux éventuellement 0) séparés par des espaces, indiquant le nombre de fois pour chaque paire de 2 à 12.

Essayez-le en ligne!

A titre de comparaison, le nombre moyen théorique de fois où chaque paire apparaîtra en moyenne peut être calculé comme 6:gtY+36/100*.

Si le nombre de rouleaux augmente, les valeurs obtenues approchent des valeurs théoriques. Voir par exemple les valeurs obtenues et théoriques avec 10000 rouleaux.

CJam, 18 20 octets

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

Essayez-le en ligne!

Perl 6 , 30 octets

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

(^6).pickest un nombre aléatoire de zéro à cinq. xx 100fait une liste de cent éléments de ces nombres. xx 2produit deux de ces listes. [Z+]zippe ces deux listes avec ajout, produisant une liste de cent éléments de rouleaux de deux dés. Enfin, bagmet cette liste dans un sac, qui est une collection avec une multiplicité. Exemple de sortie REPL:

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

Cela signifie que 1, 9 et 0 se sont produits quatre fois chacun, quatre se sont produits quatorze fois, etc. Étant donné que les "dés" dans ce code produisent un nombre compris entre 0 et 5, ajoutez deux à chacun de ces nombres pour obtenir une paire de rouleaux les dés standard 1-6 produiraient.

R , 45 37 octets

-7 octets grâce à Jarko Dubbledam

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

Renvoie un objet table d'éléments et de décompte de chacun. Exclut toutes les valeurs qui ne se sont pas produites.

Essayez-le en ligne!

ancienne version:

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

sample(6,200,T)échantillonne 200 fois 1:6uniformément avec remplacement, puis il crée une matrice à 2 lignes, additionne les colonnes, puis les trie par ordre croissant et calcule les longueurs des analyses. Omet toutes les sommes de dés qui ne sont pas atteintes.

Renvoie un rleobjet, qui s'imprime par défaut au format suivant:

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

où lengthssont les comptes et les valuessommes des dés.

Lien TIO

PHP, 53 octets

imprime un tableau associatif. la clé est le résultat de deux dés et la valeur est le nombre de ces résultats

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

Essayez-le en ligne!

JavaScript (ES6), 72 octets

Étant donné que la sortie "moche" est autorisée, ce qui suit produira un tableau contenant le nombre de fois où chaque score de 2 à 12 a été obtenu, avec 89 éléments supplémentaires définis sur 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 octets

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

Essayez-le en ligne!

Lance les dés et les stocke dans les 11 premiers endroits du tas, puis itère simplement à travers le tas en imprimant chaque compteur. Il s'agit de l'une des premières utilisations enregistrées du mot-clé rand combiné avec un opérateur d'affectation.

Il convient de noter que quelques modifications peuvent être apportées pour produire un histogramme des rouleaux.

Malheureusement, il doit être exécuté à partir de l' interpréteur hors ligne .

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 octets

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

J'ai essayé quelque chose de plus difficile que Jelly.

Explication:

1. Définissez la fonction qui renvoie un nombre aléatoire compris entre 1 et 6 inclus.
2. Définissez la fonction de manière anonyme et laissez yêtre la variable avec la somme des rouleaux.
3. mettez à jour l'endroit approprié dans la liste en ajoutant 1.
4. si nous sommes à 100 rouleaux, arrêtez. Sinon, rappelez-vous en passant vous-même et la liste mise à jour.
5. retourner le tableau mis à jour.

Doit être appelé comme p.(p,[0,0,0,0,0,0,0,0,0,0,0,0,0]) . Il lèvera un avertissement, mais il renverra le tableau souhaité avec 13 éléments, les 2 premiers doivent être ignorés.

Java 8, 104 octets

Un lambda renvoyant une int[]des fréquences. Attribuer à Supplier<int[]>.

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

Essayez-le en ligne

Lambda non 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 octets

Solution:

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

Exemple:

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

Explication:

Lancez un dé 100?6, lancez à nouveau un dé et ajoutez les vecteurs ensemble. Ensuite, voyez où chaque résultat correspond à la plage 0..10, puis résumez toutes les vérités dans chaque liste:

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

Remarques:

«Golf» consiste principalement à échanger des qmots clés pour les kéquivalents, à savoir eachet til.

QBIC , 45 octets

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

Explication:

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

,∘≢⌸+/?100 2⍴6

Présente les données sous forme de tableau avec la colonne de gauche représentant la somme et la droite représentant le nombre d'occurrences.

Expliqué

        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

Post précédent:

APL, 36 31 octets

5 octets enregistrés grâce à @ Adám

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

Explication

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

Comment ça 11⍴⍉⌽fmarche?

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

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

Essayez-le en ligne ou regardez-le au terrain de pêche !

Le format de sortie laid est une séquence de nombres séparés par des sauts de ligne, où le n ième nombre dit combien de fois la somme était n - c'est moche parce qu'il imprime toujours, pour tous les entiers positifs n , bien que la plupart des lignes sera 0. ( La liaison TIO est modifiée pour s'arrêter après n = 12, au prix de 5 octets.)

Le terrain de jeu de poissons est assez lent - il faut environ trois minutes et demie pour imprimer jusqu'à n = 12 à vitesse maximale - vous pouvez donc le modifier pour lancer 10 paires de dés au lieu de 100 en changeant aa*la 5e ligne en a  (c'est-à-dire asuivi de deux espaces).

Les jets de dés aléatoires sont effectués par ce bit:

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

Les xs changent la direction du poisson au hasard. En supposant que cela soit implémenté avec des probabilités égales, il est clair que le résultat du jet de dé est une distribution uniforme par symétrie.

Une fois que le poisson a lancé 100 paires de dés, il compte combien de fois la somme était n avec ce bit (déballé pour plus de clarté et commençant en haut à gauche):

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

Nous gardons n à l'avant de la pile et utilisons le registre pour compter le nombre de fois où n apparaît.

Javascript 85 75 caractères

Merci Shaggy!

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

Histoire

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 octets

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

Essayez-le en ligne!

Format de sortie:

<sum> <# rolls>

Pour les sommes avec zéro rouleau, la colonne des rouleaux est vide.

PHP, 65 octets

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

imprime un interligne 0_, puis les occurrences de 2 à 12, suivies d'un trait de soulignement chacune.
Courez avec -nrou essayez-le en ligne .

K (oK) , 24 22 octets

Solution:

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

Essayez-le en ligne!

Explication:

k«port» de ma qsolution. L'évaluation se produit de droite à gauche, d'où des crochets autour du 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

Modifications:

• -2 octets commutant chacun à gauche pour chacun à la fois, et chaque gauche + flip pour chacun à droite

Pyth, 21 octets

V100aY,O6O6)VTlfqsTNY

Sort chaque étape de la création des rouleaux, puis sort la fréquence de chaque somme 0 - 10 sur une ligne distincte.

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 octets

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

Essayez-le en ligne!

Explications

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