^{Ein Follow-up zu dieser Herausforderung}

Geben Sie bei einem Satz gemischter Würfel die Häufigkeitsverteilung aus, indem Sie alle Würfel würfeln und die gewürfelten Zahlen auf jedem Würfel summieren.

Betrachten Sie zum Beispiel 1d12 + 1d8(Rollen von 1 12-seitigem Würfel und 1 8-seitigem Würfel). Die maximalen und minimalen Rollen sind 20und 2verbunden, die dem Walzen ähnlich ist 2d10(2 10 seitige Würfel). Es 1d12 + 1d8ergibt sich jedoch eine flachere Verteilung als 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].

Regeln

• Die Frequenzen müssen in aufsteigender Reihenfolge der Summe aufgeführt werden, der die Frequenz entspricht.
• Das Beschriften der Frequenzen mit den entsprechenden Summen ist zulässig, aber nicht erforderlich (da die Summen aus der erforderlichen Reihenfolge abgeleitet werden können).
• Sie müssen keine Eingaben verarbeiten, bei denen die Ausgabe den für Ihre Sprache darstellbaren Bereich von Ganzzahlen überschreitet.
• Führende oder nachfolgende Nullen sind nicht zulässig. Es sollten nur positive Frequenzen im Ausgang erscheinen.
• Sie können die Eingabe in jedem vernünftigen Format vornehmen (Liste der Würfel ( [6, 8, 8]), Liste der Würfelpaare ( [[1, 6], [2, 8]]) usw.).
• Die Frequenzen müssen so normiert werden, dass der GCD der Frequenzen 1 ist (zB [1, 2, 3, 2, 1]statt [2, 4, 6, 4, 2]).
• Alle Würfel haben mindestens ein Gesicht (also d1ist a das Minimum).
• Das ist Code-Golf , also gewinnt der kürzeste Code (in Bytes). Standardlücken sind wie gewohnt verboten.

Testfälle

Diese Testfälle gegeben werden als input: output, wobei die Eingabe als eine Liste von Paaren gegeben ist [a, b]repräsentiere a b-seitige Würfel (so [3, 8]bezeichnet 3d8, und [[1, 12], [1, 8]]bezieht sich auf 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]

Jelly ,  14  7 Bytes

-3 Byte dank Mr. Xcoder (Verwendung eines impliziten Bereichs zur Vermeidung von Leading R; Ersetzen von Reduction durch das dyadische kartesische Produkt und Flatten durch das p/F€für diesen Zweck integrierte kartesische Produkt Œp.)

ŒpS€ĠL€

Ein monadischer Link, der eine Liste mit Würfelgesichtern erstellt und die normalisierte Verteilung der ansteigenden Beträge zurückgibt.

Probieren Sie es online!

Wie?

Durchläuft die Liste der Würfel "Größen" (implizit), macht sie zu ihrer Liste der Gesichter, erhält dann das kartesische Produkt dieser Listen (alle möglichen Würfe des Würfelsatzes), summiert diese Würfe und erhält die Gleichheitsgruppen Indizes (nach aufsteigendem Wert) und nimmt die Länge jeder Gruppe.

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

Hinweis: Es gibt immer nur eine Möglichkeit, das Minimum zu würfeln (indem bei jedem Würfel eine Eins gewürfelt wird), und wir zählen keine Würfe doppelt, sodass keine GCD-Normalisierung erforderlich ist.

MATL , 8 Bytes

1i"@:gY+

Die Eingabe ist ein Array von (möglicherweise wiederholten) Chipgrößen.

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

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)

Schale , 7 Bytes

mLkΣΠmḣ

Input ist eine Liste von Würfeln. Probieren Sie es online!

Erläuterung

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 Bytes

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

Probieren Sie es online!

Haskell , 63 Bytes

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

Probieren Sie es online!

Haskell , 68 Bytes

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

Probieren Sie es online!

Oktave , 88 69 58 56 Bytes

