2025-10-02：不同 XOR 三元组的数目Ⅰ。用go语言，给你一个长度为 n 的数组 nums，数组恰好包含 1 到 n 这 n 个整数（每个数出现一次）

2025-10-02：不同 XOR 三元组的数目Ⅰ。用go语言，给你一个长度为 n 的数组 nums，数组恰好包含 1 到 n 这 n 个整数（每个数出现一次）。

对任意满足 i ≤ j ≤ k 的下标三元组，把对应的三个元素按位异或得到一个数，称为该三元组的异或结果。

问在所有可能的下标三元组中，这些异或结果一共能出现多少个不同的值，并返回这个不同值的个数。

1 <= n == nums.length <= 100000。

1 <= nums $i$ <= n。

nums 是从 1 到 n 的整数的一个排列。

输入： nums = $3,1,2$ 。

输出： 4。

解释：

可能的 XOR 三元组值包括：

(0, 0, 0) → 3 XOR 3 XOR 3 = 3
(0, 0, 1) → 3 XOR 3 XOR 1 = 1
(0, 0, 2) → 3 XOR 3 XOR 2 = 2
(0, 1, 2) → 3 XOR 1 XOR 2 = 0

不同的 XOR 值为 {0, 1, 2, 3}，因此输出为 4。

题目来自力扣3513。

解决过程分析

1. 关键观察（脑筋急转弯）

这个问题的核心是一个数学洞察 ：对于给定的排列，所有可能的三元组异或结果的不同值数量只与数组长度 n 有关，而与数组中元素的具体排列顺序无关。

2. 算法逻辑

当 n ≤ 2 时：直接返回 n。因为当数组元素很少时，所有可能的异或结果就是数组元素本身。
当 n > 2 时 ：返回 1 << bits.Len(uint(n))，这里的 bits.Len(uint(n)) 计算的是能够表示数字 n 所需的最小二进制位数。

3. 具体计算步骤

以输入 nums = [3,1,2]（n=3）为例：

计算 bits.Len(uint(3))：数字 3 的二进制是 11，需要 2 位来表示
计算 1 << 2：即 2 的 2 次方，结果为 4
最终输出为 4，与题目示例一致

4. 数学原理说明

这种简洁解法的背后原理是：当 n > 2 时，所有可能的异或结果恰好构成一个从 0 到 2^k - 1 的连续整数集合，其中 k 是满足 2^k ≥ n 的最小整数。这利用了异或运算的完备性和排列的特殊性质。

复杂度分析

时间复杂度：O(1)

算法只进行了常数次操作：检查 n 的大小，计算二进制位数，执行位运算
与输入规模 n 无关，是常数时间复杂度

空间复杂度：O(1)

只使用了固定数量的变量（n 的存储等），没有使用随输入规模增长的额外数据结构
是常数空间复杂度

Go完整代码如下：

go 复制代码

package main

import (
	"fmt"
	"math/bits"
)

func uniqueXorTriplets(nums []int) int {
	n := len(nums)
	if n <= 2 {
		return n
	}
	return 1 << bits.Len(uint(n))
}

func main() {
	nums := []int{3, 1, 2}
	result := uniqueXorTriplets(nums)
	fmt.Println(result)
}

Python完整代码如下：

python 复制代码

# -*-coding:utf-8-*-

def unique_xor_triplets(nums: list[int]) -> int:
    """
    对于长度 n 的排列 nums（包含 1..n），当 n <= 2 时返回 n，
    否则返回 2^(floor(log2(n)) + 1)，即 1 << n.bit_length()。
    """
    n = len(nums)
    if n <= 2:
        return n
    return 1 << n.bit_length()


if __name__ == "__main__":
    nums = [3, 1, 2]
    result = unique_xor_triplets(nums)
    print(result)