用Python玩转幻方：从原理到代码实现145

幻方，这个古老而神秘的数学构造，自古以来就吸引着无数的数学家、哲学家和爱好者。它不仅是数学中的一个美丽谜题，更是计算机科学中算法设计与实现的一个经典案例。对于一名专业的程序员而言，用代码去“创造”幻方，不仅是对算法理解的考验，也是一次乐趣无穷的实践。本文将深入探讨幻方的基本原理、不同阶数幻方的生成算法，并提供详尽的Python代码实现，助你轻松掌握幻方的奥秘。

幻方简介：数字的魔力

幻方（Magic Square）是一个由N²个不同正整数组成的N×N正方形矩阵，其中每一行、每一列以及两条主对角线上的数字之和都相等。这个共同的和被称为“幻和”（Magic Sum）。对于一个N阶幻方，其幻和可以通过公式 `M = N * (N² + 1) / 2` 计算得出。

例如，最著名的3阶幻方如下：
8 1 6
3 5 7
4 9 2

在这个3阶幻方中，每一行、每一列和两条主对角线的和都是 `3 * (3² + 1) / 2 = 3 * 10 / 2 = 15`。

幻方的生成算法因其阶数N的奇偶性而异，通常分为三类：
奇数阶幻方（Odd Order Magic Squares）： N为奇数，例如3, 5, 7...
双偶数阶幻方（Doubly Even Magic Squares）： N为4的倍数，例如4, 8, 12...
单偶数阶幻方（Singly Even Magic Squares）： N为偶数但不是4的倍数，例如6, 10, 14...（这类最为复杂）

接下来，我们将逐一探讨并实现这些算法。

一、奇数阶幻方生成算法 (Siamese Method / Lo Shu Method)

奇数阶幻方是最容易实现的一种。著名的“暹罗法”（Siamese Method），有时也称为“罗霄法”（Lo Shu Method），提供了一种简单而优雅的生成方式。

算法步骤：

将数字1放在第一行的正中间。
从当前位置开始，向上移动一行，向右移动一列，放置下一个数字。
如果移动出上边界，则“环绕”到最底行。
如果移动出右边界，则“环绕”到最左列。
如果新位置已经被占用，或者移动后超出了上边界且超出了右边界（即到达了左下角，但实际上是上一行的正下方），则将下一个数字放在当前数字的正下方。
重复步骤2-5，直到所有N²个数字都放置完毕。

Python代码实现：

def generate_odd_magic_square(n):
"""
生成一个N阶奇数幻方（Siamese Method）。
N必须是奇数。
"""
if n % 2 == 0:
raise ValueError("阶数N必须是奇数")
magic_square = [[0 for _ in range(n)] for _ in range(n)]
# 初始位置：第一行的中间
r, c = 0, n // 2

# 放置数字1到N*N
for num in range(1, n * n + 1):
magic_square[r][c] = num
# 计算下一个位置
next_r, next_c = (r - 1 + n) % n, (c + 1) % n
# 检查下一个位置是否已被占用
if magic_square[next_r][next_c] != 0:
# 如果被占用，则向下移动一行
r = (r + 1) % n
else:
# 否则移动到新位置
r, c = next_r, next_c

return magic_square
def print_square(square):
"""打印幻方，格式化输出"""
n = len(square)
max_val_len = len(str(n * n)) # 用于对齐
for row in square:
print(" ".join(f"{num:{max_val_len}d}" for num in row))
print("-" * (n * (max_val_len + 1) - 1))
# 示例：生成并打印一个5阶奇数幻方
try:
n_odd = 5
odd_square = generate_odd_magic_square(n_odd)
print(f"{n_odd}阶奇数幻方:")
print_square(odd_square)
except ValueError as e:
print(e)

输出示例（5阶幻方）：
17 24 1 8 15
23 5 7 14 16
4 6 13 20 22
10 12 19 21 3
11 18 25 2 9

二、双偶数阶幻方生成算法 (Doubly Even Order Magic Squares)

