^{Theo dõi thử thách này}

Cho một bộ xúc xắc hỗn hợp, xuất ra phân phối tần số của việc lăn tất cả chúng và tổng các số cán trên mỗi khuôn.

Ví dụ, hãy xem xét 1d12 + 1d8(cán 1 khuôn 12 mặt và 1 khuôn 8 mặt). Tối đa và tối thiểu cuộn là 20và 2, tương ứng, tương tự như cán 2d10(xúc xắc 2 10 mặt). Tuy nhiên, 1d12 + 1d8kết quả trong một phân phối phẳng hơn 2d10: [1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 8, 8, 7, 6, 5, 4, 3, 2, 1]so với [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1].

Quy tắc

• Các tần số phải được liệt kê theo thứ tự tăng dần của tổng mà tần số tương ứng.
• Ghi nhãn tần số với các khoản tiền tương ứng được cho phép, nhưng không bắt buộc (vì các khoản tiền có thể được suy ra từ thứ tự yêu cầu).
• Bạn không phải xử lý các đầu vào trong đó đầu ra vượt quá phạm vi số nguyên có thể biểu thị cho ngôn ngữ của bạn.
• Các số 0 đứng đầu hoặc dấu không được phép. Chỉ có tần số dương sẽ xuất hiện ở đầu ra.
• Bạn có thể lấy đầu vào ở bất kỳ định dạng hợp lý nào (danh sách xúc xắc ( [6, 8, 8]), danh sách các cặp súc sắc ( [[1, 6], [2, 8]]), v.v.).
• Các tần số phải được chuẩn hóa để GCD của các tần số là 1 (ví dụ [1, 2, 3, 2, 1]thay vì [2, 4, 6, 4, 2]).
• Tất cả súc sắc sẽ có ít nhất một mặt (vì vậy a d1là tối thiểu).
• Đây là mã golf , vì vậy mã ngắn nhất (tính bằng byte) sẽ thắng. Lỗ hổng tiêu chuẩn bị cấm, như thường lệ.

Các trường hợp thử nghiệm

Các trường hợp thử nghiệm này được đưa ra dưới dạng input: output, trong đó đầu vào được đưa ra dưới dạng danh sách các cặp [a, b]đại diện cho a bxúc xắc có mặt (vì vậy [3, 8]tham chiếu 3d8và [[1, 12], [1, 8]]đề cập đến 1d12 + 1d8).

[[2, 10]]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
[[1, 1], [1, 9]]: [1, 1, 1, 1, 1, 1, 1, 1, 1]
[[1, 12], [1, 8]]: [1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 8, 8, 7, 6, 5, 4, 3, 2, 1]
[[2, 4], [3, 6]]: [1, 5, 15, 35, 68, 116, 177, 245, 311, 363, 392, 392, 363, 311, 245, 177, 116, 68, 35, 15, 5, 1]
[[1, 3], [2, 13]]: [1, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 37, 36, 33, 30, 27, 24, 21, 18, 15, 12, 9, 6, 3, 1]
[[1, 4], [2, 8], [2, 20]]: [1, 5, 15, 35, 69, 121, 195, 295, 423, 579, 761, 965, 1187, 1423, 1669, 1921, 2176, 2432, 2688, 2944, 3198, 3446, 3682, 3898, 4086, 4238, 4346, 4402, 4402, 4346, 4238, 4086, 3898, 3682, 3446, 3198, 2944, 2688, 2432, 2176, 1921, 1669, 1423, 1187, 965, 761, 579, 423, 295, 195, 121, 69, 35, 15, 5, 1]
[[1, 10], [1, 12], [1, 20], [1, 50]]: [1, 4, 10, 20, 35, 56, 84, 120, 165, 220, 285, 360, 444, 536, 635, 740, 850, 964, 1081, 1200, 1319, 1436, 1550, 1660, 1765, 1864, 1956, 2040, 2115, 2180, 2235, 2280, 2316, 2344, 2365, 2380, 2390, 2396, 2399, 2400, 2400, 2400, 2400, 2400, 2400, 2400, 2400, 2400, 2400, 2400, 2399, 2396, 2390, 2380, 2365, 2344, 2316, 2280, 2235, 2180, 2115, 2040, 1956, 1864, 1765, 1660, 1550, 1436, 1319, 1200, 1081, 964, 850, 740, 635, 536, 444, 360, 285, 220, 165, 120, 84, 56, 35, 20, 10, 4, 1]

