资讯 / 正文

【真题】3元素之和等于目标整数

【真题】3元素之和等于目标整数

下面这段代码的功能是:从用户输入的列表中,找出所有「三个不同位置的元素之和等于目标整数 n」的组合,每个组合以元组形式收集到 listb,最后打印。

lista = eval(input(”输入一个列表:”))n = int(input(”输入一个整数:”))listb = []lista_len = len(lista)for i in range(lista_len):    for j in range(i + 1, lista_len):        for k in range(j + 1, lista_len):            if lista[i] + lista[j] + lista[k] == n:                tup = (lista[i], lista[j], lista[k])                listb.append(tup)print(listb)

假设的测试数据

为了注释具体,我们固定一组输入:

  • 列表输入:[1, 2, 3, 4, 5]
  • 目标整数:n = 9

预期:找出三个不同位置的元素,和为 9。候选组合(按索引 i<j<k 顺序):

  • (1,3,5) → 1+3+5=9 ✓
  • (2,3,4) → 2+3+4=9 ✓
  • (1,2,6) 不存在 6
  • 其余检查后不满足

所以预期输出:[(1, 3, 5), (2, 3, 4)]


第 1 行

lista = eval(input(”输入一个列表:”))

原子级拆解:

  1. input("输入一个列表:")
       - 在屏幕显示提示 输入一个列表:,等待用户键入并回车。   - 返回值永远是字符串。例如用户输入 [1, 2, 3, 4, 5],得到字符串 "[1, 2, 3, 4, 5]"。
  2. eval(...)
       - 把字符串当作 Python 表达式求值。   - eval("[1, 2, 3, 4, 5]") 会解析成真正的列表对象 [1, 2, 3, 4, 5]。   - ⚠️ 安全警告:eval 会执行任意代码,用户若输入 __import__("os").system("rm -rf /") 之类会真的执行。生产代码应改用 ast.literal_eval 或 json.loads。
  3. lista = ...
       - 把求值得到的列表绑定到变量 lista。   - 本测试中:lista = [1, 2, 3, 4, 5]

执行后状态:

lista = [1, 2, 3, 4, 5]

第 2 行

n = int(input(”输入一个整数:”))

原子级拆解:

  1. input("输入一个整数:")
       - 显示提示,读取用户输入,返回字符串。用户输入 9,得到 "9"。
  2. int("9")
       - 把字符串转成整数 9。   - 若用户输入非整数(如 abc),抛 ValueError。
  3. n = ...
       - 绑定到 n。

执行后状态:

n = 9

第 3 行

listb = []

原子级拆解:

  • 创建一个空列表,用于收集满足条件的元组。
  • 此时 listb = []。

为什么用列表而不是集合?

  • 列表保持插入顺序,结果可预测。
  • 若用集合,重复组合会被去重,但输出顺序不稳定。

执行后状态:

listb = []

第 4 行

lista_len = len(lista)

原子级拆解:

  • len(lista)
     返回元素个数。本测试 len([1,2,3,4,5]) = 5。
  • 存到 lista_len,避免在循环条件里反复调用 len(微优化,也提高可读性)。

执行后状态:

lista_len = 5

第 5 行

for i in range(lista_len):

原子级拆解:

  • range(5)
     产生 0, 1, 2, 3, 4。
  • i
     依次取这些值,代表第一个元素的索引。
  • 循环范围是 0..4,因为三数组合的第一个元素最多取到索引 2 才可能有后两个(但这里不提前优化,直接全遍历)。

i 的取值序列:0 → 1 → 2 → 3 → 4


第 6 行

for j in range(i + 1, lista_len):

原子级拆解:

  • 内层循环,j 从 i+1 开始,到 lista_len-1 结束。
  • 为什么从 i+1 开始? 保证 j > i,即第二元素在第一个之后,避免重复组合(如 (1,2,3) 和 (2,1,3))以及同一元素被用两次。
  • range(i+1, 5)
     产生 i+1, i+2, ..., 4。

