HR技术面试题和笔试试题

最新推荐文章于 2026-08-19 10:51:35 发布

原创最新推荐文章于 2026-08-19 10:51:35 发布 · 972 阅读

27 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

1.技术面试题

（1）详细描述单调栈的工作原理和应用场景

答：工作原理：（以递减栈为例）

遍历数组中的每个元素
如果栈不为空，且新元素比栈顶大，就把栈顶元素弹出（因为破坏了递减）
把新元素入栈
被弹出的元素，它的「下一个更大元素」就是当前新元素
应用场景：1.找下一个更大/更小的数
```
              2.接雨水问题
```
```
              3.最大矩形面积
```

              4.去重并保持最小字典序

（2）详细描述单调队列的工作原理和应用场景

答：问题：数组 [1,3,-1,-3,5,3,6,7]，窗口大小3，找每个窗口的最大值

步骤：工作原理：

初始队伍为空，第一个人1进队 → [1]
第二个人3来了：比1高，1离开，3进队 → [3]
第三个人-1来了：比3矮，直接站后面 → [3,-1]
✅ 第一个窗口形成，队头3就是最大值
第四个人-3来了：比-1矮，站后面 → [3,-1,-3]
✅ 第二个窗口，队头3还是最大值
第五个人5来了：
- 比-3高 → -3离开
- 比-1高 → -1离开
- 比3高 → 3离开
- 队伍空了，5进队 → [5]
  ✅ 第三个窗口，最大值是5
  四、能解决什么问题？
滑动窗口最值
- 股票7天内的最高价格
- 服务器1小时内的最大请求量
- 核心：窗口移动时快速找到最值
实时数据流最值
- 设计一个系统，随时能返回过去N个数的最大值
- 比如监控系统显示最近5分钟的CPU最高使用率
游戏排行榜
- 实时显示前10名玩家分数（单调队列维护排名）

2.HR面试题

（1）如果竞争对手用双倍薪资挖你，你会怎么选择？

答：我不会只看薪资多少来决定。会先想自己现在更需要什么 —— 是短期多赚钱，还是长期能学到东西、有好的发展空间。也会看看现在的工作有没有不可替代的好处，比如能积累稀缺经验、团队氛围好之类的。综合这些再选，不会单纯因为薪资翻倍就走。

（2）我们觉得你今天表现一般，不符合岗位要求，你有什么想说的？

答：谢谢提醒，其实我也意识到今天有些地方回答不够到位。比如刚才提到的知识点，确实是我之前接触较少的。不过面试结束后我会立刻去查资料、看案例，弄清楚它的核心逻辑 —— 之前我遇到类似的陌生领域，也是这样先拆解问题，再找行业文章、请教同行，最后把学到的用在实际工作里。我一直觉得，比起已经掌握的，保持快速学习和迭代的能力更重要，也希望能有机会在实践中不断提升自己。

3.选择题

（1）在Python中，以下哪个不是循环控制语句？

A. break
B. continue
C. pass
D. return

答：D
return ：函数返回语句，用于结束函数执行并返回值，不属于循环控制语句

（2）以下代码的输出结果是什么？

for i in range(5):
    if i == 3:
        continue
    print(i, end=' ')

A. 0 1 2 3 4
B. 0 1 2 4
C. 0 1 2
D. 3

答：B
当 i == 3 时，执行 continue 语句，跳过当前迭代的 print 语句因此，最终输出为 0 1 2 4

（3）完成以下代码，使其能够打印出1到100之间所有的偶数：

for i in range(1, 101):
    if ______:
        print(i, end=' ')

A. i % 2 == 0
B. i % 2 == 1
C. i / 2 == 0
D. i // 2 == 0

答：A

i % 2 == 0 表示当 i 除以2的余数为0时（即偶数），执行 print(i)

（4）以下代码有一个错误，导致它无法正确计算1到10的和。请选择正确的修改方案：

sum = 0
i = 1
while i < 10:
    sum += i
    i += 1
print(sum)

A. 将i < 10改为i <= 10
B. 将i += 1改为i += 2
C. 将sum += i改为sum = sum + i + 1
D. 将i = 1改为i = 0

答：A
原代码中 while i < 10: 表示当 i 小于10时才执行循环体，因此当 i 等于10时循环终止，少计算了10

（5）以下代码的输出结果是什么？

for i in range(3):
    for j in range(2):
        print(f"({i},{j})", end=' ')

A. (0,0) (0,1) (1,0) (1,1) (2,0) (2,1)
B. (0,0) (1,0) (2,0) (0,1) (1,1) (2,1)
C. (0,0) (0,1) (0,2) (1,0) (1,1) (1,2)
D. (0,0) (1,1) (2,2)

答：A
代码包含两层嵌套循环：外层循环 i 取值为 0, 1, 2 （共3次迭代），内层循环 j 取值为 0, 1 （共2次迭代）

（6）完成以下代码，使其能够打印出斐波那契数列的前10个数：

a, b = 0, 1
for _ in range(10):
    print(a, end=' ')
    ______