Thạch ,  14  7 byte

-3 byte nhờ vào ông Xcoder (sử dụng một phạm vi ngầm để tránh dẫn đầu R; thay thế giảm bằng sản phẩm Cartesian dyadian và làm phẳng p/F€, với sản phẩm Cartesian tích hợp cho mục đích đó, Œp).

ŒpS€ĠL€

Một liên kết đơn âm lấy một danh sách các mặt xúc xắc và trả về phân phối chuẩn hóa của các khoản tiền tăng dần.

Hãy thử trực tuyến!

Làm sao?

Đi qua danh sách "kích cỡ" xúc xắc (ngầm) làm cho chúng vào danh sách các khuôn mặt của chúng, sau đó lấy sản phẩm của Cartesian trong các danh sách đó (tất cả các cuộn có thể của bộ xúc xắc), sau đó tổng hợp các cuộn đó, lấy các nhóm bằng nhau các chỉ số (theo giá trị tăng dần) và lấy độ dài của mỗi nhóm.

ŒpS€ĠL€ - Link: list of numbers, dice  e.g. [2,5,1,2]
Œp      - Cartisian product (implicit range-ification -> [[1,2],[1,2,3,4,5],[1],[1,2]])
        -                   -> [[1,1,1,1],[1,1,1,2],[1,2,1,1],[1,2,1,2],[1,3,1,1],[1,3,1,2],[1,4,1,1],[1,4,1,2],[1,5,1,1],[1,5,1,2],[2,1,1,1],[2,1,1,2],[2,2,1,1],[2,2,1,2],[2,3,1,1],[2,3,1,2],[2,4,1,1],[2,4,1,2],[2,5,1,1],[2,5,1,2]]
  S€    - sum €ach          -> [4,5,5,6,6,7,7,8,8,9,5,6,6,7,7,8,8,9,9,10]
    Ġ   - group indices     -> [[1],[2,3,11],[4,5,12,13],[6,7,14,15],[8,9,16,17],[10,18,19],[20]]
     L€ - length of €ach    -> [1,3,4,4,4,3,1]

Lưu ý: chỉ có một cách để cuộn tối thiểu (bằng cách lăn một con trên mỗi con xúc xắc) và chúng tôi không tính hai lần bất kỳ cuộn nào, do đó không cần phải thực hiện chuẩn hóa GCD.

MATL , 8 byte

1i"@:gY+

Đầu vào là một mảng các kích cỡ khuôn (có thể lặp lại).

Hãy thử trực tuyến! Hoặc là xác minh tất cả các trường hợp thử nghiệm .

Giải trình

1      % Push 1
i      % Input: numeric array
"      % For each k in that array
  @    %   Push k
  :    %   Range: gives [1 2 ... k]
  g    %   Convert to logical: gives [1 1 ... 1]
  Y+   %   Convolution, with full size
       % End (implicit). Display (implicit)

Husk , 7 byte

mLkΣΠmḣ

Đầu vào là một danh sách súc sắc. Hãy thử trực tuyến!

Giải trình

mLkΣΠmḣ  Implicit input, say x=[3,3,6].
     mḣ  Map range: [[1,2,3],[1,2,3],[1,2,3,4,5,6]]
    Π    Cartesian product: [[1,1,1],[1,1,2],..,[3,3,6]]
  kΣ     Classify by sum: [[[1,1,1]],[[1,1,2],[1,2,1],[2,1,1]],..,[[3,3,6]]]
mL       Map length: [1,3,6,8,9,9,8,6,3,1]

Haskell , 54 byte

1%r=r
n%r=zipWith(+)(r++[0,0..])$0:(n-1)%r
foldr(%)[1]

Hãy thử trực tuyến!

Haskell , 63 byte

f l=[sum[1|t<-mapM(\x->[1..x])l,sum t==k]|k<-[length l..sum l]]

