1.技术面试题

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

答：
        单调栈（Monotonic Stack）：单调栈是一种特殊的栈结构，其内部元素始终保持单调递增或单调递减的顺序。这种结构在处理某些特定类型的问题时，能够提供高效的解决方案。
        工作原理 ：
        通过维护栈内元素的有序性（单调递增或单调递减）来高效地解决诸如寻找下一个更大/更小元素等问题。在单调递增栈中，栈内元素从栈底到栈顶保持递增顺序，每当有新元素入栈时，会不断弹出栈顶小于新元素的元素，以确保栈的单调性；同样，在单调递减栈中，栈内元素从栈底到栈顶保持递减顺序，新元素入栈时会弹出栈顶大于新元素的元素。通过这种机制，单调栈能够在O(n)的时间复杂度内处理一系列元素，找到每个元素在序列中左边或右边的第一个更大或更小的元素，广泛应用于解决诸如股票价格、柱状图中最大矩形面积等问题。
        应用场景 ：
        ①寻找下一个更大/更小元素：给定一个数组，找到每个元素后面第一个比它大的元素，或者第一个比它小的元素。比如股票价格问题(给定一个数组表示股票每天的价格，找到每个价格后面第一个更高的价格)、柱状图中最大矩形面积（通过单调栈可以高效地找到每个柱子左右两边第一个比它矮的柱子，从而计算最大矩形面积）。② 滑动窗口问题：在一个滑动窗口中寻找最大值或最小值。比如：LeetCode 239. 滑动窗口最大值(虽然单调队列更常用，但单调栈也可以用于某些滑动窗口问题，通过维护一个单调递减的栈来找到窗口内的最大值)。③ 表达式求值：解析和计算包含括号的数学表达式。比如括号匹配(使用单调栈来匹配括号，确保每个左括号都有一个对应的右括号) 、表达式求值(通过栈来计算表达式的值，处理运算符的优先级)。④拓扑排序：在有向无环图（DAG）中找到一个线性排序，使得对于每一条有向边 uv，u 在 v 的前面。比如任务调度（在任务之间存在依赖关系时，使用拓扑排序来确定任务的执行顺序）⑤ 计算逆波兰表达式（后缀表达式）：计算逆波兰表达式（后缀表达式）的值。比如表达式求值(使用栈来计算逆波兰表达式的值，处理运算符和操作数)。⑥解析HTML/XML标签：在解析HTML或XML文档时，使用栈来匹配开始和结束标签。⑦编译器设计：在词法分析和语法分析阶段，栈用于处理运算符优先级和表达式求值。

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

答：
        单调队列(Monotonic Queue)是一种特殊的数据结构，它维护一个队列，使得队列中的元素按照某种单调性（如单调递增或单调递减）排列。单调队列通常用于解决滑动窗口问题，特别是需要快速找到滑动窗口内的最大值或最小值的问题。
        工作原理 ：
        单调队列是一种通过维护队列内元素单调性（单调递增或递减）来高效处理特定问题的数据结构。其工作原理是，在元素入队时，从队尾开始移除所有违反单调性的元素，以确保队列从头到尾始终保持所需的单调顺序；同时，在元素出队时，从队头移除过期的元素（即超出当前处理窗口范围的元素）。这种机制使得单调队列能够在一次遍历中，以线性时间复杂度高效地解决诸如滑动窗口最值问题等需要频繁查询区间最值的场景。

        应用场景 ：
        单调队列广泛应用于需要高效查找滑动窗口内最值的场景。
        ① 滑动窗口最大值/最小值问题：在给定数组和窗口大小的情况下，快速找到每个窗口内的最大值或最小值，比如LeetCode的239号问题。②. 优化动态规划问题：在某些动态规划问题中，单调队列可以用于优化状态转移过程，比如在股票买卖问题中寻找某个区间的最佳买卖时机。③. 图形处理：在图像处理中，单调队列可用于边缘检测和特征提取，通过维护像素值的单调性来识别图像中的重要特征。④. 其他区间最值问题：在某些算法竞赛题目中，单调队列被用来优化查询区间最值的操作，提高算法效率。

