Beispiel #1
0
def get_winner(hole_cards, community_cards):

    #generate deck that has the hole cards missing
    the_deck = prob_functions.generate_deck(hole_cards)

    num_players = len(hole_cards)

    # Create results data structures which tracks results of comparisons
    # 1) result_histograms: a list for each player that shows the number of
    #    times each type of poker hand (e.g. flush, straight) was gotten
    # 2) winner_list: number of times each player wins the given round
    # 3) result_list: list of the best possible poker hand for each pair of
    #    hole cards for a given board
    result_list, winner_list = [None] * num_players, [0] * (num_players + 1)
    result_histograms = []
    for player in range(num_players):
        result_histograms.append([0] * 10)

    # Find the best possible poker hand given the created board and the
    # hole cards and save them in the results data structures
    (suit_histogram,
            histogram, max_suit) = prob_functions.preprocess_board(community_cards)
    for index, hole_card in enumerate(hole_cards):
        result_list[index] = prob_functions.detect_hand(hole_card, community_cards,
                                     suit_histogram, histogram, max_suit)

    # Find the winner of the hand and tabulate results
    winner_index = prob_functions.compare_hands(result_list)

    return [winner_index]
Beispiel #2
0
def get_winner(hole_cards, community_cards):

    #generate deck that has the hole cards missing
    the_deck = prob_functions.generate_deck(hole_cards)

    num_players = len(hole_cards)

    # Create results data structures which tracks results of comparisons
    # 1) result_histograms: a list for each player that shows the number of
    #    times each type of poker hand (e.g. flush, straight) was gotten
    # 2) winner_list: number of times each player wins the given round
    # 3) result_list: list of the best possible poker hand for each pair of
    #    hole cards for a given board
    result_list, winner_list = [None] * num_players, [0] * (num_players + 1)
    result_histograms = []
    for player in range(num_players):
        result_histograms.append([0] * 10)

    # Find the best possible poker hand given the created board and the
    # hole cards and save them in the results data structures
    (suit_histogram, histogram,
     max_suit) = prob_functions.preprocess_board(community_cards)
    for index, hole_card in enumerate(hole_cards):
        result_list[index] = prob_functions.detect_hand(
            hole_card, community_cards, suit_histogram, histogram, max_suit)

    # Find the winner of the hand and tabulate results
    winner_index = prob_functions.compare_hands(result_list)

    return [winner_index]
Beispiel #3
0
def single_prob(hole_cards, num_iterations, given_board):

    if given_board == []:
        given_board = None

    #generate deck that has the hole cards missing
    the_deck = prob_functions.generate_deck(hole_cards)

    num_players = len(hole_cards)

    # Create results data structures which tracks results of comparisons
    # 1) result_histograms: a list for each player that shows the number of
    #    times each type of poker hand (e.g. flush, straight) was gotten
    # 2) winner_list: number of times each player wins the given round
    # 3) result_list: list of the best possible poker hand for each pair of
    #    hole cards for a given board
    result_list, winner_list = [None] * num_players, [0] * (num_players + 1)
    result_histograms = []
    for player in range(num_players):
        result_histograms.append([0] * 10)

    # Choose whether we're running a Monte Carlo or exhaustive simulation
    board_length = 0 if given_board == None else len(given_board)

    # When a board is given, exact calculation is much faster than Monte Carlo
    # simulation, so default to exact if a board is given
    if given_board is not None or num_iterations == "e":
        generate_boards = prob_functions.generate_exhaustive_boards
    else:
        generate_boards = prob_functions.generate_random_boards

    # Run simulations
    for remaining_board in generate_boards(the_deck, num_iterations,
                                           board_length):
        # Generate a new board
        if given_board:
            board = given_board[:]
            board.extend(remaining_board)
        else:
            board = remaining_board

        # Find the best possible poker hand given the created board and the
        # hole cards and save them in the results data structures
        (suit_histogram, histogram,
         max_suit) = prob_functions.preprocess_board(board)
        for index, hole_card in enumerate(hole_cards):
            result_list[index] = prob_functions.detect_hand(
                hole_card, board, suit_histogram, histogram, max_suit)

        # Find the winner of the hand and tabulate results
        winner_index = prob_functions.compare_hands(result_list)
        winner_list[winner_index] += 1

        # Increment what hand each player made
        for index, result in enumerate(result_list):
            result_histograms[index][result[0]] += 1
    return prob_functions.return_results(hole_cards, winner_list)
Beispiel #4
0
def single_prob(hole_cards, num_iterations, given_board):

    if given_board == []:
        given_board = None

    #generate deck that has the hole cards missing
    the_deck = prob_functions.generate_deck(hole_cards)

    num_players = len(hole_cards)

    # Create results data structures which tracks results of comparisons
    # 1) result_histograms: a list for each player that shows the number of
    #    times each type of poker hand (e.g. flush, straight) was gotten
    # 2) winner_list: number of times each player wins the given round
    # 3) result_list: list of the best possible poker hand for each pair of
    #    hole cards for a given board
    result_list, winner_list = [None] * num_players, [0] * (num_players + 1)
    result_histograms = []
    for player in range(num_players):
        result_histograms.append([0] * 10)

    # Choose whether we're running a Monte Carlo or exhaustive simulation
    board_length = 0 if given_board == None else len(given_board)

    # When a board is given, exact calculation is much faster than Monte Carlo
    # simulation, so default to exact if a board is given
    if given_board is not None or num_iterations == "e":
        generate_boards = prob_functions.generate_exhaustive_boards
    else:
        generate_boards = prob_functions.generate_random_boards

    # Run simulations
    for remaining_board in generate_boards(the_deck, num_iterations, board_length):
        # Generate a new board
        if given_board:
            board = given_board[:]
            board.extend(remaining_board)
        else:
            board = remaining_board

        # Find the best possible poker hand given the created board and the
        # hole cards and save them in the results data structures
        (suit_histogram,
                histogram, max_suit) = prob_functions.preprocess_board(board)
        for index, hole_card in enumerate(hole_cards):
            result_list[index] = prob_functions.detect_hand(hole_card, board,
                                         suit_histogram, histogram, max_suit)

        # Find the winner of the hand and tabulate results
        winner_index = prob_functions.compare_hands(result_list)
        winner_list[winner_index] += 1

        # Increment what hand each player made
        for index, result in enumerate(result_list):
            result_histograms[index][result[0]] += 1
    return prob_functions.return_results(hole_cards, winner_list)