初级组初赛
逐题答案与解题过程

a = [3, 1, 4, 5, 2]
ans = 0
for i in range(5):
    if a[i] > ans:
        ans = a[i]
print(ans)

循环始终保存已经读过的元素中的最大值；最后输出 5。

队列先进先出，栈后进先出。下表的队列左端为队首，栈右端为栈顶。

最后弹出的是 3。

字符串逐字符比较，不能把它们当作数字大小或英文数词的数值比较。

设 A 表示外出观星，P 表示看见北极星，C 表示多云。题设是 A ⇒ P 和 C ⇒ ¬P。

1. 由第二条的逆否命题得到 P ⇒ ¬C。今晚 P 为真，故今晚非多云，ii 成立。
2. 第一条只给出观星的必要条件。即使看得见北极星，Alice 也可能留在家中，所以 i 不一定成立。

不能把 A ⇒ P 直接反过来用成 P ⇒ A。

a = [[2, 4, 1], [5, 0, 2]]
row_sum = 0
for row in range(2):
    row_sum = 0  # 选项 D：进入每一行时清零
    for col in range(3):
        row_sum += a[row][col]
    print(row_sum, end=" ")

两行的和分别是 2+4+1=7、5+0+2=7。原程序没有在换行时清零，会输出 7 14。

选项 A 把累加改成赋值，最后只留下每行末项 1、2；B 只改变输出的除法，得到 2、4；C 在内层每一列都清零，也只留下末项。因此应选 D。

C++ 对应插入 row_sum = 0;，位置也是外层循环内、内层循环前。

1. 从最左侧未覆盖的点开始：[1,5] 覆盖 1、2、5。
2. 下一个未覆盖点为 6：[6,10] 覆盖 6、7、10。
3. 下一个未覆盖点为 11：[11,15] 覆盖 11、15。

三次可行。又因为 1、6、11 两两相差至少 5，而同一扫描内两点的距离至多为 4，所以这三个点必须分属三次扫描。下界与构造相等，最优答案为 3。

先按次关键字「姓名升序」排好，再按主关键字「分数降序」作稳定排序。

第二轮决定整体的分数顺序；对同分记录，它保留第一轮已经排好的姓名顺序。这正是选项 C。

A 保留的是姓名降序；B、D 最后一轮按姓名排序，会把姓名变成主关键字，不符合要求。

records.sort(key=lambda r: r.name)
records.sort(key=lambda r: r.score, reverse=True)

以上是 Python 稳定排序的示意；也可以直接用复合关键字 (-score, name)。

把最长和最短的工作配对，可取：

于是 12 分钟全部完成。任何方案中，10 分钟的工作都必须与另一项配对，而最短另一项也要 2 分钟，故总完成时间至少为 12。构造达到下界。

设六个位置为 a₁,…,a₆。

1. 前两个读数均为 4。由于 4 只出现一次，必须在两对位置的交点，即 a₂=4。
2. 中间两个读数均为 6，同理 a₄=6。
3. 最后读数为 5，故 a₅、a₆ 中恰有一个为 5，有 2 种选位。
4. 剩余三个位置放入 1、2、3，任意排列都满足其余上界，有 3!=6 种。

总数为 2×6=12。两类结构是 _ 4 _ 6 _ 5 与 _ 4 _ 6 5 _。已穷举 6!=720 个排列核验。

N 为奇数时不可能：每次翻转 N−1 个位，这是偶数个位。因此 1 的个数的奇偶性始终保持为偶数；目标全 1 含奇数个 1，不可达。这也包含 N=1。

N 为偶数时可以：把每个位置都选一次，总共 N 次。任意一个位只在选择自己时不翻转，合计翻转 N−1 次；该数为奇数，所以每个位最终都是 1。

恰好是 2、4、…、100，共 50 个。

a = 2026
b = 27
b *= a * b
b %= a
print(a + b)

b *= a * b 等价于把旧 b 乘上 a * 旧b，所以 b 变成 2026×27²=1,476,954。它是 a 的整数倍，取余后 b=0，输出 2026。

累加 5+3+1+2=11。逻辑「或」允许任意一个条件成立，但两个条件都成立时仍只加一次。

先每天放 1 根，剩余 3 根按整数分拆分类。相邻和为 3 恰好对应相邻出现 1,2 或 2,1。

