网站 设计 精髓宝鸡seo排名
# 1.技术面试题
**（1）详细描述单调栈的工作原理和应用场景**
答：单调栈是一种特殊的栈数据结构，其核心特性是栈内元素始终保持单调递增或单调递减的顺序。单调栈的核心价值是高效寻找元素的前后边界（如 “下一个更大 / 更小元素”），因此广泛用于解决数组中与 “边界” 相关的优化问题。
**（2）详细描述单调队列的工作原理和应用场景**
答：通过双端操作维护队列内元素的单调性（递增 / 递减），同时移除无效元素，确保每个元素仅入队 / 出队一次；单调队列的核心价值是高效维护动态区间（如滑动窗口）的极值，尤其适用于需要频繁更新区间并查询最大 / 最小值的问题。
# 2.HR面试题
**（1）如果竞争对手用双倍薪资挖你，你会怎么选择？**
答：贵公司在云原生方面具有很大的价值，这正是我希望深耕的领域。我过往学习的云原生需要得到锻炼形成互补，这种‘能力 - 需求’的精准匹配，其实是很难用薪资衡量的。
**（2）我们觉得你今天表现一般，不符合岗位要求，你有什么想说的？**
答：无论结果如何，我都很认可贵公司在云原生上的布局，也确实很希望能在这样的平台成长。如果这次没机会，我会把今天的反馈当成改进的方向，未来如果有更匹配的岗位开放，我还会再努力争取。
# 3.选择题
**（1）在Python中，以下哪个不是循环控制语句？**
A. `break`
B. `continue`
C. `pass`
D. `return`
答：D. `return`，本质上是函数控制语句，而非直接作用于循环。
**（2）以下代码的输出结果是什么？**
```python
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. `0 1 2 4`
**（3）完成以下代码，使其能够打印出1到100之间所有的偶数：**
```python
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`
**（4）以下代码有一个错误，导致它无法正确计算1到10的和。请选择正确的修改方案：**
```python
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. 将`i < 10`改为`i <= 10`
**（5）以下代码的输出结果是什么？**
```python
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. `(0,0) (0,1) (1,0) (1,1) (2,0) (2,1)`
**（6）完成以下代码，使其能够打印出斐波那契数列的前10个数：**
```python
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, b = b, a + b`
**（7）以下代码的输出结果是什么？**
```python
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. `1 2 4 5 Done`
**（8）以下代码的输出结果是什么？**
```python
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()
```
A.
```
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
```
B.
```
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
```
C.
```
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
```
D.
```
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.
```
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
```
**（9）以下代码的输出结果是什么？**
```python
for i in range(4):
for j in range(4):
if (i + j) % 2 == 0:
print("*", end="")
else:
print("#", end="")
print()
```
A.
```
****
####
****
####
```
B.
```
*#*#
#*#*
*#*#
#*#*
```
C.
```
*#*#
*#*#
*#*#
*#*#
```
D.
```
****
****
****
****
```
答：B.
```
*#*#
#*#*
*#*#
#*#*
```
**（10）以下代码的输出结果是什么？**
```python
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. `24`
# 4.问答题
**（1）Python中有哪几种基本的循环结构？请简要说明它们的语法和适用场景。**
答：for 循环：遍历可迭代对象（如列表、元组、字符串、字典、集合等；已知迭代次数（如 range() 生成的序列）
while循环：未知迭代次数，需根据条件动态判断（如用户输入验证、网络请求重试）。条件持续满足时执行（如游戏主循环、守护进程）。
**（2）Python中有哪些循环控制语句？它们各自的作用是什么？请给出示例说明。**
答：continue 语句作用：跳过当前循环的剩余代码，直接进入下一次迭代。continue 语句作用：跳过当前循环的剩余代码，直接进入下一次迭代。else 子句（循环正常结束时执行）作用：在循环正常结束（未被 break 终止）时执行。
**（3）在Python的for循环中，range()函数扮演着重要角色。请详细说明range()函数的语法、参数含义和使用方法，并给出至少3个不同用法的示例。**
答：语法与参数含义：start（可选，默认 = 0）：序列起始值（包含）。 stop（必选）：序列结束值（不包含）。 step（可选，默认 = 1）：步长（相邻元素的差值），可为负数（表示倒序）。使用方法：1. 单参数2. 双参数3. 三参数4. 负步长
**（4）什么是嵌套循环？请解释嵌套循环的工作原理。**
答：嵌套循环是指在一个循环体内部再放置另一个循环。外层循环每执行一次，内层循环会完整执行一轮，形成 “外层控制行，内层控制列” 的结构。常见于处理多维数据（如矩阵、网格）或需要多次迭代的场景。外层循环启动后，进入第一次迭代。内层循环开始执行，完整遍历所有迭代次数。内层循环结束后，外层循环进入下一次迭代，再次触发内层循环的完整执行。重复上述过程，直到外层循环终止。
**（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
>
> 输出：
>
> 相离
答：
```python
# #读取输入
rect1 = list(map(float, input().split()))
rect2 = list(map(float, input().split()))
# 解析矩形参数
x1, y1, w1, h1 = rect1
x2, y2, w2, h2 = rect2
# 计算边界
left1, right1 = x1 - w1 / 2, x1 + w1 / 2
top1, bottom1 = y1 + h1 / 2, y1 - h1 / 2
left2, right2 = x2 - w2 / 2, x2 + w2 / 2
top2, bottom2 = y2 + h2 / 2, y2 - h2 / 2
# 判断包含关系
if (left1 <= left2 and right1 >= right2 and top1 >= top2 and bottom1 <= bottom2) or \ (left2 <= left1 and right2 >= right1 and top2 >= top1 and bottom2 <= bottom1): print("包含")
# 判断相离关系
elif right1 < left2 or left1 > right2 or bottom1 > top2 or top1 < bottom2:
print("相离")
else:
print("重叠")
```
**（6）编写代码，打印如下数字图案**
```python
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
```
答：
```python
# n = 7
# 金字塔的行数
for i in range(n):
# 计算当前行的数字列表
max_power = 2 ** i
left_part = [2 ** j for j in range(i + 1)]
right_part = left_part[:-1][::-1] # 排除最后一个元素并反转
line = left_part + right_part
# 将数字转换为字符串并居中对齐
line_str = ' '.join(map(str, line)) total_width = 2 * (2 ** (n-1)) - 1 # 底层的宽度
formatted_line = line_str.center(total_width)
print(formatted_line)
```
**（7）编写代码，打印如下星星图案**
```python
*
***
*****
*******
*********
*******
*****
***
*
```
答：
```python
# n = 5 # 金字塔的上半部分行数
# 打印上半部分
for i in range(n):
spaces = n - i - 1
stars = 2 * i + 1
print(' ' * spaces + '*' * stars + ' ' * spaces)
# 打印下半部分
for i in range(n-2, -1, -1):
spaces = n - i - 1
stars = 2 * i + 1 print(' ' * spaces + '*' * stars + ' ' * spaces)
```
**（8）编写代码，求最小公倍数**
**题目描述**
输入两个正整数，计算其最小公倍数，例如4和2的最小公倍数是4，3和5的最小公倍数是15
**输入输出描述**
输入两个正整数
输出最小公倍数
**示例1**
> 输入：
>
> 3 9
>
> 输出：
>
> 9
**示例2**
> 输入：
>
> 4 6
>
> 输出：
>
> 12
答：
```python
# a, b = map(int, input().split())
def gcd(x, y):
while y:
x, y = y, x % y
return x
lcm = a * b // gcd(a, b)
print(lcm)
```