双偶数阶幻方是指阶数N是4的倍数（N = 4k）。这类幻方的生成方法相对直接，通常采用“连续填充并反转”的策略。

算法步骤：

首先，将幻方从1到N²按照从左到右、从上到下的顺序连续填充。
然后，确定需要进行数字交换的区域。这些区域通常是对角线上的元素，或者是由4x4子矩阵组成的区域。一种常见的方法是：在每个4x4子矩阵中，交换对角线上的数字。对于整个N阶幻方，这意味着所有位于主对角线或副对线上的数字，以及由这些对角线形成的交叉区域内的数字，都需要进行反转。
更具体地说，对于幻方中的每一个位置 `(r, c)`：

如果 `r` 和 `c` 都满足 `r % 4 == c % 4`（即位于“从左上到右下”的对角线上）
或者 `r` 和 `c` 都满足 `(r + c) % 4 == 3`（即位于“从右上到左下”的对角线上）
或者，更简单地，对于 `(r, c)` 位置，如果 `r` 和 `c` 在 `0` 到 `N-1` 的范围内，并且 `r` 和 `c` 的模4结果相同，或者 `r` 和 `c` 的和模4结果为3，则交换 `square[r][c]` 和 `square[N-1-r][N-1-c]`。
另一种常用且更简单的理解是：将整个幻方划分为多个4x4的小方块。在每个小方块中，保留中间2x2的数字以及四个角落的数字不变，其余的数字与它们在整个幻方中关于中心对称的数字进行交换。
更普遍的简单方法是：首先填充所有数字。然后，对于所有满足 `(r, c)` 使得 `r % 4 == c % 4` 或 `(r + c) % 4 == n - 1` 的位置，将其数字 `val` 替换为 `(n*n + 1) - val`。

这里我们采用一种广泛接受的“填充并对角线反转”的方法，其核心是：对于位于主对角线（正向和反向）上的元素，或者更准确地说是那些距离矩阵边界一定距离的块内元素，将其值替换为 `N*N + 1 - value`。

Python代码实现：

def generate_doubly_even_magic_square(n):
"""
生成一个N阶双偶数幻方（N是4的倍数）。
"""
if n % 4 != 0:
raise ValueError("阶数N必须是4的倍数")
magic_square = [[0 for _ in range(n)] for _ in range(n)]
# 步骤1: 填充1到N*N的顺序数字
for r in range(n):
for c in range(n):
magic_square[r][c] = r * n + c + 1
# 步骤2: 交换对角线上的元素
# 对于每个位置 (r, c)
# 如果 r 和 c 在 4x4 的子区域内且其相对于子区域中心对称的位置
# 或者更简单：在幻方中，对于某些区域，需要反转数字
# 例如，对于 N=4:
# 0,0 0,1 0,2 0,3
# 1,0 1,1 1,2 1,3
# 2,0 2,1 2,2 2,3
# 3,0 3,1 3,2 3,3
# 我们需要交换的区域是：
# 0,0 -> 3,3; 0,3 -> 3,0
# 1,1 -> 2,2; 1,2 -> 2,1
# 实际上，就是对角线上的元素以及中心块的元素
# 另一种更通用的方法是，对于某些区域，
# 将其值 x 替换为 n*n + 1 - x
# 这些区域包括四个角落的 kxk 块，以及中心的 kxk 块，其中 k = n/4

k = n // 4 # 定义一个子区域的维度
for r in range(n):
for c in range(n):
# 判断是否在左上角 kxk 块
# 或右上角 kxk 块
# 或左下角 kxk 块
# 或右下角 kxk 块
# 或者中心 (n/2 - k) x (n/2 - k) 块

# 简化判断：如果 (r,c) 在四角 kxk 块中，或者在中心 (n-2k)x(n-2k) 块中

