^{Bu zorluğun bir takibi}

Bir dizi karışık zar verildiğinde, bunların hepsini haddeleme ve her bir kalıpta haddelenmiş sayıları toplama sıklık dağılımını gösterir.

Örneğin, düşünün 1d12 + 1d8(yuvarlama 12 12 taraflı kalıp ve 18 8 taraflı kalıp). Maksimum ve minimum silindirler sırasıyla 20ve 2buna benzer şekilde yuvarlanmaya benzer 2d10(2 10 taraflı zar). Ancak, 1d12 + 1d8daha düz bir dağılımındaki sonuçları 2d10: [1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 8, 8, 7, 6, 5, 4, 3, 2, 1]versus [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1].

kurallar

• Frekanslar, karşılık gelen toplamın artan sırasına göre listelenmelidir.
• Frekansları karşılık gelen toplamlarla etiketlemeye izin verilir, ancak gerekli değildir (toplamlar istenen siparişten alınabildiği için).
• Çıktının, diliniz için temsil edilebilir tam sayı aralığını aştığı girişleri ele almanız gerekmez.
• Önde gelen veya sondaki sıfırlara izin verilmez. Çıktıda yalnızca pozitif frekanslar görünmelidir.
• Girdiyi herhangi bir makul formatta (zar listesi ( [6, 8, 8]), zar çifti listesi ( [[1, 6], [2, 8]]) vb.) Alabilirsiniz .
• Frekansların GCD'si 1 olacak şekilde frekanslar normalize edilmelidir (örneğin [1, 2, 3, 2, 1]yerine [2, 4, 6, 4, 2]).
• Tüm zarlar en az bir yüze sahip olacaktır (yani a d1minimumdur).
• Bu kod-golf , bu yüzden en kısa kod (bayt cinsinden) kazanır. Her zamanki gibi standart boşluklar yasaktır.

Test Kılıfları

Gibi bu test durumları verilmiştir input: outputgiriş çiftlerinin bir listesini olarak verilir burada, [a, b]temsil a btaraflı zar (böylece [3, 8]karşılık gelir 3d8ve [[1, 12], [1, 8]]karşılık gelir 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]

Jöle ,  14  7 bayt

- Bay Xcoder sayesinde -3 bayt (öncülüğü önlemek için örtülü bir ürün yelpazesinin kullanımı; azalmış olanı Rdyadik Kartezyen ürün p/F€ile değiştirmek ve kartezyen ürün bu amaç için yerleşik olarak düzleştirmek, Œp)

ŒpS€ĠL€

Zarların bir listesini alan ve artan meblağların normalleştirilmiş dağılımını iade eden monadik bir bağlantı.

Çevrimiçi deneyin!

Nasıl?

Zarlar "büyüklükler" listesinde (dolaylı olarak) yüz listelerinde bulunur, sonra bu listelerin Kartezyen ürününü alır (zar kümesinin tüm olası rulolarını), sonra bu ruloları toplar, eşit grupları alır Endeksler (artan değer ile) ve her grubun uzunluğunu alır.

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

Not: Minimumları atmanın sadece bir yolu vardır (her zardan birini atmak suretiyle) ve herhangi bir ruloyu çift saymıyoruz, bu nedenle bir GCD normalizasyonu gerçekleştirmeye gerek yok.

MATL , 8 bayt

1i"@:gY+

Giriş (muhtemelen tekrarlanan) kalıp boyutları dizisidir.

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın .

açıklama

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)

Kabuğu , 7 bayt

mLkΣΠmḣ

Giriş bir zar listesidir. Çevrimiçi deneyin!

açıklama

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 bayt

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

Çevrimiçi deneyin!

Haskell , 63 bayt

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

Çevrimiçi deneyin!

Haskell , 68 bayt

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

Çevrimiçi deneyin!

Octave , 88 69 58 56 bayt

Haskell yanıt de belirtildiği gibi, bu kullanım, örneğin bir 3-taraflı dağılımı ve bir 5-taraflı zar iki vektörün ayrık katlama olması [1,1,1]ve [1,1,1,1,1]. Akıllı golf oynamaya değer -11 bayt için @LuisMendo!

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

Çevrimiçi deneyin!

Bu başvuru özyinelemeli bir yaklaşım kullanıyor. Ancak bir döngü kullanırsanız, biraz daha uzun olurdu:

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 bayt

Bu çözüm , belki de daha doğal bir yaklaşımla önceki meydan okumada @ Sherlock9'unki ile neredeyse aynıydı . @xnor daha kısa bir Haskell çözümüne sahip !

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

Açıklama:

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

Çevrimiçi deneyin!

Önceki çözüm:

