^{이 도전에 대한 후속 조치}

혼합 주사위 세트가 주어지면 모든 롤링의 주파수 분포를 출력하고 각 다이에서 롤 수를 합산합니다.

예를 들어 1d12 + 1d8(롤링 1 12면 다이 및 1 8면 다이)을 고려하십시오. 최대 및 최소 롤은 각각 20및 2롤링과 비슷합니다 2d10(2 10면 주사위). 그러나, 1d12 + 1d8보다 평평 분포 결과 2d10: [1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 8, 8, 7, 6, 5, 4, 3, 2, 1]대 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1].

규칙

• 주파수는 주파수에 해당하는 합계의 순서대로 나열되어야합니다.
• 주파수를 해당 합계로 레이블링하는 것은 허용되지만 필수는 아닙니다 (요청은 필요한 순서에서 추론 될 수 있으므로).
• 출력이 언어의 표현 가능한 정수 범위를 초과하는 입력을 처리 할 필요가 없습니다.
• 선행 또는 후행 0은 허용되지 않습니다. 출력에는 양의 주파수 만 나타나야합니다.
• 합리적인 형식 (다이스 목록 ( [6, 8, 8]), 주사위 쌍 목록 ( [[1, 6], [2, 8]]) 등) 으로 입력 할 수 있습니다 .
• 주파수의 GCD가 1이되도록 주파수를 정규화해야합니다 (예 : [1, 2, 3, 2, 1]대신 [2, 4, 6, 4, 2]).
• 모든 주사위는 최소한 하나의면을 가질 것입니다 (그래서 a d1는 최소입니다).
• 이것은 code-golf 이므로 가장 짧은 코드 (바이트)가 이깁니다. 표준 허점 은 평소와 같이 금지되어 있습니다.

테스트 사례

이러한 테스트 케이스가 제공되는 input: output입력은 쌍 목록으로 제공되는 경우, [a, b]대표 a b양면 주사위 (그렇게 [3, 8]지칭 3d8하며 [[1, 12], [1, 8]]지칭 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]

젤리 ,  14  7 바이트

Xcoder 덕분에 -3 바이트 (선행을 피하기 위해 암시 적 범위 사용 R; 이차원적인 데카르트 제품으로 축소를 대체 p/F€하고 바로 그 목적으로 내장 된 데카르트 제품으로 평면화 Œp)

ŒpS€ĠL€

주사위면의 목록을 가져와 증가하는 합의 정규 분포를 반환하는 모나드 링크.

온라인으로 사용해보십시오!

방법?

주사위 "크기"(암시 적으로)의 목록을 통과하여 얼굴 목록으로 만든 다음 해당 목록의 데카르트 곱 (주사위 세트의 가능한 모든 롤)을 가져온 다음 해당 롤을 합산하고 동일한 그룹을 얻습니다. 인덱스 (오름차순) 및 각 그룹의 길이를 사용합니다.

Œ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]

참고 : 최소 주사위를 굴리는 방법은 하나 뿐이며 (각 주사위마다 하나씩 굴림) 롤을 두 번 계산하지 않으므로 GCD 정규화를 수행 할 필요가 없습니다.

MATL , 8 바이트

1i"@:gY+

입력은 (반복 될 수있는) 다이 크기의 배열입니다.

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

설명

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)

껍질 , 7 바이트

mLkΣΠmḣ

입력은 주사위 목록입니다. 온라인으로 사용해보십시오!

설명

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]

하스켈 , 54 바이트

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

온라인으로 사용해보십시오!

하스켈 , 63 바이트

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

온라인으로 사용해보십시오!

하스켈 , 68 바이트

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

온라인으로 사용해보십시오!

옥타브 , 88 69 58 56 바이트

하스켈 대답 한 바와 같이, 본 사용 예 3 양면의 분포 및 5 면체 두 벡터의 이산 콘벌 루션 사실 [1,1,1]과 [1,1,1,1,1]. 영리한 골프 -11 바이트 가치의 @LuisMendo에 감사드립니다!

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

온라인으로 사용해보십시오!

이 제출은 재귀 적 접근을 사용하고 있습니다. 그러나 루프를 사용하면 약간 길어집니다.

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

하스켈 , 80 78 64 바이트

이 솔루션은 이전의 도전 과제에서 @ Sherlock9 와 거의 동일한 방식으로 마무리되었습니다 . @xnor는 더 짧은 Haskell 솔루션을 가지고 있습니다 !

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

설명:

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

온라인으로 사용해보십시오!

이전 솔루션 :