1. 额外的 3 根全放一天：得到一个 4 和四个 1。4 放哪一天都行，共 5 种。
2. 额外根数按 2+1 分配：得到一个 3、一个 2 和三个 1。2 不能邻接 1，只能放在一端，并让唯一邻居为 3。因此只有 (2,3,1,1,1) 和 (1,1,1,3,2)，共 2 种。
3. 额外根数按 1+1+1 分配：得到三个 2 和两个 1。一行中同时有 1 和 2，必存在相邻交界，所以无效。

总数为 5+2=7。完整列表：

1, 1, 1, 1, 4
1, 1, 1, 3, 2
1, 1, 1, 4, 1
1, 1, 4, 1, 1
1, 4, 1, 1, 1
2, 3, 1, 1, 1
4, 1, 1, 1, 1

cnt = 0
i = 1
while cnt * cnt <= x:
    cnt += i
    i += 1
print(cnt)

cnt 的取值依次是三角数 0 → 1 → 3 → 6 → 10 → 15 → 21 → …。

1. 必须能从 10 走到 15，故 10²≤x，即 x≥100。
2. 到达 15 后必须停止，故 15²>x，即 x≤224。

所以 x∈[100,224]，个数为 224−100+1=125。x=225 会继续走到 21，不计入。

1. 最后一项为新最小值，所以必须是 1。
2. 第五项为新最大值，而 1 在最后，所以第五项必须是 6。
3. 第四项也为新最大值，剩余的 5 必须出现在第四项，故第四项为 5。
4. 前三项只能是 2、3、4。第二项比第一项小，第三项既不创新高也不创新低，故第三项夹在前两项之间。唯一顺序为 4,2,3。

答案 4,2,3,5,6,1，已穷举确认唯一。

可行构造：5 →(+3) 8 →(×4) 32 →(−2) 30 →(÷1) 30。

证明不能更大：设加数为 a，减数为 b，乘数为 m，除数为 d。所有操作数均为正数。

1. 若 d=1，除法无影响。加法放在乘法前可使它被放大，减法放在乘法后可使扣除最少。因此结果至多 m(5+a)−b。a、b、m 是 2、3、4 的排列，最大值在 m=4、a=3、b=2 时取得，为 30。
2. 若 d≥2，初始 5 对最终值的贡献恒为 5m/d；加数 a 的贡献至多为 am；减数的贡献始终为负，忽略它只会提高上界。因此结果≤5m/d+am≤10+12=22，小于 30。这里 m≤4，且不同操作数的乘积 am≤4×3=12。

故最大值为 30。另用精确分数穷举 4!×4!=576 种方案核验，避免浮点误差。

from itertools import permutations
from fractions import Fraction

best = Fraction(-10**9)
for ops in permutations("+-*/"):
    for nums in permutations([1, 2, 3, 4]):
        v = Fraction(5)
        for op, n in zip(ops, nums):
            if op == "+": v += n
            elif op == "-": v -= n
            elif op == "*": v *= n
            else: v /= n
        best = max(best, v)
print(best)  # 30

(a) G：逐位统计非零位

def f(n: int) -> bool:
    c = 0
    while n > 0:
        if n % 10 != 0:  # G = n%10
            c += 1
        n //= 10
    return c == 1

n%10 取个位，n//=10 去掉个位，最终 c 就是非零位个数。

(b) H：去掉末尾的全部 0

def g(n: int) -> bool:
    while n % 10 == 0:
        n //= 10
    return n < 10  # H = n<10

若原数形如 d×10ᵏ（1≤d≤9），去掉所有末尾 0 后只剩一位。反之，剩下两位或更多，且个位非零，就至少有两个非零位。题设 n≥1，因此无需处理 0 的死循环。

(c) I：检查最高位以下的余数

def h(n: int) -> bool:
    p = 1
    while n // p >= 10:
        p *= 10
    return n % p == 0  # I = n%p

循环结束后，p 是不超过 n 的最大 10 的幂。例如 n=6000 时 p=1000。n%p=0 当且仅当最高位以下全为 0。单个位数时 p=1，余数也为 0，符合要求。