2.HR面试题

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

答：
        如果竞争对手用双倍薪资挖我，我首先会非常感激他们对我的认可。然而，我目前在公司的工作非常充实，学到了很多，也得到了很多支持和帮助。对我来说，职业发展不仅仅取决于薪资，更取决于工作内容、团队合作以及公司提供的成长机会。我非常重视职业道德和忠诚度，在没有充分了解和考虑的情况下，我不会轻易做出跳槽的决定。目前，我正在积极参与公司的一个重要项目，并且希望能够在这个项目中做出更大的贡献。当然，如果有机会了解竞争对手的offer，我也会认真考虑。但最终的选择会基于多方面的因素，包括职业发展、公司文化以及个人价值观。总的来说，我会综合考虑多方面因素，做出最符合我职业规划的选择。

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

答：
        首先，非常感谢您给我这个机会参加面试，并且坦诚地分享您的看法。我理解您可能对我今天的表现有一些顾虑，可能在某些方面我没有完全达到您的期望。在面试过程中，我意识到自己在某些方面可能表现得不够充分，比如在回答某些问题时可能没有提供足够的细节，或者在某些技术问题上没有给出最准确的答案。然而，我也想强调，我非常重视这次面试的机会，并且在面试结束后，我会认真反思自己的表现，找出不足之处并加以改进。我相信通过不断的学习和实践，我能够不断提升自己的能力。尽管如此，我仍然非常对这个岗位充满热情，并且我相信我的技能和经验与岗位要求是匹配的。我之前的工作经历和项目经验使我具备了解决类似问题的能力，并且我非常愿意在这个岗位上继续学习和成长。如果您能给我一些具体的建议或反馈，我将非常感激。同时，我也希望能够有机会进一步展示我的能力，或者参与一些试用期项目，以证明我的价值。

3.选择题

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

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

答：
        D. return
        备注:①break用于跳出循环;②continue 用于跳过当前循环的剩余部分，继续下一次循环;③pass 是一个空操作语句，用于占位，不影响循环的执行;④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. 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
        备注:B. i % 2 == 1判断奇数；C. i / 2 == 0和D. i // 2 == 0，除非i=0，但i从1开始

（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. 将 i < 10 改为 i <= 10
        备注:①选项 B 会跳过一些数字；②选项 C 会改变累加的逻辑；③选项 D 会从 0 开始，但循环条件仍然是 i < 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. (0,0) (0,1) (1,0) (1,1) (2,0) (2,1)
        备注:i从0到2，j从0到1

（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, b = b, a + b
        备注:斐波那契数列的规则是：每个数等于前两个数之和。①B. a, b = a + b, b，b不变②C. a, b = b, a，a和b交换③D. a, b = a + 1, b + 1，a和b都递增不符合定义。

（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. 1 2 4 5 Done

（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()

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 

答：
        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 

        备注:·i从1到4.·j从1到4，i*j>10停止循环

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

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.

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

答：
        C.

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

        备注:i从0到3.·j从0到3，（i+j）%2==0打印*，反之#

（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. 24
        备注:三个都是1到4，且if语句要求互不相同，则4*3*2=24

4.问答题

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

答：
        在Python中，有三种基本的循环结构：for 循环、while 循环和列表推导式（List Comprehension）。
        1.for 循环:①语法：

for 变量 in 可迭代对象:
    循环体

②适用场景：当你知道需要迭代的次数或有一个明确的可迭代对象（如列表、元组、字符串、字典、集合或range对象））时，使用for循环。
        2.while 循环:①语法：

while 条件:
    循环体

②适用场景：当确定需要迭代的次数，但有一个可以改变的条件时，使用while循环
        3.列表推导式（List Comprehension）:①语法：

count = 0
while count < 5:
    print(count)
    count += 1

②适用场景：当需要基于一个可迭代对象创建一个新的列表，并且可以在一行内简洁表达时，使用列表推导式。这个方式结合了for循环和条件判断。

