^{ติดตามความท้าทายนี้}

รับลูกเต๋าชุดผสมเอาท์พุทการแจกแจงความถี่ของการกลิ้งทั้งหมดและรวมตัวเลขที่หมุนในแต่ละดาย

ตัวอย่างเช่นให้พิจารณา1d12 + 1d8(กลิ้งดายแบบ 12 หน้า 1 ชิ้นและดายแบบด้าน 8 1 ชิ้น) ม้วนสูงสุดและต่ำสุดคือ20และ2ตามลำดับซึ่งคล้ายกับกลิ้ง2d10(2 10-sided ลูกเต๋า) อย่างไรก็ตาม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]

กฎระเบียบ

• ความถี่จะต้องระบุไว้ในลำดับที่เพิ่มขึ้นของผลรวมที่สอดคล้องกับความถี่
• อนุญาตให้ติดฉลากความถี่ที่มีผลรวมที่สอดคล้องกัน แต่ไม่จำเป็น (เนื่องจากสามารถสรุปได้จากลำดับที่ต้องการ)
• คุณไม่ต้องจัดการอินพุตที่เอาต์พุตเกินช่วงของจำนวนเต็มที่แทนค่าได้สำหรับภาษาของคุณ
• ไม่อนุญาตให้นำหน้าหรือต่อท้าย เฉพาะความถี่บวกควรปรากฏในผลลัพธ์
• คุณสามารถรับอินพุตในรูปแบบที่สมเหตุสมผล (รายการของลูกเต๋า ( [6, 8, 8]), รายการของคู่ลูกเต๋า ( [[1, 6], [2, 8]]), ฯลฯ )
• ความถี่จะต้องถูกทำให้เป็นมาตรฐานเพื่อให้ GCD ของความถี่เป็น 1 (เช่น[1, 2, 3, 2, 1]แทน[2, 4, 6, 4, 2])
• ลูกเต๋าทั้งหมดจะมีอย่างน้อยหนึ่งหน้า (ดังนั้นd1คือขั้นต่ำ)
• นี่คือโค้ดกอล์ฟดังนั้นรหัสที่สั้นที่สุด (เป็นไบต์) ชนะ ช่องโหว่มาตรฐานเป็นสิ่งต้องห้ามตามปกติ

กรณีทดสอบ

กรณีทดสอบเหล่านี้จะได้รับเป็น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 ไบต์

-3 ไบต์ขอขอบคุณMr. Xcoder (ใช้ช่วงโดยปริยายเพื่อหลีกเลี่ยงการเป็นผู้นำR; แทนที่การลดลงโดยผลิตภัณฑ์ dyadic คาร์ทีเซียนและแผ่แบนp/F€ด้วยผลิตภัณฑ์คาร์ทีเซียนในตัวสำหรับจุดประสงค์นั้น, Œp)

ŒpS€ĠL€

ลิงค์ monadic ที่รับรายการของใบหน้าลูกเต๋าและคืนค่าการกระจายของผลรวมที่เพิ่มขึ้นตามปกติ

ลองออนไลน์!

อย่างไร?

ผ่านรายการของ "ขนาด" ลูกเต๋า (โดยปริยาย) ทำให้พวกเขาอยู่ในรายการใบหน้าจากนั้นก็จะได้ผลิตภัณฑ์คาร์ทีเซียนของรายการเหล่านั้น (ทั้งหมดที่เป็นไปได้ของชุดลูกเต๋า) จากนั้นก็สรุปจำนวนม้วนเหล่านั้นได้กลุ่มที่เท่าเทียมกัน ดัชนี (ตามค่าจากน้อยไปหามาก) และใช้ความยาวของแต่ละกลุ่ม

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

Husk , 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]

Haskell , 54 ไบต์

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

ลองออนไลน์!

Haskell , 63 ไบต์

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

ลองออนไลน์!

Haskell , 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 ไบต์

ตามที่ระบุไว้ในคำตอบที่ Haskell, การใช้งานนี้ความจริงที่ว่าการกระจายของเช่น 3 ด้านและ 5 ด้านลูกเต๋าเป็นบิดที่ไม่ต่อเนื่องของสองเวกเตอร์และ[1,1,1] [1,1,1,1,1]ขอบคุณ @LuisMendo สำหรับการเล่นกอล์ฟที่ฉลาดถึง -11 ไบต์!

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

Haskell , 80 78 64 ไบต์

การแก้ปัญหานี้จบลงด้วยความใกล้เคียงกับ@ Sherlock9ในการท้าทายครั้งก่อนด้วยวิธีการที่เป็นธรรมชาติมากขึ้น @xnor มีวิธีแฮสเคลล์ที่สั้นกว่า !

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 (Mathematica)ขนาด 26 ไบต์

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

ลองออนไลน์!

ดัดแปลงคำตอบของฉันกับความท้าทายก่อนหน้านี้ นี่เป็นเพียงการสร้างผลลัพธ์ที่เป็นไปได้ทั้งหมดรวมพวกเขาและสรุปผล

เพื่อความสนุกเราสามารถเขียนมันได้Tally@*Total@*Thread@*Tuples@*Rangeแต่นั่นนานกว่านั้น

ภาษา Wolfram (Mathematica) , 41 ไบต์

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

ลองออนไลน์!