A. a, b = b, a + b
B. a, b = a + b, b
C. a, b = b, a
D. a, b = a + 1, b + 1

答：A
先打印当前 a 的值
然后将 a 更新为原来的 b ， b 更新为原来的 a + b
如此循环10次，即可得到前10个数

（7）以下代码的输出结果是什么？

i = 0
while i < 5:
    i += 1
    if i == 3:
        continue
    print(i, end=' ')
else:
    print("Done")

A. 1 2 3 4 5 Done
B. 1 2 4 5 Done
C. 1 2 4 5
D. 1 2 Done

答：B
代码包含 while-else 结构，当循环正常结束（非 break 终止）时执行 else 子句
关键逻辑：当 i == 3 时执行 continue ，跳过当前循环的 print 语句

（8）以下代码的输出结果是什么？

for i in range(1, 5):
    for j in range(1, 5):
        if i * j > 10:
            break
        print(f"{i}*{j}={i*j}", end=" ")
    print()

1*1=1 1*2=2 1*3=3 1*4=4 
2*1=2 2*2=4 2*3=6 2*4=8 
3*1=3 3*2=6 3*3=9 3*4=12 
4*1=4 4*2=8 4*3=12 4*4=16

1*1=1 1*2=2 1*3=3 1*4=4 
2*1=2 2*2=4 2*3=6 2*4=8 
3*1=3 3*2=6 3*3=9 
4*1=4 4*2=8

1*1=1 1*2=2 1*3=3 1*4=4 
2*1=2 2*2=4 2*3=6 2*4=8 
3*1=3 3*2=6 3*3=9

1*1=1 1*2=2 1*3=3 1*4=4 
2*1=2 2*2=4 2*3=6 2*4=8

答：B

代码包含两层嵌套循环，外层 i 取值 1-4 ，内层 j 取值 1-4
核心逻辑：当 i*j > 10 时执行 break ，终止当前内层循环并进入下一个外层循环
每次内层循环结束后执行 print() 输出空行，实现换行效果

逐行执行分析：

（9）以下代码的输出结果是什么？

for i in range(4):
    for j in range(4):
        if (i + j) % 2 == 0:
            print("*", end="")
        else:
            print("#", end="")
    print()

****
####
****
####

*#*#
#*#*
*#*#
#*#*

*#*#
*#*#
*#*#
*#*#

****
****
****
****

答：B

代码通过嵌套循环生成4x4的字符矩阵，核心逻辑是根据 i+j 的奇偶性决定输出 * 或 # ：
- 当 (i+j) % 2 == 0 （i和j奇偶性相同）时输出 *
- 否则（i和j奇偶性不同）输出 #
外层循环控制行数（4行），内层循环控制每行字符（4个），内层循环结束后执行 print() 换行

逐行输出分析：

（10）以下代码的输出结果是什么？

count = 0
for i in range(1, 5):
    for j in range(1, 5):
        for k in range(1, 5):
            if i != j and j != k and i != k:
                count += 1
print(count)

A. 24
B. 36
C. 60
D. 64

答：A

代码通过三重嵌套循环遍历 i, j, k （均取值 1-4 ），统计满足三个变量互不相等的组合数量
核心条件： i != j and j != k and i != k （三个变量两两互不相等）

4.问答题

（1）Python中有哪几种基本的循环结构？请简要说明它们的语法和适用场景。

答：for循环（适合已知次数/遍历序列）
while循环（适合条件控制/次数不定
循环控制语句

break ：立即终止当前循环，跳出循环体
continue ：跳过当前循环的剩余部分，直接进入下一次迭代
else 子句：循环正常结束（非break终止）时执行

（2）Python中有哪些循环控制语句？它们各自的作用是什么？请给出示例说明。

答：break - 立即退出循环
作用：遇到 break 时，直接终止当前循环，跳到循环外的下一行代码。示例：找到第一个偶数就停止
continue - 跳过当前迭代
作用：跳过当前循环中剩余的代码，直接进入下一次迭代。示例：只打印奇数
pass - 空操作占位符
作用：语法上需要语句但逻辑上不需要执行任何操作时使用，避免语法错误。示例：暂时不实现循环体
循环else子句（特殊控制结构）
作用：当循环正常结束（不是通过 break ）时执行 else 块中的代码。示例：判断是否找到目标

（3）在Python的for循环中，range()函数扮演着重要角色。请详细说明range()函数的语法、参数含义和使用方法，并给出至少3个不同用法的示例。

答：基本语法
range() 函数用于生成一个整数序列，语法有三种形式：

range(stop) - 从0开始，到stop-1结束
range(start, stop) - 从start开始，到stop-1结束
range(start, stop, step) - 从start开始，步长为step，到stop-1结束（step≠0）二、参数说明

start ：起始值（包含），默认0
stop ：结束值（不包含），必须指定
step ：步长，默认1（正数表示递增，负数表示递减）三、使用示例
示例1：单参数形式（只指定结束值）
示例2：双参数形式（指定起始值和结束值）
示例3：三参数形式（指定步长）
示例4：负数步长（倒序生成）

（4）什么是嵌套循环？请解释嵌套循环的工作原理。

