欧拉计划Problem #11代码输出异常，寻求错误排查帮助

主要错误点分析 #

1. 水平检查函数（horizontalCheck）逻辑混乱 #

原函数在计算连续4个数的乘积时，每乘一个数就更新最大值，随后执行除法操作，直接破坏了乘积计算逻辑：

for k in range(j, j + 4):
    checkSum *= int(smallArray[i][k])
    if checkSum > maxHorizontal:
        maxHorizontal = checkSum
    elif int(smallArray[i][j]) != 0:
        checkSum //= int(smallArray[i][j])

问题在于：

• 每次乘完单个数字就判断最大值，此时checkSum是1到k的累积乘积，并非连续4个数的乘积
• 除法操作会重置checkSum为后续数字的乘积，最终checkSum实际是第4个数字的值，而非四个数的乘积

2. 垂直检查函数（verticalCheck）多余的除法操作 #

原函数计算完垂直方向4个数的乘积后，执行了无意义的除法：

if checkVerticalSum > maxVertical:
    maxVertical = checkVerticalSum
elif int(smallArray[i][j]) != 0:
    checkVerticalSum //= int(smallArray[i][j])

此处除法操作既不会被后续循环复用，也不会影响最大值计算，属于冗余错误代码。

3. 对角线检查函数（diagonalCheck、oppositeDiagonalCheck）无效冗余代码 #

两个对角线函数中，计算完4个数乘积后存在以下代码：

if k < 3 and int(smallArray[i + k][j + k]) != 0:
    checkDiagonalSum //= int(smallArray[i + k][j + k])

由于for k in range(4)结束后，k的值固定为3，k<3永远为假，这段代码永远不会执行；同时即使执行，也会破坏乘积结果，属于错误的冗余逻辑。

修正后的代码 #

smallArray = []

grid = """08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48"""

gridArray = grid.split("\n")

for i in range(len(gridArray)):
    smallArray.append(gridArray[i].split(" "))

def horizontalCheck(smallArray):
    maxHorizontal = 0
    for i in range(len(smallArray)):
        for j in range(len(smallArray[i]) - 3):
            product = 1
            for k in range(j, j + 4):
                product *= int(smallArray[i][k])
            if product > maxHorizontal:
                maxHorizontal = product
    return maxHorizontal

def verticalCheck(smallArray):
    maxVertical = 0
    for i in range(len(smallArray) - 3):
        for j in range(len(smallArray[i])):
            product = 1
            for k in range(i, i + 4):
                product *= int(smallArray[k][j])
            if product > maxVertical:
                maxVertical = product
    return maxVertical

def diagonalCheck(smallArray):
    maxDiagonal = 0
    for i in range(len(smallArray) - 3):
        for j in range(len(smallArray[i]) - 3):
            product = 1
            for k in range(4):
                product *= int(smallArray[i + k][j + k])
            if product > maxDiagonal:
                maxDiagonal = product
    return maxDiagonal

def oppositeDiagonalCheck(smallArray):
    maxDiagonal = 0
    # 简化循环范围：从第4行开始（索引3），列从0到第17列（索引17）
    for i in range(3, len(smallArray)):
        for j in range(len(smallArray[i]) - 3):
            product = 1
            for k in range(4):
                product *= int(smallArray[i - k][j + k])
            if product > maxDiagonal:
                maxDiagonal = product
    return maxDiagonal

# 计算所有方向的最大值
max_product = max(
    horizontalCheck(smallArray),
    verticalCheck(smallArray),
    diagonalCheck(smallArray),
    oppositeDiagonalCheck(smallArray)
)

print("水平方向最大值:", horizontalCheck(smallArray))
print("垂直方向最大值:", verticalCheck(smallArray))
print("正对角线方向最大值:", diagonalCheck(smallArray))
print("反对角线方向最大值:", oppositeDiagonalCheck(smallArray))
print("全局最大值:", max_product)

修正说明 #

• 所有函数改为先计算连续4个数的完整乘积，再与当前最大值比较，移除了所有多余的除法操作和中间错误的最大值更新
• 反对角线函数的循环范围简化为正向遍历，逻辑更清晰，结果与原范围一致
• 新增全局最大值计算，直接输出欧拉计划Problem #11的预期结果：70600674

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