假设您有两个六面骰子。将线对滚动100次，计算每对的总和。打印出每个总和发生的次数。如果从未汇总过一笔总和，则必须包括零或某种方式以标识该特定笔从未从未汇总过。

示例输出：[3、3、9、11、15、15、11、15、7、8、3]

总和索引中表示了总和的滚动次数-2

在此示例中，两个总和被滚动3次（[2-2]），三个总和被滚动3次[[3-2]），四个总和被滚动9次（[4-2]），依此类推上。掷骰子总和并不重要（5和2与6和1相同）

只要您解释应该如何读取数据，“丑陋”的输出就可以了（尾随零，大量额外输出，奇怪的数据表示方式等）。

果冻，13 12 字节

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

尼拉迪亚链接。输出格式是的列表[value, count]。

（零滚动表示输出中不存在此类条目-例如，的输出[[6, 12], [7, 74], [8, 14]]将标识仅对六，七和八的总和进行了滚动。）

在线尝试！

怎么样？

³Ḥ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字节

-7个字节感谢@JonathanAllan
-1个字节感谢@FelipeNardiBatista

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

在线尝试！

输出具有两个前导零

05AB1E，21 19字节

-2个字节，感谢@Emigna

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

在线尝试！

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个字节

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

简单实施。如果从未达到任何总和，则将0其从列表中省略。

MATL，17个字节

6H100I$Yrs!11:Q=s

输出是一个由11个数字组成的列表（其中一些可能为0），中间用空格隔开，表示每对从2到12的次数。

在线尝试！

为了进行比较，可以将每对平均出现的理论平均次数计算为6:gtY+36/100*。

如果增加辊数，则获得的值接近理论值。例如，参见10000卷获得的和理论值。

CJam，18个 20字节

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

在线尝试！

Perl 6，30个字节

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

(^6).pick是从零到五的随机数。 xx 100列出这些数字的一百个元素。 xx 2产生两个这样的列表。 [Z+]压缩这两个列表，并生成两个骰子卷的一百个元素列表。最后，bag将该列表放入袋子中，这是一个具有多重性的集合。REPL输出示例：

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

这意味着1、9和0分别出现四次，四次发生十四次，依此类推。由于此代码中的“骰子”产生的数字为0-5，因此请在这些数字中分别加上两个，以得到掷骰子对将产生标准1-6个骰子。

R，45 37字节

-7个字节，感谢Jarko Dubbledam

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

返回一个表对象，该对象包含元素和每个元素的计数。排除未发生的任何值。

在线尝试！

旧版本：

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

sample(6,200,T)从1:6替换均匀地采样200次，然后制作一个包含2行的矩阵，对各列求和，然后将它们按升序排序并计算游程的长度。忽略所有未达到的骰子总和。

返回一个rle对象，默认情况下以以下格式打印：

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

lengths计数在哪里values，骰子和是。

TIO链接

PHP，53字节

打印一个关联数组。关键是两个骰子的结果，值是这些结果的计数

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

在线尝试！

JavaScript（ES6），72个字节

看到“丑陋”的输出是允许的，下面的代码将输出一个数组，该数组包含2-12之间的每个乐谱滚动的次数，另外89个元素设置为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个字节

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

在线尝试！

掷骰子，并将它们存储在堆的前11个位置，然后遍历堆并打印每个计数器。这是rand关键字与赋值运算符结合使用的最早记录的用途之一。

值得注意的是，可以对输出的直方图进行一些修改。

不幸的是，它必须从脱机解释器运行。

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字节

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

尝试了比果冻更难的东西。

说明：

1. 定义函数，该函数返回1到6之间的一个随机数。
2. 匿名定义函数，并将y其作为总和的变量。
3. 通过添加1更新列表中的适当位置。
4. 如果我们有100卷，请退出。否则，再次打电话给自己，并传递自己和更新的列表。
5. 返回更新后的数组。

应该叫p.(p,[0,0,0,0,0,0,0,0,0,0,0,0,0])。它将发出警告，但是它将返回包含13个元素的所需数组，前两个应忽略。

Java 8，104字节

返回int[]频率的Lambda 。分配给Supplier<int[]>。

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

在线试用

非高尔夫λ

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

解：

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

例：

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

说明：

掷骰子100?6，再掷骰子，然后将向量相加。然后查看每个结果与0..10范围匹配的位置，然后总结每个列表中的所有true：

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

笔记：

“高尔夫”大多是换出q关键字的k等价物，即each和til。

QBIC，45字节

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

说明：

[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个字节

,∘≢⌸+/?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

上一篇：

APL，36 31字节

@Adám节省了5个字节

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

说明

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

如何 11⍴⍉⌽f运作？

⍝ ⌽ - 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字节

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

在线尝试，或在鱼游乐场观看！

丑陋的输出格式是由换行符分隔的数字序列，其中第n个数字表示总和是n的多少倍，这是丑陋的，因为它将永远打印所有正整数n，尽管大多数行将为0。（将TIO链接修改为在n之后停止 = 12，以5个字节为代价。）

鱼场相当慢- 以最快的速度打印n = 12 大约需要三分半钟-因此，您可能需要修改它以将10对骰子代替100对骰子，方法aa*是将第5行的a  （那是，a后跟两个空格）。

随机掷骰子通过以下方式完成：

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

的 x小号随意改变鱼的方向。假设以相等的概率实现，显然模辊结果是对称分布的均匀分布。

一旦鱼掷出100对骰子，就用这个位来计算总和为n的次数（为了清楚起见，将其展开，并从左上方开始）：

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

我们将n放在堆栈的最前面，并使用寄存器计算n出现的次数。

Java脚本 85 75个字符

谢谢毛茸茸的！

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

历史

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个字节

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

在线尝试！

输出格式：

<sum> <# rolls>

对于零卷总和，“卷数”列为空白。

PHP，65字节

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

先打印前导0_，然后出现2​​到12，然后再下划线。
运行-nr或在线尝试。

K（oK），24 22字节

解：

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

在线尝试！

说明：

k我的q解决方案的“端口” 。评估是从右到左进行的，因此，在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

编辑：

• -2个字节将每个左键切换为两个键，将每个左键+翻转切换为每个右键

Pyth，21个字节

V100aY,O6O6)VTlfqsTNY

输出创建卷的每个步骤，然后在单独的行上输出每个总和0-10的频率。

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字节

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

在线尝试！

说明

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