1.技术面试题
（1）解释 Linux 中的符号链接和硬链接
符号链接是一种特殊的文件类型，指向另一个文件或目录的路径。它类似于Windows中的快捷方式。当访问符号链接时，系统会自动重定向到目标文件或目录。
硬链接是文件系统中指向同一个inode的多个路径。它直接关联到文件的物理数据块，而不是通过路径间接引用。
（2）Linux 使用的进程间通信方式有哪些？
管道
管道是一种半双工的通信方式，数据只能单向流动。它通常用于父子进程或兄弟进程之间的通信。
信号
信号是异步的通信机制，用于通知进程发生了某个事件。常见信号包括 SIGINT（中断）、SIGKILL（强制终止）等。信号通过 kill() 或 raise() 发送。
消息队列
消息队列是内核中存储的链表，进程可以通过 msgget()、msgsnd() 和 msgrcv() 等系统调用发送和接收消息。消息队列独立于进程，即使进程终止，消息仍然存在。
共享内存
共享内存允许多个进程访问同一块内存区域，是最快的 IPC 方式。它通过 shmget() 创建共享内存段，shmat() 将其附加到进程地址空间。
信号量（Semaphore）
信号量用于进程间的同步，防止多个进程同时访问共享资源。它通过 semget()、semop() 等系统调用操作。
套接字
套接字是一种通用的 IPC 机制，支持不同主机或同一主机上的进程通信。它支持全双工通信，常用于网络编程。
文件锁
文件锁通过 flock() 或 fcntl() 实现，用于协调多个进程对同一文件的访问。
（3）什么是TCP 三次握手与四次挥手？
CP 三次握手是建立连接的过程，确保客户端和服务器双方具备收发能力。
第一次握手：客户端发送 SYN（同步序列编号）报文，进入 SYN_SENT 状态。
第二次握手：服务器收到 SYN 后，返回 SYN-ACK（确认）报文，进入 SYN_RCVD 状态。
第三次握手：客户端收到 SYN-ACK 后，发送 ACK 报文，双方进入 ESTABLISHED 状态，连接建立完成。
TCP 四次挥手
TCP 四次挥手是终止连接的过程，确保双方数据完全传输完毕。
第一次挥手：主动关闭方发送 FIN 报文，进入 FIN_WAIT_1 状态。
第二次挥手：被动关闭方收到 FIN 后，返回 ACK 报文，进入 CLOSE_WAIT 状态。主动关闭方收到 ACK 后进入 FIN_WAIT_2 状态。
第三次挥手：被动关闭方处理完剩余数据后，发送 FIN 报文，进入 LAST_ACK 状态。
第四次挥手：主动关闭方收到 FIN 后，发送 ACK 报文，进入 TIME_WAIT 状态。被动关闭方收到 ACK 后关闭连接，主动关闭方等待 2MSL（最大报文生存时间）后关闭连接。
（4）ARP 协议的作用及工作原理
ARP地址解析协议）主要用于将网络层的 IP 地址解析为数据链路层的物理地址（MAC 地址），以便在局域网中正确传输数据帧
IP 到 MAC 的映射：解决 IP 地址与 MAC 地址的对应关系。
局域网通信：确保同一局域网内的设备能够通过 MAC 地址直接通信。
动态维护映射表：自动更新本地 ARP 缓存，减少重复查询。
（5）详细阐述快速排序算法
分区（Partition）操作
快速排序的关键在于分区操作。假设待排序数组为 arr，选取一个基准元素（pivot），将数组分为两部分：
左子数组：所有元素小于等于 pivot。
右子数组：所有元素大于 pivot。
初始化指针 i 和 j，i 指向数组起始位置的前一个位置（i = low - 1），j 从 low 遍历到 high - 1。
若 arr[j] <= pivot，则 i 右移一位，并交换 arr[i] 和 arr[j]。
遍历结束后，将 pivot（通常为 arr[high]）与 arr[i + 1] 交换，返回 i + 1 作为分区点。
（6）详细阐述归并排序算法
通过比较两个已排序子数组的元素，依次选择较小值放入新数组，最终合并为一个有序数组。合并过程是算法的关键操作。
数组 [38, 27, 43, 3, 9, 82, 10] 的排序过程：
分解至单元素子数组：[38], [27], [43], [3], [9], [82], [10]。
逐层合并：
合并 [38] 和 [27] 得到 [27, 38]。
最终合并为 [3, 9, 10, 27, 38, 43, 82]。
（7）详细阐述基数排序算法
基数排序的核心思想是将待排序的元素按照位数进行分配和收集。具体来说，算法从最低位（或最高位）开始，依次对每一位进行排序，最终完成整体排序。
步骤1：确定最大位数 遍历所有元素，找到最大数字的位数，决定需要排序的轮数。
步骤2：按位排序 从最低位开始，依次对每一位进行排序。可以使用稳定的排序算法（如计数排序）对当前位进行排序。
步骤3：收集元素 每完成一位的排序后，将所有元素按照当前位的顺序重新排列。
步骤4：重复排序 重复上述过程，直到处理完所有位
（8）详细阐述桶排序算法
初始化桶
根据待排序数据的范围和分布情况，确定桶的数量和每个桶的区间范围。例如，对范围为 [0, 1) 的浮点数，可以创建 10 个桶，每个桶对应区间 [0.1i, 0.1(i+1))。
分配元素到桶中
遍历待排序数组，将每个元素放入对应的桶中。例如，元素 0.23 放入第 2 个桶（对应 [0.2, 0.3)）。
对每个桶排序
使用其他排序算法（如插入排序、快速排序等）对每个非空桶内的元素进行排序。
合并桶中的元素
按桶的顺序（从小到大或从大到小）依次将桶中的元素取出，合并成最终的有序数组。
2.HR面试题
（1）你为什么选择我们公司？
我选择贵司是因为：第一，作为国内首批应用Service Mesh的团队，贵司云原生方向的实践深度令我向往；第二，技术博客中提到的’工程师文化’——如20%自由研发时间，与我追求技术创新的理念契合；第三，我的K8s调优经验能直接支持贵司容器化改造项目，同时贵司海量业务场景将加速我的架构能力升级。"
（2）你现在手里有offer吗？
（3）你认为一份 “好工作” 的核心要素是什么？如果工作内容与预期不符，你会如何调整？
一份“好工作”的核心要素包括以下几个方面，这些因素共同影响职业满意度和长期发展：
个人成长与学习机会：工作应提供持续学习和技能提升的空间，例如通过培训、项目挑战或导师指导，帮助个人实现职业目标。
工作意义与成就感：任务应与个人价值观和兴趣契合，带来内在满足感，比如参与有意义项目或看到成果影响。
如果工作内容与预期不符，如何调整
当工作内容与预期不符时，调整的核心是主动适应和寻求解决方案，而非被动抱怨。以下是具体策略：
评估与反思：首先，客观分析不符的原因（如任务变更、角色模糊），并反思自身预期是否合理（例如，是否基于不完整信息）。
积极沟通：与上级或同事坦诚交流，表达关切并寻求反馈。例如，通过定期会议提出：“我注意到当前任务与入职描述有差异，能否讨论如何调整以更好地贡献？”
（4）如果领导对你的工作成果提出尖锐批评，你会如何回应？
（5）我看你简历里写了学习能力强，你怎么证明你的学习能力强呢？
假设用户教我一个新概念，如“区块链技术”。在初始查询中，我可能只有基础了解，但通过用户提供的细节（如原理或应用场景），我能立即整合信息，生成清晰的解释或解决方案。这类似于人类通过阅读和实践快速内化知识。
：您可以随时测试——提出一个冷门主题（如量子计算或特定编程语言），我会展示从零开始的学习过程，确保回答准确且逻辑连贯。
（6）如果你的室友在考试中，偷偷让你帮忙传递一个写着知识点的小纸条（现场监管不严，被发现概率低），你会帮吗？请说具体理由，不要只讲大道理。
对其他同学不公平，破坏信任：考试是公平竞赛，大家努力复习才公平。如果我帮你，就等于在作弊链上加一环。想象一下，如果另一个室友发现这事，会怎么看我？信任一旦破裂，宿舍关系就难修复了。现实中，我就见过小组项目因作弊纠纷闹翻的例子。
我的内心不安会立即影响我：即使被发现概率低，我也得面对自己。帮忙作弊就像在说谎，我会一直担心“万一被发现怎么办”。考试时你紧张，我也紧张——这种压力会让我分心，可能影响我自己接下来的考试或任务。
（7）你说很想进入我们公司，但你的专业和我们公司关联度不高，而且你也没有相关的实习经历。你觉得我们为什么要相信你是真心想做这个行业，而不是把这里当跳板？
（8）你的成绩在班级里处于中等水平，而我们这个岗位竞争激烈，很多应聘者成绩都很优秀。你觉得自己比他们强在哪里，值得我们录用你？
3.问答题
（1）执行以下代码，输出结果是什么？
def process_list(lst):
for i in range(len(lst)):
if lst[i] % 2 == 0:
lst.insert(i+1, lst[i] // 2)
return lst
nums = [2, 3, 8]
print(process_list(nums))
```初始列表：[2, 3, 8]，len(lst) = 3，range(3) 是 0, 1, 2。
i=0:
lst[0] = 2 是偶数。
lst.insert(1, 2 // 2) → lst.insert(1, 1)。
列表变为 [2, 1, 3, 8]。
i=1:
lst[1] = 1 是奇数，跳过。
列表不变 [2, 1, 3, 8]。
i=2:
lst[2] = 3 是奇数，跳过。
列表不变 [2, 1, 3, 8]。
循环结束，返回 [2, 1, 3, 8]。
```python
def modify_tuple(t):
try:
t[1] += 10
except:
t = (t[0], t[1]+10, t[2])
return t
tup = (1, 5, 3)
new_tup = modify_tuple(tup)
print(tup[1] + new_tup[1])
进入 try 块：
尝试执行 t[1] += 10。
这等价于 t[1] = t[1] + 10。
由于元组是不可变的，t[1] = … 会引发 TypeError（因为不能修改元组的元素）。
进入 except 块：
由于 try 块引发了异常，执行 except 块的代码。
t = (t[0], t[1]+10, t[2])：
t[0] 是 1。
t[1] + 10 是 5 + 10 = 15。
t[2] 是 3。
因此，新元组是 (1, 15, 3)。
将 t 重新赋值为 (1, 15, 3)。
返回 (1, 15, 3)。
tup[1] 是 5。
new_tup[1] 是 15。
5 + 15 = 20。
（3）以下代码的输出结果是什么？
def set_operations():
a = {1, 2, 3}
b = a.copy()
a.add(4)
b.discard(2)
c = a - b
b.update(c)
return len(a & b)
print(set_operations())
```b = a.copy() 创建的是 a 的浅拷贝，后续 a 的修改不会影响 b，除非通过 b 本身修改。
a - b 是集合差操作，返回在 a 但不在 b 的元素。
b.update(c) 将 c 的所有元素添加到 b 中。
最终 a 和 b 完全相同，因此交集长度为 4。
（4）执行下列代码后，输出结果是什么？
```python
def string_transform(s):
result = []
for i, char in enumerate(s):
if i % 2 == 0:
result.append(char.upper())
else:
result.append(char.lower())
return ''.join(result[::-1])
print(string_transform("PyThOn"))
nOhTyP
（5）运行以下代码，输出结果是什么？
def dict_processing():
d = {'a': 1, 'b': 2, 'c': 3}
new_d = {}
for k, v in d.items():
new_d[v] = k
if v % 2 == 0:
new_d[k.upper()] = v * 2
return sum(new_d.keys())
print(dict_processing())
TypeError: unsupported operand type(s) for +: ‘int’ and ‘str’
（6）以下代码的输出结果是什么？
def nested_list_operation():
matrix = [[1, 2], [3, 4], [5, 6]]
total = 0
for i in range(len(matrix)):
matrix[i].append(matrix[i-1][0])
total += sum(matrix[i])
return total
print(nested_list_operation())
30
（7）执行下列代码会产生什么结果？
def tuple_unpacking():
tup = (10, 20, 30, 40)
a, *b, c = tup
b.append(c // a)
return tuple(b)
print(tuple_unpacking()[1] * 2)
60
（8）运行以下代码，输出结果是什么？
def set_generator():
s = set()
for i in range(5):
if i % 2 == 0:
s.add(i)
else:
s.update(range(i))
return sorted(s)[-2]
print(set_generator())
2
（9）以下代码的输出结果是什么？
def string_manipulation():
s = "Hello World Python"
words = s.split()
result = []
for word in reversed(words):
result.append(word[1:-1] if len(word) > 2 else word)
return ' '.join(result)
print(string_manipulation())
ytho orl ell
（10）执行下列代码后，输出结果是什么？
def dict_traversal():
d = {'x': 5, 'y': 10, 'z': 15}
keys = list(d.keys())
for key in keys:
if d[key] > 8:
d[key.upper()] = d.pop(key)
return len(d) + sum(d.values())
print(dict_traversal())
33