如何用Python生成幻方矩阵？现有代码仅支持奇数阶求修正

给定一个N×N规格的矩阵篮子，每个格子放入1到N²范围内的鸡蛋，需排列成幻方矩阵，使每行、每列及两条对角线的和相等。现有代码仅支持奇数阶幻方，需修改以支持偶数阶。

修改后的完整代码 #

def generate_magic_square(n):
    # 初始化矩阵
    magic_square = [[0 for _ in range(n)] for _ in range(n)]
    
    if n % 2 == 1:
        # 奇数阶幻方（原算法优化，修正整数除法）
        i = n // 2
        j = n - 1
        num = 1
        while num <= n * n:
            if i == -1 and j == n:
                j = n - 2
                i = 0
            else:
                if j == n:
                    j = 0
                if i < 0:
                    i = n - 1
            if magic_square[i][j] != 0:
                j -= 2
                i += 1
                continue
            magic_square[i][j] = num
            num += 1
            j += 1
            i -= 1
    elif n % 4 == 0:
        # 双偶阶幻方（n为4的倍数）
        for i in range(n):
            for j in range(n):
                magic_square[i][j] = (n * i) + j + 1
        # 反转特定区域的数字
        for i in range(n):
            for j in range(n):
                # 跳过4x4子块的对角线位置
                if (i % 4 == 0 and j % 4 == 0) or (i % 4 == 3 and j % 4 == 3) or \
                   (i % 4 == 0 and j % 4 == 3) or (i % 4 == 3 and j % 4 == 0):
                    continue
                # 在同一4x4子块的非对角线区域反转数字
                if (i // 4) % 2 == (j // 4) % 2:
                    magic_square[i][j] = n * n + 1 - magic_square[i][j]
    else:
        # 单偶阶幻方（n为偶数但非4的倍数，即n=4k+2）
        k = n // 2
        # 生成k阶奇数幻方作为基础
        odd_square = generate_magic_square(k)
        # 填充四个象限
        quadrant_offset = [0, 2*k*k, 3*k*k, k*k]
        for i in range(k):
            for j in range(k):
                magic_square[i][j] = odd_square[i][j] + quadrant_offset[0]
                magic_square[i][j + k] = odd_square[i][j] + quadrant_offset[1]
                magic_square[i + k][j] = odd_square[i][j] + quadrant_offset[2]
                magic_square[i + k][j + k] = odd_square[i][j] + quadrant_offset[3]
        # 交换左侧象限的特定元素
        for i in range(k):
            for j in range(k):
                if j != k // 2:
                    # 上半部分非中间列交换
                    if i < k // 2:
                        magic_square[i][j], magic_square[i + k][j] = magic_square[i + k][j], magic_square[i][j]
                    # 中间行非倒数第二列交换
                    if i == k // 2 and j != k // 2 - 1:
                        magic_square[i][j], magic_square[i + k][j] = magic_square[i + k][j], magic_square[i][j]
        # 交换中间位置的元素
        magic_square[k//2][k//2], magic_square[k//2 + k][k//2] = magic_square[k//2 + k][k//2], magic_square[k//2][k//2]
    
    # 计算并输出幻和
    magic_sum = n * (n * n + 1) // 2
    print(f"每行、每列及对角线的鸡蛋总和: {magic_sum}\n")
    # 格式化输出矩阵
    for row in magic_square:
        print(' '.join(f"{num:2d}" for num in row))

if __name__ == "__main__":
    n = int(input("请输入矩阵的行数: "))
    if n < 3:
        print("幻方至少需要3阶（3×3及以上）")
    else:
        generate_magic_square(n)

代码功能说明 #

• 奇数阶幻方：保留原算法核心，修正了整数除法问题，确保索引为整数，避免类型错误。
• 双偶阶幻方：先按顺序填充数字，再反转4×4子块内非对角线位置的数字，保证行、列、对角线和一致。
• 单偶阶幻方：基于奇数阶幻方生成四个象限，通过交换特定位置元素调整幻和，适配n=4k+2类型的偶数阶。

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