2026-08-12：统计下标的相反奇偶性得分。用go语言，给定一个整数数组，需要为数组中的每个位置计算一个分数。这个分数等于：在当前索引右

2026-08-12：统计下标的相反奇偶性得分。用go语言，给定一个整数数组，需要为数组中的每个位置计算一个分数。这个分数等于：在当前索引右侧的所有元素中，与当前元素奇偶性不同（即一个是奇数，另一个是偶数）的元素个数。最终返回一个与原数组等长的数组，按顺序给出每个索引对应的分数。

1 <= nums.length <= 100。

1 <= nums[i] <= 100。

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

输出： [2,1,1,0]。

解释：

nums[0] = 1，为奇数。因此，下标 j = 1 和 j = 3 满足条件，所以下标 0 的分数为 2。

nums[1] = 2，为偶数。因此，下标 j = 2 满足条件，所以下标 1 的分数为 1。

nums[2] = 3，为奇数。因此，下标 j = 3 满足条件，所以下标 2 的分数为 1。

nums[3] = 4，为偶数。因此，没有下标满足条件，所以下标 3 的分数为 0。

因此，answer = [2, 1, 1, 0]。

题目来自力扣3917。

算法的大体过程：

步骤一：初始化数据结构

• • 获取输入数组nums的长度n。

• • 创建一个与nums等长的整型切片（数组）ans，用来存放每个位置最终计算出的分数。

• • 创建一个长度为 2 的整型数组cnt，用来动态记录在从右向左遍历过程中，已经遇到过的偶数和奇数的个数。通常约定cnt[0]存放偶数个数，cnt[1]存放奇数个数，初始都为 0。

步骤二：从右向左遍历数组
使用循环，索引i从n-1递减到0，逐步处理每一个元素。这么做的目的是保证当我们处理位置i时，所有在它右侧的元素（即索引大于i的元素）都已经被统计进了cnt中。

对于当前索引i，执行以下子步骤：

1. 1.判断当前元素的奇偶性
   用nums[i] & 1得到当前数字的奇偶标记x。如果nums[i]是奇数，x为1；如果是偶数，x为0。

2. 2.查询右侧相反奇偶性的个数
   题目要求的分数是：在当前索引右侧，与当前元素奇偶性不同的元素个数。
   既然当前元素的奇偶性是x，那么与之相反的奇偶性就是x ^ 1（异或运算将0变1、1变0）。
   在cnt数组中，cnt[x ^ 1]存放的，恰好就是已经扫描过的右侧元素中，奇偶性为x ^ 1的个数。
   把cnt[x ^ 1]的值赋给ans[i]，即得到位置i的得分。

3. 3.更新计数器
   当前元素自身现在也要成为“右侧元素”的一部分（供更左侧的索引查询）。因此，将它按奇偶性计入cnt中，即执行cnt[x]++。这样，当遍历到更左边的索引时，当前元素就已经被正确统计在内了。

步骤三：返回结果

• • 循环结束后，ans中已经按顺序存储了每个索引对应的分数，直接返回ans即可。

具体执行示例（输入 [1,2,3,4]）

• • 初始：cnt = [0, 0]

• • i=3：nums[3]=4，偶数x=0；右侧相反奇偶性个数cnt[1]=0，ans[3]=0；然后cnt[0]加 1 →cnt=[1,0]。

• • i=2：nums[2]=3，奇数x=1；右侧相反奇偶性个数cnt[0]=1，ans[2]=1；然后cnt[1]加 1 →cnt=[1,1]。

• • i=1：nums[1]=2，偶数x=0；右侧相反奇偶性个数cnt[1]=1，ans[1]=1；然后cnt[0]加 1 →cnt=[2,1]。

• • i=0：nums[0]=1，奇数x=1；右侧相反奇偶性个数cnt[0]=2，ans[0]=2；然后cnt[1]加 1 →cnt=[2,2]。

• • 最终得到ans = [2, 1, 1, 0]，与题目描述一致。

复杂度分析

• •时间复杂度：算法只对数组进行了一次从右向左的遍历，循环内部只包含常数次位运算、数组访问和自增操作。整体时间复杂度为O(n)，其中 n 为数组长度。

• •额外空间复杂度：除了输入数组外，算法额外使用了一个长度为 n 的结果数组ans和一个固定大小为 2 的计数数组cnt。如果不将输出数组计入额外空间，则辅助空间为O(1)；若将必要的输出结构也视为额外空间，则总额外空间复杂度为O(n)。一般在该类问题中，输出数组是必需的，因此可以说总的额外空间复杂度是O(n)。

package main

 import (
    "fmt"
)

 func countOppositeParity(nums []int) []int {
    n := len(nums)
    ans := make([]int, n)
    cnt := [2]int{}
    for i := n - 1; i >= 0; i-- {
        x := nums[i] & 1  // x 的奇偶性
        ans[i] = cnt[x^1] // 查询右侧奇偶性不等于 x（即 x^1）的元素个数
        cnt[x]++
    }
    return ans
}

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

Python完整代码如下：

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

 from typing import List

 def count_opposite_parity(nums: List[int]) -> List[int]:
    n = len(nums)
    ans = [0] * n
    cnt = [0, 0]  # cnt[0] 记录右侧偶数个数，cnt[1] 记录右侧奇数个数
    for i in range(n - 1, -1, -1):
        parity = nums[i] & 1          # 当前元素的奇偶性，0为偶，1为奇
        ans[i] = cnt[parity ^ 1]      # 右侧与当前奇偶性不同的元素个数
        cnt[parity] += 1
    return ans

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

C++完整代码如下：

  

  


 std::vector countOppositeParity(const std::vector& nums) {
    int n = nums.size();
    std::vector ans(n);
    int cnt[2] = {0, 0}; // cnt[0] 偶数个数，cnt[1] 奇数个数
    for (int i = n - 1; i >= 0; --i) {
        int parity = nums[i] & 1;      // 当前元素的奇偶性，0偶1奇
        ans[i] = cnt[parity ^ 1];      // 右侧不同奇偶性的元素个数
        cnt[parity]++;
    }
    return ans;
}

 int main() {
    std::vector nums = {1, 2, 3, 4};
    std::vector result = countOppositeParity(nums);
    for (int x : result) {
        std::cout << x << " ";
    }
    std::cout << std::endl;
    return 0;
}

我们相信人工智能为普通人提供了一种“增强工具”，并致力于分享全方位的AI知识。在这里，您可以找到最新的AI科普文章、工具评测、提升效率的秘籍以及行业洞察。 欢迎关注“福大大架构师每日一题”，发消息可获得面试资料，让AI助力您的未来发展。