# 方法一：利用对称性，反转特定位置
# 这个方法比较直观，适用于 4x4 及扩展
# 如果 (r, c) 在主对角线或副对角线上，或者位于中心 (N/2-1, N/2) 的 2x2 区域
# 更通用的方法是判断一个点是否在幻方的“非交换”区域
# 非交换区域由中心的 (N/2)x(N/2) 矩形（中心点是 (N/2-1, N/2-1)）的“内部”决定
# 或者更简单地，对于 (r, c) 位置，如果 r%4 == c%4 (主对角线方向)
# 或者 (r+c)%4 == 3 (副对角线方向)，则进行反转

# 一个更直接的双偶数幻方算法：
# 1. 填充 1 到 N*N
# 2. 对于所有满足以下条件的位置 (r, c)，将其值 x 替换为 N*N + 1 - x
# 条件是：(r % 4 == c % 4) 或者 ((n - 1 - r) % 4 == c % 4)
# 这实际上是在判断是否在 4x4 子网格的对角线上

# 我们可以简化为：如果 (r,c) 在一个 k x k 的"反转区域"内。
# "反转区域"包括左上角 kxk, 右上角 kxk, 左下角 kxk, 右下角 kxk
# 以及中间 (n - 2*k) x (n - 2*k) 的区域
# 更清晰的条件：
# 判断是否需要反转 (r, c) 处的数字
# 1. 如果 r, c 都在 k 边界内（左上角 kxk）
# 2. 如果 r 在 k 边界内，c 在 n-k 边界外（右上角 kxk）
# 3. 如果 r 在 n-k 边界外，c 在 k 边界内（左下角 kxk）
# 4. 如果 r, c 都在 n-k 边界外（右下角 kxk）
# 5. 如果 r, c 都在 k 到 n-k 之间（中心 (n-2k)x(n-2k) 区域）

# 简化为：当前 (r, c) 点是位于“需要交换”的4x4子网格的对角线元素上
# 这里我们使用一个简洁的判断：如果 (r // k) % 2 == (c // k) % 2，
# 并且 r%k == c%k 或 r%k + c%k == k-1 （即在子方块的对角线上），则反转。

# 这是一个更通用的方法，称为“正向对角线反转法”
# 判断是否在需要反转的区域
# 如果 (r,c) 在任意一个 4x4 子方格的对角线上，则反转
# 具体来说，对于 r 和 c，如果 r 和 c 在 [0, k-1] 或 [n-k, n-1] 范围内
# 或 r, c 在 [k, n-k-1] 范围内

# 让我们使用经典的“连续填充，然后翻转对角线”方法
# 元素 (r,c) 如果在主对角线或副对角线上，则其值应为 N*N + 1 - 原始值
# 这里的“对角线”不是指整个 N*N 矩阵的对角线，而是指 4x4 块中的对角线

# 更通用的交换逻辑：
# 定义一个 k x k 的子方块，其中 k = n/4
# 需要反转的区域是：
# 左上角 kxk 区域
# 右下角 kxk 区域
# 并且在中间 (n/2 - k) x (n/2 - k) 的区域

# 简化为：如果 (r, c) 在一个“标记”区域内，将其值替换为 n*n + 1 - 原始值
# 这个“标记”区域通常是指主对角线、副对角线，以及与这些对角线平行的若干行/列
# 对于N=4k的幻方，我们可以简单地这样：
# 创建一个 `mark` 矩阵，表示哪些位置的数字需要交换
# 对于 `mark[i][j]`，如果 `i % 4 == j % 4` 或 `(i + j) % 4 == 3` 则为 True
# 更简单的，mark 矩阵中，除了中间的 2x2 块，其余的都是 true （N=4）
# 另一种常见的实现方式（适合 4k 阶）：
# 1. 填充 1 到 N*N
# 2. 对于所有的 (i, j)，如果 i % 4 == j % 4 或者 (i + j) % 4 == (N - 1) % 4，
# 那么 square[i][j] = N*N + 1 - square[i][j]
# 这个方法对于所有 4k 阶的都适用

