有关下列Python代码的说法，错误的是（ ）。

#自定义函数SORTED()仿Python的sorted()功能
def SORTED(for_in_data, fx = None, Reverse = False):
lst = list(for_in_data)
if fx == None:
lst.sort(reverse = Reverse)
else:
lst.sort(key = lambda x:fx(x), reverse = Reverse)
return lst

下列Python代码用于判断一个正整数是否是质数，相关说法中正确的是（ ）。

def is_prime(N):
if N <= 1:
return False
if N == 2 or N == 3 or N == 5:
return True
if N % 2 == 0 or N % 3 == 0 or N % 5 == 0:
return False
i = 7
step = 4
finish_number = int(N ** 0.5) + 1
while i <= finish_number:
if N % i == 0:
return False
i += step
step = 6 - step
return True

下列Python代码用于求解两个正整数的最大公约数，相关说法中错误的是（ ）。

def gcd0(big, small):
if big < small:
big, small = small, big
if big % small == 0:
return small
return gcd0(small, big % small)
def gcd1(big,small):
if big < small:
big, small = small, big
for i in range(small, 0, -1):
if big % i == 0 and small % i == 0:
return i

在Python中，可以用字典模拟单向或双向链表的实现。下面的代码模拟单向链表，和链表对象相比，有关其缺点的说法，错误的是（ ）。

node1 = {'data': 1, 'next': None}
node2 = {'data': 2, 'next': None}
node1['next'] = node2

基于上题代码，模拟单向链表实现插入新节点函数insertNode()的代码如下，横线处应填入的代码是（ ）。

def insertNode(linkNode, newNodeData):
newNode = __________________________
_________________________

下面的Python代码用于实现双向链表。is_empty()函数用于判断链表是否为空，横线处不能填入的代码是（ ）。

class double_link:
class Node:
def __init__(self, data):
self.data = data
self.prev = None
self.next = None
def __init__(self):
self.head = None
self.tail = None
self._size = 0
def is_empty(self):
return ___________

基于上题代码正确的前提下，填入相应代码完善append()函数，用于在尾部增加新节点（ ）。

def append(self, data):
new_node = self.Node(data)
if self.is_empty():
self.head = new_node
self.tail = new_node
else:
——————————————————
——————————————————
——————————————————
self._size += 1
return new_node

下面的Python代码，用于求一系列数据中的最大值。有关其算法说法错误的是（ ）。

def find_max(nums):
if not nums:
raise ValueError("输入数组不能为空")
def _find_max(left, right):
if left == right:
return nums[left]
mid = (left + right) // 2
return max(
_find_max(left, mid),
_find_max(mid + 1, right)
)
return _find_max(0, len(nums) - 1)

基于上题的find_max()实现，下面的说法错误的是（ ）。

下面的Python代码，用于求一系列数据中的最大值。有关其算法说法错误的是（ ）。

def find_max(nums):
if not nums:
raise ValueError("输入数组不能为空")
if len(nums) == 1:
return nums[0]
mid = len(nums) // 2
return max(
find_max(nums[:mid]),
find_max(nums[mid:])
)

下面的Python代码，用于求一系列数据中的最大值。有关其算法说法错误的是（ ）。

def find_max(nums):
if not nums:
raise ValueError("输入数组不能为空")
max_value = nums[0]
for i in nums:
if max_value < i:
max_value = i
return max_value

下面的代码用于列出求1到N之间的所有质数，错误的说法是（ ）。

def is_prime(N):
if N <= 1:return False
finish_number = int(N ** 0.5) + 1
for i in range(2, finish_number):
if N % i == 0:
return False
return True
N = int(input())
print([n for n in range(1,N+1) if is_prime(n)])

硬币找零，要求找给客户最少的硬币。下面是其实现代码，相关说法正确的是（ ）。

coins = sorted(list(map(int, input().split())), reverse=True)
amount = int(input())
result = {coin: 0 for coin in coins}
for coin in coins:
num = amount // coin
result[coin] = num
amount -= num * coin
if amount == 0:
break
for coin in coins:
print(f"{coin}角需要{result[coin]}枚")

下面Python代码用于在升序lst中查找目标值target最后一次出现的位置。相关说法，正确的是（ ）。

def binary_search(lst, target):
if len(lst) == 0:
return None
low, high = 0, len(lst)-1
while low < high:
mid = (low + high + 1) // 2
if lst[mid] <= target:
low = mid
else:
high = mid - 1
return low if lst[low] == target else None

有关下面Python代码的说法，错误的是（ ）。

