基于用户输入尺寸生成幻方的Python程序开发需求

幻方是指每行、每列及两条对角线的和均相等的方阵，以下是针对不同阶数幻方的Python实现方案：

奇数阶幻方（n 为奇数） #

最经典的实现方法是罗伯法（Siamese Method），核心步骤如下：

• 将数字1放在第一行的中间位置
• 后续每个数字放在当前位置的右上方
• 若右上方超出上边界，则放置到同列的最下方
• 若右上方超出右边界，则放置到同行的最左方
• 若右上方已有数字，则放置到当前位置的正下方

实现代码 #

def generate_odd_magic_square(n):
    if n % 2 == 0:
        raise ValueError("该函数仅支持奇数阶幻方生成")
    
    # 初始化n阶空方阵
    magic_square = [[0] * n for _ in range(n)]
    
    row, col = 0, n // 2
    num = 1
    
    while num <= n * n:
        magic_square[row][col] = num
        num += 1
        # 计算下一个位置的坐标
        next_row, next_col = (row - 1) % n, (col + 1) % n
        # 如果下一个位置已有数字，调整到当前位置正下方
        if magic_square[next_row][next_col] != 0:
            row += 1
        else:
            row, col = next_row, next_col
    
    return magic_square

def print_magic_square(square):
    n = len(square)
    for row in square:
        print(" ".join(f"{num:4}" for num in row))

# 使用示例
if __name__ == "__main__":
    n = int(input("请输入幻方的尺寸（奇数）："))
    try:
        magic_square = generate_odd_magic_square(n)
        print(f"{n}阶幻方：")
        print_magic_square(magic_square)
        # 验证幻和（幻和公式：n*(n²+1)/2）
        magic_sum = n * (n**2 + 1) // 2
        print(f"幻和为：{magic_sum}")
    except ValueError as e:
        print(e)

偶数阶幻方 #

偶数阶幻方分为两种情况：双偶阶（n 能被4整除）和单偶阶（n为偶数但不能被4整除）

双偶阶幻方（n % 4 == 0） #

采用对称交换法实现：

1. 从左到右、从上到下依次填入1到n²的数字
2. 将方阵划分为4x4的小方块，对每个小方块的对角线元素进行中心对称交换（即用n²+1减去该位置的数字）

实现代码片段 #

def generate_double_even_magic_square(n):
    if n % 4 != 0:
        raise ValueError("该函数仅支持双偶阶幻方生成")
    
    magic_square = [[i * n + j + 1 for j in range(n)] for i in range(n)]
    
    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):
                magic_square[i][j] = n * n + 1 - magic_square[i][j]
    
    return magic_square

单偶阶幻方（n % 2 == 0 and n % 4 != 0） #

单偶阶幻方通过分块调整实现，核心逻辑：

1. 将n表示为2*(2k+1)，把方阵分为A、B、C、D四个(2k+1)阶子方阵
2. 用罗伯法生成四个子幻方，按规则调整子方阵的数值偏移
3. 交换A与C、B与D中特定区域的元素，最终合并为完整幻方

简化实现代码 #

def generate_single_even_magic_square(n):
    if n % 2 != 0 or n % 4 == 0:
        raise ValueError("该函数仅支持单偶阶幻方生成")
    
    k = n // 2
    # 生成四个奇数阶子幻方
    A = generate_odd_magic_square(k)
    B = generate_odd_magic_square(k)
    C = generate_odd_magic_square(k)
    D = generate_odd_magic_square(k)
    
    # 为子方阵添加数值偏移
    for i in range(k):
        for j in range(k):
            A[i][j] += k*k
            B[i][j] += 2*k*k
            C[i][j] += 3*k*k
    
    # 交换指定区域的元素
    for i in range(k):
        for j in range(k - k//2):
            A[i][j], C[i][j] = C[i][j], A[i][j]
        for j in range(k//2 + 1, k):
            B[i][j], D[i][j] = D[i][j], B[i][j]
        if i == k//2:
            B[i][k//2], D[i][k//2] = D[i][k//2], B[i][k//2]
    
    # 合并子方阵为最终幻方
    magic_square = []
    for i in range(k):
        magic_square.append(A[i] + B[i])
    for i in range(k):
        magic_square.append(C[i] + D[i])
    
    return magic_square

通用生成函数 #

整合以上方法，实现支持所有合法阶数（n≥3）的通用幻方生成函数：

def generate_magic_square(n):
    if n < 3:
        raise ValueError("幻方尺寸至少为3")
    if n % 2 == 1:
        return generate_odd_magic_square(n)
    elif n % 4 == 0:
        return generate_double_even_magic_square(n)
    else:
        return generate_single_even_magic_square(n)

调用时直接传入幻方尺寸n，通过print_magic_square函数即可格式化打印结果。

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