Wie in der Haskell-Antwort erwähnt, wird dabei die Tatsache ausgenutzt, dass die Verteilung von z. B. einem 3-seitigen und einem 5-seitigen Würfel die diskrete Faltung der beiden Vektoren [1,1,1]und ist [1,1,1,1,1]. Vielen Dank an @LuisMendo für -11 Bytes cleveres Golfen!

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

Probieren Sie es online!

Diese Einreichung verwendet einen rekursiven Ansatz. Wenn Sie jedoch eine Schleife verwenden würden, wäre diese etwas länger:

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 Bytes

Diese Lösung entsprach fast der von @ Sherlock9 in der vorherigen Herausforderung mit dem vielleicht natürlicheren Ansatz. @xnor hat eine noch kürzere Haskell-Lösung !

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

Erläuterung:

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

Probieren Sie es online!

Vorherige Lösung:

Hierbei wird die diskrete Faltungsfunktion von @AndersKaseorg verwendet. Die Beobachtung hier ist, dass die Verteilung von zB einem 3-seitigen und einem 5-seitigen Würfel die diskrete Faltung der beiden Vektoren [1,1,1]und ist [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

Probieren Sie es online!

Wolfram Language (Mathematica) , 26 Byte

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

Probieren Sie es online!

Eine Modifikation meiner Antwort auf die vorherige Herausforderung . Dies generiert einfach alle möglichen Ergebnisse, addiert sie und summiert die Ergebnisse.

Zum Spaß könnten wir es so schreiben Tally@*Total@*Thread@*Tuples@*Range, aber das ist länger.

Wolfram Language (Mathematica) , 41 Bytes

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

Probieren Sie es online!

Dies ist der faltungsbasierte Ansatz (hier nehmen wir Faltungen über das Produkt der Erzeugungsfunktionen - 1+x+x^2+...+x^(N-1)ist die Erzeugungsfunktion zum Rollen eines dN - und nehmen dann die Liste der Koeffizienten). Ich schließe es ein, weil die erste Lösung für große Eingaben nicht praktisch ist.

Mathematica, 44 Bytes

Gibt die mit den entsprechenden Summen gekennzeichneten Frequenzen aus

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

Probieren Sie es online!

-5 Bytes von Martin Ender

Vielen Dank an Mischa Lawrow für die Mitteilung, dass "Labeled" gültig ist

Pyth , 12 Bytes

lM.gs.nk*FSM

Probieren Sie es hier aus!

Wie?

lM.gs.nk * FSM ~ Volles Programm.

          SM ~ Map mit eingeschlossenem unärem Integer-Bereich [1, N].
        * F ~ Falte (Reduziere um) kartesisches Produkt.
  .g ~ Ergebnis nach Funktion gruppieren.
    sn ~ Die Summe der Liste, wenn sie abgeflacht ist.
lM ~ Länge jeder Gruppe.

Jelly , 14 Bytes

R+Ѐ/FċЀSR$ḟ0

Probieren Sie es online!

Die Eingabe ist eine Liste von Werkzeugwerten. Ich könnte Golf spielen, indem ich mir ĠL€die andere Gelee-Antwort stehle , aber dann könnte ich auch Golf spielen und am Ende das Gleiche tun, also lasse ich es einfach so, wie es ist

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

Probieren Sie es online!

Danke für Mego / Jonathon Allan für 1 Byte.

05AB1E , 11 Bytes

€L.«âOO{γ€g

Probieren Sie es online!

Wie es funktioniert

€ L. «ÂOO {γ € g - Volles Programm.

€ L - Für jedes N in der Liste erhalten Sie [1 .. N].
  . «- Falte eine dyadische Funktion zwischen jedem Element in einer Liste von rechts nach links.
    â - Und wählen Sie kartesisches Produkt als diese Funktion.
     O - Jeweils abflachen.
      O - Summe jeweils.
       {γ - Sortiere und gruppiere in Reihen gleicher benachbarter Werte.
         € g - Holen Sie sich die Längen von jedem.

Dank Emigna 1 Byte gespart !

R , 51 Bytes

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

Probieren Sie es online!

Nimmt eine Liste von Würfeln und gibt einen benannten Vektor von Frequenzen zurück; Die Namen (Werte der Würfelsummen) sind über den Frequenzen aufgedruckt.

R , 59 Bytes

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

Probieren Sie es online!

Ein ReduceAnsatz anstelle des oben beschriebenen iterativen.

R , 62 Bytes

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

Probieren Sie es online!

Ein Faltungsansatz. Es werden einige Warnungen ausgegeben, dass nur das erste Element von Dfür den Ausdruck verwendet wird 1:D, die Ausgabe jedoch nicht beeinflusst wird. Wenn wir nicht den Regesamten Teil der Lösung übernehmen müssten, wären es 58 Bytes.

APL (Dyalog Classic) , 12 10 Bytes

-2 danke an @ Adám

⊢∘≢⌸+/↑,⍳⎕

Probieren Sie es online!

Die Eingabe ⎕ist eine Liste von N Würfeln

⍳⍵ ist ein N-dimensionales Array verschachtelter Vektoren - alle möglichen Würfelwürfe

+/↑, flacht die Arrays ab und summiert die Würfe

⊢∘≢⌸ zählt, wie viele von jeder einzelnen Summe in der Reihenfolge ihres ersten Auftretens aufgelistet sind, was glücklicherweise mit ihrer aufsteigenden Reihenfolge übereinstimmt

Ruby , 72 Bytes

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

Probieren Sie es online!

Nimmt eine Liste von Würfeln als Eingabe. Zweifellos kann man Golf spielen, aber nicht schlecht.

Pari / GP , 37 Bytes

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

Probieren Sie es online!

Sauber , 154 142 136 107 100 85 + 13 = 98 Bytes

Input ist eine Liste von Würfeln.

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

Die Antwort ist in Form eines Lambda.

+13 Bytes vonimport StdEnv , wodurch das dafür benötigte Modul importiert wird.

Probieren Sie es online!

JavaScript (ES6), 83 Byte

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

Nimmt die Eingabe jedes Würfels als separaten Parameter.

JavaScript (ES6), 76 74 Byte

Nimmt die Eingabe als eine Liste von Würfeln.

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

Testfälle

Das Verarbeiten der letzten beiden Testfälle würde das Aktivieren der TCO oder das Erhöhen der Standard-Stack-Größenbeschränkung der JS-Engine erfordern.

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

Formatiert und kommentiert

NB: Dies ist eine kommentierte Version meiner ursprünglichen Einreichung, die redu () verwendet hat. Es ist 2 Bytes länger, aber leichter zu lesen.

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 Bytes

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

Der erste Eingang ist eine Liste mit der Anzahl der Würfel und der zweite Eingang ist eine Liste mit der Anzahl der Seiten jedes Würfels.

Perl 5 , 94 Bytes

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

Probieren Sie es online!

Das Eingabeformat ist eine Liste von Würfeln, die durch Zeilenumbrüche getrennt sind. Somit würde 1d10 + 2d8 wie folgt eingegeben:

10
8
8

SageMath, 46 Bytes

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

Probieren Sie es online aus

Dies ist eine Anpassung meiner Lösung an die andere Herausforderung . Es nimmt beliebig viele Würfel als Parameter auf (zB f(4,4,6,6,6)für 2d4+3d6) und gibt eine Liste zurück.

Python 2 + NumPy , 62 Bytes

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

Probieren Sie es online!

Nach wie vor habe ich diese Lösung der obigen beigefügt, da sie im Wesentlichen gleichwertig ist. Beachten Sie, dass diese Funktion ein NumPy-Array und keine Python-Liste zurückgibt, sodass die Ausgabe bei Ihnen etwas anders aussiehtprint es .

numpy.ones(x)ist der "richtige" Weg, ein Array für die Verwendung mit NumPy zu erstellen, und daher könnte es anstelle von verwendet werden [x*[1]], aber es ist leider viel länger.