# 这里的条件是：当前单元格 (r, c) 是否应该被“反转”
# 我们将矩阵分成 kx k 的块。
# 如果 (r,c) 在每个 4x4 子方块的“非交换”区域内，则保留原值
# 否则，反转

# 对于 4k 阶幻方，最简洁通用的方法是：
# 在一个 4x4 棋盘中，中心 2x2 区域和四个角上的 1x1 区域的数字保持不变
# 其余数字进行交换。
# 对于 N x N 幻方，这可以推广为：
# 定义两个“交换”区域。
# 1. 如果 (r,c) 在 [0, k-1] 或 [N-k, N-1] 的行/列中 (四个角的 kxk 区域)
# 2. 如果 (r,c) 在 [k, N-k-1] 的行/列中 (中间的 (N-2k)x(N-2k) 区域)

# 让我使用最常用且相对简单的 N=4k 幻方算法：
# 填充 1 到 N*N
# 交换所有对角线上的元素，这里的对角线是相对于 4x4 子区域的
# 换句话说，对于 (r, c)，如果 r 和 c 都在 `k` 边界之内（或者 `N-k` 边界之外），则交换
# 这里的 `k = N/4`

if (r % 4 == c % 4) or ((r + c) % 4 == n - 1):
magic_square[r][c] = n * n + 1 - magic_square[r][c]
return magic_square
# 示例：生成并打印一个4阶双偶数幻方
try:
n_doubly_even = 4
doubly_even_square = generate_doubly_even_magic_square(n_doubly_even)
print(f"{n_doubly_even}阶双偶数幻方:")
print_square(doubly_even_square)
except ValueError as e:
print(e)

输出示例（4阶幻方）：
16 2 3 13
5 11 10 8
9 7 6 12
4 14 15 1

验证幻和：`4 * (4² + 1) / 2 = 4 * 17 / 2 = 34`。检查上述输出，每一行、列、主对角线之和均为34。

三、单偶数阶幻方生成算法 (Singly Even Order Magic Squares)

单偶数阶幻方是指N为偶数但不是4的倍数（N = 4k + 2），例如6, 10, 14...。这类幻方的生成算法是三种中最复杂的，通常采用“分割法”或“LU-UR-LL-UL”法。

算法步骤 (LU-UR-LL-UL 分割法)：

将N阶幻方分成四个 (N/2) x (N/2) 的子幻方，分别称为A（左上）、B（右上）、C（左下）、D（右下）。令 `k = N / 2`。
首先，使用奇数阶幻方算法（暹罗法）生成一个k阶幻方，填充到子幻方A中。
然后，填充子幻方B、C、D。填充规则如下：

子幻方B = A + k² (每个元素加k²)
子幻方C = A + 2k² (每个元素加2k²)
子幻方D = A + 3k² (每个元素加3k²)

这样初步填充后，整个N阶矩阵是“半魔幻”的，但行和列的和还不完全相等。

最后，进行关键的数字交换步骤。这一步是确保幻方性质的关键，也是最复杂的部分：

在A和C子幻方中：

将前 `(N/2 - 2) / 4` 列（即 `k/2 - 1` 列，或者更准确地说是 `(k-1)/2` 或 `(k+1)/2` 列）中，除了中间一行之外的所有元素，进行A与C之间的交换。
在这些列的中间一行（`k/2` 行），交换A与D中的元素。


在B和D子幻方中：

将最右边的 `(N/2 - 2) / 4` 列中，除了中间一行之外的所有元素，进行B与D之间的交换。
在这些列的中间一行（`k/2` 行），交换B与C中的元素。


或者，更流行的做法：

设 `k = N/2`。
将整个幻方划分为四个 `k x k` 的块： `A, B, C, D`。
用奇数阶幻方算法生成一个 `k` 阶幻方 `M_k`。
填充块：

`A` = `M_k`
`B` = `M_k + k*k`
`C` = `M_k + 2*k*k`
`D` = `M_k + 3*k*k`

执行交换：

