Geben Sie bei zwei positiven ganzen Zahlen aund bdie Häufigkeitsverteilung der rollenden a- bseitigen Würfelzeiten aund der Summierung der Ergebnisse aus.

Eine Häufigkeitsverteilung listet die Häufigkeit jeder möglichen Summe auf, wenn jede mögliche Folge von Würfeln einmal auftritt. Die Frequenzen sind also ganze Zahlen, deren Summe gleich ist b**a.

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.

Testfälle

Format: a b: output

1 6: [1, 1, 1, 1, 1, 1]
2 6: [1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1]
3 6: [1, 3, 6, 10, 15, 21, 25, 27, 27, 25, 21, 15, 10, 6, 3, 1]
5 2: [1, 5, 10, 10, 5, 1]
6 4: [1, 6, 21, 56, 120, 216, 336, 456, 546, 580, 546, 456, 336, 216, 120, 56, 21, 6, 1]
10 10: [1, 10, 55, 220, 715, 2002, 5005, 11440, 24310, 48620, 92368, 167860, 293380, 495220, 810040, 1287484, 1992925, 3010150, 4443725, 6420700, 9091270, 12628000, 17223250, 23084500, 30427375, 39466306, 50402935, 63412580, 78629320, 96130540, 115921972, 137924380, 161963065, 187761310, 214938745, 243015388, 271421810, 299515480, 326602870, 351966340, 374894389, 394713550, 410820025, 422709100, 430000450, 432457640, 430000450, 422709100, 410820025, 394713550, 374894389, 351966340, 326602870, 299515480, 271421810, 243015388, 214938745, 187761310, 161963065, 137924380, 115921972, 96130540, 78629320, 63412580, 50402935, 39466306, 30427375, 23084500, 17223250, 12628000, 9091270, 6420700, 4443725, 3010150, 1992925, 1287484, 810040, 495220, 293380, 167860, 92368, 48620, 24310, 11440, 5005, 2002, 715, 220, 55, 10, 1]
5 50: [1, 5, 15, 35, 70, 126, 210, 330, 495, 715, 1001, 1365, 1820, 2380, 3060, 3876, 4845, 5985, 7315, 8855, 10626, 12650, 14950, 17550, 20475, 23751, 27405, 31465, 35960, 40920, 46376, 52360, 58905, 66045, 73815, 82251, 91390, 101270, 111930, 123410, 135751, 148995, 163185, 178365, 194580, 211876, 230300, 249900, 270725, 292825, 316246, 341030, 367215, 394835, 423920, 454496, 486585, 520205, 555370, 592090, 630371, 670215, 711620, 754580, 799085, 845121, 892670, 941710, 992215, 1044155, 1097496, 1152200, 1208225, 1265525, 1324050, 1383746, 1444555, 1506415, 1569260, 1633020, 1697621, 1762985, 1829030, 1895670, 1962815, 2030371, 2098240, 2166320, 2234505, 2302685, 2370746, 2438570, 2506035, 2573015, 2639380, 2704996, 2769725, 2833425, 2895950, 2957150, 3016881, 3075005, 3131390, 3185910, 3238445, 3288881, 3337110, 3383030, 3426545, 3467565, 3506006, 3541790, 3574845, 3605105, 3632510, 3657006, 3678545, 3697085, 3712590, 3725030, 3734381, 3740625, 3743750, 3743750, 3740625, 3734381, 3725030, 3712590, 3697085, 3678545, 3657006, 3632510, 3605105, 3574845, 3541790, 3506006, 3467565, 3426545, 3383030, 3337110, 3288881, 3238445, 3185910, 3131390, 3075005, 3016881, 2957150, 2895950, 2833425, 2769725, 2704996, 2639380, 2573015, 2506035, 2438570, 2370746, 2302685, 2234505, 2166320, 2098240, 2030371, 1962815, 1895670, 1829030, 1762985, 1697621, 1633020, 1569260, 1506415, 1444555, 1383746, 1324050, 1265525, 1208225, 1152200, 1097496, 1044155, 992215, 941710, 892670, 845121, 799085, 754580, 711620, 670215, 630371, 592090, 555370, 520205, 486585, 454496, 423920, 394835, 367215, 341030, 316246, 292825, 270725, 249900, 230300, 211876, 194580, 178365, 163185, 148995, 135751, 123410, 111930, 101270, 91390, 82251, 73815, 66045, 58905, 52360, 46376, 40920, 35960, 31465, 27405, 23751, 20475, 17550, 14950, 12650, 10626, 8855, 7315, 5985, 4845, 3876, 3060, 2380, 1820, 1365, 1001, 715, 495, 330, 210, 126, 70, 35, 15, 5, 1]

