Предположим, у вас есть две шестигранные кости. Бросьте пару 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+]сжимает эти два списка с добавлением, создавая список из 100 элементов с двумя кубиками. Наконец, 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 игральных костей произведет.

Р , 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) образцы 200 раз от 1:6 с заменой, затем создает матрицу из 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 Link

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>

СИЛОС , 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

Эликсир, 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 элементами, первые 2 следует игнорировать.

Java 8, 104 байта

Лямбда, возвращающая int[]частоты. Присвоить 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, затем суммируйте все истины в каждом списке:

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 байт

5 байтов сохранено благодаря @ Adám

(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 s изменить направление рыбы в случайном порядке. Предполагая, что это реализовано с равными вероятностями, ясно, что результат броска матрицы является равномерным распределением по симметрии.

После того, как рыба бросила 100 пар костей, она подсчитывает, сколько раз сумма была n с этим битом (для ясности развернута и начинается в верхнем левом углу):

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

Мы держим n в начале стека и используем регистр для подсчета количества раз, когда появляется n .

Javascript 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или попробуйте онлайн .

К (ок) , 24 22 байта

Решение:

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

Попробуйте онлайн!

Объяснение:

k«порт» моего qрешения. Оценка происходит справа налево, отсюда и квадратные скобки ( !)

+/(!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;
}