Regex per calcolare mano di poker dritto?

Question

C'è una regex per calcolare mano di poker dritto?

sto usando stringhe per rappresentare le carte ordinate, come:

AAAAK#sssss = 4 aces and a king, all of spades.
A2345#ddddd = straight flush, all of diamonds.

In Java, sto usando queste espressioni regolari:

regexPair = Pattern.compile(".*(\\w)\\1.*#.*");
regexTwoPair = Pattern.compile(".*(\\w)\\1.*(\\w)\\2.*#.*");
regexThree = Pattern.compile(".*(\\w)\\1\\1.*#.*");
regexFour = Pattern.compile(".*(\\w)\\1{3}.*#.*");
regexFullHouse = Pattern.compile("((\\w)\\2\\2(\\w)\\3|(\\w)\\4(\\w)\\5\\5)#.*");
regexFlush = Pattern.compile(".*#(\\w)\\1{4}");

Come calcolare i valori dritto (sequenze) con regex?

Modifica

apro un'altra domanda per risolvere lo stesso problema, ma utilizzando il valore ASCII del char, per regex essere breve. Dettagli qui .

Grazie!

Answer 1

Devo ammettere che le espressioni regolari non sono il primo strumento avrei pensato di per fare questo. Posso tranquillamente garantire che qualsiasi RE in grado di farlo ad una mano indifferenziati sta per essere molto più orribile e molto meno leggibile rispetto al codice di procedura equivalente.

Supponendo che le carte sono ordinati per valore nominale (e sembrano essere altrimenti i vostri regex elencati non avrebbe funzionato o), e deve usare un'espressione regolare, è potrebbe utilizzare un costrutto come

2345A|23456|34567|...|9TJQK|TJQKA

per rilevare il valore nominale parte della mano.

In realtà, da quanto ho capito qui del mani "standard", di seguito devono essere controllati in ordine di priorità decrescente:

Royal/straight flush: "(2345A|23456|34567|...|9TJQK|TJQKA)#(\\w)\\1{4}"
Four of a kind:       ".*(\\w)\\1{3}.*#.*"
Full house:           "((\\w)\\2\\2(\\w)\\3|(\\w)\\4(\\w)\\5\\5)#.*"
Flush:                ".*#(\\w)\\1{4}"
Straight:             "(2345A|23456|34567|...|9TJQK|TJQKA)#.*"
Three of a kind:      ".*(\\w)\\1\\1.*#.*"
Two pair:             ".*(\\w)\\1.*(\\w)\\2.*#.*"
One pair:             ".*(\\w)\\1.*#.*"
High card:            (none)

In sostanza, quelli sono uguali ai suoi, tranne che ho aggiunto al Royal / straight flush e rettilineo. A condizione li si controlla in ordine, si dovrebbe ottenere il miglior punteggio dalla mano. Non c'è espressione regolare per la carta più alta dal momento che, a quel punto, è l'unico punteggio si può avere.

Ho cambiato anche la ruota in acciaio (avvolgente) rettilinei da A2345 a 2345A in quanto essi saranno ordinati in questo modo.

Answer 2

ho riscritto l'espressione regolare per questo, perché ho trovato frustrante e confusa. Raggruppamenti rendono molto più senso per questo tipo di logica. L'ordinamento è stato fatto usando un metodo sorta di matrice standard JavaScript quindi la strana ordine delle carte, sono in ordine alfabetico. Ho fatto il mio in javascript, ma l'espressione regolare potrebbe essere applicata ad java.

hands = [
    { regex: /(2345A|23456|34567|45678|56789|6789T|789JT|89JQT|9JKQT|AJKQT)#(.)\2{4}.*/g , name: 'Straight flush' },
    { regex: /(.)\1{3}.*#.*/g , name: 'Four of a kind' },
    { regex: /((.)\2{2}(.)\3{1}#.*|(.)\4{1}(.)\5{2}#.*)/g , name: 'Full house' },
    { regex: /.*#(.)\1{4}.*/g , name: 'Flush' },
    { regex: /(2345A|23456|34567|45678|56789|6789T|789JT|89JQT|9JKQT|AJKQT)#.*/g , name: 'Straight' },
    { regex: /(.)\1{2}.*#.*/g , name: 'Three of a kind' },
    { regex: /(.)\1{1}.*(.)\2{1}.*#.*/g , name: 'Two pair' },
    { regex: /(.)\1{1}.*#.*/g , name: 'One pair' },
  ];