นี่คือวิธีการที่ใช้วิธีการแบบคอนเวย์ (ในที่นี้เราใช้การสร้างความเชื่อมั่นผ่านผลิตภัณฑ์ของการสร้างฟังก์ชั่น - 1+x+x^2+...+x^(N-1)เป็นฟังก์ชั่นการสร้างสำหรับการหมุน dN - จากนั้นนำรายการของค่าสัมประสิทธิ์) ฉันรวมไว้เพราะโซลูชั่นแรกไม่สามารถใช้งานได้จริงสำหรับอินพุตขนาดใหญ่

Mathematica ขนาด 44 ไบต์

ส่งออกความถี่ที่มีป้ายกำกับด้วยผลรวมที่สอดคล้องกัน

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

ลองออนไลน์!

-5 ไบต์จาก Martin Ender

ขอบคุณ Misha Lavrov ที่บอกให้ฉันรู้ว่า "ติดป้าย" ถูกต้อง

Pyth , 12 ไบต์

lM.gs.nk*FSM

ลองที่นี่!

อย่างไร?

lM.gs.nk * FSM ~ โปรแกรมเต็มรูปแบบ

          SM ~ แผนที่พร้อมช่วงจำนวนเต็มรวมทั้งหมด [1, N]
        * F ~ Fold (ย่อขนาด) ผลิตภัณฑ์คาร์ทีเซียน
  .g ~ จัดกลุ่มตามผลลัพธ์ฟังก์ชั่น
    sn ~ ผลรวมของรายการเมื่อแบน
lM ~ ความยาวของแต่ละกลุ่ม

เยลลี่ขนาด 14 ไบต์

R+Ѐ/FċЀSR$ḟ0

ลองออนไลน์!

อินพุตคือรายการของค่าตาย ฉันทำได้โดยการขโมยĠL€จากคำตอบของเยลลี่คนอื่น แต่จากนั้นฉันก็สามารถลงสนามในครึ่งแรกและจบลงด้วยสิ่งเดียวกันดังนั้นฉันจะทิ้งมันไว้ว่ามันจะเป็นอย่างไร

Python 2 , 120 119 bytes

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

ลองออนไลน์!

Thks สำหรับ Mego / Jonathon Allan 1 ไบต์

05AB1E , 11 ไบต์

€L.«âOO{γ€g

ลองออนไลน์!

มันทำงานอย่างไร

€ L. «âOO {γ€ g - โปรแกรมเต็มรูปแบบ

€ L - สำหรับแต่ละ N ในรายการให้ได้ [1 .. N]
  . « - พับฟังก์ชัน dyadic ระหว่างแต่ละองค์ประกอบในรายการจากขวาไปซ้าย
    - และเลือกผลิตภัณฑ์คาร์ทีเซียนเป็นฟังก์ชันนั้น
     O - แผ่ให้เรียบ
      O - รวมกัน
       {γ - เรียงลำดับและจัดกลุ่มให้มีค่าติดกันเท่ากัน
         € g - รับความยาวของแต่ละ

บันทึก 1 ไบต์ต้องขอบคุณEmigna !

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 ไบต์

-2 ขอบคุณ @ Adám

⊢∘≢⌸+/↑,⍳⎕

ลองออนไลน์!

อินพุต⎕คือรายการของ N ลูกเต๋า

⍳⍵ เป็นอาร์เรย์ N - มิติของเวกเตอร์ซ้อนกัน - เป็นไปได้ทั้งหมดพ่น

+/↑, แผ่อาร์เรย์และผลรวมของการโยน

⊢∘≢⌸ นับจำนวนผลรวมที่ไม่ซ้ำกันแต่ละรายการตามลำดับการปรากฏตัวครั้งแรกของพวกเขาซึ่งโชคดีที่เกิดขึ้นพร้อมกับคำสั่งที่เพิ่มขึ้นของพวกเขา

Ruby , 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]

คำตอบอยู่ในรูปของแลมบ์ดา

+13ไบต์จากimport StdEnvซึ่งนำเข้าโมดูลที่จำเป็นสำหรับการทำงาน

ลองออนไลน์!

JavaScript (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

รับอินพุตของแต่ละ die เป็นพารามิเตอร์แยกกัน

JavaScript (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(', '))

จัดรูปแบบและแสดงความคิดเห็น

หมายเหตุ: นี่เป็นรุ่นที่แสดงความคิดเห็นของการส่งครั้งแรกของฉันซึ่งใช้ลด () มันยาวกว่า 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

Clojure, 96 ไบต์

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

อินพุตแรกคือรายการของจำนวนลูกเต๋าและอินพุตที่สองคือรายการจำนวนด้านของแต่ละลูกเต๋า

Perl 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)สำหรับ2d4+3d6) และส่งคืนรายการ

Python 2 + NumPy , 62 ไบต์

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

ลองออนไลน์!

ก่อนหน้านี้ฉันได้รวมวิธีแก้ปัญหานี้ไว้กับโซลูชันด้านบนเนื่องจากมีค่าเท่ากัน โปรดทราบว่าฟังก์ชั่นนี้จะส่งกลับอาร์เรย์ NumPy และไม่ใช่รายการ Python ดังนั้นเอาต์พุตจะดูแตกต่างออกไปเล็กน้อยถ้าคุณprintใช้

numpy.ones(x)เป็นวิธีที่ "ถูกต้อง" ในการสร้างอาร์เรย์สำหรับใช้กับ NumPy และสามารถใช้แทนได้[x*[1]]แต่น่าเสียดายที่นานกว่านั้นมาก