[Mathematik] Wahrscheinlichkeitsrechnung für Karten

[Namenloser]

Wie viele Karten gibt es denn insgesamt? Gibt es insgesamt nur 13+2 Karten, oder gibt es Karten doppelt?

Also ich habe erst mal eine einfachere Variante ausgerechnet: Wie hoch ist die Wahrscheinlichkeit, dass man beim Ziehen von 5 Karten eine Summe von 26 legen kann? Dabei ist die Reihenfolge nicht berücksichtigt, d.h. die Karten werden alle in einem Rutsch gezogen, was der Startsituation entspricht.

Code:

# ruby
def calculatePropability(cards, n, remaining_sum)
  if (n <= 0) || (cards.empty?)
    return 0.0
  end

  propability = 0.0;

  cards.each_with_index do |card, index|
    # set of remaining cards
    new_cards = cards.clone;
    new_cards.delete_at(index);

    new_remaining_sum = remaining_sum - card;

    # we have won the game
    if new_remaining_sum == 0
      item_propability = 1.0
    # we have lost the game
    elsif new_remaining_sum < 0
      item_propability = 0.0
    else
      item_propability = calculatePropability(new_cards, n-1, new_remaining_sum);
    end

    # add up partial propabilities
    propability += (1.0/cards.count)*item_propability;
  end

  return propability;
end

cards = (1..13).to_a + [0,0]; # cards from 1 to 13, 2 jokers
n = 5;
sum = 26;

puts calculatePropability(cards, n, sum);

Nichts großartiges...

Die ausgegebene Wahrscheinlichkeit ist hier ungefähr 11.18%.

Wie gesagt, das Nachziehen ist nicht berücksichtigt, es wird nur ausgegeben, wie hoch die Wahrscheinlichkeit mit den 5 Start-Karten ist. Über das Nachziehen muss ich noch mal genauer nachdenken. Aber vielleicht ist der Algorithmus schon mal ein Ansatz...

Ich glaube, dass es letztendlich aber keine andere Berechnungsmöglichkeit gibt, als alle Möglichkeiten durchzuiterieren, sprich Bruteforce.

[Codewalker]

Zitat von NamenLozer:

Wie viele Karten gibt es denn insgesamt? Gibt es insgesamt nur 13+2 Karten, oder gibt es Karten doppelt?

13+2 ist richtig. Es gibt keine doppelten Karten.

Zitat von NamenLozer:

Ich glaube, dass es letztendlich aber keine andere Berechnungsmöglichkeit gibt, als alle Möglichkeiten durchzuiterieren, sprich Bruteforce.

Ich hoffe nicht

Und ja, der Algorithmus ist schonmal ein Anfang (auch wenn mein Ruby eingerostet ist)

[Namenloser]

Ich hab mir noch was überlegt, um die Anzahl der möglichen Züge für eine verbleibende Anzahl von Karten auf dem Stapel auszurechnen:

Code:

def calculatePossibilities(hand_count, stack_count)
  if stack_count <= 0
    # number of possible cards to play: hand_count
    hand_count
  else
    # number of possible cards to pick from stack: stack_count
    # number of possible cards to play: hand_count
    # remaining number of moves: calculatePossibilities(hand_count, stack_count-1)
    stack_count*hand_count*calculatePossibilities(hand_count, stack_count-1)
  end
end

puts calculatePossibilities(5, 13+2-5);

hand_count ist dabei einfach eine Konstante, die angibt wie viele Karten man in der Hand hält (5).

Hoffe ich hab da jetzt keinen Denkfehler. Damit ergeben sich 1.77×10¹⁴ mögliche Spielzüge.

Nur, wie man die beiden Ergebnisse jetzt verknüpft, bzw. ob man sie überhaupt verknüpfen kann, oder ob mein Ansatz kompletter murks ist, damit bin ich überfragt. Ich geb’s an dieser Stelle daher einfach mal auf... aber angefixt hast du mich.

Fände es sehr interessant, wenn jemand, der von Mathe mehr Ahnung hat als ich, hier doch noch eine Lösung postet.

[Codewalker]

Also, kurzes Update, zumindest zur Theorie:

Um die Anzahl der Permutationen zu reduzieren, kann man folgendes nutzen:

• Die Reihenfolge der ersten 5 Handkarten ist irrelevant
• Beide Gewinnkarten sind identisch zu behandeln (mach aus 15! schonmal 15!/2)
• Nach maximal 6 Karten muss die Summe 26 genau erreicht sein. Es gibt keine Kartenkombination mit >6 Karten, die Summe 26 ergibt

Man müsste also alle Permutationen aufzählen, wobei die ersten 5 Elemente zu sortieren sind.
Dann sind es in Summe (nur ) (15 über 5) * 10! = 10897286400
Immer noch viel, aber weniger als anfangs gedacht.