def sqrt_binary(n, epsilon=1e-10):
if n < 0:
raise ValueError("输入必须为非负整数")
if n == 0 or n == 1:
return n
# 阶段1：
low, high = 1, n
k = 0
while low <= high:
mid = (low + high) // 2
mid_sq = mid * mid
if mid_sq == n:
return mid
elif mid_sq < n:
k = mid
low = mid + 1
else:
high = mid - 1
# 阶段2：（略）
return result

下面Python代码是用欧几里得算法求两个大于0的正整数的最大公约数，a大于b还是小于b都适用。（ ）

def gcd(a, b):
while b:
a, b = b, a % b
return a

假设函数gcd()函数能正确求两个正整数的最大公约数，则下面的lcm()函数能求相应两数的最小公倍数。（ ）

def lcm(a, b):
return a * b // gcd(a, b)

在下面的Python代码中，for-in每次循环都将执行n ** 0.5，并取整后加上1。（ ）

def is_prime(n):
if n <= 1:
return False
for i in range(2, int(n**0.5) + 1):
if n % i == 0:
return False
return True

下面的Python代码用于输出每个数对应的质因数列表。（ ）

n, m = map(int,input().split())
if n > m:
n, m = m, n
prime_factor = {}
for i in range(n, m + 1):
j, k = 2, i
while k != 1:
if k % j == 0:
prime_factor[i] = prime_factor.get(i,[]) + j
k //= j
continue
j += 1
print(prime_factor)

下面Python代码执行后输出是15。（ ）

def func(n):
if n <= 0:
return 0
n -= 1
return n + func(n)
print(func(5))

求解最短路径的Dijkstra算法是贪心算法。（ ）

下面的Python代码用于归并排序，假如整体交换merge()和merge_sort()两个函数的先后位置，则程序执行将触发异常。（ ）

def merge(left, right):
result, i, j = [], 0, 0
while i < len(left) and j < len(right):
if left[i] <= right[j]:
result.append(left[i])
i += 1
else:
result.append(right[j])
j += 1
result.extend(left[i:])
result.extend(right[j:])
return result
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr) // 2
left_arr = merge_sort(arr[:mid])
right_arr = merge_sort(arr[mid:])
print("HERE")
return merge(left_arr, right_arr)

基于上一题的Python代码，代码将输出一次HERE字符串。（ ）

基于上上题的Python代码，切片将产生新的list，可以优化为就地排序。（ ）

下面的Python代码实现快速排序，该排序是稳定排序。（ ）

def qSort(arr):
if len(arr) <= 1:
return arr
pivot = arr[len(arr) // 2]
left, middle, right = [], [], []
for num in arr:
if num < pivot:
left.append(num)
elif num > pivot:
right.append(num)
else:
middle.append(num)
return qSort(left) + middle + qSort(right)

奖品兑换

时间限制：3.0 s
内存限制：512.0 MB
题面描述
班主任给上课专心听讲、认真完成作业的同学们分别发放了若干张课堂优秀券和作业优秀券。同学们可以使用这两种券找班主任兑换奖品。具体来说，可以使用a张课堂优秀券和b张作业优秀券兑换一份奖品，或者使用b张课堂优秀券和a张作业优秀券兑换一份奖品。现在小A有n张课堂优秀券和m张作业优秀券，他最多能兑换多少份奖品呢？

第一行，两个正整数n, m。第二行，两个正整数a, b。

输出共一行，一个整数，表示最多能兑换的奖品份数。

样例输入
8 8
2 1
样例输出
5
数据范围
对于所有测试点，保证1 ≤ n, m, a, b ≤ 10⁹。

最大公因数

时间限制：3.0 s
内存限制：512.0 MB
题面描述
对于两个正整数a, b，它们的最大公因数记为gcd(a, b)。对于n个正整数a₁, a₂, ..., aₙ，它们的最大公因数为gcd(a₁, gcd(a₂, ...))。给定n个正整数a₁, a₂, ..., aₙ以及q组询问。对于第i组询问，请求出gcd(a₁ + i, a₂ + i, ..., aₙ + i)。

第一行，两个正整数n, q。第二行，n个正整数a₁, a₂, ..., aₙ。

输出共q行，第i行包含一个正整数，表示gcd(a₁ + i, a₂ + i, ..., aₙ + i)。

样例输入
5 3
6 9 12 18 30
样例输出
1
3
1
数据范围
对于所有测试点，保证2 ≤ n ≤ 10⁵，1 ≤ q ≤ 10⁵，1 ≤ ai ≤ 10⁹。