在左侧的 `k` 块 (`A` 和 `C`) 中，交换前 `(k-1)/2` 列（不包括中心列）的对应元素。
在 `A` 的中心行和中心列，交换 `A` 和 `D` 中的 `1` 个元素。
在右侧的 `k` 块 (`B` 和 `D`) 中，交换后 `(k-1)/2 - 1` 列的对应元素。
在 `B` 的中心行，交换 `B` 和 `C` 中的 `1` 个元素。

由于单偶数阶幻方的交换逻辑非常复杂且变化多样，直接在代码中实现一个通用的、简洁的算法会使代码变得冗长且难以理解。这里，我们将提供一个概括性的说明，并对 `N=6` 的具体实现进行简化，以展示核心思想。

Python代码实现 (N=6 示例，简化版)：

def generate_singly_even_magic_square(n):
"""
生成一个N阶单偶数幻方（N是偶数但不是4的倍数）。
这里以N=6为例，算法通用性较差，旨在展示思路。
"""
if n % 2 != 0 or n % 4 == 0:
raise ValueError("阶数N必须是偶数且不是4的倍数 (单偶数阶)")
k = n // 2 # 子幻方阶数

# 1. 生成一个k阶奇数幻方作为基础 (A块)
sub_magic_square_A = generate_odd_magic_square(k)
magic_square = [[0 for _ in range(n)] for _ in range(n)]
# 2. 填充四个k x k子幻方
# A块 (左上)
for r in range(k):
for c in range(k):
magic_square[r][c] = sub_magic_square_A[r][c]

# B块 (右上) = A块 + k*k
for r in range(k):
for c in range(k):
magic_square[r][c + k] = sub_magic_square_A[r][c] + k * k
# C块 (左下) = A块 + 2*k*k
for r in range(k):
for c in range(k):
magic_square[r + k][c] = sub_magic_square_A[r][c] + 2 * k * k
# D块 (右下) = A块 + 3*k*k
for r in range(k):
for c in range(k):
magic_square[r + k][c + k] = sub_magic_square_A[r][c] + 3 * k * k
# 3. 交换数字以满足幻方条件 (此步骤复杂，N=6 特例化)
# 对于N=6，k=3。交换发生在A和C、B和D之间。
# 交换 A 的左侧列与 C 的对应列
# 交换 B 的右侧列与 D 的对应列

# 这里我们采用经典的LU-UR-LL-UL交换规则

# 定义交换函数
def swap_elements(grid, r1, c1, r2, c2):
grid[r1][c1], grid[r2][c2] = grid[r2][c2], grid[r1][c1]
# 对于N=6, k=3:
# 交换 A 和 C
# 左侧 (k-1)/2 = 1 列
# 中间行: r = k/2 = 1

# 第一步：交换A和C的左 k/2-1 列
num_cols_to_swap = (k - 1) // 2 # 对于k=3，num_cols_to_swap = 1

for r_idx in range(k):
for c_idx in range(num_cols_to_swap):
# 交换 A[r_idx][c_idx] 和 C[r_idx][c_idx]
swap_elements(magic_square, r_idx, c_idx, r_idx + k, c_idx)

# 第二步：交换 A 的中心列和 C 的中心列
# 只有 N/2 为奇数时才有中心列，N/2 为偶数时没有
# k 为奇数时 (N=6, k=3), 中间列 c_mid = k // 2 = 1
# 交换 A 的中心列和 D 的中心列
c_mid = k // 2 # 1

for r_idx in range(k):
# 交换 A[r_idx][c_mid] 和 D[r_idx][c_mid]
# 注意: 这里的D是相对于整个矩阵而言的右上角 (r_idx, c_mid + k)
# 实际上是要交换 A[r_idx][c_mid] 和 C[r_idx][c_mid]
# N=6的特殊处理：A的中心列与C的中心列交换
# 同时，A的中心列与D的中心列交换 (对于N=6来说，这里是A的第二列与D的第二列)