C++ 的三个填空与 Python 相同，依次为 n%10、n<10、n%p；原 C++ 框架的整数除法使用 / 和 /=。

(a) J：最先经过 X 的 11 个球中，向左几个？

X 初始白色，只在球经过它时翻色，所以从 X 出发的方向交替为 L、R、L、R、…。前 11 次经过有 6 次向左。这问的是「经过 X 的前 11 个球」，不是「总共落下的前 11 个球」。

(b) K：前 16 个球中，几个经过 X？

顶点把 16 个球均分成 8、8；第二层两个点又各分成 4、4，因此第三层各点接收 4,8,4。中间 X 接收 8 个。

(c) L：前 16 个球中，几个从出口 2 离开？

第三层的 4、8、4 均为偶数，各自均分后，第四层接收 2,6,6,2。第四层再均分，五个出口收到 1,4,6,4,1。所以出口 2 收到 6 个。

下表给出逐球模拟作交叉核验，L/R 分别表示左/右：

state = [[0] * (r + 1) for r in range(4)]
exits = [0] * 5
hits_x = 0
for _ in range(16):
    c = 0
    for r in range(4):
        if r == 2 and c == 1:
            hits_x += 1
        direction = state[r][c]  # 0 左，1 右
        state[r][c] ^= 1
        c += direction
    exits[c] += 1
print(hits_x)  # 8
print(exits)   # [1, 4, 6, 4, 1]

# 程序 (1)
a, b = "12 34".split()
print(a + b)  # 1234

# 程序 (2)
a, b = map(int, "12 34".split())
print(a + b)  # 46

split() 得到两个字符串，字符串的 + 是拼接；int 转换后，+ 才是数值加法。

每一步都使用当前值，所以结果是 8 5。print 的默认分隔符是一个空格。

range(10) 给出 0 至 9；过滤后 i 为 0,2,4,6,8，各加 2 得到 [2,4,6,8,10]。

总和为 2+4+6+8+10=30。注意 range(10) 不包含 10，但计算后的元素可以等于 10。

累加的是 1+4+7+3+6=21。下标从 0 开始，并且先累加、后更新。

a = [[0] * 6] * 7
a[0][0] += 1
s = 0
for i in range(7):
    for j in range(6):
        s += a[i][j]
print(s)  # 7

外层的 *7 复制的是对同一个内层列表的引用。因此 a[0] 到 a[6] 都指向同一行；修改 a[0][0] 后，每一行看上去都是 [1,0,0,0,0,0]。累加时这一行被遍历 7 次，故结果为 7。

这不是把全部 42 个位置都改成 1。若需要 7 个独立的行，应写 [[0]*6 for _ in range(7)]；但本题必须按原程序解读。

i%5 的周期是 0,1,2,3,4，再取 %4 后的周期为 0,1,2,3,0，每周期和为 6。

0 至 19 恰有 4 个完整周期，总和为 4×6=24。不能把 (i%5)%4 简化成 i%4。

数组在原地更新。后半段读取前半段时，读到的是已经改过的值。

最终列表为 [5,1,3,8,4,2,8]，拼接输出是 5138428。

Python 的 ^ 是按位异或。满足 v^v=0、v^0=v，并具有交换律和结合律。

下标同时依赖 i%2 与 i%5，故以 10 为周期。前 10 轮的下标为：

0, 3, 2, 1, 4, 4, 1, 2, 3, 0

每个下标恰好出现两次，所以一个完整周期的异或为 0。2027=202×10+7，只需看最后 7 轮，其下标为 0,3,2,1,4,4,1。

两次 4 和两次 1 抵消，剩下 a[0]^a[3]^a[2]=7^18^2。二进制为：

00111  (7)
10010  (18)
00010  (2)
-----
10111  (23)

结果为 23，不是乘方运算。

def convert(s: str) -> list[int]:
    n = len(s)
    t = []
    I = 'I'
    O = 'O'
    for x in s:
        t.append(int(x == I))  # D = x==I
    return t

x 为字母 I 时，比较结果为 True，int(True)=1；x 为字母 O 时，比较结果为 False，int(False)=0。例如 convert("IOI") 得到 [1,0,1]。

印刷题目使用的是字母 I 和 O；不是数字 1 和 0。直接 int(x) 会报错，字符串之间的按位 & 也不可用。