循环结构	语法	适用场景	特点/控制语句
for 循环	for 变量 in 可迭代对象: 循环体	遍历已知次数或明确可迭代对象的元素	可嵌套，支持break、continue、pass
while 循环	while 条件: 循环体	当条件为True时重复执行，常用于不确定迭代次数的场景	可嵌套，支持break、continue、pass
列表推导式	[表达式 for 变量 in 可迭代对象 if 条件]	基于可迭代对象创建新列表，简洁表达循环和条件过滤	单行代码，语法简洁高效

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

答：
        在Python中，有几种用于控制循环执行流程的语句，主要包括break、continue、else和pass。
         1. break:
        break语句用于立即终止当前所在的循环，无论循环条件是否仍然为True；当执行到break时，程序会跳出循环体，继续执行循环之后的代码。
         ①适用场景:当满足某个条件时，需要提前退出循环时使用。
         ②示例:

for i in range(6):
    if i == 3:
        break  # 当i等于3时，退出循环
    print(i)

         输出：

	0
	1
	2

         2. continue:
        continue语句用于跳过当前循环的剩余部分，立即进入下一次循环迭代；当执行到continue时，程序会跳过当前循环体中continue之后的所有代码，直接进入下一次循环的条件判断。
         ①适用场景:当满足某个条件时，需要跳过当前迭代的剩余部分，继续下一次循环时使用。
         ②示例:

for i in range(5):
    if i == 2:
        continue  # 当i等于2时，跳过本次循环的剩余部分
    print(i)

         输出：

	0
	1
	3
	4

         3. else:
        虽然不是循环控制语句本身，但在循环中使用else子句可以与break语句结合使用，以检测循环是否被break提前终止。
         ①适用场景:用于检测循环是否被break提前终止，如果循环正常结束则执行else子句
         ②示例:

for i in range(3):
    print(i)
else:
    print("循环结束")

         输出：

	0
	1
	2
	循环结束

         4. pass:
        pass语句是一个空操作语句，它什么也不做；它用于在语法上需要一条语句但程序逻辑上不需要任何操作的地方，作为占位符使用。
         ①适用场景:在编写代码时，暂时不想实现某个功能或循环体，可以使用pass作为占位符。
         ②示例:

for i in range(5):
    if i == 2:
        pass  # 暂时不执行任何操作，作为占位符
    else:
        print(i)

         输出：

	0
	1
	3
	4

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

答：
        在Python的for循环中，range()函数是一个非常重要的工具，用于生成一系列整数序列。
        1. range()函数的语法:

	range(stop)
	range(start, stop[, step])

        2. 参数含义:
        ①start：序列的起始值。默认为0。如果只提供一个参数，则该参数被视为stop。②stop：序列的结束值（不包含该值本身）。生成的序列会从start开始，到stop - 1结束。③step：序列中元素的增量或步长。默认为1。可以是正数或负数，但不能为0。
        备注：start和step在实际应用中可以省略。
        3. 使用方法:
        range()函数返回一个range对象，该对象是一个可迭代的序列。在for循环中，range()函数常用于指定循环的次数或迭代的次数。
        4. 示例:
        示例 1：仅使用stop参数:

	# 打印0到4的数字
	for i in range(5):
	    print(i)

        输出：

	0
	1
	2
	3
	4

        备注:只提供了一个参数5，表示从0开始，到5结束（不包含5），步长默认为1。
        示例 2：使用start和stop参数:

	# 打印2到9的数字
	for i in range(2, 10):
	    print(i)

        输出：

	2
	3
	4
	5
	6
	7
	8
	9

        备注:提供了两个参数2和10，表示从2开始，到10结束（不包含10），步长默认为1。
        示例 3：使用start、stop和step参数:

	# 打印从10到2，步长为-2的序列
	for i in range(10, 1, -2):
	    print(i)

        输出：

	10
	8
	6
	4
	2

        备注:提供了三个参数10、1和-2，表示从10开始，到2结束（包含2，因为range函数的结束值是不包含的，但这里因为步长为负数，所以会包含2），步长为-2。
        示例 4：使用负数步长:

	# 打印从-5到-1的数字
	for i in range(-5, 0):
	    print(i)

        输出：

	-5
	-4
	-3
	-2
	-1

        备注: 从-5开始，到0结束（不包含0），步长默认为1。
        示例 5：使用range()生成空序列:

	# 打印空序列
	for i in range(5, 5):
	    print(i)

        输出：

