def str_to_card(card_string): """ Convert this string to a pokerbots.engine.game.Card instance. Note that I don't check whether or not you passed the right format! """ if isinstance(card_string, Card): return card rank_str = card_string[0].lower() suit_str = card_string[1].lower() rank = 2 suit = 1 if rank_str == "t": rank = 10 elif rank_str == "j": rank = 11 elif rank_str == "q": rank = 12 elif rank_str == "k": rank = 13 elif rank_str == "a": rank = 14 if suit_str == "s": suit = 1 elif suit_str == "h": suit = 2 elif suit_str == "d": suit = 3 elif suit_str == "c": suit = 4 return Card(rank, suit)
def write_odd_xors_to_rank(): # 7-0 result = {} for combination in combinations(xrange(13), 7): # All bits are different, so you can just use or # Should have 13 choose 7 = 1716 odd_xor = reduce(__or__, map(lambda rank: 1 << rank, combination)) hand = [ Card(combination[0] + 2, 1), Card(combination[1] + 2, 2), Card(combination[2] + 2, 3), Card(combination[3] + 2, 4), Card(combination[4] + 2, 1), Card(combination[5] + 2, 2), Card(combination[6] + 2, 3) ] hand_combinations = combinations(hand, 5) result[odd_xor] = min( map(HandEvaluator.Five.evaluate_rank, hand_combinations)) assert len(result) == 1716 fh = open("seven.odd_xors_to_rank.py", "w") fh.write("odd_xors_to_rank = {\n") fh.write(",\n".join( map( lambda chunk: ", ".join( map(lambda k: "%s: %s" % (k, result[k]), chunk)), chunker(result.keys(), 4)))) fh.write("}") fh.close()
def write_even_xors_to_rank(): # 0-3 result = {} for combination in combinations(xrange(13), 3): # you can just use or again, since they're all the same # Should have 13 choose 3 = 286 even_xor = reduce(__or__, map(lambda rank: 1 << rank, combination)) hand = [ Card(combination[0] + 2, 1), Card(combination[0] + 2, 2), Card(combination[1] + 2, 3), Card(combination[1] + 2, 4), Card(combination[2] + 2, 1), Card(combination[2] + 2, 2) ] hand_combinations = combinations(hand, 5) result[even_xor] = min( map(HandEvaluator.Five.evaluate_rank, hand_combinations)) assert len(result) == 286 fh = open("six.even_xors_to_rank.py", "w") fh.write("even_xors_to_rank = {\n") for key_group in chunker(result.keys(), 4): if len(key_group) == 4: fh.write("%s: %s, %s: %s, %s: %s, %s: %s,\n" % (key_group[0], result[key_group[0]], key_group[1], result[key_group[1]], key_group[2], result[key_group[2]], key_group[3], result[key_group[3]])) else: # last group has 2 fh.write("%s: %s, %s: %s\n" % (key_group[0], result[key_group[0]], key_group[1], result[key_group[1]])) fh.write("}") fh.close()
def write_flush_rank_bits_to_rank(): result = {} for i in xrange(5, 8): # 5,6,7 ranks of same suit # Should have 13 choose 7 plus 13 choose 6 plus 13 choose 5 # which is 1716 + 1716 + 1287 = 4719 for combination in combinations(xrange(13), i): combo = list(combination) bits = reduce(__or__, map(lambda rank: 1 << rank, combination)) cards = map(lambda rank: Card(rank + 2, 1), combination) hand_combinations = combinations(cards, 5) result[bits] = min( map(HandEvaluator.Five.evaluate_rank, hand_combinations)) assert len(result) == 1716 + 1716 + 1287 fh = open("seven.flush_rank_bits_to_rank.py", "w") fh.write("flush_rank_bits_to_rank = {\n") fh.write(",\n".join( map( lambda chunk: ", ".join( map(lambda k: "%s: %s" % (k, result[k]), chunk)), chunker(result.keys(), 4)))) fh.write("}") fh.close()
def write_prime_products_to_rank(): # 4-0, 2-1, 0-2 """ Write a table mapping products of 6 ranks' corresponding prime numbers to hand rank. Only do it for hands in certain combinations, though, or the table gets really big. """ result = {} # Choose four ranks, frequency (1,1,1,3) for combination in combinations(xrange(13), 4): # Choose each one to appear three times # Should be 4 * 13 choose 4 = 2860 combo = list(combination) for i in xrange(4): rank = combo[i] other_ranks = combo[0:i] + combo[i + 1:4] prime_for_rank = LookupTables.primes[rank] # first get the product we need product = prime_for_rank * prime_for_rank * prime_for_rank * \ reduce(mul, map(lambda rank: LookupTables.primes[rank], other_ranks)) # now generate the hand we need hand = [Card(rank + 2, 1), Card(rank + 2, 2), Card(rank + 2, 3)] hand = hand + map(lambda rank: Card(rank + 2, 4), other_ranks) hand_combinations = combinations(hand, 5) # now map the product to the 5-card hand rank result[product] = min( map(HandEvaluator.Five.evaluate_rank, hand_combinations)) # Choose three cards, frequencies (1,1,4) and (1,3,2) for combination in combinations(xrange(13), 3): combo = list(combination) # Choose each one to appear four times for (1,1,4) # Should be 3 * 13 choose 3 = 858 for i in xrange(3): rank = combo[i] other_ranks = combo[0:i] + combo[i + 1:3] prime_for_rank = LookupTables.primes[rank] product = prime_for_rank * prime_for_rank * \ prime_for_rank * prime_for_rank * \ reduce(mul, map(lambda rank: LookupTables.primes[rank], other_ranks)) hand = [ Card(rank + 2, 1), Card(rank + 2, 2), Card(rank + 2, 3), Card(rank + 2, 4) ] hand = hand + map(lambda rank: Card(rank + 2, 4), other_ranks) hand_combinations = combinations(hand, 5) result[product] = min( map(HandEvaluator.Five.evaluate_rank, hand_combinations)) # Now for each combination, permute so that we can do (1,3,2) # Should be 6 * 13 choose 3 = 1716 for permute in permutations(combo): # permute contains the ranks in each order primes = map(lambda rank: LookupTables.primes[rank], permute) product = primes[0] * primes[1] * primes[1] * primes[1] * primes[ 2] * primes[2] hand = [ Card(permute[0] + 2, 1), Card(permute[1] + 2, 2), Card(permute[1] + 2, 3), Card(permute[1] + 2, 4), Card(permute[2] + 2, 1), Card(permute[2] + 2, 2) ] hand_combinations = combinations(hand, 5) result[product] = min( map(HandEvaluator.Five.evaluate_rank, hand_combinations)) # Choose two ranks, frequencies (2,4) for combination in combinations(xrange(13), 2): combo = list(combination) # Each needs to be the two once # Should have 2 * 13 choose 2 = 156 for permute in permutations(combo): # permute contains the ranks in each order primes = map(lambda rank: LookupTables.primes[rank], permute) product = primes[0] * primes[0] * primes[1] * primes[1] * primes[ 1] * primes[1] hand = [ Card(permute[0] + 2, 1), Card(permute[0] + 2, 2), Card(permute[1] + 2, 3), Card(permute[1] + 2, 4), Card(permute[1] + 2, 1), Card(permute[1] + 2, 2) ] hand_combinations = combinations(hand, 5) result[product] = min( map(HandEvaluator.Five.evaluate_rank, hand_combinations)) # at the end, we should have 2860 + 858 + 1716 + 156 keys in the table assert len(result) == (2860 + 858 + 1716 + 156) fh = open("six.prime_products_to_rank.py", "w") fh.write("prime_products_to_rank = {\n") for key_group in chunker(result.keys(), 4): if len(key_group) == 4: fh.write("%s: %s, %s: %s, %s: %s, %s: %s,\n" % (key_group[0], result[key_group[0]], key_group[1], result[key_group[1]], key_group[2], result[key_group[2]], key_group[3], result[key_group[3]])) else: # last group has 2 fh.write("%s: %s, %s: %s\n" % (key_group[0], result[key_group[0]], key_group[1], result[key_group[1]])) fh.write("}") fh.close()
def write_even_xors_to_odd_xors_to_rank(): # 4-1, 2-2 result = defaultdict(dict) # choose five ranks, frequencies (1,1,1,1,2) for combination in combinations(xrange(13), 5): # Choose each one to appear twice # Should be 5 * 13 choose 5 = 6435 combo = list(combination) for i in xrange(5): rank = combo[i] other_ranks = combo[0:i] + combo[i + 1:5] even_xor = 1 << rank odd_xor = reduce(__or__, map(lambda rank: 1 << rank, other_ranks)) # now generate the hand we need hand = [Card(rank + 2, 1), Card(rank + 2, 2)] hand = hand + map(lambda rank: Card(rank + 2, 3), other_ranks) hand_combinations = combinations(hand, 5) # now map the product to the 5-card hand rank result[even_xor][odd_xor] = min( map(HandEvaluator.Five.evaluate_rank, hand_combinations)) # choose four ranks, frequencies (1,1,2,2) for combination in combinations(xrange(13), 4): # Now choose every possible pair from those four to appear twice # Should have (4 choose 2) * (13 choose 4) = 6 * 715 = 4290 combo = list(combination) for pair_ranks in combinations(combo, 2): one_ranks = filter(lambda rank: rank not in pair_ranks, combo) even_xor = reduce(__or__, map(lambda rank: 1 << rank, pair_ranks)) odd_xor = reduce(__or__, map(lambda rank: 1 << rank, one_ranks)) hand = [ Card(pair_ranks[0] + 2, 1), Card(pair_ranks[0] + 2, 2), Card(pair_ranks[1] + 2, 3), Card(pair_ranks[1] + 2, 4), Card(one_ranks[0] + 2, 1), Card(one_ranks[1] + 2, 2) ] hand_combinations = combinations(hand, 5) result[even_xor][odd_xor] = min( map(HandEvaluator.Five.evaluate_rank, hand_combinations)) # this assertion is more complex # First, count the even_xor keys assert len(result) == 13 + 78 # Then count the leaves assert reduce(add, map(lambda even_xor: len(result[even_xor]), result)) == 6435 + 4290 fh = open("six.even_xors_to_odd_xors_rank.py", "w") fh.write("even_xors_to_odd_xors_to_rank = {\n") for even_xor in result.keys(): fh.write("%s: { " % (even_xor, )) fh.write(",\n".join( map( lambda chunk: ", ".join( map( lambda odd_xor: "%s: %s" % (odd_xor, result[even_xor][odd_xor]), chunk)), chunker(result[even_xor].keys(), 4)))) fh.write(" },\n") fh.write("}") fh.close()
def write_flush_rank_bits_to_rank(): result = {} for combination in combinations(xrange(13), 6): # Should have 13 choose 6 = 1716 combo = list(combination) bits = reduce(__or__, map(lambda rank: 1 << rank, combination)) cards = [ Card(combo[0] + 2, 1), Card(combo[1] + 2, 1), Card(combo[2] + 2, 1), Card(combo[3] + 2, 1), Card(combo[4] + 2, 1), Card(combo[5] + 2, 1) ] hand_combinations = combinations(cards, 5) result[bits] = min( map(HandEvaluator.Five.evaluate_rank, hand_combinations)) for combination in combinations(xrange(13), 5): # Should have 13 choose 5 = 1287 combo = list(combination) bits = reduce(__or__, map(lambda rank: 1 << rank, combination)) cards = [ Card(combo[0] + 2, 1), Card(combo[1] + 2, 1), Card(combo[2] + 2, 1), Card(combo[3] + 2, 1), Card(combo[4] + 2, 1) ] result[bits] = HandEvaluator.Five.evaluate_rank(cards) assert len(result) == 1716 + 1287 fh = open("six.flush_rank_bits_to_rank.py", "w") fh.write("flush_rank_bits_to_rank = {\n") for key_group in chunker(result.keys(), 4): if len(key_group) == 4: fh.write("%s: %s, %s: %s, %s: %s, %s: %s,\n" % (key_group[0], result[key_group[0]], key_group[1], result[key_group[1]], key_group[2], result[key_group[2]], key_group[3], result[key_group[3]])) else: # last group has 3 fh.write( "%s: %s, %s: %s, %s: %s\n" % (key_group[0], result[key_group[0]], key_group[1], result[key_group[1]], key_group[2], result[key_group[2]])) fh.write("}") fh.close()
def write_odd_xors_to_rank(): # 6-0, 2-0 result = {} for combination in combinations(xrange(13), 6): # in the case where six different bits are set, you # can substitute or # Should have 13 choose 6 = 1716 odd_xor = reduce(__or__, map(lambda rank: 1 << rank, combination)) hand = [ Card(combination[0] + 2, 1), Card(combination[1] + 2, 2), Card(combination[2] + 2, 3), Card(combination[3] + 2, 4), Card(combination[4] + 2, 1), Card(combination[5] + 2, 2) ] hand_combinations = combinations(hand, 5) result[odd_xor] = min( map(HandEvaluator.Five.evaluate_rank, hand_combinations)) for combination in combinations(xrange(13), 2): # convert to rank number with 2 bits on # by only choosing two numbers, we can use or instead of xor # Should have 13 choose 2 = 78 odd_xor = reduce(__or__, map(lambda rank: 1 << rank, combination)) hand = [ Card(combination[0] + 2, 1), Card(combination[0] + 2, 2), Card(combination[0] + 2, 3), Card(combination[1] + 2, 4), Card(combination[1] + 2, 1), Card(combination[1] + 2, 2) ] hand_combinations = combinations(hand, 5) result[odd_xor] = min( map(HandEvaluator.Five.evaluate_rank, hand_combinations)) assert len(result) == 1716 + 78 fh = open("six.odd_xors_to_rank.py", "w") fh.write("odd_xors_to_rank = {\n") for key_group in chunker(result.keys(), 4): if len(key_group) == 4: fh.write("%s: %s, %s: %s, %s: %s, %s: %s,\n" % (key_group[0], result[key_group[0]], key_group[1], result[key_group[1]], key_group[2], result[key_group[2]], key_group[3], result[key_group[3]])) else: # last group has 2 fh.write("%s: %s, %s: %s\n" % (key_group[0], result[key_group[0]], key_group[1], result[key_group[1]])) fh.write("}") fh.close()
def evaluate_opponent(self): if self.hands_played >= 1: last_pot = 0.0 self_bet_for_round = 0 opponent_bet_for_round = 0 opponent_bet_strength_preflop = [] opponent_bet_strength_flop = [] opponent_bet_strength_turn = [] opponent_bet_strength_river = [] street = 'preflop' # obtain opponent's betting behavior from the previous round, and determine strength of hand if there's a showdown # for play in self.last[1]: if play[0] == self.name: if isinstance(play[1], Post): last_pot = last_pot + play[1].amount self_bet_for_round = play[1].amount elif isinstance(play[1], Bet): last_pot = last_pot + play[1].amount self_bet_for_round = play[1].amount elif isinstance(play[1], Raise): last_pot = last_pot - self_bet_for_round + play[ 1].amount self_bet_for_round = play[1].amount elif isinstance(play[1], Call): last_pot = last_pot + opponent_bet_for_round - self_bet_for_round self_bet_for_round = opponent_bet_for_round elif play[0] == self.opponent['name']: strength_of_bet = zeros(0) if isinstance(play[1], Post): last_pot = last_pot + play[1].amount opponent_bet_for_round = play[1].amount elif isinstance(play[1], Bet): last_pot = last_pot + play[1].amount opponent_bet_for_round = play[1].amount opponent_bet_strength = play[1].amount / last_pot elif isinstance(play[1], Raise): last_pot = last_pot - opponent_bet_for_round + play[ 1].amount opponent_bet_strength = ( play[1].amount - opponent_bet_for_round) / last_pot opponent_bet_for_round = play[1].amount elif isinstance(play[1], Call): last_pot = last_pot + self_bet_for_round - opponent_bet_for_round opponent_bet_strength = ( self_bet_for_round - opponent_bet_for_round) / last_pot opponent_bet_for_round = self_bet_for_round elif isinstance(play[1], Check): opponent_bet_strength = 0.0 elif isinstance(play[1], Show): #print play[1].hand #print last_board opponent_hand_strength_preflop = HandEvaluator.evaluate_hand( play[1].hand, []) opponent_hand_strength_flop = HandEvaluator.evaluate_hand( play[1].hand, last_board[0:3]) opponent_hand_strength_turn = HandEvaluator.evaluate_hand( play[1].hand, last_board[0:4]) opponent_hand_strength_river = HandEvaluator.evaluate_hand( play[1].hand, last_board) opponent_hand_strength = [ opponent_hand_strength_preflop, opponent_hand_strength_flop, opponent_hand_strength_turn, opponent_hand_strength_river ] opponent_bet_strength = [ opponent_bet_strength_preflop, opponent_bet_strength_flop, opponent_bet_strength_turn, opponent_bet_strength_river ] for i in xrange(0, 4): for j in xrange(0, len(opponent_bet_strength[i])): self.opponent_showdown_hand_strength.append( opponent_hand_strength[i]) self.opponent_showdown_bet_strength.append( opponent_bet_strength[i][j]) if len(self.opponent_showdown_hand_strength ) > self.p6: self.opponent_showdown_hand_strength = self.opponent_showdown_hand_strength[ -self.p6:] self.opponent_showdown_bet_strength = self.opponent_showdown_bet_strength[ -self.p6:] degree = 1 if len(self.opponent_showdown_hand_strength ) > self.p6 / 2: self.coeff = polyfit( self.opponent_showdown_hand_strength, self.opponent_showdown_bet_strength, degree) self.corr = corrcoef( self.opponent_showdown_hand_strength, self.opponent_showdown_bet_strength)[0, 1] # store first coefficient, which estimate's opponent's A self.opponent_showdown_potodds_estimate = self.coeff[ 0] else: self.corr = 0 if isinstance(play[1], Bet) or isinstance(play[1], Raise): if street == 'preflop': opponent_bet_strength_preflop.append( opponent_bet_strength) elif street == 'flop': opponent_bet_strength_flop.append( opponent_bet_strength) elif street == 'turn': opponent_bet_strength_turn.append( opponent_bet_strength) elif street == 'river': opponent_bet_strength_river.append( opponent_bet_strength) self.opponent_bet_history = append( self.opponent_bet_history, strength_of_bet) elif play[0] == 'Dealer': self_bet_for_round = 0 opponent_bet_for_round = 0 if len(play[1].cards) == 12: street = 'flop' elif len(play[1].cards) == 16: street = 'turn' elif len(play[1].cards) == 20: street = 'river' card_string = play[1].cards last_board_string = play[1].cards last_board = [] for i in xrange(0, 5): str_pos = 4 * i + 1 if card_string[str_pos] == 'A': card_rank = 14 elif card_string[str_pos] == 'K': card_rank = 13 elif card_string[str_pos] == 'Q': card_rank = 12 elif card_string[str_pos] == 'J': card_rank = 11 elif card_string[str_pos] == 'T': card_rank = 10 else: card_rank = int(card_string[str_pos]) str_pos = 4 * i + 2 if card_string[str_pos] == 's': card_suit = 1 elif card_string[str_pos] == 'h': card_suit = 2 elif card_string[str_pos] == 'd': card_suit = 3 elif card_string[str_pos] == 'c': card_suit = 4 last_board.append(Card(card_rank, card_suit))
def write_even_xors_to_odd_xors_to_rank(): # 5-1, 3-2, 1-3, 1-1 result = defaultdict(dict) # choose six ranks, frequencies (1,1,1,1,1,2)) for combination in combinations(xrange(13), 6): # Choose each one to appear twice # Should be 6 * 13 choose 6 = 10296 combo = list(combination) for i in xrange(6): rank = combo[i] other_ranks = combo[0:i] + combo[i + 1:6] even_xor = 1 << rank odd_xor = reduce(__or__, map(lambda rank: 1 << rank, other_ranks)) # now generate the hand we need hand = [ Card(rank + 2, 1), Card(rank + 2, 2), Card(other_ranks[0] + 2, 3), Card(other_ranks[1] + 2, 4), Card(other_ranks[2] + 2, 1), Card(other_ranks[3] + 2, 2), Card(other_ranks[4] + 2, 3), ] hand_combinations = combinations(hand, 5) # now map the product to the 5-card hand rank result[even_xor][odd_xor] = min( map(HandEvaluator.Five.evaluate_rank, hand_combinations)) # choose five ranks, frequencies (1,1,1,2,2) for combination in combinations(xrange(13), 5): # Now choose every possible pair from those five to appear twice # Should have (5 choose 2) * (13 choose 5) = 12870 combo = list(combination) for pair_ranks in combinations(combo, 2): one_ranks = filter(lambda rank: rank not in pair_ranks, combo) even_xor = reduce(__or__, map(lambda rank: 1 << rank, pair_ranks)) odd_xor = reduce(__or__, map(lambda rank: 1 << rank, one_ranks)) hand = [ Card(pair_ranks[0] + 2, 1), Card(pair_ranks[0] + 2, 2), Card(pair_ranks[1] + 2, 3), Card(pair_ranks[1] + 2, 4), Card(one_ranks[0] + 2, 1), Card(one_ranks[1] + 2, 2), Card(one_ranks[2] + 2, 3) ] hand_combinations = combinations(hand, 5) result[even_xor][odd_xor] = min( map(HandEvaluator.Five.evaluate_rank, hand_combinations)) # choose four ranks, frequencies (1,2,2,2) for combination in combinations(xrange(13), 4): # Now choose every possible rank to be the 1 # Should have 4 * 13 choose 4 = 2860 combo = list(combination) for i in xrange(4): rank = combo[i] other_ranks = combo[0:i] + combo[i + 1:4] even_xor = reduce(__or__, map(lambda rank: 1 << rank, other_ranks)) odd_xor = 1 << rank # now generate the hand we need hand = [ Card(rank + 2, 1), Card(other_ranks[0] + 2, 2), Card(other_ranks[0] + 2, 3), Card(other_ranks[1] + 2, 4), Card(other_ranks[1] + 2, 1), Card(other_ranks[2] + 2, 2), Card(other_ranks[2] + 2, 3), ] hand_combinations = combinations(hand, 5) # now map the product to the 5-card hand rank result[even_xor][odd_xor] = min( map(HandEvaluator.Five.evaluate_rank, hand_combinations)) # choose two ranks, frequencies (3,4) for combination in combinations(xrange(13), 2): # Both can be the 3 # Should have 2 * 13 choose 2 = 156 combo = list(combination) for i in xrange(2): three = combo[i] four = combo[1 - i] even_xor = 1 << four odd_xor = 1 << three hand = [ Card(three + 2, 1), Card(three + 2, 2), Card(three + 2, 3), Card(four + 2, 1), Card(four + 2, 2), Card(four + 2, 3), Card(four + 2, 4) ] hand_combinations = combinations(hand, 5) result[even_xor][odd_xor] = min( map(HandEvaluator.Five.evaluate_rank, hand_combinations)) # this assertion is more complex # First, count the even_xor keys assert len(result) == 13 + 78 + 286 # Then count the leaves assert reduce(add, map(lambda even_xor: len(result[even_xor]), result)) == 10296 + 12870 + 2860 + 156 fh = open("seven.even_xors_to_odd_xors_rank.py", "w") fh.write("even_xors_to_odd_xors_to_rank = {\n") for even_xor in result.keys(): fh.write("%s: { " % (even_xor, )) fh.write(",\n".join( map( lambda chunk: ", ".join( map( lambda odd_xor: "%s: %s" % (odd_xor, result[even_xor][odd_xor]), chunk)), chunker(result[even_xor].keys(), 4)))) fh.write(" },\n") fh.write("}") fh.close()
def write_prime_products_to_rank(): # 5-0, 3-0, 3-1, 1-2 """ Write a table mapping products of 6 ranks' corresponding prime numbers to hand rank. Only do it for hands in certain combinations, though, or the table gets really big. """ result = {} # Choose five ranks, frequency (1,1,1,1,3) for combination in combinations(xrange(13), 5): # Choose each one to appear three times # Should be 5 * 13 choose 5 = 6435 combo = list(combination) for i in xrange(5): rank = combo[i] other_ranks = combo[0:i] + combo[i + 1:5] prime_for_rank = LookupTables.primes[rank] # first get the product we need product = prime_for_rank * prime_for_rank * prime_for_rank * \ reduce(mul, map(lambda rank: LookupTables.primes[rank], other_ranks)) # now generate the hand we need hand = [Card(rank + 2, 1), Card(rank + 2, 2), Card(rank + 2, 3)] hand = hand + map(lambda rank: Card(rank + 2, 4), other_ranks) hand_combinations = combinations(hand, 5) # now map the product to the 5-card hand rank result[product] = min( map(HandEvaluator.Five.evaluate_rank, hand_combinations)) # Choose three cards, frequencies (1,3,3), (1,2,4), or (3,2,2) for combination in combinations(xrange(13), 3): combo = list(combination) # Choose each one to appear once (1,3,3) # Same one can be the 3 in (3,2,2) # Should be 2 * 3 * 13 choose 3 = 1716 for i in xrange(3): rank = combo[i] other_ranks = combo[0:i] + combo[i + 1:3] prime_for_rank = LookupTables.primes[rank] # (1,3,3) product = prime_for_rank * reduce( mul, map( lambda rank: LookupTables.primes[rank] * LookupTables. primes[rank] * LookupTables.primes[rank], other_ranks)) hand = [ Card(rank + 2, 1), Card(other_ranks[0] + 2, 2), Card(other_ranks[0] + 2, 3), Card(other_ranks[0] + 2, 4), Card(other_ranks[1] + 2, 1), Card(other_ranks[1] + 2, 2), Card(other_ranks[1] + 2, 3) ] hand_combinations = combinations(hand, 5) result[product] = min( map(HandEvaluator.Five.evaluate_rank, hand_combinations)) # (3,2,2) product = prime_for_rank * prime_for_rank * prime_for_rank * reduce( mul, map( lambda rank: LookupTables.primes[rank] * LookupTables. primes[rank], other_ranks)) hand = [ Card(rank + 2, 1), Card(rank + 2, 2), Card(rank + 2, 3), Card(other_ranks[0] + 2, 1), Card(other_ranks[0] + 2, 2), Card(other_ranks[1] + 2, 3), Card(other_ranks[1] + 2, 4) ] hand_combinations = combinations(hand, 5) result[product] = min( map(HandEvaluator.Five.evaluate_rank, hand_combinations)) # Permute each combination (1,2,4) # Should be 6 * 13 choose 3 = 1716 for permute in permutations(combination): one = permute[0] two = permute[1] four = permute[2] product = LookupTables.primes[one] *\ LookupTables.primes[two] * LookupTables.primes[two] *\ LookupTables.primes[four] * LookupTables.primes[four] *\ LookupTables.primes[four] * LookupTables.primes[four] hand = [ Card(one + 2, 1), Card(two + 2, 2), Card(two + 2, 3), Card(four + 2, 1), Card(four + 2, 2), Card(four + 2, 3), Card(four + 2, 4) ] hand_combinations = combinations(hand, 5) result[product] = min( map(HandEvaluator.Five.evaluate_rank, hand_combinations)) # Choose four ranks, frequencies (1,1,1,4) and (1,1,3,2) for combination in combinations(xrange(13), 4): combo = list(combination) # Choose one to be the 4 # This one is also the 3 for i in xrange(4): # Deal with (1,1,1,4) # Should have 4 * 13 choose 4 = 2860 rank = combo[i] other_ranks = combo[0:i] + combo[i + 1:4] prime_for_rank = LookupTables.primes[rank] product = prime_for_rank * prime_for_rank *\ prime_for_rank * prime_for_rank *\ reduce(mul, map(lambda rank: LookupTables.primes[rank], other_ranks)) hand = [ Card(rank + 2, 1), Card(rank + 2, 2), Card(rank + 2, 3), Card(rank + 2, 4) ] hand = hand + map(lambda rank: Card(rank + 2, 1), other_ranks) hand_combinations = combinations(hand, 5) result[product] = min( map(HandEvaluator.Five.evaluate_rank, hand_combinations)) # Use the 4 as the 3 now # Now pick another to be the 2 to do (1,1,3,2) # Should have 4 * 3 * 13 choose 4 = 8580 three = rank for j in xrange(3): two = other_ranks[j] ones = other_ranks[0:j] + other_ranks[j + 1:3] product = LookupTables.primes[three] * LookupTables.primes[three] * LookupTables.primes[three] *\ LookupTables.primes[two] * LookupTables.primes[two] *\ LookupTables.primes[ones[0]] * LookupTables.primes[ones[1]] hand = [ Card(three + 2, 1), Card(three + 2, 2), Card(three + 2, 3), Card(two + 2, 1), Card(two + 2, 2), Card(ones[0] + 2, 1), Card(ones[1] + 2, 2) ] hand_combinations = combinations(hand, 5) result[product] = min( map(HandEvaluator.Five.evaluate_rank, hand_combinations)) # Choose two ranks, frequencies (2,4) for combination in combinations(xrange(13), 2): combo = list(combination) # Each needs to be the two once # Should have 2 * 13 choose 2 = 156 for permute in permutations(combo): # permute contains the ranks in each order primes = map(lambda rank: LookupTables.primes[rank], permute) product = primes[0] * primes[0] * primes[1] * primes[1] * primes[ 1] * primes[1] hand = [ Card(permute[0] + 2, 1), Card(permute[0] + 2, 2), Card(permute[1] + 2, 3), Card(permute[1] + 2, 4), Card(permute[1] + 2, 1), Card(permute[1] + 2, 2) ] hand_combinations = combinations(hand, 5) result[product] = min( map(HandEvaluator.Five.evaluate_rank, hand_combinations)) # at the end, we should have 2860 + 858 + 1716 + 156 keys in the table assert len(result) == (6435 + 1716 + 1716 + 2860 + 8580 + 156) fh = open("seven.prime_products_to_rank.py", "w") fh.write("prime_products_to_rank = {\n") fh.write(",\n".join( map( lambda chunk: ", ".join( map(lambda k: "%s: %s" % (k, result[k]), chunk)), chunker(result.keys(), 4)))) fh.write("}") fh.close()
import sys sys.path.append("../") from pokerbots.engine.game import Card from pokerbots.player.hand_evaluator import HandEvaluator from itertools import combinations import random deck = [ Card(2,1), Card(2,2), Card(2,3), Card(2,4), Card(3,1), Card(3,2), Card(3,3), Card(3,4), Card(4,1), Card(4,2), Card(4,3), Card(4,4), Card(5,1), Card(5,2), Card(5,3), Card(5,4), Card(6,1), Card(6,2), Card(6,3), Card(6,4), Card(7,1), Card(7,2), Card(7,3), Card(7,4), Card(8,1), Card(8,2), Card(8,3), Card(8,4), Card(9,1), Card(9,2), Card(9,3), Card(9,4), Card(10,1), Card(10,2), Card(10,3), Card(10,4), Card(11,1), Card(11,2), Card(11,3), Card(11,4), Card(12,1), Card(12,2), Card(12,3), Card(12,4), Card(13,1), Card(13,2), Card(13,3), Card(13,4), Card(14,1), Card(14,2), Card(14,3), Card(14,4) ] number_of_runs = 1000 def eval_6_with_5(): for i in xrange(number_of_runs): turn = random.sample(deck, 6) possible_hands = combinations(turn, 5) rank = min(map(HandEvaluator.Five.evaluate_rank, possible_hands))
# This is just a file to test the lookup bot # primes = [2,3,5,7,11,13,17,19,23,29,31,37,41] import sys sys.path.append("../") from pokerbots.engine.game import Card from pokerbots.player.hand_evaluator import HandEvaluator from itertools import combinations # 2 card hands hands_2 = { "7-2": [Card(2, 1), Card(7, 2)], "7-2 suited": [Card(2, 1), Card(7, 1)], "9-8 suited": [Card(8, 1), Card(9, 1)], "6-6": [Card(6, 1), Card(6, 2)], "10-10": [Card(10, 2), Card(10, 3)], "A-K": [Card(14, 3), Card(13, 3)], "big slick": [Card(14, 3), Card(13, 3)], "rockets": [Card(14, 3), Card(14, 2)] } # 5 card hands hands_5 = { "straight flush": [Card(14, 1), Card(13, 1), Card(12, 1), Card(11, 1), Card(10, 1)], "quads": [Card(7, 1), Card(7, 2), Card(7, 3),