Oktave , 38 Bytes

@(a,b)round(ifft(fft((a:a*b<a+b)).^a))

Probieren Sie es online!

Erläuterung

Das Hinzufügen unabhängiger Zufallsvariablen entspricht dem Falten ihrer Wahrscheinlichkeitsmassenfunktionen (PMF) oder dem Multiplizieren ihrer charakteristischen Funktionen (CF). Somit ist die CF der Summe aunabhängiger, gleichverteilter Variablen gegeben durch die einer einzelnen Variablen, die hoch genug ist von a.

Die CF ist im Wesentlichen die Fourier-Transformation der PMF und kann somit über eine FFT berechnet werden. Die PMF einer einzelnen b-sided Matrize ist einheitlich auf 1, 2, ..., b. Es sind jedoch zwei Änderungen erforderlich:

• 1wird anstelle der tatsächlichen Wahrscheinlichkeitswerte ( 1/b) verwendet. Auf diese Weise wird das Ergebnis de-normalisiert und enthält nach Bedarf ganze Zahlen.
• Das Auffüllen mit Nullen ist erforderlich, damit die FFT-Ausgabe die entsprechende Größe ( a*b-a+1) hat und das implizite periodische Verhalten, das von der FFT angenommen wird, die Ergebnisse nicht beeinflusst.

Sobald die charakteristische Funktion der Summe erhalten wurde, wird eine inverse FFT verwendet, um das Endergebnis zu berechnen, und es wird eine Rundung angewendet, um Gleitkommaungenauigkeiten zu korrigieren.

Beispiel

Betrachten Sie Eingänge a=2, b=6. Der Code erstellt a:a*b<a+beinen Vektor mit b=6Einsen, der auf die Größe Null aufgefüllt ist a*b-a+1:

[1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0]

Dann fft(...)gibt

[36, -11.8-3.48i, 0.228+0.147i, -0.949-1.09i, 0.147+0.321i, -0.083-0.577i, -0.083+0.577i, 0.147-0.321i, -0.949+1.09i, 0.228-0.147i, -11.8+3.48i]

Man kann hier fast die sinc-Funktion erkennen (Fourier-Transformation eines Rechteckimpulses).

(...).^aWirft jeden Eintrag auf aund ifft(...)nimmt dann die inverse FFT, die gibt

[1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1]

Obwohl die Ergebnisse in diesem Fall genau Ganzzahlen sind, kann es im Allgemeinen zu relativen Fehlern in der Größenordnung kommen 1e-16, weshalb dies round(...)erforderlich ist.

Mathematica, 29 Bytes

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

Erzeugt einfach alle möglichen Würfelwürfe, nimmt deren Gesamtwerte und zählt dann. Jede Frequenz ist mit ihrem Wert gekennzeichnet.

Mathematica, 38 Bytes

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

Erweitert (1+x+x^2+...+x^(a-1))^bund nimmt die Koeffizienten von x. Da 1+x+x^2+...+x^(a-1)die Erzeugungsfunktion für einen einzelnen Würfelwurf und Produkte Windungen entsprechen - Additionswerte von Würfeln - ergibt das Ergebnis die Häufigkeitsverteilung.

Haskell , 90 79 77 75 Bytes

Vielen Dank an Lynn für den kartesischen Produkttrick . -11 Bytes dank vieler Haskell-Tricks von Funky Computer Man, -2 Bytes durch Namensgebung, -2 Bytes dank Laikoni. Golfvorschläge sind willkommen! Probieren Sie es online!

import Data.List
g x=[1..x]
a!b=map length$group$sort$map sum$mapM g$b<$g a