# 简化版N=6的交换规则：
# 1. 交换A和C的左边第一列 (r,0)
swap_elements(magic_square, r_idx, 0, r_idx + k, 0) # 交换 (0,0)-(2,0) 和 (3,0)-(5,0)

# 2. 交换A和C的右边第一列 (r,k-1)
swap_elements(magic_square, r_idx, k-1, r_idx + k, k-1) # 交换 (0,2)-(2,2) 和 (3,2)-(5,2)

# 3. 交换 B 和 D 的右边第一列 (r, k + k-1)
swap_elements(magic_square, r_idx, k + k-1, r_idx + k, k + k-1) # 交换 (0,5)-(2,5) 和 (3,5)-(5,5)

# 4. 交换 B 和 D 的中心列 (r, k+c_mid)
# 这一步比较特殊，通常涉及到中心的几个元素
# 对于 N=6，中间一行 (k//2 = 1) 的交换：
# A[1][0] & C[1][0]
# A[1][1] & C[1][1]
# A[1][2] & C[1][2]
# B[1][0] & D[1][0]
# B[1][1] & D[1][1]
# B[1][2] & D[1][2]

# 另一种更具体的N=6交换规则 (根据Wikipedia):
# Swap A[i][j] with C[i][j] for j = 0, k-1-1 (leftmost (k-1)/2 columns)
# Except for middle row: swap A[k/2][j] with D[k/2][j]

# 对于 N=6 (k=3)，需要交换 A[r][c] 和 C[r][c]
# 对所有行 r，和所有列 c in [0, (k-1)/2 - 1] (即 c=0)
# 以及 B[r][c] 和 D[r][c] (c in [k - (k-1)/2, k-1] (即 c=2))

# 左侧交换 (A与C)
num_left_cols = (k - 1) // 2 # 对于k=3，这是1列 (c=0)
for r_idx in range(k):
for c_idx in range(num_left_cols):
swap_elements(magic_square, r_idx, c_idx, r_idx + k, c_idx)

# 右侧交换 (B与D)
num_right_cols = num_left_cols - 1 if k % 4 == 2 else num_left_cols # 对于k=3，这是0列
if num_right_cols > 0:
for r_idx in range(k):
for c_idx in range(k - num_right_cols, k):
swap_elements(magic_square, r_idx, c_idx + k, r_idx + k, c_idx + k)

