FIP 第一次小测复习速查

智能程序设计基础课程第一次小测的复习速查笔记

这篇笔记用于课程智能程序设计基础(FIP)的第一次小测的复习。

第一次小测

时间	范围
2026/10/08 13:25-13:40	W1-W4理论课内容&阅读材料

W1-计算

理论课内容

参考材料 1 计算.pdf

预备知识

命令式编程语言 命令是一行一行的，按照书写顺序依次执行

Python程序保存在后缀为.py的文件中，可以被Python解释器执行。

IPO环节

IPO=输入（input），处理（process），输出（output） 这是一般的程序具备的三个基本环节。

输出

函数print()

• print函数将字符串参数打印在终端中作为输出
• 多个字符串参数使用逗号连接，默认使用空格连接
• 可选参数end缺省为'\n'即换行符，也即print()函数每次打印完内容会自动换行，可以通过设置end=' '或者其他字符来改变末尾的输出

输入

函数input()

• 读入用户在终端中输入的一行作为函数的返回结果
• 用户的键盘输入在按下[Enter]之后才会被函数读取
• input()函数的返回值是一个字符串，即使输入的是数字
• 可以向input()函数传递一个字符串参数作为终端中输入的提示词

number = int(input("Enter your favorite number:"))
# 终端中显示效果如下
# Enter your favorite number:

变量

变量是值的名字，在Python中使用=进行赋值。先算右边，再让左边的名字指向这个值；赋值后不是一直维持数学上的相等关系。

变量命名规则

• 必须以字母、下划线开头，后面可以跟任意数量的字母，数字，下划线
• 变量名区分大小写
• 变量名不能含有空格
• 变量名不能以数字开头
• 变量名不能与Python中的关键字（keywords）重复
• 变量名不要与内置函数名重复；语法上允许，但会覆盖原来的名字，如sum = 0后不能直接调用sum()

数据类型

Python中数据类型有很多，之后会进行介绍，这里先讨论基本的三类

函数type()

• 将一个变量作为参数传递给type()函数，会返回变量储存值的数据类型，基本的有：
  • int：整型
  • float：浮点型
  • str：字符串 数据类型间的差异之后再进行介绍

数据类型转换函数

• int()函数：把可以转变的字符串，或浮点型转换为整型，对于浮点数来说，这进行的是向零取整，即砍掉小数部分
• float()函数：把可以转变的字符串，或整型转换为浮点型
• str()函数：把浮点型，整型转换为一个字符串

计算

表达式(expression)

表达式是由运算数(oprand)和运算符(operator)组成的用于计算的式字

运算数

Python是动态类型语言，同一个变量可以先后指向不同类型的值。不同类型能否运算要看具体规则，如1 + 2.0可以，'1' + 2会报错。

数字运算符

Python中数字的运算符主要有如下类型

符号	计算	结合
+	加法	自左向右
-	减法	自左向右
*	乘法	自左向右
/	除法	自左向右
//	向下取整的除法	自左向右
%	取余	自左向右
**	乘方	自右向左

乘方自右向左扫描的含义是2 ** 3 ** 2 == 2 ** (3 ** 2)

赋值

• 赋值语句把一个值和一个变量绑定在一起，我们说“把一个值赋给一个变量”，这是一个动态的操作，而不是一种静态的关系

自增/自减

Python中如下的写法是很常见的，含义就是一种快速的赋值写法。

total = total + item
total += item
total -= item
total /= item
...

关系运算符

Python中关系运算符主要有如下类型

运算符	描述
==	判断等于
!=	判断不等于
>	判断大于
<	判断小于
>=	判断大于等于
<=	判断小于等于

关系表达式的结果属于一种数据类型，称为布尔型(bool)。 布尔型只包含两个值True和False一般来说也可以用1和0代之。

运算符的优先级

• 算术运算符优先级高于关系运算符
• 关系运算符优先级高于赋值运算符
• 括号可以改变运算优先级

