मिश्रित पासा रोल की आवृत्ति वितरण

Question

^{इस चुनौती के लिए अनुवर्ती}

मिश्रित पासा के एक सेट को देखते हुए, उन सभी को रोल करने की आवृत्ति वितरण का उत्पादन करें और प्रत्येक मरने पर लुढ़का संख्याओं को समेटें।

उदाहरण के लिए, विचार करें 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]।

नियम

• उस आवृत्ति के बढ़ते क्रम में आवृत्तियों को सूचीबद्ध किया जाना चाहिए जिसके लिए आवृत्ति मेल खाती है।
• संगत रकम के साथ आवृत्तियों को लेबल करने की अनुमति है, लेकिन आवश्यक नहीं है (क्योंकि रकम आवश्यक आदेश से अनुमान लगाई जा सकती है)।
• आपको उन इनपुट्स को हैंडल करने की आवश्यकता नहीं है जहां आउटपुट आपकी भाषा के लिए पूर्णांकों की प्रतिनिधित्व योग्य सीमा से अधिक है।
• शून्य या अनुगामी शून्य की अनुमति नहीं है। केवल सकारात्मक आवृत्तियों को आउटपुट में दिखाई देना चाहिए।
• आप किसी भी उचित प्रारूप (पासा की [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]

Comments

सैंडबॉक्स

— मेगो

Answer 1

जेली ,  14  7 बाइट्स

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

नोट: न्यूनतम रोल करने के लिए केवल एक ही तरीका है (प्रत्येक और प्रत्येक पासा पर एक रोल करके) और हम किसी भी रोल को डबल-गिनती नहीं कर रहे हैं, इसलिए जीसीडी सामान्यीकरण करने की आवश्यकता नहीं है।

Comments

धन्यवाद, मैं सोच रहा था कि क्या हमें कभी भी ज़रूरत है ÷g/$(क्या हमेशा मीन या अधिकतम पाने का एक ही तरीका नहीं है?)

— जोनाथन एलन

यह एक लायक शेयर विकल्प सोचा:ŒpS€µLƙ

— श्री Xcoder

Answer 2

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)

Answer 3

भूसी , 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]

Answer 4

हास्केल , 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]

इसे ऑनलाइन आज़माएं!

Answer 5

ऑक्टेव , 88 69 58 56 बाइट्स

जैसा कि हास्केल उत्तर में उल्लेख किया गया है, यह इस तथ्य का उपयोग करता है कि उदाहरण के लिए 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

Answer 6

हास्केल , 80 78 64 बाइट्स

यह समाधान लगभग उसी प्राकृतिक दृष्टिकोण के साथ पिछली चुनौती में @ शर्लक 9 में से एक के रूप में समाप्त हुआ । @ 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

इसे ऑनलाइन आज़माएं!

Answer 7

वोल्फ्राम भाषा (गणितज्ञ) , 26 बाइट्स

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

इसे ऑनलाइन आज़माएं!

पिछली चुनौती के लिए मेरे जवाब का एक संशोधन । यह बस सभी संभावित परिणाम उत्पन्न करता है, उन्हें जोड़ता है, और परिणामों को लंबा करता है।

मनोरंजन के लिए, हम इसे लिख सकते हैं Tally@*Total@*Thread@*Tuples@*Range, लेकिन यह अधिक लंबा है।

वोल्फ्राम लैंग्वेज (मैथमेटिका) , 41 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह दृढ़ संकल्प आधारित दृष्टिकोण है (यहां, हम जनरेटिंग फ़ंक्शन के उत्पाद के माध्यम से संकल्प लेते हैं - 1+x+x^2+...+x^(N-1)एक डीएन को रोल करने के लिए जनरेटिंग फ़ंक्शन है - और फिर गुणांक की सूची लेते हैं)। मैं इसे शामिल करता हूं क्योंकि पहला समाधान बड़े इनपुट के लिए व्यावहारिक नहीं है।

Answer 8

मैथेमेटिका, 44 बाइट्स

इसी sums के साथ लेबल आवृत्तियों को आउटपुट करता है

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

इसे ऑनलाइन आज़माएं!

मार्टिन एंडर से -5 बाइट्स

मीशा लावरोव को धन्यवाद देने के लिए कि मुझे पता है कि "लेबल" वैध है

Answer 9

पायथ , 12 बाइट्स

lM.gs.nk*FSM

यहाँ यह कोशिश करो!

कैसे?

lM.gs.nk * FSM ~ पूर्ण कार्यक्रम।

          SM ~ समावेशी पूर्णांक श्रेणी [1, N] के साथ नक्शा।
        * एफ ~ गुना (द्वारा कम) कार्टेशियन उत्पाद।
  .g ~ फ़ंक्शन परिणाम द्वारा समूह।
    sn ~ जब चपटा हुआ सूची का योग।
एलएम ~ प्रत्येक समूह की लंबाई।

Answer 10

जेली , 14 बाइट्स

R+Ѐ/FċЀSR$ḟ0

इसे ऑनलाइन आज़माएं!

इनपुट मर मूल्यों की एक सूची है। मैं ĠL€अन्य जेली उत्तर से चोरी करके इसे नीचे गिरा सकता हूं, लेकिन फिर मैं पहली छमाही को भी नीचे कर सकता हूं और एक ही चीज के साथ समाप्त हो सकता हूं, इसलिए मैं इसे छोड़ दूँगा