（	无输出）

        备注：start和stop相同，且步长为正数时，生成的序列为空。

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

答：
        嵌套循环（Nested Loop）是指在一个循环结构内部再包含一个或多个循环结构。换句话说，一个循环的循环体中又包含了另一个完整的循环。这种结构常用于处理多维数据结构或需要执行多层次迭代的任务。
        工作原理: 外层循环每执行一次，内层循环就会完整地执行一遍。
        1. 外层循环：首先执行外层循环的第一次迭代。
        2. 内层循环：在每次外层循环的迭代中，内层循环会从开始到结束完整地执行一遍。
        3. 重复过程：当内层循环执行完毕后，外层循环会进行下一次迭代，然后内层循环再次完整地执行一遍。
        4. 循环结束：当外层循环的所有迭代都完成后，整个嵌套循环结构结束。
        执行流程:
        1. 外层循环开始，执行第一次迭代。
        2. 进入内层循环，执行内层循环的所有迭代。
        3. 内层循环结束后，返回外层循环，进行下一次迭代。
        4. 重复步骤2和3，直到外层循环的所有迭代都完成。

（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

输出：

相离

答：

def get boundaries(x, y, w, h):
    left = x - w / 2
    right = x + w / 2
    bottom = y - h / 2
    top = y + h / 2
    return left, right, bottom, top

def is contain(r1, r2):
    l1, r1, b1, t1 = r1
    l2, r2, b2, t2 = r2
    return l1 <= l2 and r1 >= r2 and b1 <= b2 and t1 >= t2

def is overlap(r1, r2):
    l1, r1, b1, t1 = r1
    l2, r2, b2, t2 = r2
    return not (r1 < l2 or r2 < l1 or t1 < b2 or t2 < b1)

def get relation(r1, r2):
    if is contain(r1, r2):
        return "contain"
    elif is contain(r2, r1):
        return "contain"
    elif is overlap(r1, r2):
        return "overlap"
    else:
        return "disjoint"

def main():
    import sys
    input lines = sys.stdin.read().splitlines()
    if len(input lines) < 2:
        return
    rect1 = list(map(float, input lines[0].strip().split()))
    rect2 = list(map(float, input lines[1].strip().split()))
    if len(rect1) != 4 or len(rect2) != 4:
        return
    r1 = get boundaries(rect1[0], rect1[1], rect1[2], rect1[3])
    r2 = get boundaries(rect2[0], rect2[1], rect2[2], rect2[3])
    relation = get relation(r1, r2)
    print(relation)

if __name__ == "__main__":
    main()

（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

答：

n = 7
for i in range(1, n + 1):
    for j in range(n - i):
        print("    ", end="")
    for j in range(i):
        print(f"1\t", end="")
    for j in range(i - 1):
        print(f"{2 ** j * 2}\t", end="")
    for j in range(i - 1, -1, -1):
        print(f"{2 ** j}\t", end="")
    print()

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

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

答：

n = 5
for i in range(n):
    for j in range(n - i - 1):
        print(" ", end="")
    for j in range(2 * i + 1):
        print("*", end="")
    print()
for i in range(n - 2, -1, -1):
    for j in range(n - i - 1):
        print(" ", end="")
    for j in range(2 * i + 1):
        print("*", end="")
    print()

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

题目描述

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

输入输出描述

输入两个正整数

输出最小公倍数

示例1

输入：

3 9

输出：

9

示例2

输入：

4 6

输出：

12

答：

import math

def calculate_lcm(a, b):
    return abs(a * b) // math.gcd(a, b)

def main():
    try:
        a, b = map(int, input().split())    
        lcm = calculate_lcm(a, b)
        print(lcm)
    except ValueError:
        print("请输入两个正整数，用空格分隔。")

if __name__ == "__main__":
    main()