Bu @AndersKaseorg ayrık evrişim işlevini kullanıyor. Buradaki gözlem, örneğin 3 taraflı ve 5 taraflı bir zarın dağılımının, iki vektörün ayrık evrişimi olduğu [1,1,1]ve [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

Çevrimiçi deneyin!

Wolfram Dili (Mathematica) , 26 bayt

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

Çevrimiçi deneyin!

Önceki mücadeleye cevabımın bir modifikasyonu . Bu sadece tüm olası sonuçları üretir, ekler ve sonuçları verir.

Eğlenmek için yazabiliriz Tally@*Total@*Thread@*Tuples@*Range, ama daha uzun.

Wolfram Dili (Mathematica) , 41 bayt

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

Çevrimiçi deneyin!

Bu, evrişime dayalı yaklaşımdır (burada, üreteç işlevlerinin ürünü üzerinden evrimleşme yapıyoruz - 1+x+x^2+...+x^(N-1)bir dN döndürmek için üreteç işlevidir - ve sonra katsayıların listesini alır). Bunu ekliyorum çünkü ilk çözüm büyük girdiler için pratik değil.

Mathematica, 44 bayt

İlgili toplamlarla etiketlenmiş frekansları çıkarır.

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

Çevrimiçi deneyin!

-5 Martin Ender'den gelen bayt sayısı

Misha Lavrov'a "etiketli" nin geçerli olduğunu bildirdiği için teşekkürler

Pyth , 12 bayt

lM.gs.nk*FSM

Burada dene!

Nasıl?

lM.gs.nk * FSM ~ Tam program.

          Kapsayıcı tamsayı aralığına sahip SM ~ Haritası [1, N].
        * F ~ Katla (Küçült) Kartezyen ürün.
  .g ~ İşlev sonucuna göre gruplandır.
    sn ~ Düzleştirildiğinde listenin toplamı.
İM ~ Her grubun uzunluğu.

Jöle , 14 bayt

R+Ѐ/FċЀSR$ḟ0

Çevrimiçi deneyin!

Giriş, kalıp değerlerinin bir listesidir. ĠL€Diğer Jelly cevabından çalarak golf oynayabilirdim ama sonra ilk yarıya kadar golf oynayabilir ve aynı şeyle bitirebilirim.

Python 2 , 120 119 bayt

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

Çevrimiçi deneyin!

1 bayt için Mego / Jonathon Allan için Thks.

05AB1E , 11 bayt

€L.«âOO{γ€g

Çevrimiçi deneyin!

Nasıl çalışır

€ L. «“ {{€ g - Tam program.

€ L - Listedeki her N için, [1 .. N] değerini alın.
  . «- Listedeki her bir eleman arasında sağdan sola doğru iki yönlü bir fonksiyon katlayın.
    â - Ve bu fonksiyon olarak kartezyen ürünü seçin.
     O - Her birini düzleştirin.
      O - Her birini toplayın.
       {γ - Sıralayın ve eşit bitişik değerlerden oluşan çalışmalara gruplayın.
         € g - Her birinin uzunluğunu alın.

Emigna sayesinde 1 byte kurtarıldı !

R , 51 bayt

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

Çevrimiçi deneyin!

Bir zar listesini alır ve adlandırılmış bir frekans vektörünü döndürür; isimler (zar toplamlarının değerleri) frekansların üzerinde yazılıdır.

R , 59 bayt

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

Çevrimiçi deneyin!

ReduceYukarıdaki yinelemeden ziyade bir yaklaşım.

R , 62 bayt

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

Çevrimiçi deneyin!

Bir evrişim yaklaşımı. Dİfade için sadece ilk elemanını kullandığı, 1:Dancak çıktıyı etkilemediği konusunda birkaç uyarı verecektir . ReÇözümün tamamını almak zorunda kalmazsak, 58 bayt olur.

APL (Dyalog Klasik) , 12 10 bayt

-2 @ Adám sayesinde

⊢∘≢⌸+/↑,⍳⎕

Çevrimiçi deneyin!

giriş ⎕N zarının bir listesidir

⍳⍵ N boyutlu bir yuvalanmış vektör dizisidir - tüm olası kalıp atışları

+/↑, dizileri düzleştirir ve atışları toplar

⊢∘≢⌸ ilk görünüm sırasına göre listelenen her benzersiz toplamın kaç tanesini, neyse ki artan sıralarıyla çakıştığını sayar

Ruby , 72 bayt

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

Çevrimiçi deneyin!

Giriş olarak zarların bir listesini alır. Hiç şüphe yok ki aşağı golf olabilir, ama çok kötü değil.

Pari / GP , 37 bayt

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

Çevrimiçi deneyin!

Temiz , 154 142 136 107 100 85 + 13 = 98 bayt

Giriş bir zar listesidir.

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

Cevap bir lambda şeklindedir.

+13 baytimport StdEnvBunun çalışması için gereken modülü ithal eden .

Çevrimiçi deneyin!

JavaScript (ES6), 83 bayt

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

Her kalıbın girişini ayrı bir parametre olarak alır.

JavaScript (ES6), 76 74 bayt

Bir zar listesi olarak girdi alır.

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

Test durumları

Son iki test durumunun işlenmesi, TCO'yu etkinleştirmeyi veya JS motorunun varsayılan yığın boyutu sınırını arttırmayı gerektirir.

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

Biçimlendi ve yorumlandı

Not: Bu, ilk gönderimimin reduc () kullandığı yorumlanmış bir sürümüdür. 2 bayt daha uzun fakat okunması daha kolay.

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 bayt

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

İlk giriş, zar sayısının bir listesidir ve ikinci giriş, her zardaki yüz sayısının bir listesidir.

Perl 5 , 94 bayt

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

Çevrimiçi deneyin!

Giriş formatı, yeni satırlarla ayrılmış bir zar listesidir. Böylece, 1d10 + 2d8 şöyle girecektir:

10
8
8

SageMath, 46 bayt

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

Çevrimiçi deneyin

Bu benim çözümümün diğer zorluklara uyarlanmasıdır . Herhangi bir sayıda zarda parametre olarak kullanılır (örneğin f(4,4,6,6,6)için 2d4+3d6) ve bir liste döndürür.

Python 2 + NumPy , 62 bayt

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

Çevrimiçi deneyin!

Daha önce olduğu gibi, esasen eşdeğer oldukları için bu çözümü yukarıdaki ile ekledim. Bu işlevin bir Python listesi değil bir NumPy dizisi döndürdüğünü ve bu nedenle çıktıların biraz farklı göründüğünü unutmayın print.

numpy.ones(x)NumPy ile kullanmak için bir dizi yapmanın "doğru" yoludur ve bu nedenle bunun yerine kullanılabilir [x*[1]], ancak ne yazık ki çok daha uzundur.