Bestimmen Sie die Häufigkeit der zahlen zeigt sich in Würfel Rollen

Für ein Spiel, das ich bin versucht zu bestimmen, die Häufigkeit, mit der ein bestimmter # zeigen sich bei einer bestimmten Anzahl der Würfel gerollt werden. Ich weiß... diese Frage scheint seltsam. Lassen Sie mich versuchen es zu erklären mit reellen zahlen.

So, für 1 sterben, die Frequenz für jede Zahl identisch sein. 1-6 die show wird die gleiche Anzahl von Zeiten.

Nun für 2 Würfel, die Dinge anders. Ich kann mir vorstellen 5,6,7 werden die meisten Häufig gerollt, während die zahlen an beiden enden des Spektrums zeigen sich weniger oder gar nicht (im Fall 1). Ich würde gerne wissen, wie die Berechnung dieser Liste und zeigen Sie Sie in der richtigen Reihenfolge, von den meisten häufigen zum weniger häufigen.

Irgendwelche Gedanken?

@duffymo - Es wäre wirklich schön, wenn um irgendeine Art von einem Algorithmus zu kommen mit ihm. Es scheint, dass in der oben beschriebenen Weise wird erfordern eine Menge von hand aufnehmen und ablegen von zahlen. Wenn mein sterben zu zählen ist dynamisch bis zu sagen wir 10, tun, von hand wirkungsloser und lästig, denke ich. 🙂

Sind Sie mit dem hinzufügen der zahlen? Warum hast du zu dem Schluss kommen, 5,6 und 7 würde zeigen, bis mehr?
es könnte sein, dass mir nur unter der Annahme falsch, dass 5,6,7 würde häufiger sein - aber ich Stütze diese Annahme auf der Tatsache, dass eine Rolle zu 5 könnte 2+3 & 4+1 in der Erwägung, dass eine 3 kann nur zeigen, bis mit einem 2+1; sechs 3+3, 4+2, 5+1; etc.

InformationsquelleAutor bugfixr | 2009-01-29

3

Groben Entwurf einer rekursiven Art und Weise, es zu tun:
```
public static IEnumerable<KeyValuePair<int, int>> GetFrequenciesByOutcome(int nDice, int nSides)
{
    int maxOutcome = (nDice * nSides);
    Dictionary<int, int> outcomeCounts = new Dictionary<int, int>();
    for(int i = 0; i <= maxOutcome; i++)
        outcomeCounts[i] = 0;

    foreach(int possibleOutcome in GetAllOutcomes(0, nDice, nSides))
        outcomeCounts[possibleOutcome] = outcomeCounts[possibleOutcome] + 1;

    return outcomeCounts.Where(kvp => kvp.Value > 0);
}

private static IEnumerable<int> GetAllOutcomes(int currentTotal, int nDice, int nSides)
{
    if (nDice == 0) yield return currentTotal;
    else
    {
        for (int i = 1; i <= nSides; i++)
            foreach(int outcome in GetAllOutcomes(currentTotal + i, nDice - 1, nSides))
                yield return outcome;
    }
}
```
Wenn ich mich nicht Irre, sollte dies ausspucken KeyValuePairs organisiert wie die [- Taste, Frequenz].

BEARBEITEN: FYI, nach dem ausführen dieser, es zeigt die Frequenzen für GetFrequenciesByOutcome(2, 6) zu sein:

2: 1

3: 2

4: 3

5: 4

6: 5

7: 6

8: 5

9: 4

10: 3

11: 2

12: 1
- Ich Frage mich, warum das downvoted, da sonst niemand zur Verfügung gestellt hat, einen Algorithmus.
- Stimmt nicht - siehe Antwort #1.
- #1 ist eine Berechnung, und nicht ein Algorithmus. Es wurde vorgeschlagen, dass die Berechnung manuell durchgeführt werden, und dann die Tabelle hard-codiert (AUA) - ich würde viel lieber ein echtes Algorithmus so, als manuell die Berechnung der zahlen und codieren Sie.
- Der Algorithmus ist relativ einfach wie bubblesort ist...und mit ähnlicher Effizienz Probleme. Es ist die nur - Algorithmus vorgestellt, so weit, aber für große zahlen, es geht um weitaus intensiver als nötig. Besser, einfach nur code die Mathematik dahinter. (Einige andere Beiträge über links auf die Mathematik).
- Das ist richtig, die Mathematik ist besser. Der Algorithmus ist nur eine einfache simulation von allen möglichen würfeln, die, wie Sie sich vorstellen können, könnte eine Menge von Rollen der Würfel.
InformationsquelleAutor mqp
11

