Poker

Paula Cazali

Modelacion y Simulacion 1

Los numeros de las cartas se iran tomando desde \(2\) a \(14\). Donde \(14\) representa el valor mas alto de las cartas que en este caso seria el A.

• Espadas: “E”
• Corazones: “C”
• Treboles: “T”
• Diamantes: “D”

library(plyr)
library(dplyr)

Se declaran los vectores con los numeros de cartas y un vector con los suits.

ranks_order_weight <- c('2'=2, '3'=3, '4'=4, '5'=5, '6'=6, '7'=7, '8'=8, '9'=9, 'T'=10, J=11, Q=12, K=13, A=14)
ranks <- names(ranks_order_weight)
ranks

 [1] "2" "3" "4" "5" "6" "7" "8" "9" "T" "J" "Q" "K" "A"

suit = c('E','C','T','D')
suit

[1] "E" "C" "T" "D"

Se define una funcion que genere el mazo completo de cartas. El proposito de esto es que no se generen dos cartas iguales de forma aleatoria.

newMazo <- function(ranks, suit){
  mazo <- c()
  for(rank in ranks){
    for(suitItem in suit){
      mazo <- c(mazo,paste(rank, suitItem, sep = "", collapse = NULL))
    }
  }
  return(mazo)
}

Generando el mazo de cartas:

mazo <- newMazo(ranks, suit)
mazo

 [1] "2E" "2C" "2T" "2D" "3E" "3C" "3T" "3D" "4E" "4C" "4T" "4D" "5E" "5C" "5T" "5D" "6E" "6C" "6T" "6D" "7E" "7C" "7T" "7D"
[25] "8E" "8C" "8T" "8D" "9E" "9C" "9T" "9D" "TE" "TC" "TT" "TD" "JE" "JC" "JT" "JD" "QE" "QC" "QT" "QD" "KE" "KC" "KT" "KD"
[49] "AE" "AC" "AT" "AD"

Funcion que genera cartas elegidas del mazo al azar.

#Funcion que genera una lista de n cantidad de cartas al azar
cardGenerator <- function(mazo, cantCards){
  listCards <- sample(mazo, cantCards, replace = FALSE)
  return(listCards)
}

Probando la funcion cardGenerator() para una mano de poker:

cards <- cardGenerator(mazo, 5)
cards

[1] "TD" "QC" "6C" "7D" "9C"

Esta funcion devuelve el valor de la carta: * pos = 1 se obtiene el rank de la carta * pos = 2 se obtiene el suit de la carta

getRankSuitCard <- function(hand, pos){
  h1 <- c()
  for(h in hand){
    h1 <- c(h1, substr(h, pos, pos))
  }
  return(h1)
}

Probando la funcion getRankSuitCard():

getRankSuitCard(cards, 1)

[1] "T" "Q" "6" "7" "9"

getRankSuitCard(cards, 2)

[1] "D" "C" "C" "D" "C"

Funcion que verifica si la mano de poker es Flush:

isFlush <- function(hand){
  suitValue <- getRankSuitCard(hand, 2)
  if(length(union(suitValue, suitValue)) == 1){
    return(TRUE)
  }
  return(FALSE)
}

Probando la funcion isFlush()

prueba <- c("4E","5E","2E","QE","AE")
isFlush(prueba)

[1] TRUE

prueba <- c("4C","4E","2E","QE","AE")

Funcion que genera una lista con la respectiva cantidad de repeticiones de elementos:

CounterF <- function(list){
  return(plyr::count(list))
}

Funcion que devuelve los valores de la cantidad de veces que se repite esa carta.

getCounterValue <- function(counter){
  return(counter$freq)
}

Devuelve el arreglo de las veces que se repite una determinada carta, con este ejemplo se puede ver que hay un par en prueba:

getCounterValue(CounterF(getRankSuitCard(prueba,1)))

[1] 1 2 1 1

La funcion typeHand() indica que tipo de jugada hay en la mano, no indica flush ni estalera.

