德州扑克翻牌前筹码栈转行动列表：修复get_actions函数

问题分析 #

我们需要根据玩家筹码栈的差值列表，生成符合德州扑克翻牌前规则的行动序列。核心逻辑是跟踪当前需跟注的金额，按玩家顺序处理每个决策（弃牌/加注/跟注），其中初始小盲（玩家4）和大盲（玩家5）的下注为强制操作，不计入行动列表。

修复后的代码 #

from more_itertools import pairwise

stacks = [[102,102,102,102], [101,101,99,99], [103.5,103.5,103.5], [100.5,100.5,100.5,93,79.5], [105.5,105.0,105.0,105.0], [94,93,93,93,93,73]]

def transform_stacks(stacks):
    # 计算每个玩家的筹码栈变化差值（仅保留有效变化）
    u = [[float(x) - float(y) for (x, y) in pairwise(stacks[z]) if x != '' and y != '' and abs(float(y) - float(x)) > 0.499] for z in range(len(stacks))]
    return u

transposed = transform_stacks(stacks)

def get_actions(transposed_diffs):
    player_bets = [0.0] * 6
    ptrs = [0] * 6
    folded = [False] * 6
    current_bet = 1.0  # 初始大盲金额
    
    # 初始化小盲和大盲的已下注（从差值中提取强制下注部分）
    if transposed_diffs[4] and transposed_diffs[4][0] == 0.5:
        player_bets[4] = transposed_diffs[4][0]
        ptrs[4] = 1
    if transposed_diffs[5] and transposed_diffs[5][0] == 1.0:
        player_bets[5] = transposed_diffs[5][0]
        ptrs[5] = 1
    
    actions = []
    
    while True:
        all_in_sync = True
        for player in range(6):
            if folded[player]:
                continue
            if player_bets[player] == current_bet:
                continue
            
            all_in_sync = False
            diffs = transposed_diffs[player]
            current_ptr = ptrs[player]
            
            # 无剩余筹码变化，判定为弃牌
            if current_ptr >= len(diffs):
                folded[player] = True
                actions.append("Fold")
                continue
            
            bet_amount = diffs[current_ptr]
            new_total_bet = player_bets[player] + bet_amount
            
            if new_total_bet > current_bet:
                # 加注，记录总下注金额
                actions.append(f"Raise {new_total_bet}")
                current_bet = new_total_bet
            elif new_total_bet == current_bet:
                # 跟注
                actions.append("Call")
            
            # 更新玩家下注状态
            player_bets[player] = new_total_bet
            ptrs[player] += 1
        
        if all_in_sync:
            break
    
    return actions

# 测试输出
result = get_actions(transposed)
print(result)
# 按示例格式输出
print(" - ".join(result))

关键逻辑说明 #

1. 初始化处理：

   • 从差值列表中提取玩家4（小盲）和玩家5（大盲）的强制下注金额，跳过这些强制操作的差值，仅处理后续决策。
   • 初始化当前需跟注金额为大盲的1BB。

2. 循环处理行动：

   • 每轮遍历所有玩家，检查是否所有未弃牌玩家的下注金额都等于当前需跟注金额，若满足则结束循环。
   • 对每个需行动的玩家：
     • 若没有剩余筹码变化，标记为弃牌并添加Fold行动。
     • 若有筹码变化，计算总下注金额：
       • 总金额大于当前需跟注金额：判定为加注，更新当前需跟注金额并添加Raise {总金额}行动。
       • 总金额等于当前需跟注金额：判定为跟注，添加Call行动。
     • 更新玩家的已下注金额和差值列表指针。

输出结果 #

运行代码后会输出：

['Fold', 'Raise 2', 'Fold', 'Raise 7.5', 'Fold', 'Raise 21', 'Fold', 'Call']
Fold - Raise 2 - Fold - Raise 7.5 - Fold - Raise 21 - Fold - Call

内容的提问来源于stack exchange，提问作者Alice Myers