Gibt es 6*6 = 36 Kombinationen für zwei Würfel.

2 = 1+1 nur einmal vorkommen kann, also seine Frequenz ist 1/36.
3 = 1+2 oder 2+1, also seine Frequenz ist 2/36 = 1/18.
4 = 1+3, 2+2, oder 3+1, also seine Frequenz ist, 3/36 = 1/12.

Können Sie den rest heraus, bis zwölf.

Jeder backgammon-Spieler kennt diese gut.

InformationsquelleAutor duffymo
5

Gibt es kein echtes "Algorithmus" oder simulation notwendig - es ist eine einfache Rechnung basierend auf einem abgeleiteten Formel von De Moivre:

http://www.mathpages.com/home/kmath093.htm

Und es ist nicht ein "bell-Kurve" - oder normal-Verteilung.
- Nicht eine Glockenkurve? Sie sich da sicher? Ich meine, es ist bestimmt geformt wie eine Glocke, obwohl ich gebe zu, dass meine Statistiken sind schwach genug, dass ich überzeugt werden konnte, es war nicht "normal" - Verteilung, und vielleicht nicht die klassische "Glockenkurve".
- (BTW, toller link...ich werde abstimmen, falls man mich überzeugen kann, dass es nicht wirklich eine Glockenkurve.)
- Es ist eine diskrete Verteilung, also konnte es nicht sein, eine echte Normalverteilung. Jedoch, wie die meisten Distributionen, es ist asymptotisch normal - für eine große Anzahl von würfeln, die normale Verteilung ist eine bessere Näherung (und technisch einfacher).
- Das ist in Ordnung...das, was ich dachte, und ich abgesichert, dass die Art und Weise in meinem Beitrag: dass es annähernd eine Normalverteilung. Das war das problem ich hatte mit dieser Antwort...es bedeutet, Sie sind zwei verschiedene Tiere, anstatt nur eine Frage der Streckung der Iterationen aus, um die Unendlichkeit.
- Je größer die Anzahl der Würfel, je näher die Annäherung an eine Normalverteilung. Aus diesem Grund (die faktorielle in der Kombinatorik) für eine große Anzahl von Würfel der Normalverteilung verwendet werden kann, mehr schnell.
InformationsquelleAutor Cade Roux

Fügen Sie das array von der Frequenz des vorherigen Rollen, 'Seite' Zeiten durch die Verlagerung der position, dann werden Sie das array der Frequenzen, die jeder zahlen zeigen.

1, 1, 1, 1, 1, 1  # 6 sides, 1 roll

1, 1, 1, 1, 1, 1
   1, 1, 1, 1, 1, 1
      1, 1, 1, 1, 1, 1
         1, 1, 1, 1, 1, 1
            1, 1, 1, 1, 1, 1
+              1, 1, 1, 1, 1, 1
_______________________________
1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1  # 6 sides, 2 rolls

1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1
   1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1
      1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1
         1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1
            1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1
+              1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1
______________________________________________
1, 3, 6,10,15,21,25,27,27,25,21,15,10, 6, 3, 1  # 6 sides, 3 rolls

Dies ist viel schneller als brute-force-simulation, da die einfache Gleichung ist die beste.
Hier ist mein Python ist3 Umsetzung.

def dice_frequency(sides:int, rolls:int) -> list:
    if rolls == 1:
        return [1]*sides
    prev = dice_frequency(sides, rolls-1)
    return [sum(prev[i-j] for j in range(sides) if 0 <= i-j < len(prev))
            for i in range(rolls*(sides-1)+1)]

beispielsweise

