মিশ্র ডাইস রোলগুলির ফ্রিকোয়েন্সি বিতরণ

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 বাইট

-৩ বাইটস মিঃ এক্সকোডারকে ধন্যবাদ (নেতৃত্ব এড়ানোর জন্য একটি অন্তর্নিহিত পরিসীমা ব্যবহার 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ƙ

— মিঃ এক্সকোডার

Answer 2

এমএটিএল , 8 বাইট

1i"@:gY+

ইনপুটটি ডাই আকারের (সম্ভবত পুনরাবৃত্ত) অ্যারে is

এটি অনলাইন চেষ্টা করুন! বা সমস্ত পরীক্ষার কেস যাচাই করুন ।

ব্যাখ্যা

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]। ধন্যবাদ @ লুইস মেন্ডো -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

Haskell, , 80 78 64 বাইট

এই সমাধানটি সম্ভবত আরও প্রাকৃতিক পদ্ধতির সাথে পূর্ববর্তী চ্যালেঞ্জের @ শেরলক 9 এর একের সমান হয়ে গেছে । @ এক্সনরের একটি আরও ছোট হ্যাস্কেল সমাধান রয়েছে !

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

ওল্ফ্রাম ভাষা (গণিত) , ২ by বাইট a

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

এটি অনলাইন চেষ্টা করুন!

পূর্ববর্তী চ্যালেঞ্জের আমার উত্তরটির একটি পরিবর্তন । এটি কেবল সমস্ত সম্ভাব্য ফলাফল উত্পন্ন করে, এগুলি যুক্ত করে এবং ফলাফলকে দীর্ঘায়িত করে।

মজা করার জন্য, আমরা এটি লিখতে পারি Tally@*Total@*Thread@*Tuples@*Rangeতবে এটি আরও দীর্ঘ longer

ওল্ফ্রাম ভাষা (গণিত) , 41 বাইট

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

এটি অনলাইন চেষ্টা করুন!

এটি কনভোলশন-ভিত্তিক পদ্ধতির (এখানে, আমরা উত্পাদনশীল ফাংশনগুলির মাধ্যমে কনভোলিউশনগুলি গ্রহণ করি - 1+x+x^2+...+x^(N-1)এটি একটি ডিএন রোল করার জন্য উত্পন্ন ফাংশন - এবং তারপরে সহগের তালিকাটি নেওয়া হয়)। আমি এটি অন্তর্ভুক্ত করি কারণ প্রথম সমাধানটি বড় ইনপুটগুলির জন্য ব্যবহারিক নয়।

Answer 8

গণিত, 44 বাইট

সংশ্লিষ্ট অঙ্কগুলির সাথে লেবেলযুক্ত ফ্রিকোয়েন্সিগুলি আউটপুট করে

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

এটি অনলাইন চেষ্টা করুন!

মার্টিন ইন্ডার থেকে -5 বাইট

"লেবেলযুক্ত" বৈধ কিনা তা আমাকে জানতে দেওয়ার জন্য মিশা লাভ্রভকে ধন্যবাদ জানাই

Answer 9

পাইথ , 12 বাইট

lM.gs.nk*FSM

এখানে চেষ্টা করুন!

কিভাবে?

lM.gs.nk * এফএসএম ~ সম্পূর্ণ প্রোগ্রাম।

          এসএম ~ সমেত সমাপ্তি পূর্ণসংখ্যার পরিসীমা সহ মানচিত্র [1, এন]।
        * এফ ~ ভাঁজ (দ্বারা হ্রাস) কার্তেসিয়ান পণ্য।
  .g function ফাংশন ফলাফল দ্বারা গ্রুপ।
    sn ~ সমতল যখন তালিকার যোগফল।
lM each প্রতিটি গ্রুপের দৈর্ঘ্য।

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 বাইটের জন্য ধন্যবাদ।

Comments

... অর্থাৎ একটি বাইট সংরক্ষণ করুন ।

— জোনাথন অ্যালান

Answer 12

05 এ বি 1 ই , 11 বাইট

€L.«âOO{γ€g

এটি অনলাইন চেষ্টা করুন!

কিভাবে এটা কাজ করে

€ এল। «ÂOO {γ € জি - সম্পূর্ণ প্রোগ্রাম।

€ এল - তালিকার প্রতিটি এন এর জন্য [1 .. এন] পান।
  । «- তালিকার ডান থেকে বামে প্রতিটি উপাদানের মধ্যে একটি ডায়াডিক ফাংশন ভাঁজ করুন।
    । - এবং সেই ফাংশন হিসাবে কার্টেসিয়ান পণ্য চয়ন করুন।
     ও - প্রতিটি সমতল করুন।
      ও - প্রতিটি যোগফল।
       {γ - বাছাই করুন এবং সমান সংলগ্ন মানগুলির রানগুলিতে গ্রুপ করুন।
         । G - প্রত্যেকটির দৈর্ঘ্য পান।

এমিগিনার প্রতি 1 বাইট সংরক্ষিত !

Comments

আপনি এর Oপরিবর্তে করতে পারেন€˜

— এমিগিনা

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 @ অ্যাডমকে ধন্যবাদ

⊢∘≢⌸+/↑,⍳⎕

এটি অনলাইন চেষ্টা করুন!

ইনপুট ⎕ এন ডাইসের একটি তালিকা

⍳⍵ নেস্টেড ভেক্টরগুলির একটি N- মাত্রিক অ্যারে - সমস্ত সম্ভাব্য ডাই থ্রো

+/↑, অ্যারে সমতল করে এবং নিক্ষেপের পরিমাণ যোগ করে

⊢∘≢⌸ ভাগ্যক্রমে তাদের ক্রমবর্ধমান ক্রমের সাথে মিলেমিশে প্রথম উপস্থিতির ক্রম অনুযায়ী তালিকাভুক্ত প্রতিটি অনন্য রাশির মধ্যে কতটি গণনা করা হয়

Comments

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

— অ্যাডাম

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

জাভাস্ক্রিপ্ট (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

পৃথক প্যারামিটার হিসাবে প্রতিটি ডাই এর ইনপুট নেয়।

Answer 19

জাভাস্ক্রিপ্ট (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=[])

পরীক্ষার মামলা

শেষ দুটি পরীক্ষার কেস প্রক্রিয়াজাতকরণের জন্য টিসিও সক্ষম করা বা জেএস ইঞ্জিনের ডিফল্ট স্ট্যাকের আকার সীমা বাড়ানো দরকার।

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

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

এটি অনলাইন চেষ্টা করুন!

আগের মতোই, আমি এই সমাধানটি উপরেরটির সাথে অন্তর্ভুক্ত করেছি, যেহেতু তারা মূলত সমতুল্য। নোট করুন যে এই ফাংশনটি পাইমথন তালিকা নয় একটি নম্পপি অ্যারে প্রদান করে, তাই আপনি যদি আউটপুট খানিকটা আলাদা দেখায় print।

numpy.ones(x)NumPy এর সাথে ব্যবহারের জন্য একটি অ্যারে তৈরি করার "সঠিক" উপায় এবং [x*[1]]এটি এর জায়গায় ব্যবহার করা যেতে পারে তবে দুর্ভাগ্যক্রমে এটি আরও দীর্ঘ।