举例:

  • 当 i = 0:j ∈ {1,2,3,4}
  • 当 i = 1:j ∈ {2,3,4}
  • 当 i = 2:j ∈ {3,4}
  • 当 i = 3:j ∈ {4}
  • 当 i = 4:range(5,5) 为空,内层不执行

第 7 行

for k in range(j + 1, lista_len):

原子级拆解:

  • 最内层循环,k 从 j+1 开始到 4。
  • 为什么从 j+1 开始? 保证 k > j > i,三个索引严格递增,组合不重复、不重用同一元素。
  • 这是「组合」而不是「排列」的标准写法。

举例:

  • 当 i=0, j=1:k ∈ {2,3,4}
  • 当 i=0, j=2:k ∈ {3,4}
  • 当 i=1, j=2:k ∈ {3,4}
  • 当 i=3, j=4:range(5,5) 为空

第 8 行

if lista[i] + lista[j] + lista[k] == n:

原子级拆解:

  • 取出三个索引对应的元素,求和,与目标 n 比较。
  • 相等则进入 if 块。
  • 注意:比较的是值,不是索引;相同值在不同位置会被视为不同组合(如列表含重复元素时)。

以i=0, j=2, k=4为例:

  • lista[0]=1
    ,lista[2]=3,lista[4]=5
  • 1+3+5 = 9 == n
     → 成立,进入 if

以i=0, j=1, k=2为例:

  • 1+2+3 = 6 ≠ 9
     → 不进入

第 9 行

tup = (lista[i], lista[j], lista[k])

原子级拆解:

  • 把三个元素打包成元组tup。
  • 元组是不可变的,适合作为「组合」的表示,也避免后续被误改。
  • 注意:元组元素顺序是 (i, j, k) 索引顺序,即按原列表位置排列,不是按值大小排序。

本测试中第一次命中的是:

i=0, j=2, k=4 → tup = (1, 3, 5)

第 10 行

listb.append(tup)

原子级拆解:

  • append
     把 tup 追加到 listb 末尾。
  • 原地修改 listb,返回 None。
  • 每次命中,listb 增加一个元组。

第一次命中后:

listb = [(1, 3, 5)]

第 11 行

print(listb)

原子级拆解:

  • 循环全部结束后,打印收集到的所有组合。
  • 输出是列表的字符串表示。

本测试的完整执行过程(只列命中):

i
j
k
三元素
和
是否等于 9
0
1
2
1,2,3
6
✗
0
1
3
1,2,4
7
✗
0
1
4
1,2,5
8
✗
0
2
3
1,3,4
8
✗
0
2
4
1,3,5
9
✓ → (1,3,5)
0
3
4
1,4,5
10
✗
1
2
3
2,3,4
9
✓ → (2,3,4)
1
2
4
2,3,5
10
✗
1
3
4
2,4,5
11
✗
2
3
4
3,4,5
12
✗

最终输出:

[(1, 3, 5), (2, 3, 4)]

复杂度与行为分析

时间复杂度

  • 三层循环,组合数 ,即 O(n³)。
  • 对 n=5,迭代 10 次;n=100,约 161700 次;n=1000,约 1.66 亿 次。
  • 大列表会非常慢。优化方向:排序 + 双指针(O(n²))或用字典/集合(视题目要求)。

空间复杂度

  • listb
     最坏存  个元组,O(n³)。
  • 若只需计数,可只存计数而不存元组。

重复元素的处理

  • 若 lista = [1, 1, 2, 3],n = 4:
    • 索引组合 (0,2,3) → (1,2,3) 和 6 否
    • 索引组合 (1,2,3) → (1,2,3) 和 6 否
    • 实际值相同的不同位置会被视为不同组合,结果可能有重复元组。
    • 若需去重,可在末尾 listb = list(set(listb)) 或改用集合,但会丢失顺序。

如果你希望,我可以再给出输入输出交互示例(包括用户输入、程序回显、逐步变量变化),或者把它改成去重版本 / 双指针 O(n²) 版本并逐行注释。

← 返回资讯列表