dice_frequency(6,1) == [1, 1, 1, 1, 1, 1]
dice_frequency(6,2) == [1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1]
dice_frequency(6,3) == [1, 3, 6, 10, 15, 21, 25, 27, 27, 25, 21, 15, 10, 6, 3, 1]

Beachten Sie, dass Sie verwenden sollten 'target number - roll count' index der Liste zu bekommen die Häufigkeit jeder Zahl. Wenn Sie möchten, um Wahrscheinlichkeiten verwenden 'Seite'^'roll count' als Nenner.

sides = 6
rolls = 3
freq = dice_frequency(sides,rolls)
freq_sum = sides**rolls
for target in range(rolls,rolls*sides+1):
    index = target-rolls
    if 0 <= index < len(freq):
        print("%2d : %2d, %f" % (target, freq[index], freq[index]/freq_sum))
    else:
        print("%2d : %2d, %f" % (target, 0, 0.0))

Dieser code yeilds

 3 :  1, 0.004630
 4 :  3, 0.013889
 5 :  6, 0.027778
 6 : 10, 0.046296
 7 : 15, 0.069444
 8 : 21, 0.097222
 9 : 25, 0.115741
10 : 27, 0.125000
11 : 27, 0.125000
12 : 25, 0.115741
13 : 21, 0.097222
14 : 15, 0.069444
15 : 10, 0.046296
16 :  6, 0.027778
17 :  3, 0.013889
18 :  1, 0.004630

InformationsquelleAutor jinhwanlazy

2

Es gibt viele Sachen online zu würfeln Wahrscheinlichkeit. Hier ist ein link, der mir geholfen mit einem Projekt Euler-Frage:

http://gwydir.demon.co.uk/jo/probability/calcdice.htm

InformationsquelleAutor Dana
1

Ordentlich factoid...

Wussten Sie, dass Pascal ' s Dreieck ist die Wahrscheinlichkeit Verteilung der Summen von N 2-seitige Würfel?
```
   1 1    - 1 die, 1 chance at 1, 1 chance at 2
  1 2 1   - 2 dice, 1 chance at 2, 2 chances at 3, 1 chance at 4
 1 3 3 1  - 3 dice, 1 chance at 3, 3 chances at 4, 3 chances at 5, 1 chance at 6 
1 4 6 4 1 - etc.
```
- Das ist ordentlich! Jetzt bin ich darüber nachdenken, wie wir verallgemeinern dieses iterative dachte Prozess (wie erstellen Sie eine Zeile nach der nächsten in Pascal ' s triangle) M-seitige Würfel.
InformationsquelleAutor Instantsoup
1

JavaScript-Implementierung mit dynamischer Funktion-Erstellung:
```
<script>
var f;
function prob(dice, value)
 {
var f_s = 'f = function(dice, value) {var occur = 0; var a = [];';
for (x = 0; x < dice; x++)
 {
f_s += 'for (a[' + x + '] = 1; a[' + x + '] <= 6; a[' + x + ']++) {';
 }
f_s += 'if (eval(a.join(\'+\')) == value) {occur++;}';
for (x = 0; x < dice; x++)
 {
f_s += '}';
 }
f_s += 'return occur;}';
eval(f_s);
var occ = f(dice, value);
return [occ, occ + '/' + Math.pow(6, dice), occ /Math.pow(6, dice)];
 };

alert(prob(2, 12)); //2 die, seeking 12
                    //returns array [1, 1/36, 0.027777777777777776]
</script>
```
EDIT: Eher enttäuscht, niemand hat darauf hingewiesen; ersetzen musste 6 * dice mit Math.pow(6, dice). Keine Verwechslungen mehr, wie die...
- Ich bin neugierig, warum Sie wählten diese Besondere Ausrufezeichen. : )
- Denn dies ist eine viel mehr angenehm, unterhaltsam Weg, code zu schreiben, als das, was ich dazu neigen, in Richtung 🙂
- Ich denke auch so. Gerade erst vor kurzem entdeckt dynamischen Funktion für die Erstellung/änderung in JavaScript; froh, eine Verwendung für Sie finden.
InformationsquelleAutor Hexagon Theory
0

