Same Rank

Let’s start with the most frequent ones, the pairs. So let PAIR be the random variable counting the numbers of pair in a hand. PAIR can take values in \([0,6]\) because a hand has 13 cards. The indicator that interests us is : \[\frac{\#PAIR=0}{4000}\approx\mathbb{P}[PAIR=0]\]

and equivalently

\[1-\frac{\#PAIR=0}{4000}\approx\mathbb{P}[PAIR>0]\]

So according to our simulations, 88 games out of the \(4 \times 1000\) didn’t have any pairs.

These are simple counts, because the hidden pairs in the three/four of a kinds have not been counted. So if we want to count these hidden pairs, we would need to build a new indicator because there is \(1\) pair in a three of a kind and \(2\) pairs in a four of a kind. So let Three_of_a_kind be the random variable counting the number of three of a kinds in a hand. It can take values in [0,3] and let Four_of_a_kind be the random variable counting the number of four of a kind in a hand. It can take values in [0,2]. Our new indicator is thus

\[All.Pairs = Pair+Three\_of\_a\_kind+2\cdot Four\_of\_a\_kind\]

Hidden.PAIR<-Games %>% mutate(
  All.Pairs = Pair + Three_of_a_kind + 2*Four_of_a_kind
) %>% group_by(All.Pairs) %>% summarise(Count=n(),Odds = n()/(4*Simulations))
Hidden.PAIR %>% kable(align="c")

As we can see, the difference in probabilities are huge because the pairs are very frequent.

We can also notice that \(All.Pairs=0\) has vanished. Indeed, as there are only 13 ranks and 13 cards in a hand, the probability to have no pairs at all is very small and our simulations did not simulate such a hand. In fact these rare hands have to have all 13 ranks, from A to K. Only the suits are random. We therefore have 4 choices for the first card that is A, then another 4 choices for the second card 2, 4 choices for 3, … 4 choices for K therefore :

\[ \mathbb{P}[PAIR=0] = \dfrac{(C_1^4)^{13}}{C_{13}^{52}} = 0.00011 \] So in other words, the 4 friends will need to play a whopping \(2500\) games in order for someone to stumble upon a hand without a pair. Lastly, we can see that the probabilities are not only shifted upwards.

So depending on your curiosity you might want to simulate the former or the latter Let’s now go over to the full houses which are once again a combination of a three of a kind and a pair. The simple version is pretty straight forward and is the minimum between the number of pairs and the number of three of a kinds because we need the same number of both of them to make a full house. \[Full\_house = \min(Three\_of\_a\_kind,Pair)\]

Games %>% mutate(
  Full_houses = pmin(Pair,Three_of_a_kind)
) %>% group_by(Full_houses) %>% summarise(Count=n(),Odds = n()/(4*Simulations))%>% kable(align="c")

As expected, there’s a more complicated version that takes into account the three/four of a kinds. For this, I designed a function that works like this :

For a certain hand of 13 cards

• All pairs and three of a kinds are matched up
• If we still have three of a kinds, which means that there are less pairs than three of a kinds, we will look for three and four of a kinds in order the break them down into pairs.
• If at this stage we still have four of a kinds, we will then break them into three of a kinds.

For example, let’s take a look at this hand :

• 2 four of a kinds \(\rightarrow\) 8 cards
• 1 three of a kind \(\rightarrow\) 3 cards
• 1 pair \(\rightarrow\) 2 cards

The pair will be matched up with the three of a kind to make the first full house. The 2 four of a kinds will be broken down into 2 pairs and 1 three of a kind so we can build a full house. This hands has therefore 2 full houses. By the way, the maximum number of full houses in a hand is 2 because we only have 13 cards per hand.

full_house_count<-function(Two,Three,Four){

# we need *Three* pairs, so we will need to convert the Three/Four_of_a_kind to pairs if there are not enough pairs
  Simple.FH<-pmin(Two,Three)
  # How many Three do we have
  Threes.remaining<-pmax(0,Three-Two)
  # We can break down Threes
  Broken.Threes<-(Threes.remaining)%/%2 #
  Threes.remaining<-Threes.remaining-Broken.Threes
  
  # Convert Fours into pairs
  pairs.converted.3 <- pmin(Four*2,Threes.remaining) # we have Four*2 pairs and need Threes.remaining pairs
  Three_of_a_kind = Simple.FH+Broken.Threes+pairs.converted.3
  pairs.remaining.4 <- (2*Four-pairs.converted.3) # We substract the converted pairs from the Four_of_a_kind
  Four_of_a_kind<-pairs.remaining.4%/%3 # We then divide this by 3 to find the number of remaining Full Houses built on Four_of_a_kind e.g. AA,AA, KK => can be built into one Full House (AAA,KK) and AA,AA,KK,KK,DD,DD => can be built into 2 Full Houses (AAA,DD) and (KKK,DD)
  Three_of_a_kind+Four_of_a_kind
  
}

Games %>% mutate(
  All.Full_houses = full_house_count(Pair,Three_of_a_kind,Four_of_a_kind)
) %>% group_by(All.Full_houses) %>% summarise(Count=n(),Odds = n()/(4*Simulations))%>% kable(align="c")

The differences between these two indicators are not massive due to the rareness of the three/four of a kinds.

Same suit

This section is the same and a lot more easier because there are no three of a kind etc. So, let SUIT be the random variable counting the number of cards with the same suit. SUIT can take values in \([1,13]\). So the lower bound is \(1\) because obviously there has to be a least one suit and the upper bound is \(13\) because every card could be of the same suit. There’s at least one flush when (SUIT > 4), there’s even a rare occurence when the hand has 2 flushes of the same suit (SUIT > 9). I just need to modify my code a little in order take this into account.

one.game<-function(deck,shuffle,i){
  shuffle %>% deck[.,] %>% mutate(Player=dist) %>% group_by(Player,Suit) %>% summarise(n=n()) %>% group_by(Player) %>%
    summarise(
      Flush = sum(n>4 & n<10), # only one flush
      Flushx2 = sum(n>9), # 2 flushes (most tricky part)
      Flushes = Flush+Flushx2*2,
      Game=i
    )
}

cl<-makeCluster(4)
registerDoParallel(cl)
set.seed(1)
Games.suit<-foreach(game=1:Simulations,.combine=rbind.data.frame,.packages="tidyverse")%dopar%{
  one.game(deck,shuffles[[game]],game)
}

stopCluster(cl)

Games.suit

## # A tibble: 4,000 x 5
##         Player Flush Flushx2 Flushes  Game
##         <fctr> <int>   <int>   <dbl> <int>
##  1     Alibaba     0       0       0     1
##  2       Baidu     1       0       1     1
##  3 Chinamobile     2       0       2     1
##  4        Didi     1       0       1     1
##  5     Alibaba     0       0       0     2
##  6       Baidu     1       0       1     2
##  7 Chinamobile     1       0       1     2
##  8        Didi     0       0       0     2
##  9     Alibaba     0       0       0     3
## 10       Baidu     0       0       0     3
## # ... with 3,990 more rows

Games.suit %>% group_by(Flushes) %>% summarise(
  Odds=n()/(4*Simulations)
) %>% kable()

The sequences

Now if we want to calculate the odds of a straight, this might be a little more tricky. I designed a function that checks for every unique rank if a sequence can be built. Obviously when the numbers of unique ranks are less than 5, we cannot build a straight. If there are more than 5 cards we can look for the difference by substracting the rank from the next rank, 5 ranks at a time. If there is a set of 5 ranks that meet the condition (difference = 1 for all 5 cards), we consider that there’s at least one straight.

is.seq<-function(C){
  l<-length(C)
  if(l<5) return(F)
  idx<-1:4
  (0:(l-5)) %>% map(`+`,idx) %>%  map(.f=function(x) all((C[x+1]-C[x])==1)) %>% unlist %>% any
}

# example
is.seq(1:13)

## [1] TRUE

is.seq(c(1,3,5,6,7,8,10,12))

## [1] FALSE

This function seems to be functional, let’s apply this to the 1000 games.

one.game<-function(deck,shuffle,i){
  shuffle %>% deck[.,] %>% mutate(Player=dist) %>% group_by(Player,Rank) %>% summarise(n=n()) %>%
  group_by(Player) %>% summarise(straight=is.seq(as.integer(Rank)),
                                 Game=i
                                 )
  }

cl<-makeCluster(4)
registerDoParallel(cl)

Games.straight<-foreach(game=1:Simulations,.combine=rbind.data.frame,.packages="tidyverse")%dopar%{one.game(deck,shuffles[[game]],game)}

stopCluster(cl)

Games.straight %>% group_by(Player) %>% summarise(
  Straight_prob=sum(straight)/(Simulations)
) %>% kable()