【无标题】

1.技术面试题

（1）解释Linux中的进程、线程和守护进程的概念，以及如何管理它们？

答：进程是操作系统资源分配的基本单位，拥有独立的地址空间和系统资源。线程是进程内的执行单元，共享进程资源但拥有独立栈空间。守护进程是在后台运行的特殊进程，脱离终端且生命周期通常较长。

管理方法：

进程：ps查看进程，kill终止进程，top监控进程
线程：pthread库创建管理，gdb调试线程
守护进程：nohup启动，systemd管理服务

（2）请详细描述OSI七层模型和TCP/IP四层模型，并说明它们之间的对应关系。每一层的主要功能是什么？各层有哪些典型的协议？

答：OSI七层模型：

物理层：比特流传输（RS-232）
数据链路层：帧传输（以太网）
网络层：路由选择（IP）
传输层：端到端连接（TCP）
会话层：会话管理（RPC）
表示层：数据格式转换（SSL）
应用层：用户接口（HTTP）
对应TCP/IP四层：

网络接口层（物理+数据链路）
网际层（网络）
传输层（传输）
应用层（会话+表示+应用）

（3）详细介绍什么是最大堆/最小堆。

答：完全二叉树结构：

最大堆：父节点值≥子节点，根节点最大
最小堆：父节点值≤子节点，根节点最小 操作时间复杂度：
插入/删除：O(log n)
获取极值：O(1) 典型应用：优先队列、堆排序

（4）详细介绍什么是二分搜索树。

答：二叉树的特殊形式：

左子树所有节点值 < 根节点值
右子树所有节点值 > 根节点值 操作复杂度：
平均情况：查找/插入/删除 O(log n)
最坏情况（退化为链表）：O(n) 优化方案：AVL树、红黑树等平衡BST

2.HR面试题

（1）我们非常欣赏你的能力，但目前只能提供比你期望薪资低20%的offer。在这种情况下，你会接受这份工作吗？如果接受，你对未来薪资增长有什么期望？如果不接受，你的底线是什么？

答：薪资评估应综合考虑发展机会、技能匹配度和市场水平。若岗位具有显著成长空间或技术挑战，可协商阶段性review机制。未来6-12个月期望通过绩效证明价值并实现薪资调整。底线取决于当地生活成本和个人职业规划。

（2）我们公司经常需要加班到深夜，有时甚至需要周末工作。你如何看待这种工作强度？你认为工作与生活的理想平衡点在哪里？

答：高效工作应注重质量而非单纯时长。支持阶段性冲刺但需要合理规划保障可持续性。理想状态是工作时间专注产出，非工作时间充分充电。建议通过流程优化和自动化减少重复劳动。

（3）你认为自己最大的优势是什么？这个优势如何帮助你胜任我们这个岗位？

答：以技术岗为例："系统性解决问题能力体现在复杂系统的模块化设计经验，曾通过架构优化将接口响应时间降低70%。这种结构化思维能快速定位贵司当前系统的性能瓶颈。

（4）你认为这份工作能为你带来什么？你能为公司创造什么价值？

答：期望获得大规模系统实战经验，同时将我的分布式系统调优经验应用于贵司产品，预估可提升15%资源利用率。长期看可培养跨团队协作的Tech Lead能力。

3.问答题

（1）以下代码运行结果是？并阐述函数func的主要功能是什么？

def func(lst):
    result = []
    for i in range(len(lst)):
        if i == len(lst) - 1:
            result.append(lst[i] * 2)
        elif lst[i] < lst[i+1]:
            result.append(lst[i] + 1)
        else:
            result.append(lst[i] - 1)
    return result

print(func([5, 3, 7, 2]))

答：[4, 4, 8, 4]
函数 func 接收一个列表 lst，通过遍历列表中的每个元素，根据以下规则生成新列表 result：

当前元素是最后一个元素时：将该元素的值乘以 2 并添加到结果中（lst[i] * 2）。
当前元素小于下一个元素时：将当前元素的值加 1 并添加到结果中（lst[i] + 1）。
当前元素不小于下一个元素时：将当前元素的值减 1 并添加到结果中（lst[i] - 1）。

（2）以下代码运行结果是？并阐述函数func的主要功能是什么？