Hãy thử trực tuyến!

Haskell , 68 byte

k%(h:t)=sum$map(%t)[k-h..k-1]
k%_=0^k^2
f l=map(%l)[length l..sum l]

Hãy thử trực tuyến!

Octave , 88 69 58 56 byte

Như đã đề cập trong câu trả lời của Haskell, điều này sử dụng thực tế là sự phân bố của một con xúc xắc 3 mặt và 5 mặt là sự kết hợp rời rạc của hai vectơ [1,1,1]và [1,1,1,1,1]. Cảm ơn @LuisMendo vì đã chơi golf thông minh -11 byte!

function y=f(c);y=1:c;if d=c(2:end);y=conv(~~y,f(d));end

Hãy thử trực tuyến!

Trình này được sử dụng một cách tiếp cận đệ quy. Nhưng nếu bạn sử dụng một vòng lặp thì nó sẽ dài hơn một chút:

function y=f(c);y=1;for k=cellfun(@(x)ones(1,x),c,'Un',0);y=conv(y,k{1});end

Haskell , 80 78 64 byte

Giải pháp này đã kết thúc gần giống như một trong những @ Sherlock9 trong thử thách trước đó với cách tiếp cận có thể tự nhiên hơn. @xnor có một giải pháp Haskell thậm chí còn ngắn hơn !

import Data.List
g x=[1..x]
map length.group.sort.map sum.mapM g

Giải trình:

                              mapM g -- all possible outcomes
                      map sum        -- the sums of all possible outcomes
map length.group.sort                -- count the frequency of each sum

Hãy thử trực tuyến!

Giải pháp trước đây:

Đây là sử dụng hàm chập rời rạc @AndersKaseorg . Quan sát ở đây là sự phân bố của một con xúc xắc 3 mặt và 5 mặt là sự kết hợp rời rạc của hai vectơ [1,1,1]và [1,1,1,1,1].

