一个数组中只有两个数字是出现一次，其他所有数字都出现了两次。 编写一个函数找出这两个只出现一次的数字。

这道题目的意思是：

给你一个数字数组，其中只有两个数字是出现一次，其它所有数字都出现了两次。请编写一个函数找出这两个只出现了一次的数字并返回它们。

答案：请参考以下 Python 代码实现：

def find_two_appear_once(nums):
# 将所有数字进行异或运算，得到的结果就是这两个只出现一次的数字的异或结果
xor = 0
for num in nums:
xor ^= num

# 找到这个异或结果中第一个为 1 的位，这个位置上它们的值不同
diff_bit = 1
while diff_bit & xor == 0:
diff_bit <<= 1

# 将所有数字分成两个集合，第一个集合中所有数字的 diff_bit 位是 0，第二个集合中所有数字的 diff_bit 位是 1
a = b = 0
for num in nums:
if num & diff_bit:
a ^= num
else:
b ^= num

return [a, b]

nums = [1, 2, 3, 4, 3, 2, 1, 5]
print(find_two_appear_once(nums)) # 输出 [4, 5]，因为只有 4 和 5 只出现了一次

相关问题

用python写一个利用二分查找 , 找出指定值并输出查找次数的代码

### 回答1：

def binary_search(arr, x):
    low = 0
    high = len(arr) - 1
    mid = 0
    count = 0
    while low <= high:
        count += 1
        mid = (high + low) // 2
        if arr[mid] < x:
            low = mid + 1
        elif arr[mid] > x:
            high = mid - 1
        else:
            return mid, count
    return -1, count

arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
x = 6
result, count = binary_search(arr, x)
if result != -1:
    print("元素在数组中的索引为:", result)
    print("查找次数:", count)
else:
    print("元素不在数组中")
    print("查找次数:", count)

这是一个使用二分查找找出指定值并输出查找次数的 Python 代码。需要注意的是，这里的数组必须是有序的。

### 回答2：
以下是一个用Python实现二分查找并输出查找次数的代码：

def binary_search(arr, target):
    low = 0
    high = len(arr) - 1
    count = 0   # 初始化查找次数为0
    
    while low <= high:
        mid = (low + high) // 2
        count += 1
        
        if arr[mid] == target:
            return count
        elif arr[mid] < target:
            low = mid + 1
        else:
            high = mid - 1
    
    return -1   # 如果未找到目标值，则返回-1

# 测试代码
arr = [1, 3, 5, 7, 9]
target = 5
result = binary_search(arr, target)
if result != -1:
    print("找到目标值，查找次数为：" + str(result))
else:
    print("未找到目标值")

以上代码首先定义了一个`binary_search`函数，该函数接收一个有序数组`arr`和目标值`target`作为参数。在函数内部，使用`low`和`high`两个指针来分别表示搜索范围的起始和结束位置。初始化查找次数`count`为0。

然后，在一个`while`循环中，根据数组的中间元素与目标值的大小关系决定下一步的搜索范围，并且每进行一次循环，`count`的值加一。

如果找到目标值，则返回查找次数`count`；如果未找到目标值，则返回-1。

最后，通过调用`binary_search`函数并输出结果来测试代码。

在以上示例中，数组`arr`为`[1, 3, 5, 7, 9]`，目标值`target`为`5`。输出结果为"找到目标值，查找次数为：2"，表示在数组中找到了目标值"5"，并且总共进行了2次查找。

### 回答3：
以下是用Python编写的利用二分查找找出指定值并输出查找次数的代码：

def binary_search(arr, target):
    low = 0
    high = len(arr) - 1
    count = 0

    while low <= high:
        mid = (low + high) // 2
        count += 1

        if arr[mid] == target:
            return count
        elif arr[mid] < target:
            low = mid + 1
        else:
            high = mid - 1

    return -1

# 测试示例
arr = [1, 2, 4, 6, 8, 9, 11, 15]
target = 9

result = binary_search(arr, target)
if result != -1:
    print("找到目标值，查找次数为：", result)
else:
    print("未找到目标值")

上述代码中的`binary_search`函数使用二分查找算法来查找指定值`target`在有序数组`arr`中的位置。每次查找过程中，根据中间元素的值与目标值的大小比较，来确定下一次查找的范围是左半部分还是右半部分。通过调整`low`和`high`的值不断缩小查找范围，最终可以找到目标值。在代码中通过引入变量`count`来记录查找次数，最终输出结果。如果未找到目标值，函数返回值为-1。

帮我编写一个冒泡排序

### 回答1：
好的，我可以帮助您编写冒泡排序的代码。这是一种简单的排序算法，通过重复地遍历要排序的数组，依次比较相邻的元素，并交换位置来达到排序的目的。

下面是一份 Python 代码：

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    return arr

arr = [64, 34, 25, 12, 22, 11, 90]
print("排序前的数组：", arr)
arr = bubble_sort(arr)
print("排序后的数组：", arr)

这是一个简单的冒泡排序实现，它能够对数组进行排序。您可以将数组作为参数传递给函数，函数将返回已排序的数组。

### 回答2：
冒泡排序是一种简单的排序算法，其原理是通过相邻元素的比较和交换来将较大的元素逐步向后移动。这里给你一个使用Python编写的冒泡排序算法示例：

def bubble_sort(arr):
n = len(arr)
for i in range(n - 1):
for j in range(n - i - 1):
if arr[j] > arr[j + 1]:
arr[j], arr[j + 1] = arr[j + 1], arr[j]
return arr

其中，arr是待排序的数组。冒泡排序的主要思想是，从数组的第一个元素开始，依次比较相邻的两个元素，将较大的元素向后交换，这样经过一轮遍历后，最大的元素会被移动到最后一个位置。接下来再对除最后一个已排序元素外的其他元素进行同样的交换操作，直到所有的元素都排好序为止。

冒泡排序的时间复杂度为O(n^2)，其中n是待排序数组的长度。由于冒泡排序的性能较差，所以在实际应用中较少使用，更常用的是快速排序、归并排序等更高效的排序算法。

### 回答3：
冒泡排序是一种简单且基础的排序算法，其原理是通过比较相邻元素的大小，逐步将最大（或最小）的元素交换到序列末尾，从而达到排序的目的。

下面是一个用Python编写的冒泡排序算法示例：

def bubble_sort(arr):
    n = len(arr)
    # 遍历数组长度-1次，每次找出当前未排序部分中的最大元素
    for i in range(n-1):
        # 每次遍历都会将当前未排序部分的最大元素交换到末尾
        for j in range(n-1-i):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

# 调用示例
arr = [4, 2, 5, 1, 3]
sorted_arr = bubble_sort(arr)
print(sorted_arr)

在上述示例中，我们定义了一个名为`bubble_sort`的函数，该函数接受一个列表作为参数，并返回排序后的列表。函数使用嵌套的`for`循环来实现冒泡排序。

外层循环控制需要进行的遍历次数，每次遍历都能确定出当前未排序部分的最大元素，所以需要进行`n-1`次遍历。

内层循环负责比较相邻元素的大小，并进行交换。如果相邻元素逆序，即前者大于后者，则进行交换操作。

最后，我们将排序后的列表打印出来，得到的结果为`[1, 2, 3, 4, 5]`。

冒泡排序的时间复杂度为O(n^2)，适用于小规模数据排序。