Ein Kartenspiel ist 52. Eine Hand ist 5 Karten von den 52 (kann kein Duplikat haben).
Was ist die geringste Anzahl von Bits, um eine 5-Karten-Hand darzustellen, und wie?
Eine Hand ist NICHT auftragsabhängig (KQ = QK). 64329 = 96432
Ja, kann 52 Bit verwenden. Das kann eine Hand aus beliebig vielen Karten darstellen.
Wenn eine Hand genau 5 Karten hat, gibt es eine Möglichkeit, sie mit weniger als 52 Bit darzustellen.
Eine einzelne Karte kann mit 6 Bit = 64 dargestellt werden. Es können also nur 6 Bit * 5 Karten = 30 Bit verwendet werden. Das wäre aber auftragsabhängig. Ich könnte einfach sortieren und das sollte funktionieren. Wenn das nicht funktionieren würde, lass es mich wissen.
Gibt es eine Möglichkeit, den Schlüssel auf 32 Bit oder weniger zu bringen und das 5-Karten-Tupel nicht sortieren zu müssen?
Dies ist für Pokersimulationen gedacht und das Sortieren wäre viel Aufwand im Vergleich zum Generieren der Hand. Wenn ich ein Wörterbuch mit dem relativen Wert jeder Hand habe, sind es zwei einfache Suchvorgänge und ein Vergleich, um den Wert zweier Hände zu vergleichen. Wenn ich zuerst die Hände sortieren muss, ist das im Vergleich zu zwei Suchvorgängen und einem Vergleich groß. In einer Simulation werden Millionen verglichen. Ich werde keine sortierten Hände von der Simulation bekommen. Die Sortierung ist nicht einfach wie 52 51 50 49 48 vor 52 51 50 49 47. Sie können gerade bündige Quads haben ....
Es sind 2598960 5 Kartenhände möglich. Das ist die Anzahl der Zeilen. Der Schlüssel sind die 5 Karten. Ich möchte einen Schlüssel mit 32 Bit oder weniger erhalten, bei dem die Karten nicht zuerst sortiert werden müssen.
Kann nicht einfach die Liste bestellen, da viele Hände binden. Anzug sind Spaten, Keule, Diamant und Herz. 7c 8c 2d 3d 4s = 7s 8s 2c 3c 4h. Es gibt eine große Anzahl von Bindungen.
Der nächste Schritt ist 64 Bit und führt zu einem Treffer der Art, anstatt die Größe des Schlüssels zu verdoppeln.
Ich habe SortedSet<int> quickSort = new SortedSet<int>() { i, j, k, m, n };die Operationszeit getestet und verdoppelt, aber ich kann es trotzdem tun.
Es wird komplexer. Ich muss in der Lage sein, ein Boot zu zweit über fünf darzustellen (22255). Das Sortieren bricht das also. Ich weiß, dass du sagen wirst, aber das geht schnell. Ja, es ist schnell und trivial, aber ich brauche so schnell wie möglich.
C # für die akzeptierte Antwort:
private int[] DeckXOR = new int[] {0x00000001,0x00000002,0x00000004,0x00000008,0x00000010,0x00000020,0x00000040,
0x00000080,0x00000100,0x00000200,0x00000400,0x00000800,0x00001000,0x00002000,
0x00004000,0x00008000,0x00010000,0x00020000,0x00040000,0x00080000,0x00100000,
0x00200000,0x00400000,0x00800000,0x01000000,0x02000000,0x04000000,0x07fe0000,
0x07c1f000,0x0639cc00,0x01b5aa00,0x056b5600,0x04ed6900,0x039ad500,0x0717c280,
0x049b9240,0x00dd0cc0,0x06c823c0,0x07a3ef20,0x002a72e0,0x01191f10,0x02c55870,
0x007bbe88,0x05f1b668,0x07a23418,0x0569d998,0x032ade38,0x03cde534,0x060c076a,
0x04878b06,0x069b3c05,0x054089a3};
public void PokerProB()
{
Stopwatch sw = new Stopwatch();
sw.Start();
HashSet<int> cardsXOR = new HashSet<int>();
int cardXOR;
int counter = 0;
for (int i = 51; i >= 4; i--)
{
for (int j = i - 1; j >= 3; j--)
{
for (int k = j - 1; k >= 2; k--)
{
for (int m = k - 1; m >= 1; m--)
{
for (int n = m - 1; n >= 0; n--)
{
counter++;
cardXOR = DeckXOR[i] ^ DeckXOR[j] ^ DeckXOR[k] ^ DeckXOR[m] ^ DeckXOR[n];
if (!cardsXOR.Add(cardXOR))
Debug.WriteLine("problem");
}
}
}
}
}
sw.Stop();
Debug.WriteLine("Count {0} millisec {1} ", counter.ToString("N0"), sw.ElapsedMilliseconds.ToString("N0"));
Debug.WriteLine("");
}