foldl1(#).map(`take`l)
(a:b)#c=zipWith(+)(0:b#c)$map(a*)c++[]#b
_#c=0<$c
l=1:l

Hãy thử trực tuyến!

Ngôn ngữ Wolfram (Mathicala) , 26 byte

Tally[Tr/@Tuples@Range@#]&

Hãy thử trực tuyến!

Một sửa đổi của câu trả lời của tôi cho thách thức trước đó . Điều này chỉ tạo ra tất cả các kết quả có thể, thêm chúng và kiểm tra kết quả.

Để giải trí, chúng tôi có thể viết nó thành Tally@*Total@*Thread@*Tuples@*Range , nhưng lâu hơn.

Ngôn ngữ Wolfram (Mathicala) , 41 byte

CoefficientList[1##&@@((x^#-1)/(x-1)),x]&

Hãy thử trực tuyến!

Đây là cách tiếp cận dựa trên tích chập (ở đây, chúng tôi thực hiện các kết quả thông qua sản phẩm của các hàm tạo - 1+x+x^2+...+x^(N-1)là hàm tạo để cuộn một dN - và sau đó lấy danh sách các hệ số). Tôi bao gồm nó bởi vì giải pháp đầu tiên không thực tế cho đầu vào lớn.

Toán học, 44 byte

Xuất ra các tần số được dán nhãn với tổng tương ứng

Tally@*Fold[Join@@Table[#+i,{i,#2}]&]@*Range

Hãy thử trực tuyến!

-5 byte từ Martin Ender

cảm ơn Misha Lavrov vì đã cho tôi biết rằng "được dán nhãn" là hợp lệ

Bình thường , 12 byte

lM.gs.nk*FSM

Hãy thử nó ở đây!

Làm sao?

lM.gs.nk * FSM ~ Chương trình đầy đủ.

          SM ~ Bản đồ với phạm vi số nguyên đơn nguyên bao gồm [1, N].
        * F ~ Fold (Giảm theo) sản phẩm của Cartesian.
  .g ~ Nhóm theo kết quả chức năng.
    sn ~ Tổng của danh sách khi làm phẳng.
lM ~ Chiều dài của mỗi nhóm.

Thạch , 14 byte

R+Ѐ/FċЀSR$ḟ0

Hãy thử trực tuyến!

Đầu vào là một danh sách các giá trị chết. Tôi có thể đánh golf xuống bằng cách đánh cắp ĠL€câu trả lời khác của Jelly nhưng sau đó tôi cũng có thể đánh golf xuống nửa đầu và kết thúc với điều tương tự vì vậy tôi sẽ để nó như thế nào

Python 2 , 120 119 byte

lambda v:[reduce(lambda a,c:sum([[b+y for b in a]for y in range(c)],[]),v,[0]).count(d)for d in range(sum(v)-len(v)+1)]

Hãy thử trực tuyến!

Thks cho Mego / Jonathon Allan cho 1 byte.

05AB1E , 11 byte

€L.«âOO{γ€g

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

€ L. «âOO {€ g - Chương trình đầy đủ.

€ L - Với mỗi N trong danh sách, hãy lấy [1 .. N].
  . «- Gấp một hàm dyadic giữa mỗi phần tử trong danh sách từ phải sang trái.
    â - Và chọn sản phẩm cartesian là chức năng đó.
     O - Làm phẳng mỗi.
      O - Tổng mỗi.
       {γ - Sắp xếp và nhóm thành các giá trị liền kề bằng nhau.
         € g - Lấy độ dài của mỗi.

Đã lưu 1 byte nhờ Emigna !

R , 51 byte

function(D){for(x in D)F=outer(F,1:x,"+")
table(F)}

Hãy thử trực tuyến!

Đưa ra một danh sách súc sắc và trả về một vectơ tần số được đặt tên; tên (giá trị của tổng xúc xắc) được in phía trên tần số.

R , 59 byte

function(D)table(Reduce(function(x,y)outer(x,1:y,"+"),D,0))

Hãy thử trực tuyến!

Một Reducecách tiếp cận chứ không phải là cách lặp ở trên.

R , 62 byte

function(D)Re(convolve(!!1:D,"if"(sum(x<-D[-1]),f(x),1),,"o"))

Hãy thử trực tuyến!

Một cách tiếp cận tích chập. Nó sẽ đưa ra một vài cảnh báo rằng nó chỉ sử dụng phần tử đầu tiên Dcho biểu thức 1:Dnhưng nó không ảnh hưởng đến đầu ra. Nếu chúng ta không phải lấy Rephần của giải pháp, nó sẽ là 58 byte.

APL (Dyalog Classic) , 12 10 byte

-2 cảm ơn @ Adám

⊢∘≢⌸+/↑,⍳⎕

Hãy thử trực tuyến!

đầu vào ⎕là một danh sách của xúc xắc N

⍳⍵ là một mảng N chiều của các vectơ lồng nhau - tất cả các cú ném chết có thể

+/↑, làm phẳng các mảng và tổng hợp các cú ném

⊢∘≢⌸ đếm có bao nhiêu của mỗi số tiền duy nhất, được liệt kê theo thứ tự xuất hiện đầu tiên của chúng, may mắn thay, trùng với thứ tự tăng dần của chúng

Ruby , 72 byte

->d{r=[0]*d.sum
[0].product(*d.map{|e|[*1..e]}){|e|r[e.sum-1]+=1}
r-[0]}

Hãy thử trực tuyến!

Đưa ra một danh sách súc sắc làm đầu vào. Không nghi ngờ gì nó có thể được đánh xuống, nhưng không quá tệ.

Pari / GP , 37 byte

v->Vec(prod(i=1,#v,(x^v[i]-1)/(x-1)))

Hãy thử trực tuyến!

Sạch sẽ , 154 142 136 107 100 85 + 13 = 98 byte

Đầu vào là một danh sách súc sắc.

\l#t=foldr(\a-> \b=[x+y\\x<-[1..a],y<-b])[0]l
=[length[v\\v<-t|u==v]\\u<-removeDup t]

Câu trả lời ở dạng lambda.

+13 byte từimport StdEnv , nhập khẩu mô-đun cần thiết để làm việc này.

Hãy thử trực tuyến!

JavaScript (ES6), 83 byte

f=(n,...a)=>n?f(...a).map((e,i)=>[...Array(n)].map(_=>r[i]=~~r[i++]+e),r=[])&&r:[1]
g=s=>o.textContent=f(...(s.match(/\d+/g)||[]).map(n=>+n)).join`, `

<input oninput=g(this.value)><p id=o>1

Lấy đầu vào của mỗi khuôn như một tham số riêng.

JavaScript (ES6), 76 74 byte

Đưa đầu vào như một danh sách súc sắc.

a=>(g=k=>a.map(d=>(s+=n%d|0,n/=d),s=0,n=k)|n?x:g(k+1,x[s]=-~x[s]))(0,x=[])

Các trường hợp thử nghiệm

Việc xử lý hai trường hợp thử nghiệm cuối cùng sẽ yêu cầu kích hoạt TCO hoặc tăng giới hạn kích thước ngăn xếp mặc định của công cụ JS.

let f =

a=>(g=k=>a.map(d=>(s+=n%d|0,n/=d),s=0,n=k)|n?x:g(k+1,x[s]=-~x[s]))(0,x=[])

console.log(f([10,10]).join(', '))
console.log(f([1,9]).join(', '))
console.log(f([12,8]).join(', '))
console.log(f([4,4,6,6,6]).join(', '))
console.log(f([3,13,13]).join(', '))

Định dạng và nhận xét

NB: Đây là phiên bản nhận xét của lần gửi đầu tiên của tôi đang sử dụng less (). Nó dài hơn 2 byte nhưng dễ đọc hơn.

a =>                    // given the list of dice a
  (g = k =>             // g = recursive function taking k = counter
    a.reduce((k, d) =>  //   for each die d in a:
      (                 //     k % d represents the current face of d
        s += k % d,     //     we add it to the total s
        k / d | 0       //     and we update k to pick the face of the next die
      ),                //     initialization:
      k,                //     start with the current value of k
      s = 0             //     total = 0
    ) ?                 //   reduce() returns 1 as soon as k = product of all dice
      x                 //     in which case we're done: stop recursion and return x
    :                   //   else:
      g(                //     do a recursive call to g() with:
        k + 1,          //       k incremented
        x[s] = -~x[s]   //       x[s] incremented
      )                 //     end of recursive call
  )(0, x = [])          // initial call to g() with k = 0 and x = empty array

Clojure, 96 byte

#(sort-by key(frequencies(reduce(fn[R D](for[d(range D)r R](+ r d 1)))[0](mapcat repeat % %2))))

Đầu vào đầu tiên là danh sách số xúc xắc và đầu vào thứ hai là danh sách số cạnh trên mỗi con xúc xắc.

Perl 5 , 94 byte

map$k{$_}++,map eval,glob join'+',map'{'.(join',',1..$_).'}',<>;say$k{$_}for sort{$a-$b}keys%k

Hãy thử trực tuyến!

Định dạng đầu vào là một danh sách các súc sắc được phân tách bằng các dòng mới. Do đó, 1d10 + 2d8 sẽ nhập dưới dạng:

10
8
8

SageMath, 46 byte

lambda*a:reduce(convolution,[x*[1]for x in a])

Dùng thử trực tuyến

Đây là một sự thích ứng của giải pháp của tôi với thách thức khác . Phải mất trong bất kỳ số lượng xúc xắc như các thông số (ví dụ như f(4,4,6,6,6)cho 2d4+3d6), và trả về một danh sách.

Python 2 + NumPy , 62 byte

lambda*a:reduce(numpy.convolve,[x*[1]for x in a])
import numpy

Hãy thử trực tuyến!

Như trước đây, tôi đã bao gồm giải pháp này với giải pháp trên, vì về cơ bản chúng tương đương nhau. Lưu ý rằng hàm này trả về một mảng NumPy chứ không phải danh sách Python, vì vậy đầu ra trông hơi khác nếu bạn làm printnhư vậy.

numpy.ones(x)là cách "chính xác" để tạo một mảng để sử dụng với NumPy, và do đó nó có thể được sử dụng thay thế [x*[1]], nhưng thật không may là lâu hơn nhiều.