Java:给你一个整数数组 nums ，除某个元素仅出现 一次 外，其余每个元素都恰出现 三次 。请你找出并返回那个只出现了一次的元素。

可以使用位运算来解决这个问题。具体来说，我们可以对所有数字的二进制表示的每一位进行统计，统计每一位上所有数字出现次数的和，并对 3 取余，如果余数不为 0，则说明只出现一次的数字在这一位上有值。最后将所有有值的位组合起来，就得到了只出现一次的数字。

以下是 Java 代码实现：

public int singleNumber(int[] nums) {
int[] bitSum = new int[32];
for (int num : nums) {
for (int i = 0; i < 32; i++) {
bitSum[i] += (num >> i) & 1;
}
}
int res = 0;
for (int i = 0; i < 32; i++) {
res |= (bitSum[i] % 3) << i;
}
return res;
}

相关问题

使用lkotlin解决这个问题：373. 查找和最小的 K 对数字 中等 491 相关企业 给定两个以 升序排列 的整数数组 nums1 和 nums2 , 以及一个整数 k 。 定义一对值 (u,v)，其中第一个元素来自 nums1，第二个元素来自 nums2 。 请找到和最小的 k 个数对 (u1,v1), (u2,v2) ... (uk,vk) 。

可以用 Kotlin 实现一个小根堆来解决这个问题。首先，我们可以将 nums1 中的每个数与 nums2 中的第一个数组合成一对，并将其加入小根堆中。然后，我们每次从堆中取出和最小的数对 (u, v)，并将 nums1 中和 u 相邻的数和 nums2 中和 v 相邻的数组成的数对加入堆中。重复这个步骤 k 次即可得到和最小的 k 个数对。

以下是 Kotlin 实现的代码：

import java.util.*

fun kSmallestPairs(nums1: IntArray, nums2: IntArray, k: Int): List<List<Int>> {
    val heap = PriorityQueue<List<Int>>(compareBy { it[0] + it[1] })
    for (i in nums1.indices) {
        heap.offer(listOf(nums1[i], nums2[0], 0))
    }
    val result = mutableListOf<List<Int>>()
    for (i in 0 until k) {
        val pair = heap.poll() ?: break
        result.add(listOf(pair[0], pair[1]))
        if (pair[2] == nums2.size - 1) continue
        heap.offer(listOf(pair[0], nums2[pair[2] + 1], pair[2] + 1))
    }
    return result
}

这个函数接受三个参数：两个整数数组 nums1 和 nums2，以及一个整数 k。它返回一个包含最小的 k 个数对的列表。在函数内部，我们首先创建一个小根堆 heap，并将 nums1 中的每个数与 nums2 中的第一个数组合成一对并加入堆中。然后，我们循环 k 次，每次从堆中取出和最小的数对 (u, v)，将其加入结果列表 result 中，并将 nums1 中和 u 相邻的数和 nums2 中和 v 相邻的数组成的数对加入堆中。最后，我们返回结果列表 result。

参考资料：

- LeetCode 题目 373. 查找和最小的 K 对数字
- Kotlin 标准库中的 PriorityQueue 类

写一个java 二分查找

### 回答1：
这是一个简单的 Java 二分查找代码：

public static int binarySearch(int[] arr, int x) {
    int left = 0;
    int right = arr.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] == x) {
            return mid;
        } else if (arr[mid] < x) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return -1;
}

该代码通过在数组中二分查找来查找特定元素 `x`。如果找到该元素，则返回其索引，否则返回 `-1`。

### 回答2：
二分查找是一种常用的查找算法，也称为折半查找。它适用于已经排序的数组中进行查找。

以下是一个用Java实现的二分查找算法：

1. 首先，我们需要定义一个方法来执行二分查找。该方法将接收三个参数：要查找的目标元素，要查找的数组以及数组的起始索引和结束索引。方法的返回值应该是目标元素在数组中的索引。

public static int binarySearch(int target, int[] arr, int low, int high) {
    while (low <= high) {
        int mid = (low + high) / 2;

        if (arr[mid] == target) {
            return mid;
        } else if (arr[mid] < target) {
            low = mid + 1;
        } else {
            high = mid - 1;
        }
    }

    return -1;
}

2. 在主函数中，我们可以定义一个已经排序的整数数组，并调用上述方法来查找一个特定的元素。我们将目标元素设置为5，并输出其在数组中的索引。

public static void main(String[] args) {
    int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int target = 5;

    int index = binarySearch(target, arr, 0, arr.length - 1);

    if (index != -1) {
        System.out.println("目标元素的索引是：" + index);
    } else {
        System.out.println("目标元素不存在于数组中。");
    }
}

上述代码中，我们首先定义了一个已排序的整型数组arr，并将要查找的目标元素设置为5。然后，我们调用binarySearch方法来查找目标元素在数组中的位置，并将结果存储在index变量中。如果找到了目标元素，则将其索引打印出来；否则，打印出目标元素不存在的提示。

这就是一个简单的Java二分查找的实现。通过二分查找算法，我们可以在较大的已排序数组中快速找到目标元素。

### 回答3：
二分查找又称折半查找，是一种高效的查找算法，前提是查找的序列要有序。

下面是一个使用Java语言实现的二分查找算法：

public class BinarySearch {
    public static int binarySearch(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;

        while (left <= right) {
            int mid = (left + right) / 2;
            if (nums[mid] == target) {
                return mid;
            } else if (nums[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }

        return -1; // 如果找不到目标元素，则返回-1
    }

    public static void main(String[] args) {
        int[] nums = {1, 3, 5, 7, 9, 11};
        int target = 7;

        int result = binarySearch(nums, target);
        if (result == -1) {
            System.out.println("目标元素不存在");
        } else {
            System.out.println("目标元素在数组中的索引为：" + result);
        }
    }
}

在上述代码中，我们定义了一个`binarySearch`方法，它接受一个已排序的整数数组`nums`和一个目标值`target`作为参数。算法通过维护两个指针`left`和`right`，分别表示当前查找范围的左右边界。

在每一次循环中，我们计算出中间索引`mid`，并与目标值进行比较。如果`nums[mid]`等于目标值，我们返回`mid`作为结果。如果`nums[mid]`小于目标值，则说明目标值可能在右侧，我们将`left`指针更新为`mid + 1`。如果`nums[mid]`大于目标值，则说明目标值可能在左侧，我们将`right`指针更新为`mid - 1`。

循环继续直到`left`大于`right`时，表示已经查找完整个数组但仍未找到目标值，此时返回-1。

以上是一个简单的Java二分查找的实现。该算法的时间复杂度为O(logN)，其中N为数组的长度。