python2

1.技术面试题

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

答：Linux中的进程
进程是操作系统分配资源的基本单位，每个进程有独立的地址空间、文件描述符和系统资源。在Linux中，进程通过fork()系统调用创建，新进程是父进程的副本。进程可以通过ps、top或htop命令查看和管理。

Linux中的线程
线程是进程的执行单元，共享同一进程的地址空间和资源。线程比进程更轻量，创建和切换开销更小。Linux通过pthread库支持多线程编程。使用ps -eLf或top -H可以查看线程信息。

Linux中的守护进程
守护进程是在后台运行的特殊进程，通常没有控制终端。它们通常在系统启动时启动，提供系统服务。常见的守护进程包括sshd、httpd等。守护进程可以通过systemctl或service命令管理。

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

答：OSI七层模型
物理层（Physical Layer）
物理层负责传输原始比特流，定义电气、机械和功能接口标准。典型协议包括以太网（IEEE 802.3）、RS-232等。主要功能涉及电压、引脚定义、传输速率和物理连接方式。

数据链路层（Data Link Layer）
数据链路层提供可靠的点对点数据传输，处理帧同步、错误检测和流量控制。典型协议有以太网（MAC子层）、PPP（点对点协议）和HDLC（高级数据链路控制）。主要功能包括帧封装、MAC地址寻址和差错控制。

网络层（Network Layer）
网络层负责路由选择、分组转发和逻辑寻址。典型协议包括IP（IPv4/IPv6）、ICMP（互联网控制报文协议）和OSPF（开放最短路径优先）。主要功能涉及IP地址分配、路由算法和拥塞控制。

传输层（Transport Layer）
传输层提供端到端的可靠或不可靠数据传输服务。典型协议有TCP（可靠传输）和UDP（不可靠传输）。主要功能包括流量控制、差错恢复和端口号分配。

会话层（Session Layer）
会话层管理通信会话的建立、维护和终止。典型协议如RPC（远程过程调用）和NetBIOS。主要功能涉及会话同步和对话控制。

表示层（Presentation Layer）
表示层处理数据格式转换、加密和压缩。典型协议包括SSL/TLS（加密）、JPEG（图像压缩）和ASCII（字符编码）。主要功能为数据翻译和加密解密。

应用层（Application Layer）
应用层直接为用户应用提供服务。典型协议有HTTP（网页浏览）、FTP（文件传输）和SMTP（电子邮件）。主要功能包括用户接口和高级服务支持。

TCP/IP四层模型
网络接口层（Network Interface Layer）
对应OSI的物理层和数据链路层，负责物理传输和链路管理。典型协议是以太网和Wi-Fi（IEEE 802.11）。

网络层（Internet Layer）
对应OSI的网络层，核心协议为IP（Internet Protocol），辅以ICMP和IGMP（组管理协议）。主要功能是路由和分组交换。

传输层（Transport Layer）
与OSI传输层完全对应，协议包括TCP（面向连接）和UDP（无连接）。主要提供端到端通信服务。

应用层（Application Layer）
合并了OSI的会话层、表示层和应用层，涵盖HTTP、DNS（域名解析）、DHCP（动态主机配置）等协议。直接支持用户应用需求。

模型对应关系
网络接口层对应OSI的物理层和数据链路层。
网络层与OSI的网络层完全一致。
传输层在两模型中功能相同。
应用层整合了OSI的会话层、表示层和应用层。

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

答：最大堆和最小堆是完全二叉树的一种特殊形式，满足堆属性（Heap Property）。堆结构常用于优先队列、堆排序等场景。
最大堆：每个节点的值都大于或等于其子节点的值，根节点为最大值。
最小堆：每个节点的值都小于或等于其子节点的值，根节点为最小值。
堆的存储方式
堆通常用数组实现，利用完全二叉树的性质进行索引映射：
父节点索引：parent(i) = (i - 1) // 2
左子节点索引：left_child(i) = 2 * i + 1
右子节点索引：right_child(i) = 2 * i + 2

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

答：二分搜索树是一种基于二叉树结构的数据结构，具有以下性质：
每个节点最多有两个子节点（左子节点和右子节点）。
对于任意节点，其左子树中的所有节点的值均小于该节点的值。
对于任意节点，其右子树中的所有节点的值均大于该节点的值。
通常不允许存在重复的节点值（具体实现可能允许重复值存储于左子树或右子树）。

2.HR面试题

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

答：接受低于期望薪资的职位时，我会与HR明确沟通未来薪资调整的可能性

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

答：长期加班和周末工作可能导致身体疲劳、心理压力增加，影响工作效率和创造力。允许灵活安排工作时间，例如核心时段+自主调整，减少通勤压力。

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

答：对代码、公式等专业内容按标准格式处理，确保技术文档的准确性。在研发或质量管理类岗位中，此类严谨性可直接减少沟通成本，提升交付质量。

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

答：该职位提供了持续学习和成长的机会，能够通过实际项目积累经验，提升专业技能。接触行业前沿技术和多元化团队协作，有助于拓宽视野，增强解决问题的能力。

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 的主要功能
函数 func 对输入列表 lst 中的每个元素进行条件判断并处理，具体逻辑如下：

最后一个元素的处理
如果当前元素是列表的最后一个元素（即 i == len(lst) - 1），将其值乘以 2 并加入结果列表。

非末尾元素的处理

当前元素小于下一个元素（即 lst[i] < lst[i+1]）：将当前元素加 1 并加入结果列表。
当前元素大于或等于下一个元素：将当前元素减 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 的主要功能
函数 func 会对输入的列表 lst 进行遍历，并根据每个元素的值进行不同的操作，最终返回一个新的列表 result。

