Припустимо, у вас є два шестигранні кубики. Згорніть пару 100 разів, обчисливши суму кожної пари. Роздрукуйте кількість разів, коли відбулася кожна сума. Якщо сума ніколи не була згорнута, ви повинні включити нуль або якийсь спосіб визначити, що ця конкретна сума ніколи не була прокату.

Приклад Вихід: [3, 3, 9, 11, 15, 15, 11, 15, 7, 8, 3]

Кількість обчислень суми представлена ​​в індексі сум - 2

У цьому прикладі двічі прокручували 3 рази ([2-2]), тричі тричі ([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

Математика, 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 байт завдяки Ярко Дабблдаму

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 Посилання

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

Еліксир, 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

The 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або спробуйте в Інтернеті .

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