2026-02-16：偶数的按位或运算。用go语言，输入一个整数数组 nums，计算数组中所有能被2整除的元素的位或（bitwise OR）结果；如果数组中没有符合条件的元素，则返回 0。

简单思路：用一个累加变量（初始为 0），遍历 nums，遇到能被2整除的数就与累加变量做位或，遍历结束后返回该累加值（若从未有过这样的数则仍为 0）。

1 <= nums.length <= 100。

1 <= nums[i] <= 100。

输入： nums = [1,8,16]。

输出： 24。

解释：

偶数为 8 和 16。它们的按位或运算结果是 24。

题目来自力扣3688。

大体过程：

1. 初始化一个累加变量 ans，将其值设为 0，用于存储最终的按位或结果。
2. 遍历整数数组 nums 中的每一个元素 x：
   • 检查当前元素 x 是否能被 2 整除（即判断 x % 2 == 0 是否成立）
   • 如果 x 是偶数，则将当前元素 x 与累加变量 ans 进行按位或运算（ans |= x），并将结果更新到 ans 中
   • 如果 x 是奇数，则跳过该元素，不对 ans 做任何操作
3. 遍历完数组中所有元素后，返回累加变量 ans 的值
   • 如果数组中有偶数元素，ans 就是这些偶数元素按位或的结果
   • 如果数组中没有偶数元素，ans 保持初始值 0，返回 0

针对示例 nums = [1, 8, 16] 的具体执行过程：

• 初始 ans = 0
• 遍历第一个元素 x = 1：1 % 2 ≠ 0，不是偶数，跳过
• 遍历第二个元素 x = 8：8 % 2 = 0，是偶数，执行 ans |= 8，即 0 | 8 = 8，ans 更新为 8
• 遍历第三个元素 x = 16：16 % 2 = 0，是偶数，执行 ans |= 16，即 8 | 16 = 24，ans 更新为 24
• 遍历结束，返回 ans = 24

复杂度分析：

• 时间复杂度： O(n)，其中 n 是数组 nums 的长度。因为只需要对数组进行一次线性遍历，每个元素只做常数时间的判断和可能的位运算操作。
• 空间复杂度： O(1)，只使用了一个额外的变量 ans 来存储结果，不随输入规模变化。

Go完整代码如下：

package main

import (
	"fmt"
)

func evenNumberBitwiseORs(nums []int) (ans int) {
	for _, x := range nums {
		if x%2 == 0 {
			ans |= x
		}
	}
	return
}

func main() {
	nums := []int{1, 8, 16}
	result := evenNumberBitwiseORs(nums)
	fmt.Println(result)
}

Python完整代码如下：

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

def evenNumberBitwiseORs(nums):
    ans = 0
    for x in nums:
        if x % 2 == 0:
            ans |= x
    return ans

def main():
    nums = [1, 8, 16]
    result = evenNumberBitwiseORs(nums)
    print(result)

if __name__ == "__main__":
    main()

C++完整代码如下：

#include <iostream>
#include <vector>

int evenNumberBitwiseORs(const std::vector<int>& nums) {
    int ans = 0;
    for (int x : nums) {
        if (x % 2 == 0) {
            ans |= x;
        }
    }
    return ans;
}

int main() {
    std::vector<int> nums = {1, 8, 16};
    int result = evenNumberBitwiseORs(nums);
    std::cout << result << std::endl;
    return 0;
}