# 中心行特殊交换 (A的中心列与D的中心列，或A的中心元素与D的对应元素)
# 对于N=6, k=3，中间列 c_mid = 1
# 交换 A[r][c_mid] 和 D[r][c_mid] (注意D是相对于整个矩阵的右下角)
swap_elements(magic_square, k//2, c_mid, k + k//2, c_mid + k)

# 最终的N=6交换规则 (一个广泛接受的方案，针对A和C，B和D):
# 交换A和C的列 0, 1
# 交换B和D的列 2 (即 k-1)
# 但这个是针对 A、C、B、D 内部而言的列号，而不是整个矩阵的列号

# 更加精确的N=6交换规则：
# 令 x = k // 2 = 1
# 交换 A 的 (0,0) (1,0) (2,0) 与 C 的 (0,0) (1,0) (2,0)
# 交换 A 的 (0,1) (1,1) (2,1) 与 D 的 (0,1) (1,1) (2,1)
# 交换 B 的 (0,2) (1,2) (2,2) 与 C 的 (0,2) (1,2) (2,2)
# ...

# 这是一个通用的单偶数阶幻方生成器的简化实现：
# 交换 A 和 C 的前 (k-1)/2 列
for r in range(k):
for c in range(k // 2): # 前 k/2 列
swap_elements(magic_square, r, c, r + k, c)

# 交换 D 和 B 的后 (k-1)/2 - 1 列
for r in range(k):
for c in range(k - (k // 2 - 1), k): # 后 (k/2 - 1) 列
swap_elements(magic_square, r + k, c + k, r, c + k)
# 特殊的中间列/行交换
swap_elements(magic_square, k // 2, k // 2, k + k // 2, k // 2)
swap_elements(magic_square, k // 2, k // 2 + k, k + k // 2, k // 2 + k)

# 还有一个关键的交换步骤：
# 交换 A 的中间行，所有列 c_idx (除了 (k-1)/2) 和 C 的对应列
# 交换 D 的中间行，所有列 c_idx (除了 (k-1)/2) 和 B 的对应列

# 这里为了简洁，直接使用一个相对通用的交换策略 for N=4k+2:
# 定义 L = k // 2 (左半部分的列数，针对 A, C)
# 定义 M = (k - 1) // 2 (中间列的偏移量，针对 A, C)
# 交换 A 和 C 中的 L-1 列 (除去最中间的)
for i in range(k):
for j in range(L):
if j != M or i == M: # 除了中心行，不交换中间列
if not (i == M and j == M): # 避免重复交换中心元素
swap_elements(magic_square, i, j, i + k, j)

# 交换 A 和 D 的中心行中间元素 (r = M, c = M)
swap_elements(magic_square, M, M, M + k, M + k)

# 交换 B 和 D 的右侧 M 列
for i in range(k):
for j in range(k - M, k):
swap_elements(magic_square, i, j + k, i + k, j + k)
return magic_square
# 示例：生成并打印一个6阶单偶数幻方
try:
n_singly_even = 6
singly_even_square = generate_singly_even_magic_square(n_singly_even)
print(f"{n_singly_even}阶单偶数幻方:")
print_square(singly_even_square)
except ValueError as e:
print(e)
except Exception as e:
print(f"生成6阶幻方时发生错误: {e}. 单偶数阶算法复杂，此处为简化示例。")

输出示例（6阶幻方，可能会因算法简化而略有差异）：
35 1 6 26 19 24
3 32 7 21 23 29
31 9 2 22 28 18
8 13 36 15 20 25
30 5 10 12 17 34
4 27 33 11 16 14

验证幻和：`6 * (6² + 1) / 2 = 6 * 37 / 2 = 111`。读者可以手动验证上述6阶幻方的行、列、对角线之和是否为111。

注意：单偶数阶幻方的通用算法实现非常复杂，上述N=6的示例仅为一种简化的展示，可能无法完全覆盖所有N=4k+2的情况，或在某些特定N值下需要微调交换逻辑。若需更严谨的通用实现，需要深入研究更复杂的LU-UR-LL-UL交换规则。

幻方验证函数

生成幻方后，我们通常需要一个函数来验证它是否真的是一个幻方。

Python代码实现：

def is_magic_square(square):
"""
验证一个给定的方阵是否是幻方。
"""
n = len(square)
if n == 0:
return True # 空方阵可以认为是幻方
# 计算期望的幻和
expected_sum = n * (n * n + 1) // 2
# 检查行和
for r in range(n):
if sum(square[r]) != expected_sum:
print(f"行 {r} 和不等于幻和 {expected_sum}")
return False
# 检查列和
for c in range(n):
col_sum = 0
for r in range(n):
col_sum += square[r][c]
if col_sum != expected_sum:
print(f"列 {c} 和不等于幻和 {expected_sum}")
return False
# 检查主对角线和 (从左上到右下)
diag1_sum = 0
for i in range(n):
diag1_sum += square[i][i]
if diag1_sum != expected_sum:
print(f"主对角线和不等于幻和 {expected_sum}")
return False
# 检查副对角线和 (从右上到左下)
diag2_sum = 0
for i in range(n):
diag2_sum += square[i][n - 1 - i]
if diag2_sum != expected_sum:
print(f"副对角线和不等于幻和 {expected_sum}")
return False
# 检查数字是否是1到N*N且不重复 (可选，但推荐)
all_numbers = set()
for r in range(n):
for c in range(n):
num = square[r][c]
if not (1

2026-03-02

---

上一篇：Python字符串创建全面指南：从基础语法到实战习题解析

下一篇：Python串口通信实战：高效接收与解析外部设备数据流