答：一、什么是嵌套循环？
嵌套循环指在一个循环（称为外层循环）的循环体内，包含另一个完整的循环结构（称为内层循环）。简单说就是“循环里套循环”，常用于处理多维数据或需要多层重复的场景。
二、工作原理

执行顺序：外层循环执行1次 → 内层循环完整执行所有次数 → 外层循环执行第2次 → 内层循环再次完整执行所有次数 → … 直到外层循环结束
类比理解：像日历一样——外层循环是“月份”（1-12月），内层循环是“天数”（每个月的天数），每个月都要完整数完当月的天数。

（5）编写代码，判断两个矩形的关系

题目描述

判断两个矩形之间的关系：包含，重叠，相离

输入输出描述

输入两行，每行四个数据，分别是矩形的中心坐标x、y和矩形的宽、高

输出两者的关系

示例1

输入：

2.5 4 2.5 43

1.5 5 0.5 3

输出：

包含

示例2

输入：

1 2 3 5.5

3 4 4.5 5

输出：

重叠

示例3

输入：

1 2 3 3

40 45 3 2

输出：

相离

答：

# # 判断两个矩形的关系：包含、重叠、相离
# 每个矩形通过中心点坐标(x,y)、宽度w和高度h来定义

# 输入第一个矩形的参数
print("===== 输入第一个矩形信息 ====")
x1 = float(input("中心x坐标: "))
y1 = float(input("中心y坐标: "))
w1 = float(input("宽度: "))
h1 = float(input("高度: "))

# 输入第二个矩形的参数
print("\n===== 输入第二个矩形信息 ====")
x2 = float(input("中心x坐标: "))
y2 = float(input("中心y坐标: "))
w2 = float(input("宽度: "))
h2 = float(input("高度: "))

# 计算矩形1的边界（上下左右）
left1 = x1 - w1 / 2   # 左边界 = 中心x - 宽度的一半
right1 = x1 + w1 / 2  # 右边界 = 中心x + 宽度的一半
top1 = y1 - h1 / 2    # 上边界 = 中心y - 高度的一半
bottom1 = y1 + h1 / 2 # 下边界 = 中心y + 高度的一半

# 计算矩形2的边界
left2 = x2 - w2 / 2
right2 = x2 + w2 / 2
top2 = y2 - h2 / 2
bottom2 = y2 + h2 / 2

# 判断包含关系
# 矩形1包含矩形2的条件：矩形2的所有边都在矩形1内部
rect1_contains = (left1 <= left2) and (right1 >= right2) and (top1 <= top2) and (bottom1 >= bottom2)
# 矩形2包含矩形1的条件：矩形1的所有边都在矩形2内部
rect2_contains = (left2 <= left1) and (right2 >= right1) and (top2 <= top1) and (bottom2 >= bottom1)

if rect1_contains:
    print("\n关系：第一个矩形包含第二个矩形")
elif rect2_contains:
    print("\n关系：第二个矩形包含第一个矩形")
else:
    # 判断是否重叠
    # x方向重叠：一个矩形的左边在另一个矩形右边的左边
    overlap_x = (left1 < right2) and (left2 < right1)
    # y方向重叠：一个矩形的上边在另一个矩形下边的上边
    overlap_y = (top1 < bottom2) and (top2 < bottom1)
    
    if overlap_x and overlap_y:
        print("\n关系：两个矩形重叠")
    else:
        print("\n关系：两个矩形相离")

（6）编写代码，打印如下数字图案

                        1
                    1	2	1
                1	2	4	2	1
            1 	2	4	8	4	2	1
        1	2	4	8	16	8	4	2	1
    1	2	4	8	16	32	16	8	4	2	1
1	2	4	8	16	32	64	32	16	8	4	2	1

答：


    spaces = '\t' * (6 - i)

    left_numbers = []
    current = 1
    for _ in range(i):
        left_numbers.append(current)
        current *= 2

    middle_number = 2 ** i

    right_numbers = []
    for num in reversed(left_numbers):
        right_numbers.append(num)

    all_numbers = left_numbers + [middle_number] + right_numbers
    number_str = '\t'.join(str(num) for num in all_numbers)

    print(spaces + number_str)

（7）编写代码，打印如下星星图案

    *
   ***
  *****
 *******
*********
 *******
  *****
   ***
    *

答：


    print(' ' * (5 - i) + '*' * (2 * i - 1))

for i in range(4, 0, -1):
    print(' ' * (5 - i) + '*' * (2 * i - 1)

（8）编写代码，求最小公倍数

题目描述

输入两个正整数，计算其最小公倍数，例如4和2的最小公倍数是4，3和5的最小公倍数是15

输入输出描述

输入两个正整数

输出最小公倍数

示例1

输入：

3 9

输出：

9

示例2

输入：

4 6

输出：

12

答：

num1, num2 = map(int, input().split())

max_num = max(num1, num2)

while True:
    if max_num % num1 == 0 and max_num % num2 == 0:
        lcm = max_num
        break
    max_num += 1
print(lcm)

标签

#python #开发语言