Answer 11

पायथन 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)]

इसे ऑनलाइन आज़माएं!

1 बाइट के लिए मेगो / जोनाथन एलन के लिए Thks।

Comments

... यानी एक बाइट बचाओ ।

— जोनाथन एलन

Answer 12

05AB1E , 11 बाइट्स

€L.«âOO{γ€g

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

€ L। «ÂOO {γ € g - पूर्ण कार्यक्रम।

€ L - सूची में प्रत्येक N के लिए, [1 .. N] प्राप्त करें।
  । «- एक सूची में प्रत्येक तत्व के बीच दाईं से बाईं ओर एक डाईएडिक फ़ंक्शन को मोड़ो।
    एक - और उस फ़ंक्शन के रूप में कार्टेशियन उत्पाद चुनें।
     ओ - प्रत्येक को समतल करें।
      हे - प्रत्येक योग।
       {, - समान आसन्न मूल्यों के रन में समूह, और समूह।
         € g - प्रत्येक की लंबाई प्राप्त करें।

Emigna के लिए 1 बाइट धन्यवाद !

Comments

आप Oइसके बजाय कर सकते हैं€˜

— Emigna

Answer 13

आर , 51 बाइट्स

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

इसे ऑनलाइन आज़माएं!

पासा की एक सूची लेता है और आवृत्तियों के एक नामित वेक्टर को वापस करता है; नाम (पासा रकम के मूल्य) आवृत्तियों के ऊपर मुद्रित होते हैं।

आर , 59 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Reduceऊपर के पुनरावृत्ति के बजाय एक दृष्टिकोण।

आर , 62 बाइट्स

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

इसे ऑनलाइन आज़माएं!

एक दृढ़ संकल्प दृष्टिकोण। यह कुछ चेतावनी देगा कि यह केवल Dअभिव्यक्ति के पहले तत्व का उपयोग कर रहा है 1:Dलेकिन यह आउटपुट को प्रभावित नहीं करता है। अगर हमें Reसमाधान का हिस्सा नहीं लेना है , तो यह 58 बाइट्स होगा।

Answer 14

एपीएल (डायलॉग क्लासिक) , 12 10 बाइट्स

-2 @ Adám को धन्यवाद

⊢∘≢⌸+/↑,⍳⎕

इसे ऑनलाइन आज़माएं!

इनपुट ⎕एन पासा की एक सूची है

⍳⍵ नेस्टेड वैक्टर का एक एन-आयामी सरणी है - सभी संभव डाई थ्रो

+/↑, सरणियों को समतल करता है और फेंकता है

⊢∘≢⌸ गिना जाता है कि उनकी पहली उपस्थिति के क्रम में सूचीबद्ध प्रत्येक अद्वितीय राशि, जो सौभाग्य से उनके बढ़ते क्रम के साथ मेल खाती है

Comments

-2: ⊢∘≢⌸+/↑,⍳⎕

— Adám

Answer 15

रूबी , 72 बाइट्स

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

इसे ऑनलाइन आज़माएं!

इनपुट के रूप में पासा की एक सूची लेता है। इसमें कोई शक नहीं कि इसे नीचे गिराया जा सकता है, लेकिन बहुत बुरा नहीं।

Answer 16

परी / जीपी , 37 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 17

क्लीन , 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, जो काम करने के लिए आवश्यक मॉड्यूल को आयात करता है।

इसे ऑनलाइन आज़माएं!

Answer 18

जावास्क्रिप्ट (ईएस 6), 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

प्रत्येक के इनपुट को एक अलग पैरामीटर के रूप में मरता है।

Answer 19

जावास्क्रिप्ट (ईएस 6), 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

Answer 20

क्लोजर, 96 बाइट्स

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

पहला इनपुट पासा की संख्या की एक सूची है, और दूसरा इनपुट प्रत्येक पासे की संख्या की एक सूची है।

Answer 21

पर्ल 5 , 94 बाइट्स

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

इसे ऑनलाइन आज़माएं!

इनपुट प्रारूप नए सिरे से अलग किए गए पासा की सूची है। इस प्रकार, 1d10 + 2d8 इनपुट के रूप में होगा:

10
8
8

Answer 22

सेजमैथ, 46 बाइट्स

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

इसे ऑनलाइन आज़माएं

यह दूसरी चुनौती के लिए मेरे समाधान का एक अनुकूलन है । यह किसी भी संख्या में पासा पैरामीटर (जैसे के f(4,4,6,6,6)लिए 2d4+3d6) के रूप में लेता है , और एक सूची देता है।

---

पायथन 2 + न्यूमपी , 62 बाइट्स

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

इसे ऑनलाइन आज़माएं!

पहले की तरह, मैंने इस समाधान को उपरोक्त के साथ शामिल किया है, क्योंकि वे अनिवार्य रूप से समान हैं। ध्यान दें कि यह फ़ंक्शन एक NumPy सरणी देता है और पायथन सूची नहीं, इसलिए यदि आप printइसे बनाते हैं तो आउटपुट थोड़ा अलग दिखता है।

numpy.ones(x)NumPy के साथ उपयोग करने के लिए एक सरणी बनाने का "सही" तरीका है, और इस प्रकार इसका उपयोग किया जा सकता है [x*[1]], लेकिन यह दुर्भाग्य से अधिक लंबा है।