（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 实现了两个已排序数组合并的功能，将 nums2 合并到 nums1 中，同时保持合并后的数组有序。nums1 初始时已预留足够空间（末尾有 0 作为占位符），合并后 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]))

答：运行结果为 6
函数 func 的主要功能
交替加减元素：
函数遍历列表，对偶数索引的元素执行加法，奇数索引的元素执行减法。例如，对于 lst[i]：

若 i 是偶数：total += lst[i]。
若 i 是奇数：total -= lst[i]。
非负约束：
每次操作后检查 total 是否为负数。若为负，立即重置为 0，确保累计值始终非负。

返回累计结果：
最终返回经过交替加减和非负约束处理后的 total 值。

（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]
函数 func 的主要功能
函数 func 对输入的列表 lst 进行以下操作：

将列表中的数字分为偶数（evens）和奇数（odds）两个子列表。
偶数列表 evens 按升序排序，奇数列表 odds 按降序排序。
最终返回合并后的列表，偶数在前，奇数在后。

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

答：运行代码 print(func([1, 2, 3, 4, 5])) 的输出结果为：
[1, 3, 5, 4, 8]
函数 func 的主要功能
函数 func 处理输入列表 lst 的逻辑如下：

初始化结果列表：创建一个空列表 result 用于存储符合条件的元素。
遍历原始列表：通过 for 循环遍历列表的原始长度（len(lst)），每次从列表头部弹出第一个元素（lst.pop(0)）。
分类处理元素：
若弹出的元素为偶数（current % 2 == 0），将其乘以 2 后追加到列表尾部（lst.append(current * 2)）。
若为奇数，直接加入 result 列表（result.append(current)）。
合并并返回结果：最终将 result（所有奇数）与处理后的 lst（剩余的偶数乘以 2 的结果）合并返回。

（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 的主要功能
函数 func 的功能是从一个列表中找出所有满足两数之和等于 10 的元素对，并将这些元素对以元组形式存储到结果列表中。具体实现逻辑如下：
外层循环遍历列表元素：从第一个元素开始，逐个检查当前元素与后续元素的组合。
内层循环配对检查：对于当前元素 lst[i]，检查其与后续每个元素 lst[j] 的和是否为 10。
记录匹配对并跳出内层循环：一旦找到满足条件的配对 (lst[i], lst[j])，将其加入结果列表 result，并立即跳出当前内层循环（避免重复记录同一元素的配对）。

（8）编写程序，反素数

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

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

答：

# Your Codes 
```def is_emirp(n):
    if not is_prime(n):
        return False
    reversed_n = int(str(n)[::-1])
    return n != reversed_n and is_prime(reversed_n)
emirps = []
n = 2
while len(emirps) < 100:
    if is_emirp(n):
        emirps.append(n)
    n += 1
for i in range(0, 100, 10):
    print(", ".join(map(str, emirps[i:i+10])))




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

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

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

答：

```python
# Your Codes 
```def is_prime(n):
    """检查一个数是否为素数"""
    if n <= 1:
        return False
    if n == 2:
        return True
    if n % 2 == 0:
        return False
    for i in range(3, int(n**0.5) + 1, 2):
        if n % i == 0:
            return False
    return True

def generate_mersenne_primes(max_p=31):
    """生成 p ≤ max_p 的所有梅森素数"""
    mersenne_primes = []
    for p in range(2, max_p + 1):
        if is_prime(p):
            mersenne = (2 ** p) - 1
            if is_prime(mersenne):
                mersenne_primes.append((p, mersenne))
    return mersenne_primes

# 调用函数并输出结果
mersennes = generate_mersenne_primes()
for p, mersenne in mersennes:
    print(f"p = {p}: 梅森素数 = {mersenne}")




**（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

答：

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

# 测试结果输出
print("i\t\tm(i)")
for i in range(1, 21):
    if i == 20:
        print(f"{i}\t\t{calculate_sequence(i)}")
    else:
        print(f"{i}\t\t{calculate_sequence(i):.3f}")




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

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

答：

```python
# Your Codes 
```digits = [1, 2, 3, 4]
result = []

for i in digits:
    for j in digits:
        for k in digits:
            if i != j and j != k and i != k:
                num = i * 100 + j * 10 + k
                result.append(num)

count = len(result)
print(f"能组成的三位数总数: {count}")
print("具体的三位数列表:")
print(result)




**（12）编写程序，计算e**

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

答：

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

def calculate_e(n):
    e_approx = 1.0  # 初始化近似值
    factorial = 1    # 初始化阶乘值
    for i in range(1, n+1):
        factorial *= i  # 计算i的阶乘
        e_approx += 1 / factorial  # 累加当前项
    return e_approx

# 设置迭代次数
iterations = 20
# 计算近似值
approx_e = calculate_e(iterations)
# 输出结果
print(f"Approximated e after {iterations} iterations: {approx_e}")
print(f"Actual value of e from math module: {math.e}")
print(f"Difference: {abs(math.e - approx_e)}")




**（13）编写程序，完全数**

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

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

**输入输出描述**

输入一个正整数

输出该数是否为完全数

**示例1**

> 输入：
>
> 6
>
> 输出：
>
> Yes

**示例2**

> 输入：
>
> 9
>
> 输出：
>
> No

答：

```python
# Your Codes 
```def is_perfect_number(num):
    if num <= 1:
        return False
    sum_of_divisors = 1  # 1 is a proper divisor for all numbers > 1
    for i in range(2, int(num**0.5) + 1):
        if num % i == 0:
            sum_of_divisors += i
            other_divisor = num // i
            if other_divisor != i:
                sum_of_divisors += other_divisor
    return sum_of_divisors == num

number = int(input())
if is_perfect_number(number):
    print("Yes")
else:
    print("No")