def func(lst):
    result = []
    for num in lst:
        if num % 3 == 0:
            result.append(num // 3)
        elif num % 2 == 0:
            result.append(num * 2)
            if num > 10:
                break
        else:
            result.append(num + 1)
    return result

print(func([9, 4, 12, 7, 14]))

答：[3, 8, 4, 8]。

函数功能分析
函数 func 的主要功能是对输入列表 lst 中的每个元素进行处理，并将处理后的结果存入一个新列表 result 中返回。具体处理逻辑如下：

如果当前数字能被 3 整除（num % 3 == 0），则将该数字除以 3 的整数部分（num // 3）加入结果列表。
如果当前数字能被 2 整除（num % 2 == 0），则将该数字乘以 2（num * 2）加入结果列表，并检查该数字是否大于 10。如果大于 10，则立即终止循环。
如果以上条件均不满足，则将当前数字加 1（num + 1）加入结果列表。

（3）以下代码运行结果是？并阐述函数func的主要功能是什么？

def func(nums1, m, nums2, n):
    i = j = k = 0
    temp = nums1.copy()
    while i < m and j < n:
        if temp[i] < nums2[j]:
            nums1[k] = temp[i]
            i += 1
        else:
            nums1[k] = nums2[j]
            j += 1
        k += 1
    while i < m:
        nums1[k] = temp[i]
        i += 1
        k += 1
    return nums1

nums1 = [1, 3, 5, 0, 0]
m = 3
nums2 = [2, 4]
n = 2
print(func(nums1, m, nums2, n))

答：[1, 2, 3, 4, 5]。

函数 func 的主要功能
函数 func 实现了两个有序数组合并为一个有序数组的功能，具体步骤如下：

将 nums1 的前 m 个元素和 nums2 的前 n 个元素合并到 nums1 中，确保合并后的数组有序。nums1 初始长度为 m + n，后 n 个元素为占位值（通常为 0）。

函数通过双指针法（i 和 j）分别遍历 nums1 的有效部分（前 m 个元素）和 nums2，比较当前指针指向的元素，将较小的元素放入 nums1 的对应位置。若其中一个数组遍历完毕，将另一个数组剩余元素直接填入 nums1 的剩余位置。

（4）以下代码运行结果是？并阐述函数func的主要功能是什么？

def func(lst):
    total = 0
    for i in range(len(lst)):
        if i % 2 == 0:
            total += lst[i]
        else:
            total -= lst[i]
        if total < 0:
            total = 0
    return total

print(func([5, 3, 2, 7, 1]))

答：4
该函数对列表元素进行交替加减运算（偶数索引加，奇数索引减），并在累加过程中保持总数非负。

（5）以下代码运行结果是？并阐述函数func的主要功能是什么？

def func(lst):
    evens = []
    odds = []
    for num in lst:
        if num % 2 == 0:
            evens.append(num)
        else:
            odds.append(num)
    evens.sort()
    odds.sort(reverse=True)
    return evens + odds

print(func([3, 1, 4, 1, 5, 9, 2, 6, 5]))

答：[2, 4, 6, 9, 5, 5, 3, 1, 1]

函数功能分析
功能1：分离奇偶数
遍历输入列表 lst，将所有偶数存入列表 evens，奇数存入列表 odds。例如输入 [3, 1, 4, 1, 5, 9, 2, 6, 5] 时：

evens 为 [4, 2, 6]
odds 为 [3, 1, 1, 5, 9, 5]
功能2：排序处理
对偶数列表 evens 进行升序排序（默认），奇数列表 odds 进行降序排序（通过 reverse=True 实现）。经过排序后：

evens 变为 [2, 4, 6]
odds 变为 [9, 5, 5, 3, 1, 1]
功能3：合并列表
将排序后的偶数列表和奇数列表合并，最终返回 evens + odds，即 [2, 4, 6, 9, 5, 5, 3, 1, 1]。

（6）以下代码运行结果是？并阐述函数func的主要功能是什么？

def func(lst):
    result = []
    for i in range(len(lst)):
        current = lst.pop(0)
        if current % 2 == 0:
            lst.append(current * 2)
        else:
            result.append(current)
    return result + lst

data = [1, 2, 3, 4, 5]
print(func(data))

答：[1, 3, 5, 8]。

函数功能分析
函数 func 的主要功能是对输入列表 lst 进行以下操作：

遍历列表中的每个元素，每次从列表头部弹出第一个元素 current。
如果 current 是偶数，将其乘以 2 后重新添加到列表的末尾。
如果 current 是奇数，直接将其添加到结果列表 result 中。
最终返回 result 和剩余未处理的 lst 的拼接结果。

（7）以下代码运行结果是？并阐述函数func的主要功能是什么？

def func(lst):
    result = []
    for i in range(len(lst)):
        for j in range(i+1, len(lst)):
            if lst[i] + lst[j] == 10:
                result.append((lst[i], lst[j]))
                break
    return result

print(func([5, 3, 7, 2, 8]))

答：[(5, 5), (3, 7), (2, 8)]
函数 func 的主要功能是：从列表中找出所有不重复的数值对，满足两数之和等于 10。具体逻辑如下：

双重循环遍历列表：外层循环固定当前元素 lst[i]，内层循环遍历后续元素 lst[j]（j 从 i+1 开始）。
检查数值和条件：当 lst[i] + lst[j] == 10 时，将数值对 (lst[i], lst[j]) 加入结果列表 result。
立即跳出内层循环：通过 break 确保每个 lst[i] 仅匹配第一个满足条件的 lst[j]，避免重复匹配。

（8）编写程序，反素数

反素数是指一个将其逆向拼写后也是一个素数的非回文数，例如17和71都是素数但不是回文数，且反转后依旧是素数

输出显示前100个反素数，每行显示10个

答：

# Your Codes ```python 
def is_prime(n):
    if n < 2:
        return False
    for i in range(2, int(n**0.5)+1):
        if n % i == 0:
            return False
    return True

def is_emirp(n):
    s = str(n)
    return s != s[::-1] and is_prime(int(s[::-1]))

count = 0
num = 2
while count < 100:
    if is_prime(num) and is_emirp(num):
        print(f"{num:4}", end=' ')
        count += 1
        if count % 10 == 0:
            print()
    num += 1
 

**（9）编写程序，梅森素数**

如果一个素数可以写成$2^p-1$的形式，其中p是某个正整数，那么这个素数就称作梅森素数

输出p≤31的所有梅森素数

答：```python 
def is_prime(n):
    if n <= 1:
        return False
    if n <= 3:
        return True
    if n % 2 == 0 or n % 3 == 0:
        return False
    i = 5
    while i * i <= n:
        if n % i == 0 or n % (i + 2) == 0:
            return False
        i += 6
    return True

def mersenne_primes(max_p):
    primes = []
    for p in range(2, max_p + 1):
        if not is_prime(p):
            continue
        mersenne = (1 << p) - 1  # 等价于2**p - 1
        if is_prime(mersenne):
            primes.append(p)
    return primes

print(mersenne_primes(31))
 

**（10）编写程序，数列求和**

编写一个函数计算下面的数列：

$m(i) = \frac{1}{2} + \frac{2}{3} + ... + \frac{i}{i + 1}$

并输出测试结果：

```python
i		m(i)
1		0.500
2		1.16
...		
19		16.40
20		17/35

答：

def calculate_sequence(i):
    total = 0.0
    for n in range(1, i + 1):
        total += n / (n + 1)
    return total
 

**（11）编写程序，组合问题**

有1、2、3、4这个四个数字，能组成多少个互不相同且无重复数字的三位数？分别又是多少？

答：
``````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:
                print(i * 100 + j * 10 + k)
                count += 1
print("Total numbers:", count)
 

（12）编写程序，计算e

你可以使用下面的数列近似计算e
$$e=1+\frac{1}{1!}+\frac{1}{2!}+\frac{1}{3!}+\frac{1}{4!}+...+\frac{1}{i!}$$
当i越大时，计算结果越近似于e

答：

# Your Codes 
``````python 
import math

def calculate_e(iterations):
    e_approx = 0.0
    for i in range(iterations):
        e_approx += 1 / math.factorial(i)
    return e_approx
n = 20
result = calculate_e(n)
print(f"经过{n}次迭代后，e的近似值为: {result}")
print(f"math模块的精确e值为: {math.e}")
 

（13）编写程序，完全数

如果一个正整数等于除了它本身之外所有正因子的和，那么这个数称为完全数

例如 6 = 3 + 2 + 1，28 = 14 + 7 + 4 + 2 + 1

输入输出描述

输入一个正整数

输出该数是否为完全数

示例1

输入：

6

输出：

Yes

示例2

输入：

9

输出：

No

答：

# Your Codes 
``````python 
def is_perfect_number(n):
    if n <= 1:
        return False
    sum_factors = 0
    for i in range(1, n):
        if n % i == 0:
            sum_factors += i
    return sum_factors == n