s = input()
print("yummy" if s[:2] != "ca" else "uhh")

给定表中，恰好只有 carrot、cabbage 以 ca 开头。对它们条件为 False，走 else 分支；其余五项条件为 True，输出 yummy。

这是满足表中全部输入的一种答案，表达式不唯一，例如 not s.startswith("ca") 也满足给定表。题面没有定义表外单词应有的输出，不把这个前缀规则当成未给出的普遍规律。

def find_symmetric_difference(s: list, t: list) -> list:
    return [x for x in s + t if (x in s) != (x in t)]

两个布尔值不相等，恰好表示一真一假，也就是仅属于一个列表。

列表各自无重复，所以仅在一边出现的元素也只会在 s+t 中出现一次。示例 s=[1,5,3]、t=[2,3,6] 得到 [1,5,2,6]。

两侧成员判断要保留括号，避免 Python 比较运算的链式解释。

(a) G：统计正负个数

def check_same_sign1(a: list[int]) -> bool:
    n = len(a)
    pos = 0
    neg = 0
    for i in range(n):
        if a[i] > 0:
            pos += 1
        else:
            neg += 1
    return pos == n or neg == n  # G

全部为正或全部为负即可。等价的短写法是 pos*neg==0；题设保证非空且没有 0。

(b) H：与固定参照元素比符号

def check_same_sign2(a: list[int]) -> bool:
    n = len(a)
    val = 0
    for i in range(n):
        val += a[i] * a[0] > 0  # H = a[0]
    return val == n

两个非零数乘积为正，当且仅当同号。固定与 a[0] 比较，所有 n 次都为真即同号。布尔值 True 累加为 1。不能填 a[i]，那样只是在检查每个数的平方是否为正，混合正负也会错误通过。

(c) I1、I2：累加符号

def check_same_sign3(a: list[int]) -> bool:
    n = len(a)
    val = 0
    for i in range(n):
        val += a[i] / abs(a[i])  # I1 = a[i]
    return val * val == n * n   # I2 = val*val

每项 a[i]/abs(a[i]) 等于 +1 或 −1。若正数有 p 个、负数有 q 个，val=p−q，n=p+q；只有 p=0 或 q=0 时，才有 val²=n²。

原框架这里是普通除法 /；本题商只有 ±1，且 n≤1000，累加结果可以精确表示，不影响平方比较。I1 与 I2 必须同时正确。

(a) J：将后续元素依次左移

def move(a: list[int], p: int) -> None:
    n = len(a)
    x = a[p]
    for i in range(p, n - 1):
        a[i] = a[i + 1]  # J = a[i+1]
    a[n - 1] = x

先保存 a[p]，再把后面所有元素左移一格，最后把保存的 x 放到末尾。例如 [4,7,4,2] 的 p=1，得到 [4,4,2,7]。

(b) K1、K2：找首个不匹配位置

def can_obtain(a: list[int], b: list[int]) -> bool:
    n = len(a)
    p = 0
    while p < n and a[p] == b[p]:
        p += 1
    if p == n:
        return True
    for i in range(p, n - 1):
        if a[i + 1] != b[i]:  # K1
            return False
    return a[p] == b[n - 1]   # K2

1. 如果全部相等，零次操作即可，直接返回 True。
2. 否则设 p 为首个不匹配的位置。候选操作是把 a[p] 移到末尾。这样 b[p] 至 b[n−2] 应等于 a[p+1] 至 a[n−1]；任何不等都应拒绝，所以 K1 使用 !=。
3. 末尾必须等于被移走的 a[p]，所以 K2 为 a[p]==b[n-1]。

为什么有重复值时也能只检查 p？若某个可行操作移走了更早的 q<p，那么 q 到 p−1 这一段在移动后仍与原列表相等。这迫使 a[q]=a[q+1]=…=a[p]。从这一段中改为移走 a[p] 会得到相同结果，所以检查 p 不会漏解。若 q>p，则位置 p 根本不会改变，不可能修复首个不匹配。

算法时间 O(n)，额外空间 O(1)。已对元素来自 {0,1,2}、长度 0 至 5 的全部 66,430 对等长列表与「枚举每个可移动位置」的结果交叉核验，包含重复元素、无需移动和单元素情形。