Poker Hand - Bestimmen eines vollen Hauses in F #

Question

Dieses Problem von meiner FullHouse-Funktion = wahr, wenn es ein Drei-Eine-Art ist. Die Funktion prüft auf ein 3 von einer Art und ein Paar, aber es erfüllt die Logik mit nur einer Drei einer Art (D, Ace) (C, Ace) (S, Ace) (D, Ten) (D, 9) . Dies ist kein volles Haus, aber es erlaubt den gleichen 3 Assen, sowohl das Paar UND die 3 einer Art zu befriedigen.

Wie schränke ich das ein, damit es die 3 einer Art nicht in ein Paar reduzieren kann?

---

Vielen Dank!

EDIT: F # Newbie

EDIT_2: Ein volles Haus ist, wenn aus der Hand von 5 Karten, die Sie ein 3 einer Art (3 den gleichen Wert haben (Anzug spielt keine Rolle, aber sie müssen sein 3x Asse oder 3x Zehner usw.)) und ein Paar (2x Zehner, 2x 8er usw. - Anzug spielt keine Rolle)

Eingang:

fullHouse [(D, K);(C, K);(S, K);(D, T);(D, V 9)];; 

Erwartete Ausgabe: false, tatsächlicher Ausgang: Wahr

Eingang:

fullHouse [(D, K);(C, K);(S, K);(D, T);(C, T)];; 

Erwartete Ausgabe: Stimmt, Tatsächliche Leistung: Echte

Answer 1

auf diesem Meiner Meinung wäre, alle Fälle von vier einer Art zu handhaben, Full House, Dreifach-, Paar oder keinem das alles zusammen.

Um dies zu tun, würde ich List.groupBy verwenden, um nach Kartenwerten zu gruppieren. Dadurch erhalten Sie eine Liste von Listen für jede Gruppe mit demselben Kartenwert. Zum Beispiel:

[(D, K);(C, K);(S, K);(D, T);(D, V 9)] |> List.groupBy (snd);; 

gibt das Ergebnis:

[(K, [(D, K); (C, K); (S, K)]); (T, [(D, T)]); (V 9, [(D, V 9)])] 

d.h. eine Liste von drei Kings, eine Liste mit einer Zehn und eine Liste von einer Neun.

Jetzt müssen Sie nur sicherstellen, dass die längsten Unterlisten am Anfang für einen bequemen Musterabgleich erscheinen. Ordnen Sie diese Liste einfach nach der Anzahl der Karten in jeder Unterliste an und dann können Sie ein Muster mit der Hand vergleichen, um das Ergebnis zu erhalten .

let (|FourOfKind|FullHouse|Triple|Pair|Other|) hand = 
    let groups = hand |> List.groupBy (snd) |> List.sortByDescending (List.length << snd) 
    match groups with 
    |(v, [c1; c2; c3; c4]) :: rest -> FourOfKind (c1, c2, c3, c4) 
    |(v, [c1; c2; c3]) :: (v2, [c4; c5]) :: rest -> FullHouse(c1, c2, c3, c4, c5) 
    |(v, [c1; c2; c3]) :: rest -> Triple(c1, c2, c3) 
    |(v, [c1; c2]) :: rest -> Pair(c1, c2) 
    |_ -> Other 

Sie könnten dann tun, z.B.

let printHand = function 
    |FourOfKind _ -> printfn "Four of a Kind" 
    |FullHouse _ -> printfn "Full House" 
    |Triple _ -> printfn "Triple" 
    |Pair _ -> printfn "Pair" 
    |Other -> printfn "Other" 

Dann in fsi:

printHand [(D, K);(C, K);(S, K);(D, T);(D, V 9)];; 
Triple 

printHand [(D, K);(C, K);(S, K);(D, T);(C, T)];; 
Full House