이것은 @AndersKaseorg 이산 컨볼 루션 함수를 사용하고 있습니다. 여기서 관찰 예 3 양면의 분포 및 5 면체 두 벡터의 이산 콘벌 루션이다이다 [1,1,1]하고 [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

온라인으로 사용해보십시오!

Wolfram Language (Mathematica) , 26 바이트

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

온라인으로 사용해보십시오!

이전 도전에 대한 나의 답변 의 수정 . 이것은 가능한 모든 결과를 생성하고 합산하여 결과를 계산합니다.

재미를 위해로 쓸 수는 Tally@*Total@*Thread@*Tuples@*Range있지만 더 길다.

Wolfram Language (Mathematica) , 41 바이트

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

온라인으로 사용해보십시오!

이것은 컨볼 루션 기반 접근 방식입니다 (여기서는 함수 생성의 결과를 통해 컨볼 루션을 수행합니다 1+x+x^2+...+x^(N-1). dN을 롤링하기위한 생성 함수입니다. 그런 다음 계수 목록을 가져옵니다). 첫 번째 솔루션은 큰 입력에 실용적이지 않기 때문에 포함시킵니다.

매스 매 티카, 44 바이트

해당 합계로 레이블이 지정된 주파수를 출력합니다.

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

온라인으로 사용해보십시오!

Martin Ender에서 -5 바이트

"labeled"가 유효하다는 것을 알려 주신 Misha Lavrov에게 감사합니다

Pyth , 12 바이트

lM.gs.nk*FSM

여기 사용해보십시오!

방법?

lM.gs.nk * FSM ~ 전체 프로그램.

          SM ~ 1 진 정수 범위 [1, N]을 포함한 맵.
        * F ~ 접기 (감소) 직교 곱.
  .g ~ 기능 결과별로 그룹화합니다.
    sn ~ 전개시리스트의 합.
lM ~ 각 그룹의 길이.

젤리 , 14 바이트

R+Ѐ/FċЀSR$ḟ0

온라인으로 사용해보십시오!

입력은 금형 값의 목록입니다. 나는 ĠL€다른 젤리 답변 을 훔쳐서 골프를 칠 수 있었지만 상반기 골프를 치고 같은 것으로 끝날 수 있습니다.

파이썬 2 , 120 119 바이트

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)]

온라인으로 사용해보십시오!

Mego / Jonathon Allan의 경우 1 바이트에 대한 값입니다.

05AB1E , 11 바이트

€L.«âOO{γ€g

온라인으로 사용해보십시오!

작동 원리

€ L.«âOO {γ € g-전체 프로그램.

€ L-목록의 각 N에 대해 [1 .. N]을 얻습니다.
  .«-목록의 각 요소 사이에 오른쪽에서 왼쪽으로 역기능을 접습니다.
    -그 기능으로 직교 곱을 선택하십시오.
     O-각각 평평하게하십시오.
      O-각각을 합산하십시오.
       {γ-동일한 인접 값의 런으로 정렬하고 그룹화합니다.
         € g-각각의 길이를 가져옵니다.

Emigna 덕분에 1 바이트 절약 !

R , 51 바이트

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

온라인으로 사용해보십시오!

주사위 목록을 가져와 명명 된 빈도의 벡터를 반환합니다. 이름 (주사위 값)은 주파수 위에 인쇄됩니다.

R , 59 바이트

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

온라인으로 사용해보십시오!

Reduce접근 방식보다는 위의 반복 하나.

R , 62 바이트

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

온라인으로 사용해보십시오!

컨벌루션 접근법. D표현식 의 첫 번째 요소 만 사용 1:D하지만 출력에는 영향을 미치지 않는다는 경고가 표시됩니다 . 우리가 Re솔루션의 일부 를 취할 필요가 없다면 58 바이트입니다.

APL (Dyalog Classic) , 12 10 바이트

@ Adám 덕분에 -2

⊢∘≢⌸+/↑,⍳⎕

온라인으로 사용해보십시오!

입력 ⎕ 은 N 주사위의 목록입니다

⍳⍵ 중첩 된 벡터의 N 차원 배열입니다-가능한 모든 다이 던지기

+/↑, 배열을 평평하게하고 던지기를 합산

⊢∘≢⌸ 처음 나타나는 순서대로 나열된 각 고유 합계의 수를 계산합니다. 다행스럽게도 증가하는 순서와 일치합니다.

루비 , 72 바이트

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

온라인으로 사용해보십시오!

주사위 목록을 입력으로받습니다. 의심 할 여지없이 골프를 밟을 수는 있지만 너무 나쁘지는 않습니다.

Pari / GP , 37 바이트

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

온라인으로 사용해보십시오!

면도 , 154 142 136 107 100 85 + 13 = 98 바이트

입력은 주사위 목록입니다.

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

답은 람다 형식입니다.

from +13 bytes import StdEnv,이 작업에 필요한 모듈을 가져옵니다.

온라인으로 사용해보십시오!

자바 스크립트 (ES6), 83 바이트

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

각 다이의 입력을 별도의 매개 변수로 취합니다.

자바 스크립트 (ES6), 76 74 바이트

주사위 목록으로 입력을받습니다.

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=[])

테스트 사례

마지막 두 테스트 사례를 처리하려면 TCO를 활성화하거나 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(', '))

형식화 및 의견

주의 : 이것은 reduce ()를 사용하고있는 초기 제출의 주석이 달린 버전입니다. 2 바이트 더 길지만 읽기 쉽습니다.

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

클로저, 96 바이트

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

첫 번째 입력은 주사위 수의 목록이고 두 번째 입력은 각 주사위의 변 수 목록입니다.

펄 5 , 94 바이트

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

온라인으로 사용해보십시오!

입력 형식은 개행으로 구분 된 주사위 목록입니다. 따라서 1d10 + 2d8은 다음과 같이 입력됩니다.

10
8
8

SageMath, 46 바이트

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

온라인으로 사용해보십시오

이것은 다른 해결책에 대한 나의 해결책의 적응이다 . 임의의 개수의 주사위를 매개 변수로 취하여 (예 : f(4,4,6,6,6)for 2d4+3d6) 목록을 반환합니다.

파이썬 2 + NumPy , 62 바이트

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

온라인으로 사용해보십시오!

이전과 마찬가지로이 솔루션은 본질적으로 동일하므로 위의 솔루션에 포함했습니다. 이 함수는 Python 목록이 아닌 NumPy 배열을 반환하므로 출력은 약간 다르게 보입니다 print.

numpy.ones(x)은 NumPy와 함께 사용할 배열을 만드는 "올바른"방법이므로 대신 사용할 수 [x*[1]]있지만 불행히도 훨씬 더 길다.