Ungolfed

import Data.List
rangeX x = [1..x]
-- sums of all the rolls of b a-sided dice
diceRolls a b = [sum y | y <- mapM rangeX $ fmap (const b) [1..a]]
-- our dice distribution
distrib a b = [length x | x <- group(sort(diceRolls a b))]

Pyth - 10 Bytes

Nimmt einfach alle möglichen Würfelkombinationen, indem das kartesische Produkt von [1, b], aZeiten, Summierung und Länge jeder Summengruppe genommen wird.

lM.gksM^SE

Test Suite .

05AB1E , 8 Bytes

LIãO{γ€g

Probieren Sie es online!

Wie?

LIãO {γ € g - Volles Programm.

L - Bereich [1 ... Eingang Nr. 1]
 I - Eingang Nr. 2.
  ã - Kartesische Kraft.
   O - Karte mit Summe.
    {- Sortieren.
     γ - Gruppieren Sie aufeinanderfolgende gleiche Elemente.
      € g - Holen Sie sich die Länge von jedem

R , 58 Bytes

function(a,b)table(rowSums(expand.grid(rep(list(1:b),a))))

Probieren Sie es online!

R , 52 Bytes

function(a,b)Re(fft(fft(a:(a*b)<a+b)^a,T)/(a*b-a+1))

Probieren Sie es online!

Ein Port des @Luis Mendo des Octave Lösung , fft(z, inverse=T)gibt leider die nicht normalisieren inverse FFT, so dass wir durch die Länge zu unterteilen, und es gibt einen complexVektor, so dass wir nur den Realteil nehmen.

SageMath, 40 Bytes

lambda a,b:reduce(convolution,[[1]*b]*a)

Probieren Sie es online aus

convolutionberechnet die diskrete Faltung zweier Listen. reducetut was es verspricht [1]*bist eine Liste von b 1s, der Häufigkeitsverteilung von 1db. [[1]*b]*aerstellt eine verschachtelte Liste von aKopien von b 1s.

Python 2 + NumPy , 56 Bytes

lambda a,b:reduce(numpy.convolve,[[1]*b]*a)
import numpy

Probieren Sie es online!

Ich habe diese Lösung in die obige eingeschlossen, da sie im Wesentlichen gleichwertig ist. Beachten Sie, dass diese Funktion ein NumPy-Array und keine Python-Liste zurückgibt, sodass die Ausgabe etwas anders aussieht, wenn Sie printes tun .

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

Gelee , 5 Bytes

ṗS€ĠẈ

Probieren Sie es online!

Beachten Sie, dass dies die Argumente in umgekehrter Reihenfolge nimmt.

Wie?

ṗS € ĠL € - Volles Programm (dyadisch) | Beispiel: 6, 2

ṗ - Kartesische Potenz (mit implizitem Bereich) | [[1, 1], [1, 2], ..., [6, 6]]
 S € - Summe je | [2, 3, 4, ..., 12]
   Ġ - Indizes nach Werten gruppieren | [[1], [2, 7], [3, 8, 13], ..., [36]]
    L € - Länge jeder Gruppe | [1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1]

Alternativlösungen:

ṗZSĠL€
ṗZSµLƙ
ṗS€µLƙ

Python 2 , 102 91 Bytes

lambda b,a:map(map(sum,product(*[range(a)]*b)).count,range(b*~-a+1))
from itertools import*

Probieren Sie es online!

Haskell , 61 Bytes

g x=[1..x]
a#b=[sum[1|m<-mapM g$b<$g a,sum m==n]|n<-[a..a*b]]

Probieren Sie es online! Verwenden Sie als a#b.

Teilweise basierend auf Sherlock9s Haskell-Antwort .

MATL , 9 Bytes

:Z^!Xs8#u

Gleicher Ansatz wie Maltysens Pyth-Antwort .

Die Eingaben erfolgen in umgekehrter Reihenfolge. Probieren Sie es online!

Pari / GP , 28 Bytes

a->b->Vec(((x^b-1)/(x-1))^a)

Probieren Sie es online!

Perl 5 , 53 Bytes

$g=join',',1..<>;map$r[eval]++,glob"+{$g}"x<>;say"@r"

Probieren Sie es online!

Eingabeformat:

b
a

JavaScript (ES6), 94 Byte

f=(n,m,a=[1],b=[])=>n?[...Array(m)].map((_,i)=>a.map((e,j)=>b[j+=i]=(b[j]|0)+e))&&f(n-1,m,b):a

<div oninput=o.textContent=f(+n.value,+m.value).join`\n`><input id=n type=number min=0 value=0><input id=m type=number min=1 value=1><pre id=o>1

Begrenzt durch 32-Bit-Integer-Überlauf, aber Floats können stattdessen zu einem Preis von 1 Byte verwendet werden.

J , 25 24 21 20 Bytes

3 :'#/.~,+//y$i.{:y'

Probieren Sie es online!

Anfangs habe ich die [0..n-1] -Liste inkrementiert, um [1..n] zu erhalten, aber anscheinend ist dies nicht erforderlich.

Javascript (ES6), 89 Byte

b=>g=a=>a?(l=[..."0".repeat(b-1),...g(a-1)]).map((_,i)=>eval(l.slice(i,i+b).join`+`)):[1]

Nimmt Eingaben in umgekehrter Reihenfolge vor f(b)(a)

f=b=>g=a=>a>0?(l=[..."0".repeat(b-1),...g(a-1)]).map((_,i)=>eval(l.slice(i,i+b).join`+`)):[1]
r=_=>{o.innerText=f(+inb.value)(+ina.value)}

<input id=ina type=number min=0 onchange="r()" value=0>
<input id=inb type=number min=1 onchange="r()" value=1>
<pre id=o></pre>

Eigentlich , 13 12 Bytes

-1 Byte danke an Herrn Xcoder. Probieren Sie es online!

R∙♂Σ;╗╔⌠╜c⌡M

Ungolfed

                Implicit input: b, a
R∙              ath Cartesian power of [1..b]
  ♂Σ            Get all the sums of the rolls, call them dice_rolls
    ;╗          Duplicate dice_rolls and save to register 0
      ╔         Push uniquify(dice_rolls)
       ⌠  ⌡M    Map over uniquify(dice_rolls), call the variable i
        ╜         Push dice_rolls from register 0
         c        dice_rolls.count(i)
                Implict return

AWK , 191 Bytes

Gibt Frequenzen als vertikale Spalte aus.

func p(z){for(m in z)S[z[m]]++
for(i=$1;i<=$1*$2;i++)print S[i]}func t(a,b,z,s){if(a){if(R++)for(n in z)for(i=0;i++<b;)s[n,i]=z[n]+i
else for(i=0;i++<b;)s[i]=i
t(--a,b,s)}else p(z)}{t($1,$2)}

Probieren Sie es online!

Das Hinzufügen von 6 weiteren Bytes ermöglicht mehrere Sätze von Eingaben.

func p(z,S){for(m in z)S[z[m]]++
for(i=$1;i<=$1*$2;i++)print S[i]}func t(a,b,z,s){if(a){if(R++)for(n in z)for(i=0;i++<b;)s[n,i]=z[n]+i
else for(i=0;i++<b;)s[i]=i
t(--a,b,s)}else p(z)}{R=0;t($1,$2)}

Probieren Sie es online!

Clojure, 86 Bytes

#(sort-by key(frequencies(reduce(fn[r i](for[y(range %2)x r](+ x y 1)))[0](range %))))

Ein Beispiel:

(def f #(...))
(f 5 4)

([5 1] [6 5] [7 15] [8 35] [9 65] [10 101] [11 135] [12 155] [13 155] [14 135] [15 101] [16 65] [17 35] [18 15] [19 5] [20 1])

C (gcc) , 142 Bytes

i,j,k;int*f(a,b){int*r=malloc(sizeof(int)*(1+a*~-b));r[0]=1;for(i=1;i<=a;i++)for(j=i*~-b;j>=0;j--)for(k=1;k<b&k<=j;k++)r[j]+=r[j-k];return r;}

Probieren Sie es online!

Julia , 43 Bytes

f(n,d)=reduce(conv,repmat([ones(Int,d)],n))

Probieren Sie es online!