Wordle项目列表处理逻辑导致输出不稳定的问题求助

问题描述 #

开发Wordle项目时，移除列表data中不必要项的代码偶尔输出不一致。当guess设为AMPLE时，有时输出正确的AMPLE，有时会出现AMPPLE，中间的列表输出也存在差异：

正确输出示例：

['AI0', 'AC0', 'MI1', 'PI2', 'PC2', 'PW2', 'LI3', 'LC3', 'EI4', 'EC4']
['AI0', 'PI2', 'PW2', 'LI3', 'EI4']
['AC0', 'MI1', 'PC2', 'LC3', 'EC4']
AMPLE

错误输出示例：

['AC0', 'AI0', 'MI1', 'PW2', 'PI2', 'PC2', 'LI3', 'LC3', 'EI4', 'EC4']
['AI0', 'PI2', 'PI2', 'LI3', 'EI4']
['AC0', 'MI1', 'PW2', 'PC2', 'LC3', 'EC4']
AMPPLE

问题根源 #

1. 集合（set）的无序性：原代码用set(data)去重，打乱了元素顺序，导致后续排序后相同索引的元素相对顺序不可控。
2. 错误的元素生成逻辑：原双重循环会为每个字符生成多个状态项（比如同一位置的C、W、I），后续的移除逻辑仅依赖相邻元素判断，无法处理多元素乱序的情况。
3. 不完善的移除逻辑：仅遍历相邻元素，当相同索引的元素顺序不符合预期时，会漏删或重复添加要移除的项，最终导致输出错误。

解决方案 #

核心是重构字符状态的生成逻辑，直接按Wordle规则生成每个字符的正确状态，避免冗余项，无需后续复杂的去重和移除操作：

# Word and Guess
word = "APPLE"
guess = "AMPLE"

# 检查猜测有效性
if len(guess) != 5:
    print("Guess should be 5 letters long.")
elif not guess.isalpha():
    print("Guess should be an English word.")
else:
    # 统计word中各字符的出现次数，用于跟踪匹配状态
    char_count = {}
    for char in word:
        char_count[char] = char_count.get(char, 0) + 1

    # 初始化结果列表，每个位置对应一个状态
    result = []

    # 第一步：标记正确位置（C），并减少对应字符的可用次数
    for idx in range(5):
        g_char = guess[idx]
        w_char = word[idx]
        if g_char == w_char:
            result.append(f"{g_char}C{idx}")
            char_count[g_char] -= 1
        else:
            result.append(None)  # 占位，后续处理

    # 第二步：标记错误位置但存在的字符（W）和不存在的字符（I）
    for idx in range(5):
        if result[idx] is not None:
            continue  # 已经是C，跳过
        g_char = guess[idx]
        if char_count.get(g_char, 0) > 0:
            result[idx] = f"{g_char}W{idx}"
            char_count[g_char] -= 1
        else:
            result[idx] = f"{g_char}I{idx}"

    # 生成带颜色的输出
    output = ""
    for item in result:
        status = item[1]
        char = item[0]
        if status == "C":
            output += "\033[1;33;40m" + char
        elif status == "W":
            output += "\033[1;32;40m" + char
        elif status == "I":
            output += "\033[1;37;40m" + char
    output += "\033[0;37;40m"

    # 测试输出
    print(result)
    print(output)

代码说明 #

1. 字符计数跟踪：用字典统计word中每个字符的出现次数，确保W标记不会重复使用超出word中存在的字符数量。
2. 分阶段标记状态：
   • 第一遍遍历优先标记位置正确的C状态，同时减少对应字符的可用次数。
   • 第二遍遍历处理剩余字符，标记W或I状态，完全符合Wordle的规则。
3. 避免冗余项：每个位置仅生成一个状态项，无需后续去重和复杂的移除逻辑，输出结果稳定可控。

原问题代码的局部修复（如果不想重构） #

如果暂时不想完全重构，也可以修复原逻辑中的问题：

1. 有序去重：替换集合去重，保留元素生成顺序：

   # 替换原set去重代码，temp_data是原双重循环生成的列表
   seen = set()
   data = []
   for item in temp_data:
       if item not in seen:
           seen.add(item)
           data.append(item)
   

2. 稳定排序：按索引+状态优先级排序，确保相同索引的高优先级元素在前：

   # 替换原冒泡排序
   def sort_key(item):
       # 优先级：C>W>I，对应数字0>1>2
       priority = {"C":0, "W":1, "I":2}
       return (int(item[2]), priority[item[1]])
   data = sorted(data, key=sort_key)
   

3. 分组保留最优项：按索引分组，每组只保留优先级最高的元素：

   # 替换原remove循环
   grouped = {}
   for item in data:
       idx = item[2]
       if idx not in grouped:
           grouped[idx] = item
       else:
           current_prio = {"C":0, "W":1, "I":2}[item[1]]
           existing_prio = {"C":0, "W":1, "I":2}[grouped[idx][1]]
           if current_prio < existing_prio:
               grouped[idx] = item
   oL = sorted(list(grouped.values()), key=lambda x: int(x[2]))
   

这样修改后，即使元素顺序受集合影响，排序和分组逻辑也能确保每个索引只保留最高优先级的元素，输出结果稳定。

内容的提问来源于stack exchange，提问作者Troy Dave Ericson Avendano