The "old faithful" method for evaluating the high card strength of a Bridge hand uses the 4,3,2,1 method. We count 4 points for every Ace in a hand, 3 points for every King, 2 points for every Queen, and 1 point for every Jack. The total becomes the high card point count for a Bridge hand. (Since we will be calculating the probabilities for various high card point counts, we will ignore points awarded for suit distribution.)

   In the "Stats" page we presented a table showing how many different Bridge hands fall into each point count category. Here, we will show how this data is calculated.

   First, we calculate how many different Bridge hands are possible. A Bridge hand consists of 13 random cards taken from a deck that holds 52 cards. The total number of possible Bridge hands is thus: COMBIN(52, 13) = 635,013,559,600. When we calculate the probability of getting a Bridge hand with a particular point count, we divide the number of possible combinations by 635,013,559,600. It is also useful to calculate this number in advance and then compare it to the sum of all the numbers that appear in column 2 in the Stats table. If the two numbers are not identical, it is a "subtle" hint that there is an "oops" somewhere.

   To calculate the total number of Bridge hands that add up to a given point count total, we have to calculate how many honor cards combinations (Aces, Kings, Queens, Jacks) qualify and then multiply by the number of non-honor cards combinations (10 high or less) that are needed to fill out the rest of the hand.

   A 37-point hand requires 4 Aces (1 combination) times 4 Kings (1 combination) times 4 Queens (1 combination) times any one of the 4 Jacks ( COMBIN( 4, 1) = 4) to yield a total of 4 combinations.

   When we calculate how many 36-point hands exist, things get a little stickier. We could have 4 Aces, 4 Kings, 4 Queens, and 1 non-honor card. Alternately, we could have 4 Aces, 4 Kings, 3 Queens, and 2 Jacks. By the time we get to 20-point hands, there are a large number of alternate hands. Thus, we will now look at one 20-point hand and then see how to expand this to cover all possible hands.

   Suppose you are dealt 1 Ace, 2 Kings, 3 Queens, 4 Jacks, and 3 other nondescript low cards. We ask how many ways (combinations) can this be done. There are COMBIN( 4, 1) = 4 different ways to fulfill the Ace requirement. (Note: We randomly take 1 Ace from among the 4 Aces in the deck.) For each of these 4 combinations, there are COMBIN( 4, 2) = 6 different combinations for the Kings. (We randomly take 2 Kings from among the 4 Kings in the deck). Similarly we use COMBIN( 4, 3) and COMBIN( 4, 4) for the Queens and Jacks. Finally, we have to fill the rest of the Bridge hand with 3 of the non-honor cards remaining in the deck. There are 52 - 4 - 4 - 4 - 4 = 36 non-honor cards in the deck. Thus, the final component becomes COMBIN( 36, 3) = 7,140 different combinations of the 10-high or less cards.

   When we put all of the above together for our 20-point hand that contains 1 Ace, 2 Kings, 3 Queens, 4 Jacks, plus 3 low cards we get:


     equals 685,440 different ways a 20-point hand can be generated using this particular combination of Aces, Kings, Queens, Jacks, and low cards. We then repeat this for all the other quantities of Aces, Kings, Queens, Jacks, and low cards that also yield a 20-point hand. After all the calculations have been made, all you have to do is add everything together and you get the number shown in the 20-point row in the table. Then, repeat for all other point count hands (rows) in the table.

   This particular calculation could be done on a spreadsheet (or even or scientific calculator), but a computer program becomes the method of choice to cope with the large number of combinations. The general calculation for number of combinations for any arbitrary quantities of Aces, Kings, Queens, Jacks, low cards is:


   The point count for this particular Bridge Hand is 4*NbrAces + 3*NbrKings + 2*NbrQueens + 1*NbrJacks. We will be generating all possible Bridge hands, thus we will keep cumulative totals for all point counts in an array. (An array is similar to the multiple cells in a spreadsheet column.) Thus if we have "N_combinations" for a particular 20-point hand, we update the Point-count total as follows: PtCnts[20] += N_combinations. In general, this update statement will look like:
PtCnts[ThisPtCnt] += the current calculation.

   This calculation will be repeated for all possible quantities of Aces, Kings, Queens, Jacks, and remaining low cards. Thus the general format of our computer program will look like:


Thus, our "C" program becomes:

for (Aces = 0; Aces <= 4; Aces++) {                /*  For all possible nbr of Aces   */
  for (Kings = 0; Kings <= 4; Kings++) {           /*  For all possible nbr of Kings  */
    for (Queens = 0; Queens <= 4; Queens++) {      /*  For all possible nbr of Queens */
      for (Jacks = 0; Jacks <= 4; Jacks++) {       /*  For all possible nbr of Jacks  */
        TotHonors = Aces + Kings + Queens + Jacks; /*  Get total honor cards          */
        if (TotHonors > 13 )                       /*  Can't have more than 13 cards. */
          continue;                         /*  Skip to next trial update if no good. */
        TotLow = 13 - TotHonors;                   /*  Number of low cards            */
        HonorCnt = 4 * Aces + 3 * Kings + 2 * Queens + Jacks;
                                                   /*  Charles Goren's favorite       */

                                                   /*  Big calc. and update totals    */
        PtCnts[ HonorCnt] += COMBIN( 4, Aces) *
          COMBIN( 4, Kings) * COMBIN( 4, Queens) *
          COMBIN( 4, Jacks) * COMBIN( 36, TotLow);
      }                                            /*  Repeat for all Jacks           */
    }                                              /*  Repeat for all Queens          */
  }                                                /*  Repeat for all Kings           */
}                                                  /*  Repeat for all Aces            */
                                                   /*  Now output the result          */
/*  Print the table titles                        */
/*  You'll have to do some of the work yourself   */

Cum Prob = 0.0;
for (row = 37; row >= 0; row--) {
  RowProb = PtCnts[row] / 635013559600.0;
  CumProb += RowProb;
  printf(" %2d   %18g   %-11g  %g\n", row, PtCnts[row], RowProb, CumProb);
}

/*  You can tidy up the format as needed.                         */
/*  Also, it's a good idea to add up all the entries in           */
/*  the PtCnts[] array to make sure they total to 635,013,559,600 */

And that's it.

Return to Bridge Combinatorics main page

Web page generated via KompoZer