循环语句

while循环

Python中while循环是一种基于条件的循环，当while关键字后面的表达式值为True时，就重复运行循环体中的代码

break关键字

break关键字可以跳出当前循环体所在的循环，注意，在有嵌套的情况下，break跳出的也只有一层循环。

典型计算

时间差

先统一成分钟，再用//和%拆回小时、分钟。若题目允许跨过午夜，负差值加一天。

diff = h2 * 60 + m2 - (h1 * 60 + m1)
if diff < 0:
    diff += 24 * 60
print(diff // 60, diff % 60)

哨兵与平均数

total, count = 0, 0
while True:
    x = int(input())
    if x == -1:
        break
    total += x
    count += 1
if count > 0:
    print(total / count)

• 初始化放在循环外；哨兵不参与计算，先判断再累加
• 没有有效数据时不能直接除以count

阅读材料补充

一行读入多个数

h, m = map(int, input().split())

• input()读一整行，split()按空白拆开，map(int, ...)逐项转为整数
• 左边变量个数要与输入段数一致，浮点数则用map(float, ...)

格式化输出

print(1, 2, sep='-', end='!')  # 1-2!，不换行
print(f'{3.5:.2f}')           # 3.50

• sep控制参数之间的分隔，默认空格；end控制末尾，默认换行
• :.2f保留两位小数，格式化字符串前要加f
• print()负责输出，返回值是None

运算注意

• /得到浮点商，//向下取整；int()是向零截断，两者对负数可能不同
• int('3.5')报错；int(float('3.5'))得到3
• 2 ** 3 ** 2是2 ** (3 ** 2)；-2 ** 2是-(2 ** 2)
• '1' + '2'得到'12'；'2' * 3得到'222'

文件与终端

• .py是Python源文件；改代码后先保存再运行
• 相对路径从当前工作目录出发，绝对路径从磁盘或根目录出发
• cd切换目录，dir或ls查看文件，python 文件名.py运行程序

W2-枚举与减治

理论课内容

参考材料 26FIP2 枚举与减治.pdf

分支

if condition:
    ...
else:
    ...

• 条件成立执行if，否则执行else，两者只走一个
• else与对应的if对齐；多个独立if则可能都执行

逻辑运算

运算符	含义	短路规则
and	都成立	左边为假，不算右边
or	至少一个成立	左边为真，不算右边
not	取反	优先级高于and和or

0、空字符串、空容器、None为假。and、or返回选中的操作数，不一定是布尔值，如0 or 7得到7。

for与range

for i in range(2, 6):
    print(i)  # 依次输出2、3、4、5

写法	产生的整数
range(4)	0、1、2、3
range(2, 5)	2、3、4
range(5, 0, -2)	5、3、1

• 左闭右开，不包含终点；步长不能为0，参数须为整数
• range(5, 2)为空，不执行循环体
• 次数已知用for，直到条件满足或读到哨兵用while

break、continue与循环else

• break退出当前循环；continue跳过本轮剩余语句，进入下一轮
• 循环正常结束时执行else；通过break退出则不执行
• 空循环也会执行else；continue不会取消else

枚举(Enumeration)

逐一检查有限的候选解，不遗漏、不重复。最坏情况要考虑全部候选。

素数判断

若\(n\)有非平凡因子，至少一个不大于\(\sqrt n\)，所以只需检查到平方根。

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

• 0、1不是素数；2是素数
• 平方根边界要包含，如49须检查到7
• 朴素检查到\(n-1\)为\(O(n)\)，平方根界为\(O(\sqrt n)\)

减治(Decrease and Conquer)

每一步缩小问题规模，直到能直接求解。

辗转相除法

\[\gcd(a,b)=\gcd(b,a\bmod b)\]

while b != 0:
    a, b = b, a % b
print(a)

• 同步赋值先计算右边所有旧值，再赋给左边
• 不能改成a = b后再b = a % b，后一句的a已经变了
• 例如(48, 18) → (18, 12) → (12, 6) → (6, 0)，最大公约数为6
• 若求最小公倍数，先保存原来的乘积，再除以最大公约数（此处考虑正整数）

二分法求根

连续函数在端点异号的区间内至少有一个根。每次取中点，保留仍包围根的一半。

# 已知f连续，f(left) < 0 < f(right)
while right - left > eps:
    mid = (left + right) / 2
    if f(mid) < 0:
        left = mid
    else:
        right = mid
root = (left + right) / 2

• 实数中点用/；每次区间宽度减半
• 端点同号只表示不能用异号条件保证有根，不能断言无根
• 区间宽度、残差abs(f(x))、相邻估计值差是不同的终止标准，看题目要求
• 中点误差不超过最终区间宽度的一半；浮点数一般不用==判断近似相等

阅读材料补充

math模块

import math
math.sqrt(9)   # 3.0
math.sin(math.pi / 2)  # 三角函数参数用弧度

sqrt()返回浮点数，作为range上界时要转为整数并检查右开边界。eval()把字符串当表达式执行，不适合直接处理不可信输入；函数公式优先用def或lambda。

W3-迭代与模拟

理论课内容

参考材料 26FIP3 迭代与模拟.pdf

迭代

反复执行同一个规则，前一步的结果作为下一步的输入，逐渐得到足够好的近似解。

牛顿迭代法(Newton-Raphson Method)

用当前点的切线与横轴交点作为下一次估计。 \[x_{k+1}=x_k-\frac{f(x_k)}{f'(x_k)}\] 求\(a\)的平方根，令\(f(x)=x^2-a\)，得到： \[x_{k+1}=\frac{x_k+a/x_k}{2}\]

def root(a, eps):
    if a == 0:
        return 0.0
    x = max(1.0, a)
    while abs(x * x - a) >= eps:
        x = (x + a / x) / 2
    return x

• 此函数假设a >= 0、eps > 0；a=0单独处理
• 牛顿法需要导数，单根附近二阶收敛，但初值不合适可能不收敛
• 分母不能为0；a / x不能写成a // x

弦截法(Secant Method)

用最近两个点的割线代替切线，不需要导数。 \[x_{k+1}=x_k-f(x_k)\frac{x_k-x_{k-1}}{f(x_k)-f(x_{k-1})}\]

def secant(f, prev, curr, eps):
    for _ in range(100):
        fp, fc = f(prev), f(curr)
        if abs(fc) < eps:
            return curr
        if abs(fc - fp) < 1e-12:
            return None
        nxt = curr - fc * (curr - prev) / (fc - fp)
        prev, curr = curr, nxt
    return None

• 需要两个初值，不要求端点异号；也可能不收敛
• 先检查当前点是否已满足精度，再检查分母
• f是可调用的函数，取值写f(x)，不能写eval(x)
• 对\(f(x)=x^2-2\)，初值1、2，下一点为\(4/3\)

函数

def add(a, b=1):
    return a + b

• def定义函数，调用后才执行函数体；return立即结束函数并交回结果
• print是输出，不能代替return；没写return则返回None
• 位置参数按顺序对应；关键字参数按名字对应；默认值在省略参数时使用
• return a, b返回元组，可以用x, y = 函数()接收
• lst: list、-> int是类型注解，运行时默认不强制检查
• 接收或返回函数的函数称为高阶函数，如secant(f, ...)

lambda与条件表达式

f = lambda x: x * x - 2
digit = int(a[-i]) if i <= len(a) else 0

• lambda只能写表达式，结果自动返回
• 值1 if 条件 else 值2只计算选中的一边，缺位时不会访问a[-i]
• 默认参数在执行def时求值；默认列表会被多次调用共享，需要独立列表时常用None作默认值

多分支

if score >= 90:
    grade = 'A'
elif score >= 60:
    grade = 'B'
else:
    grade = 'C'

从上到下判断，命中第一条就停止后续分支判断。

蒙特卡洛方法

在单位正方形随机取\(n\)个点，其中\(m\)个在四分之一单位圆内，估算\(\pi\approx4m/n\)。

import random
random.seed(42)
hits = 0
for _ in range(n):
    x, y = random.random(), random.random()
    if x * x + y * y <= 1:
        hits += 1
print(4 * hits / n)

• random.random()范围是[0, 1)；seed用于复现，不保证结果更准确
• n须大于0；样本更多通常统计误差更小，不保证每一次结果都更准
• 典型误差量级为\(O(1/\sqrt n)\)，误差缩小10倍通常需约100倍样本
• 布丰投针在针长\(L\le d\)时，相交概率\(P=2L/(\pi d)\)

大数加法

字符串逐位模拟竖式，从个位算起：本位为total % 10，进位为total // 10。

def big_add(a, b):
    result, carry, i = '', 0, 1
    while i <= max(len(a), len(b)) or carry:
        da = int(a[-i]) if i <= len(a) else 0
        db = int(b[-i]) if i <= len(b) else 0
        total = da + db + carry
        result = str(total % 10) + result
        carry = total // 10
        i += 1
    return result

• 假设输入为非空的非负整数字符串，短数缺位补0
• 有最高位进位时须多算一轮；新数位放在结果左边
• Python的int本身支持任意精度，逐位模拟是为了学习算法
• 字符串不可变；x ** 2并非用泰勒展开实现，不能据此判断效率

字符串

• s[i]取字符，s[-1]取末尾；s[a:b]左闭右开；s[::-1]反转
• 索引越界会报错，切片端点超出范围通常会截到有效部分
• split()拆分，strip()去两端空白，'分隔符'.join(序列)拼接字符串
• replace()、upper()、lower()返回新字符串，不原地修改

阅读材料补充

多分支if-elif-else

语句示例

if condition1:
    statement1
elif condition2:
    statement2
else:
    statement_default

作为一整个语句块，执行的顺序是从上到下，在第一个为真的分支执行过后跳过后续所有分支。 需要注意多分支语句与多个if语句判断的区别，多个独立的if语句会执行多次判断，而非互斥的分档。 条件顺序也是优先级，分档时一般从严到宽，如先判断>= 90，再判断>= 60，否则高分会提前落入低档。

条件表达式

形式为

<条件为真时的值> if <条件> else <条件为假时的值>

经典示例就是刚才写过的大数字符串加法缺位补零。 先判断条件，只计算选中的一侧；先访问越界下标，再用条件选择结果，仍会报错。

lambda函数

lambda函数是一种用一个语句就能定义的简单函数，形式为

lambda <自变量>: <表达式>

表达式也可以是条件表达式，此外还可以经常和map()函数嵌套使用

double = list(map(lambda x: x * 2, lst))

• 表达式的值自动作为返回值，不能写普通赋值或多条语句
• 可以没有参数，也可以有多个参数：lambda: 0、lambda x, y: x + y
• 逻辑较长或需要多分支时用def

函数的参数

位置参数(positional argument)

按照顺序对应的参数。

关键字参数(keyword argument)

调用时将实参赋值给对应的形参。位置参数要写在关键字参数前面

默认参数

省略实参时使用默认值；普通参数列表中，有默认值的形参放在无默认值的形参后面。

def add(a, b=1):
    return a + b

add(3)       # 4
add(3, b=2)  # 5

默认值在执行def时只求值一次，默认列表会被多次调用共享。需要每次新建时用None：

def put(x, bag=None):
    if bag is None:
        bag = []
    bag.append(x)
    return bag

可变数量参数

定义处将多余实参打包，调用处才用*、**解包：

def f(*args):        # args是元组，收集多余位置实参
    ...

def g(**kwargs):     # kwargs是字典，收集多余关键字实参
    ...

返回值与函数对象

• return 值返回结果并立即结束函数，后面的语句不执行
• 单独return或执行到函数末尾，返回None
• return a, b返回元组(a, b)；打印结果不能代替返回结果
• 传函数写f，调用函数写f(x)；公式字符串不是可调用的函数

类型注解与文档字符串

def square(x: float) -> float:
    """返回x的平方，如square(2.0)得到4.0。"""
    return x * x

• x: float说明参数类型，-> float说明返回类型，默认不强制检查
• 函数体第一条字符串是文档字符串（docstring），可用help(square)查看
• 文档写清做什么、边界和样例；assert 条件可检查约定，条件为假时抛出AssertionError（了解）

作用域简介

• 函数体内部的变量名是局部的，函数体外无法调用
• 函数可以读取函数外的全局变量，但是要在函数内给全局名赋值，需要使用global关键字
• 形参也是局部名
• 局部名字不影响外部同名变量，但若传入列表后原地修改，外面也能看到变化

eval函数

eval(表达式字符串)允许把字符串当Python表达式进行上下文求值，但是注意只能是表达式，不能是语句。 不建议使用的原因有 - 字符串输入不安全容易被注入 - 公式和变量储存在字符串里容易类型或计算出错 - 报错不如正常函数清晰不易于调试

random模块

伪随机数模块，使用蒙特卡洛方法时需要调用。要注意设置种子保证环境一致。

常用函数

random.seed(a=None, version=2)

初始化伪随机数生成器，相同的种子和后续调用序列可以获得同一串伪随机数。 需要注意的是一般种子在程序开头设置一次即可，在循环里反复设置会导致随机性丢失。

random.random() -> float

获得\([0.0, 1.0)\)上均匀分布的浮点数

random.uniform(a, b) -> float

获得a与b之间均匀分布的浮点数，是否包含端点是实现定义的。 端点顺序可以颠倒，另一端是否取到与浮点舍入有关。

random.randint(a, b) -> int

返回闭区间上的随机整数。

random.randrange(stop)/ random.randrange(start, stop[, step]) -> int

等价于choice(range(...))开闭规则和range一致。

random.choice(seq)

从非空序列中随机获取一个元素。 空序列会引发IndexError。

random.shuffle(seq)

原地随机打乱可变序列。 返回None，不要写lst = random.shuffle(lst)。

random.sample(population, k) -> list

无放回随机抽样\(k\)个，返回抽中元素组成的新列表。 0 <= k <= len(population)，不改变原序列；总体有重复值时，抽出的值仍可能重复。

其他函数（了解）

• random.choices(seq, k=n)：有放回抽样，返回列表
• random.gauss(mu, sigma)、random.normalvariate(mu, sigma)：正态分布
• random.getrandbits(k)：返回由k个随机比特构成的非负整数
• import random后调用random.random()；只有from random import random后才能直接调用random()

字符串补充

字面量与转义

• 单引号、双引号都可表示字符串，三引号可以跨行
• \n换行，\t制表，\\反斜杠；原始字符串如r'C:\new'不把\n当换行
• 字符串遍历得到的是长度为1的字符串，计算数字前要转换，如int(ch)
• s += t得到新字符串再重新绑定名字，原字符串不变

内置函数

写法	返回结果
min(s) / max(s)	按码位最小 / 最大的字符；空串报错
sorted(s)	排序后的字符列表，拼回字符串用''.join(sorted(s))
reversed(s)	反向迭代器，拼回用''.join(reversed(s))
ord('A') / chr(65)	字符转码位 / 码位转字符
repr(s)	显示引号、转义等表示，便于看清内容（了解）

查找与计数

方法	含义
find(sub) / rfind(sub)	首次 / 末次出现的下标，找不到返回-1
index(sub) / rindex(sub)	同上，但找不到抛出ValueError
count(sub)	不重叠的出现次数，如'aaa'.count('aa')为1
startswith(prefix) / endswith(suffix)	判断前缀 / 后缀，返回布尔值

分割、拼接与去除

• split()按空白分割，连续空白合并；split(',')按指定分隔符分割，可能留下空串
• rsplit(sep, maxsplit)从右分割，splitlines()按行分割
• partition(sep)返回(前, 分隔符, 后)三元组，找不到时返回(原串, '', '')
• replace(old, new, count)至多替换count次，省略则全部替换
• join()的元素必须是字符串，''.join([1, 2])会报错
• strip(chars)删除两端属于指定字符集合的字符，不是删除固定子串；删固定前后缀用removeprefix()、removesuffix()

其他方法（了解）

• capitalize()首字符大写，其余小写；title()单词首字母大写；swapcase()交换大小写；casefold()用于忽略大小写比较
• ljust()、rjust()、center()对齐填充；zfill(width)左侧补零；expandtabs()展开制表符
• isalpha()、isalnum()、isspace()等返回布尔值；isdigit()为真不一定能转成int，如'²'，大数题通常限定'0'到'9'
• encode()把字符串转成字节串，decode()把字节串转回字符串
• format(3.14159, '.2f')得到'3.14'；字符串也有.format()、.format_map()，日常优先用f-string

迭代终止与数值测例

• abs(f(x)) < eps检查残差；abs(x_new - x_old) < eps检查变化量，不能随意替换
• eps太大可能停得早，太小可能因浮点误差停不下来；可加最大迭代次数
• 更新前检查危险分母：牛顿法的f'(x)，弦截法的f(curr) - f(prev)
• 比较结果时统一公式、初值、eps；随机模拟还要统一seed和调用顺序
• 手算一步、检查已知根和边界；大数加法注意'999' + '1'及不等长输入
• 1e-3表示\(10^{-3}\)，不要写成1^-3

W4-序列与查找

理论课内容

参考材料 26FIP4 序列与查找.pdf

列表与元组

• 列表[1, 2]是可变序列，字符串、元组是不可变序列
• “序列有序”表示有先后位置，不表示已经按值排序
• 单元素元组必须有逗号：(1,)；(1)只是整数

别名与浅拷贝

a = [1, 2]
b = a        # 同一对象
c = a[:]     # 新列表
b[0] = 9
print(a, c)  # [9, 2] [1, 2]

• a[:]、a.copy()、list(a)都是浅拷贝，内层可变对象仍共享
• [[0]] * 3的三个内层列表是同一对象；独立列表用[[0] for _ in range(3)]
• 元组槽位不能替换，但其中引用的列表仍可修改

基本操作

写法	含义 / 返回值
append(x)	末尾追加一个元素，返回None
extend(xs)	把多个元素逐项追加，返回None
pop()	删除并返回末尾元素
remove(x)	删除第一个相等元素；不存在报错
index(x)	首次出现的下标；不存在报错
count(x)	出现次数
sort() / reverse()	原地排序 / 反转，返回None
sorted(xs)	返回排序后的新列表

• 列表的+、*产生新列表；+=对列表通常原地扩展
• in查列表中的单个元素，[1, 2] in [1, 2, 3]为False
• 序列按字典序比较，共同前缀相同时短序列更小，不补零
• 字符串比较按Unicode码位，不是按汉字笔画

最值查找

先用第一个值作初值，再逐个比较更新；不要随意用0作最大值初值，否则全为负数时出错。

def max_index(lst):
    if not lst:
        return -1
    idx = 0
    for i in range(1, len(lst)):
        if lst[i] > lst[idx]:
            idx = i
    return idx

>保留第一次最大值位置，>=保留最后一次。min、max只返回值；空序列没有默认值时会报错。

线性查找

def linear_search(lst, target):
    for i in range(len(lst)):
        if lst[i] == target:
            return i
    return -1

• 无序表也能查，返回第一次匹配的位置
• 最坏比较\(n\)次，时间\(O(n)\)；额外空间\(O(1)\)
• -1表示没找到，不能直接拿它索引列表，否则会读到最后一项

二分查找

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

• 前提是按查找所用的规则升序排列；按时间排列不代表按温度值升序
• 闭区间[left, right]，相等时还有一个候选，所以用<=
• 每次排除中点，用mid + 1或mid - 1；空表直接返回-1
• 定长整数中left + right可能溢出，改用区间差算中点；Python整数通常无此问题
• 重复值返回某一次匹配，不保证首次；要首次则记录答案后继续向左查

手推边界

对[2, 5]查5：先left=0, right=1, mid=0，再left=1, right=1, mid=1，返回1。若用left < right，会漏掉最后一步。

复杂度

操作	时间复杂度
列表按下标读写	\(O(1)\)
列表末尾append、pop()	均摊\(O(1)\)
列表头删、中间插入、按值查找	\(O(n)\)
找最值、线性查找（最坏）	\(O(n)\)
二分查找（最坏）	\(O(\log n)\)
一般排序	\(O(n\log n)\)

• 大\(O\)表示规模增大时的增长趋势，不是具体秒数
• 忽略常数和低阶项，如\(3n+2\)为\(O(n)\)；循环每次折半为\(O(\log n)\)
• 无序数据只查一次，通常直接线性查找；多次查找才考虑先排序
• 排序后返回的是新顺序的下标，不自动对应原下标

阅读材料补充

遍历与函数参数

for i, x in enumerate([10, 20]):
    print(i, x)

• enumerate同时给下标与元素；zip按位置配对，默认按最短序列结束
• any([])为False，all([])为True
• 定义处*args收集额外位置参数为元组，**kwargs收集关键字参数为字典
• 调用处*xs拆开序列，**d拆开关键字参数；max(xs)和max(*xs)调用形式不同
• key=接收单参数函数，如sorted(xs, key=abs)；不能写sorted(xs, abs)

Markdown与公式

• #、##、###表示标题层级；代码块标明python
• 表格表头后必须有分隔行；行内代码用反引号
• $O(n)$写行内公式，$$...$$写独立公式；多字符上下标用花括号，如x_{k+1}

AI协作

SDD：规格 → 草稿 → 审查 → 验证 → 固化。先写清输入、输出、边界、样例，再对照代码检查；随机题要复现则指定seed，查找题要说明是否有序与返回值约定。

模拟小测

15分钟｜闭卷纸笔｜满分100分

范围：W1—W4（含文件夹中的阅读材料）

第1题 输出题（25分）

输入为一行23 40。写出程序的全部输出，共5行，每行5分。

h, m = map(int, input().split())
diff = 35 - (h * 60 + m)
if diff < 0:
    diff += 24 * 60
print(diff)
print(diff // 60, diff % 60)
a, b = 2, 5
a, b = b, a + b
print(a, b)
print('3' * 2 + '0')
print(f'{diff / 60:.2f}')

输出：

第2题 填空题（25分）

补全函数，返回整数闭区间[lo, hi]中所有素数的总和。保证0 <= lo <= hi <= 1000，不得调用素数库。每空5分。

def prime_sum(lo, hi):
    total = 0
    for n in range(max(2, lo), __1__):
        for d in range(2, __2__):
            if __3__:
                __4__
        else:
            total += __5__
    return total

答案：

第3题 输出题（25分）

写出程序的全部输出，共5行，每行5分。

a = [4, 2, 3]
b = a
c = a[:]
b[1] = 8
c.append(1)
print(a)
print(c[-1:0:-2])
print(a.sort())
print(b)
print((c[0], len(c)))

输出：

第4题 填空题（25分）

补全牛顿迭代函数，计算非负数a的平方根。保证0 <= a <= 100、1e-8 <= eps <= 0.1；当残差abs(x*x-a) < eps时返回当前x，a=0直接返回0.0。每空5分。

def root(a, eps):
    if __1__:
        return 0.0
    x = max(1.0, a)
    while True:
        if __2__:
            return __3__
        x = (x + __4__) / __5__

答案：