2026-06-18：计算比赛分数差。用go语言，给定一个整数数组 nums，其中 nums[i] 表示第 i 场比赛中拿到的分数。共有两位玩家：第一位为“|nums|复杂度|整数

2026-06-18：计算比赛分数差。用go语言，给定一个整数数组 nums，其中 nums[i] 表示第 i 场比赛中拿到的分数。共有两位玩家：第一位为“主动方”，第二位为“被动方”。

从第 0 场到最后一场依次进行，每场比赛都按下面规则处理：

• 若 nums[i] 是奇数，则本场开始时先交换主动方与被动方的角色。
• 另外，每当进入到第 6 的倍数对应的比赛（索引为 5、11、17、…），也要交换一次主动方与被动方。
• 交换完成后，本场由当前的主动方获得 nums[i] 分。

所有比赛结束后，计算最终分差：第一位玩家的总得分减去第二位玩家的总得分。

1 <= nums.length <= 1000。

1 <= nums[i] <= 1000。

输入： nums = [2,4,2,1,2,1]。

输出： 4。

解释：

第 0 到第 2 场比赛：第一位玩家获得 2 + 4 + 2 = 8 分。

第 3 场比赛：分数为奇数，第二位玩家成为主动玩家，获得 nums[3] = 1 分。

第 4 场比赛：第二位玩家获得 nums[4] = 2 分。

第 5 场比赛：分数为奇数，玩家互换角色。由于这是第 6 场比赛，玩家再次互换角色。第二位玩家获得 nums[5] = 1 分。

分数差为 8 - 4 = 4。

题目来自离开3847。

一、题目规则完整梳理

前置定义：

1. 两位玩家：玩家0（第一位，初始主动方）、玩家1（第二位，初始被动方）；变量active记录当前主动方，0=玩家0主动，1=玩家1主动。
2. 遍历顺序：数组索引 i 从0开始依次处理每场比赛。
3. 每场固定执行顺序：
步骤1：判断当前分数nums[i]是否为奇数，若是，交换一次主动/被动角色；
步骤2：判断当前索引i是否是5、11、17……（i%6 == 5，每第6场），若是，再交换一次主动/被动角色；
步骤3：交换全部完成后，当前active对应的玩家收下本场nums[i]分数；
4. 最终结果 = 玩家0总分 − 玩家1总分。

输入数组：nums = [2,4,2,1,2,1]，索引0~5，逐个拆解每一轮完整流程。

二、逐场分步详细推演

初始化状态：

• score = [0, 0] 玩家0总分0，玩家1总分0
• active = 0 初始主动方为玩家0

第1场：i=0，分数x=2

1. 判断x奇偶：2是偶数，不执行角色交换，active保持0；
2. 判断i%6：0%6=0≠5，不执行额外交换，active仍为0；
3. 主动方玩家0收下2分，score更新为 [2, 0]；
当前总分：玩家0=2，玩家1=0。

第2场：i=1，分数x=4

1. x=4偶数，无交换，active=0；
2. 1%6=1≠5，无额外交换，active=0；
3. 玩家0收4分，score更新 [6, 0]；
当前总分：玩家0=6，玩家1=0。

第3场：i=2，分数x=2

1. x=2偶数，不交换，active=0；
2. 2%6=2≠5，无额外交换，active=0；
3. 玩家0收2分，score更新 [8, 0]；
当前总分：玩家0=8，玩家1=0。

第4场：i=3，分数x=1

1. x=1是奇数，执行角色交换：active = 0 ^ 1 = 1；
2. 3%6=3≠5，不触发额外交换，active保持1；
3. 主动方玩家1收1分，score更新 [8, 1]；
当前总分：玩家0=8，玩家1=1。

第5场：i=4，分数x=2

1. x=2偶数，不交换，active维持1；
2. 4%6=4≠5，无额外交换，active=1；
3. 玩家1收2分，score更新 [8, 3]；
当前总分：玩家0=8，玩家1=3。

第6场：i=5，分数x=1（关键，i%6=5触发二次交换）

1. x=1是奇数，第一次交换角色：active = 1 ^ 1 = 0；
2. 判断i%6：5%6=5，满足条件，执行第二次角色交换：active = 0 ^ 1 = 1；
3. 两次交换结束，当前主动方是玩家1，收下1分，score更新 [8, 4]；
当前总分：玩家0=8，玩家1=4。

三、最终分差计算

玩家总分：玩家0=8，玩家1=4
分差 = 8 − 4 = 4，与题目输出一致。

四、复杂度分析 1. 时间复杂度

数组长度为 n，仅单层循环完整遍历数组一次，每一次循环内部仅包含奇偶取模、取余判断、异或交换、加法赋值，全部为常数 O(1) 操作，无嵌套循环、无递归。
总时间复杂度：O(n)，n 为 nums 数组长度。

2. 额外空间复杂度

额外开辟的存储空间固定不变，与输入数组长度 n 无关：

• 定长数组 score [2]：固定2个int；
• 变量 active、循环变量i、临时x：单个基础整型；
不存在动态数组、切片、哈希表等随n扩容的空间。
总额外空间复杂度：O(1)（常数级空间）。

Go完整代码如下：

package main

 import (
    "fmt"
)

 func scoreDifference(nums []int)int {
    score := [2]int{}
    active := 0// 主动玩家一开始是第一位玩家
    for i, x := range nums {
        active ^= x % 2// 如果 x 是奇数，主动玩家换人
        if i%6 == 5 {
            active ^= 1// 主动玩家换人
        }
        score[active] += x
    }
    return score[0] - score[1]
}

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

Python完整代码如下：

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

 defscore_difference(nums):
    score = [0, 0]
    active = 0# 主动玩家一开始是第一位玩家
    for i, x inenumerate(nums):
        active ^= x % 2# 如果 x 是奇数，主动玩家换人
        if i % 6 == 5:
            active ^= 1# 主动玩家换人
        score[active] += x
    return score[0] - score[1]

 defmain():
    nums = [2, 4, 2, 1, 2, 1]
    result = score_difference(nums)
    print(result)

 if __name__ == "__main__":
    main()

C++完整代码如下：

#include  

#include  


 int scoreDifference(const std::vector& nums) {
    int score[2] = {0, 0};
    int active = 0; // 主动玩家一开始是第一位玩家

     for (size_t i = 0; i < nums.size(); ++i) {
        int x = nums[i];
        active ^= (x % 2); // 如果 x 是奇数，主动玩家换人
        if (i % 6 == 5) {
            active ^= 1; // 主动玩家换人
        }
        score[active] += x;
    }

     return score[0] - score[1];
}

 int main() {
    std::vector nums = {2, 4, 2, 1, 2, 1};
    int result = scoreDifference(nums);
    std::cout << result << std::endl;
    return0;
}