Scheint es einige Rätsel um genau das "warum" ist dies, und zwar duffymo erklärt hat, ein Teil davon, ich freue mich auf weitere post, der sagt:

Sollte es keinen Grund, warum 5, 6 und 7 sollten gerollt werden, mehr [als 2] da der erste Wurf der Würfel ist ein unabhängiges Ereignis von der zweiten Augenzahl und beide haben die gleiche Wahrscheinlichkeit von 1-6 gerollt.

Gibt es einen gewissen Reiz auf diese. Aber es ist falsch...weil die erste Rolle beeinflusst die Chancen. Die Argumentation kann wohl am leichtesten über ein Beispiel.

Sagen, ich bin versucht, herauszufinden, ob die Wahrscheinlichkeit des rollenden 2 oder 7 ist eher auf zwei Würfel. Wenn ich den ersten Würfel und bekommen eine 3, was sind meine Chancen jetzt von Rollen insgesamt 7? Offensichtlich, 1 in 6. Was sind meine Chancen, Rollen insgesamt 2? 0 in der 6...da gibt ' s nichts kann ich roll auf den zweiten Würfel zu haben, mein insgesamt 2.

Aus diesem Grund, 7 ist sehr (die meisten) wahrscheinlich gerollt werden...denn egal welche Rolle ich auf die zuerst sterben, kann ich trotzdem auf die richtige Summe durch würfeln der richtigen Zahl auf dem zweiten Würfel. 6 und 8 sind ebenso etwas weniger wahrscheinlich, 5 und 9, und so weiter, bis wir erreichen, 2 und 12, ebenso wenig bei 1 zu 36 chance pro Stück.

Wenn dir dieses Grundstück (Summe vs-Wahrscheinlichkeit) erhalten Sie eine schöne Glockenkurve (oder, genauer gesagt, eine blockartige aproximation einer wegen der diskreten Natur des Experiments).

InformationsquelleAutor Beska

Nach viel recherche im Internet und stackoverflow fand ich Dr. Math erklärt es auch in einem working-Funktion (ein link in der anderen Antwort hat, eine falsche Formel). Ich konvertiert Dr. Math ist der Formel zu C# und meine nUnit-tests (die hatte schon ausfallen, bevor Sie mit anderen versuche den code) alle bestanden.

Ersten hatte ich zu schreiben ein paar Hilfsfunktionen:

  public static int Factorial(this int x)
  {
     if (x < 0)
     {
        throw new ArgumentOutOfRangeException("Factorial is undefined on negative numbers");
     }
     return x <= 1 ? 1 : x * (x-1).Factorial();
  }

Wegen der Art, wie wählen funktioniert in der Mathematik, erkannte ich, könnte ich reduzieren auf die Berechnungen, wenn ich hatte eine überladene Funktion Factorial, die mit einer unteren Schranke. Diese Funktion kann aus der Patsche helfen, wenn die Untergrenze erreicht ist.

  public static int Factorial(this int x, int lower)
  {
     if (x < 0)
     {
        throw new ArgumentOutOfRangeException("Factorial is undefined on negative numbers");
     }
     if ((x <= 1) || (x <= lower))
     {
        return 1;
     }
     else
     {
        return x * (x - 1).Factorial(lower);
     }
  }

  public static int Choose(this int n, int r)
  {
     return (int)((double)(n.Factorial(Math.Max(n - r, r))) /((Math.Min(n - r, r)).Factorial()));
  }

Wenn diese an Ort und Stelle waren, war ich in der Lage zu schreiben

  public static int WaysToGivenSum(int total, int numDice, int sides)
  {
     int ways = 0;
     int upper = (total - numDice) /sides; //we stop on the largest integer less than or equal to this
     for (int r = 0; r <= upper; r++)
     {
        int posNeg = Convert.ToInt32(Math.Pow(-1.0, r)); //even times through the loop are added while odd times through are subtracted
        int top = total - (r * sides) - 1;
        ways += (posNeg * numDice.Choose(r) * top.Choose(numDice - 1));
     }
     return ways;
  }

InformationsquelleAutor Frank Luke

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.