typeHand <- function(hand){
  listCant <- CounterF(getRankSuitCard(hand, 1))
  counterHand <- CounterF(getCounterValue(listCant))
  if(counterHand[1,2] > 3){
    return("No hand")
  } else if(counterHand[1,2] > 2){
    return("Pair")
  } else if(counterHand[1,2] > 1){
    return("Three of a Kind")
  } else if(counterHand[2,2] == 2 & counterHand[1,2] == 1){
    return("Two Pairs")
  } else if(counterHand[2,1] == 4){
      return("Four of a Kind")
  }
  else{
    return( "Full House")
  }
}

prueba2 <- c("6D","9E","QD","6E","QT")
typeHand(prueba2)

[1] "Two Pairs"

Funcion que verifica si es escalera:

isStraight <- function(hand){
  rankValue <- getRankSuitCard(hand,1)
  valueCounts <- getCounterValue(CounterF(rankValue))
  weightsV <- c()
  for(i in rankValue){
    weightsV <- c(weightsV, ranks_order_weight[as.character(i)])
  }
  rangeValue <- max(weightsV) - min(weightsV)
  if(length(union(valueCounts, valueCounts)) == 1 & rangeValue == 4){
    return(TRUE)
  }else{
    return(FALSE)
  }
}

Prueba de la funcion isStraight():

prueba3 <- c("4E","6D","5T","3E","7T")
isStraight(prueba3)

[1] TRUE

Funcion que verifica la mano, que juego hay en la mano de poker.

gameHand <- function(hand){
  flushBoolean <- isFlush(hand)
  straightBoolean <- isStraight(hand)
  if(flushBoolean & straightBoolean){
    return("Straight Flush")
  }else if(flushBoolean){
    return("Flush")
  }else if(straightBoolean){
    return("Straight")
  } else{
    return(typeHand(hand))
  }
}

Probando la funcion cardGenerator()

carta_prueba <- cardGenerator(mazo, 5)
carta_prueba

[1] "9D" "6C" "7D" "6E" "9T"

gameHand(carta_prueba)

[1] "Two Pairs"

Se generaran \(50,000\) cartas de poker y se guardara en un dataframe que tipo de juego fue.

card <- cardGenerator(mazo,5)
print(c(card,gameHand(card)))

[1] "9T"   "2T"   "AD"   "QE"   "2D"   "Pair"

cards.df <- data.frame(juego = gameHand(card), stringsAsFactors = FALSE)
for(i in 1:50000){
  card <- cardGenerator(mazo,5)
  #print(c(card,gameHand(card)))
  juego <- gameHand(card)
  cards.df <- rbind(cards.df, juego, stringsAsFactors = FALSE)
}

Se contaran el total de juegos de cada tipo realizados.

cards.df2 <- cards.df
cards.df2 <- 
cards.df2 %>% 
  mutate(cant = 1)
total_juegos <-
cards.df2 %>% 
  group_by(juego) %>% 
  dplyr::summarise(count = n())

total_juegos

Ahora se van a obtener las probabilidades en base a las simulaciones realizadas:

total_juegos <-
  total_juegos %>% 
  mutate(probabilidad = count/50001)
total_juegos

Ahora se hara la simulacion con \(500,000\) manos de poker y se guardaran los juegos en un dataframe.

card2 <- cardGenerator(mazo,5)
print(c(card2,gameHand(card2)))

[1] "3C"      "9T"      "6C"      "7T"      "JC"      "No hand"

cards2.df <- data.frame(juego = gameHand(card2), stringsAsFactors = FALSE)
for(i in 1:500000){
  card2 <- cardGenerator(mazo,5)
  #print(c(card,gameHand(card)))
  juego <- gameHand(card2)
  cards2.df <- rbind(cards2.df, juego, stringsAsFactors = FALSE)
}

Se contaran el total de juegos de cada tipo realizados, ahora se hara con el dataset que tiene \(500000\) simulaciones.

cards2.df2 <- cards2.df
cards2.df2 <- 
cards2.df2 %>% 
  mutate(cant = 1)
total_juegos2 <-
cards2.df2 %>% 
  group_by(juego) %>% 
  dplyr::summarise(count = n())

total_juegos2

Ahora se van a obtener las probabilidades en base a las simulaciones realizadas:

total_juegos2 <-
  total_juegos2 %>% 
  mutate(probabilidad = count/500001)
total_juegos2