Суммы 100 рулонов двух шестигранных кубиков

14

Предположим, у вас есть две шестигранные кости. Бросьте пару 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).

«Уродливые» выходные данные хороши (множество конечных нулей, дополнительный вывод, странные способы представления данных и т. Д.), Пока вы объясняете, как данные должны читаться.

MuffinDevil
источник
2
Вы имеете в виду «распечатать количество раз, которое произошла каждая пара» или «распечатать количество раз, когда каждая сумма произошла»?
Esolanging Fruit
1
Если конкретная сумма не появляется, нужно ли указывать ее 0в списке или ее можно опустить?
Грег Мартин
1
Должны ли различные значения быть последовательно идентифицируемыми или достаточно только одного подсчета?
Джонатан Аллан
1
Если на выходе получается только количество раз, когда встречается каждая комбинация пар, зачем нам нужно суммировать значение каждого броска? Что мы должны делать с этим итогом? Что вы имеете в виду под "некрасивым"?
Лохматый
1
extra outputно мы все еще не можем вывести бесконечный список случайных чисел и сказать, что он случайно появляется где-то там, верно? Это стандартная лазейка.
Стивен

Ответы:

5

Желе , 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)
Джонатан Аллан
источник
4

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

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

Выход имеет два ведущих нуля

овс
источник
гольф до 76 байт TIO
Фелипе Нарди Батиста
3

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
kalsowerus
источник
TÝÌтF6Lã.RO¸ì}{γ€g<экономит 2 байта.
Эминья,
@ Emigna, не ожидал, что цикл будет короче, спасибо!
kalsowerus
2

Mathematica, 50 байтов

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

Простая реализация. Если какая-либо сумма никогда не будет достигнута, то 0она исключается из списка.

Грег Мартин
источник
2

MATL , 17 байт

6H100I$Yrs!11:Q=s

Выходные данные представляют собой список из 11 чисел (некоторые из них, возможно, 0), разделенных пробелами, указывающих количество раз для каждой пары от 2 до 12.

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

Для сравнения, теоретическое среднее число раз, которое каждая пара появится в среднем, может быть вычислено как 6:gtY+36/100* .

При увеличении количества валков полученные значения приближаются к теоретическим. См. Например, полученные и теоретические значения с 10000 рулонов.

Луис Мендо
источник
2

CJam, 18 20 байтов

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

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

Esolanging Fruit
источник
Это выводит в уродливом формате - число раз, когда каждый бросок произошел, представлено как длина непрерывных сегментов.
Esolanging Fruit
@JonathanAllan Хорошо, тогда хорошо. e` занимает всего два байта.
Esolanging Fruit
2

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 игральных костей произведет.

Шон
источник
Вау. Perl 6 - сила, с которой нужно считаться.
Якоб
Тем не менее, «если сумма никогда не была выброшена, вы должны указать ноль или какой-либо способ определить, что эта конкретная сумма никогда не была выброшена». Не похоже, что пакетное решение удовлетворяет это.
Якоб
Если конкретный номер не был свернут, эту ситуацию можно определить по отсутствию номера в сумке.
Шон
2

Р , 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

Giuseppe
источник
1

PHP, 53 байта

печатает ассоциативный массив. ключ - результат двух кубиков, а значение - количество этих результатов.

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

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

Йорг Хюльсерманн
источник
If a sum was never rolled, you must include a zero or some way to identify that that particular sum was never rolled.
Тит
1

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>

мохнатый
источник
Вы не тратите впустую байт, чтобы сделать это 100 элементов вместо 99 или 20 или просто даже 12?
Рохан
@RohanJhunjhunwala, вызов требует 100 бросков двух кубиков.
Лохматый
О, я думал, что просто инициализирую массив из 100 элементов для хранения рулонов.
Рохан
1

СИЛОС , 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
Рохан Джунджхунвала
источник
1

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

SalmonKiller
источник
1

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;
}
Jakob
источник
1

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.

streetster
источник
0

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
steenbergh
источник
0

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
Уриэль
источник
Сохраните несколько байтов, объединив операторы и сделав операнд молчаливым:(11⍴⍉⌽f)[⍋11⍴⍉f←,∘⍴⌸+/?100 2⍴6]
Адам
Извините, я отредактировал свое предложение, пока вы его включили. Обратите внимание на молчаливый операнд.
Адам
Тем не менее, OP допускает любой однозначный выходной формат, поэтому этого ,∘⍴⌸+/?100 2⍴6должно быть достаточно, поскольку он перечисляет встречающиеся суммы (таким образом, указывая, какие из них отсутствуют) и их частоты (поэтому сортировка не требуется).
Адам
0

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

Не дерево
источник
0

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)
Стив Беннетт
источник
Имеет смысл дать вам несколько сбережений для этого; здесь очень быстро golfed 75 байт версии вашего решения: a=[];for(i=100;i--;)a[o=(f=_=>Math.random()*6|0)()+f()]=(a[o]|0)+1;alert(a). (Примечание: в этом случае IIFE не сохраняет и не стоит ни одного байта, но бывают случаи, когда он может сэкономить вам байт или 2, поэтому удобно иметь его в своей «сумке для гольфа».)
Shaggy
О, классно, спасибо. Полезных трюков нет! Так интересно, что |0это решение для игры в гольф для "Math.floor ()", а также для "преобразования неопределенного в 0".
Стив Беннетт
0

Perl 5 , 64 байта

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

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

Выходной формат:

<sum> <# rolls>

Для сумм с нулевыми бросками столбец списков пуст.

Xcali
источник
0

PHP, 65 байт

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

печатает ведущий 0_ а затем вхождения от 2 до 12 с последующим подчеркиванием каждый.
Запустите -nrили попробуйте онлайн .

Titus
источник
0

К (ок) , 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 байта, переключающие каждый левый для каждого-обоих, и каждый левый + флип для каждого правого
streetster
источник
0

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
Дейв
источник
0

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;
}
Оливье Грегуар
источник