2026-07-12：达到目标异或值的最少删除次数。用go语言，给定一个整数数组 nums 和一个整数 target。 你可以从 nums 里删除任意多个元素（

package main

import (
    "fmt"
    "math"
    "math/bits"
    "slices"
)

func minRemovals(nums []int, target int)int {
    m := bits.Len(uint(slices.Max(nums)))
    if1<<m <= target {
        return-1
    }

    f := make([]int, 1<<m)
    for i := range f {
        f[i] = math.MinInt
    }
    f[0] = 0

    for _, x := range nums {
        nf := slices.Clone(f)
        for j, fj := range f {
            nf[j^x] = max(nf[j^x], fj+1) // x 不选 or 选
        }
        f = nf
    }

    if f[target] < 0 {
        return-1
    }
    returnlen(nums) - f[target]
}

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

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

from typing import List
import math

def minRemovals(nums: List[int], target: int) -> int:
    # 计算 nums 中最大值需要的二进制位数
    max_num = max(nums) if nums else0
    m = max_num.bit_length()
    
    # 如果所有可能异或值的范围小于等于 target，则无法达到 target
    if (1 << m) <= target:
        return-1
    
    # dp数组，f[state] 表示异或结果为 state 时最多能选择的数字个数
    # 初始化为极小值
    f = [-math.inf] * (1 << m)
    f[0] = 0
    
    for x in nums:
        # 复制当前dp状态
        nf = f.copy()
        for j, fj in enumerate(f):
            if fj != -math.inf:  # 只处理可达状态
                new_state = j ^ x
                nf[new_state] = max(nf[new_state], fj + 1)
        f = nf
    
    # 如果 target 不可达
    if f[target] < 0:
        return-1
    
    # 最少移除数 = 总长度 - 最多保留数
    returnlen(nums) - f[target]


def main():
    nums = [1, 2, 3]
    target = 2
    result = minRemovals(nums, target)
    print(result)


if __name__ == "__main__":
    main()

#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>
#include <cmath>

using namespace std;

int minRemovals(vector<int>& nums, int target) {
    // 计算 nums 中最大值需要的二进制位数
    int maxNum = *max_element(nums.begin(), nums.end());
    int m = 0;
    while ((1 << m) <= maxNum) {
        m++;
    }

    // 如果所有可能异或值的范围小于等于 target，则无法达到 target
    if ((1 << m) <= target) {
        return-1;
    }

    // dp数组，f[state] 表示异或结果为 state 时最多能选择的数字个数
    // 初始化为极小值
    int size = 1 << m;
    vector<int> f(size, INT_MIN);
    f[0] = 0;

    for (int x : nums) {
        // 复制当前dp状态
        vector<int> nf = f;
        for (int j = 0; j < size; j++) {
            if (f[j] != INT_MIN) {  // 只处理可达状态
                int newState = j ^ x;
                nf[newState] = max(nf[newState], f[j] + 1);
            }
        }
        f = nf;
    }

    // 如果 target 不可达
    if (f[target] < 0) {
        return-1;
    }

    // 最少移除数 = 总长度 - 最多保留数
    return nums.size() - f[target];
}

int main() {
    vector<int> nums = {1, 2, 3};
    int target = 2;
    int result = minRemovals(nums, target);
    cout << result << endl;
    return0;
}