【练习题】

1.技术面试题

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

答：

进程（Process）

核心概念：
进程是程序的一次执行实例，是 Linux 系统中资源分配的基本单位。
管理方法：
进程管理包括查看、创建、终止、调度等操作，可通过命令行工具和系统调用实现。

线程（Thread）

核心概念：
线程是进程内的最小执行单元，是 CPU 调度的基本单位。一个进程可以包含多个线程，这些线程共享进程的资源。
管理方法：
Linux 中线程由内核管理（NPTL，Native POSIX Thread Library），管理方式依赖线程库函数和命令行工具。

守护进程（Daemon）

核心概念：
守护进程是运行在后台的特殊进程，脱离终端控制，通常随系统启动并长期运行，用于提供持续服务。
管理方法：
守护进程的管理包括创建、启动、停止和监控，核心是确保其在后台稳定运行。

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

答：

OSI 七层模型（Open Systems Interconnection Model）

OSI 模型将网络通信划分为 7 个抽象层，自下而上分别为：

1. 物理层（Physical Layer）
   功能：
   负责传输介质（如电缆、光纤、无线）上的原始比特流传输，定义物理接口标准（电压、信号频率、引脚定义等）。
   典型协议：
   Ethernet（IEEE 802.3）：定义以太网电缆、接头和信号传输标准；
   RS-232：串口通信标准；
   USB：通用串行总线标准。
2. 数据链路层（Data Link Layer）
   功能：
   将物理层的比特流封装为帧（Frame），处理 MAC 地址（物理地址），提供错误检测和纠正（如 CRC 校验），实现相邻节点间的可靠传输。
   典型协议：
   Ethernet（MAC 子层）：定义 MAC 地址和帧格式；
   PPP（Point-to-Point Protocol）：用于点对点连接（如拨号上网）；
   ARP（Address Resolution Protocol）：将 IP 地址解析为 MAC 地址；
   RARP（Reverse ARP）：将 MAC 地址解析为 IP 地址。
3. 网络层（Network Layer）
   功能：
   将数据链路层的帧封装为数据包（Packet），处理 IP 地址（逻辑地址），负责跨网络的路由选择、拥塞控制和数据包转发。
   典型协议：
   IP（Internet Protocol）：IPv4/IPv6 定义 IP 地址和数据包格式；
   ICMP（Internet Control Message Protocol）：网络错误和控制消息（如 Ping、Traceroute）；
   IGMP（Internet Group Management Protocol）：多播组成员管理；
   Routing Protocols（如 RIP、OSPF、BGP）：路由选择协议。
4. 传输层（Transport Layer）
   功能：
   将网络层的数据包封装为段（Segment），提供端到端的可靠传输（TCP）或不可靠传输（UDP），处理端口号和流量控制。
   典型协议：
   TCP（Transmission Control Protocol）：面向连接、可靠、有序、重传确认；
   UDP（User Datagram Protocol）：无连接、不可靠、高效；
   SCTP（Stream Control Transmission Protocol）：结合 TCP 和 UDP 特性，用于电信领域。
5. 会话层（Session Layer）
   功能：
   建立、维护和管理应用程序间的会话（如 RPC 远程过程调用、数据库连接），处理会话同步和检查点（如断点续传）。
   典型协议：
   SSL/TLS（现为表示层功能）：建立安全会话；
   RPC（Remote Procedure Call）：远程过程调用；
   NetBIOS：网络基本输入输出系统。
6. 表示层（Presentation Layer）
   功能：
   处理数据的表示形式（如加密、压缩、格式转换），确保不同系统间的数据兼容性（如 ASCII→Unicode）。
   典型协议：
   SSL/TLS（安全套接层 / 传输层安全）：数据加密；
   ASCII/UTF-8：字符编码；
   JPEG/MP3：数据压缩格式；
   XML/JSON：数据表示格式。
7. 应用层（Application Layer）
   功能：
   为用户应用程序提供接口（如 HTTP、SMTP），直接与用户交互。
   典型协议：
   HTTP/HTTPS：网页传输；
   SMTP/POP3/IMAP：电子邮件；
   FTP/SFTP：文件传输；
   DNS：域名解析；
   DHCP：动态 IP 分配；
   Telnet/SSH：远程登录。

TCP/IP 四层模型

TCP/IP 模型是互联网的实际实现框架，将 OSI 的 7 层简化为 4 层：

1. 网络接口层（Network Interface Layer）
   功能：
   负责物理网络连接，包括物理层和数据链路层的功能（如网卡驱动、MAC 帧封装）。
   对应 OSI 层：物理层 + 数据链路层。
   典型协议：同 OSI 物理层和数据链路层（如 Ethernet、PPP）。
2. 网络层（Internet Layer）
   功能：
   负责跨网络的数据包路由和转发，核心是 IP 协议。
   对应 OSI 层：网络层。
   典型协议：同 OSI 网络层（如 IP、ICMP、IGMP、路由协议）。
3. 传输层（Transport Layer）
   功能：
   提供端到端的通信服务（TCP/UDP），与 OSI 传输层完全对应。
   对应 OSI 层：传输层。
   典型协议：同 OSI 传输层（TCP、UDP、SCTP）。
4. 应用层（Application Layer）
   功能：
   包含 OSI 的会话层、表示层和应用层功能，处理应用程序的网络交互。
   对应 OSI 层：会话层 + 表示层 + 应用层。
   典型协议：同 OSI 应用层（HTTP、SMTP、FTP、DNS 等）。

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

答：

最大堆和最小堆，是两种特殊的完全二叉树，属于堆数据结构的变体。它们在排序、优先队列、调度算法等场景中应用广泛。

最大堆（Max-Heap）
结构特性：
每个节点的值大于或等于其子节点的值，且根节点的值是整棵树中的最大值。

最小堆（Min-Heap）
结构特性：
每个节点的值小于或等于其子节点的值，且根节点的值是整棵树中的最小值。

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

答：

二分搜索树（Binary Search Tree, BST）是一种特殊的二叉树，其设计目的是高效地支持数据的查找、插入和删除操作。

核心定义
二分搜索树是一棵二叉树，满足以下特性：
1.左子树所有节点的值 ≤ 根节点的值
2.右子树所有节点的值 ≥ 根节点的值
3.左右子树也分别是二分搜索树（递归定义）

2.HR面试题

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

答：
第一步：确认信息
“感谢您的坦诚！能否了解一下，这个薪资差异主要是基于岗位预算，还是对我个人能力的评估调整？”
（明确薪资压低的原因，避免直接拒绝或接受）

第二步：分情况回应

若因预算限制：
“我理解公司有预算考量。如果能确保入职后有明确的绩效评估机制和薪资调整周期（例如每 6 个月一次考核），我愿意以这个薪资加入，并通过超额完成任务来证明自己的价值。请问公司对于绩效优秀的员工，通常的调薪幅度是多少？”
（接受 offer 但绑定未来加薪预期，将主动权转向绩效）
若因能力评估：
“我对自己的能力有信心，可能我们对岗位的要求理解存在偏差。能否具体指出哪些方面我需要提升，我可以在试用期重点补足。如果试用期内达到您的预期，是否可以重新评估薪资？”
（将问题转化为能力验证，争取试用期后的调整机会）

第三步：设定底线（可选透露）
“目前我的底线是不低于期望薪资的 15%，因为这涉及到我的生活成本和职业价值定位。但如果公司在培训资源、晋升通道等方面有特别的优势，我可以适当放宽考量。”
（给出弹性空间，避免绝对化拒绝）

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

答：
第一层：认可合理性
“我理解互联网 / 金融等行业存在项目高峰期加班的客观需求，过去在 XX 项目中，我也曾连续一周加班到深夜完成紧急任务。高效的执行力是职场人应有的素养。”
（展现抗压能力，避免直接否定加班）

第二层：提出解决方案
“但长期无节制的加班可能导致效率下降。我会通过优化工作流程（例如用 XX 工具自动化报表）、提前规划优先级、必要时请求团队支援等方式，尽量在正常工作时间内完成高质量交付。”
（强调用方法减少不必要加班，而非抗拒加班）

第三层：设定平衡点
“理想状态是工作时间专注产出，业余时间保持学习和健康（例如每周运动 3 次），这样反而能提升长期效率。公司是否有弹性工作制或加班调休的政策？”
（引导讨论公司实际政策，避免空谈理论）

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

答：
公式：优势类型 + 具体案例 + 岗位需求关联

“我最大的优势是快速学习能力和技术落地执行力。在 XX 公司时，我用 3 周时间自学了从未接触过的 TensorFlow 框架，并独立开发出一个图像识别工具，将团队的质检效率提升了 40%。贵司岗位 JD 中提到需要快速掌握新算法并应用于实际业务，这正是我的强项。例如，如果遇到 XX 场景（结合岗位描述举例），我可以立即投入技术调研并给出 MVP 方案。”
（用数据量化成果，精准匹配岗位技能需求）

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

答：
对个人的价值：
“这份工作能让我在 XX 领域（如 AI 医疗 / 金融科技）深入积累行业经验，尤其是接触到贵司的 XX 技术栈（如分布式系统 / 高并发处理）和 XX 级用户规模的数据，这对我的技术成长有极大吸引力。”
（聚焦具体技术或业务资源，避免空泛说 “学习机会”）

对公司的价值：
“我能立即为团队带来三方面价值：

技术落地能力：通过优化现有算法，预计可提升 XX 指标（如模型准确率 / 系统响应速度）；
项目推动效率：在过往项目中，我主导的 XX 模块提前 2 周交付，节省了 XX 成本；
知识传承：我擅长将复杂技术文档化，曾为团队编写过 XX 万字的技术指南，降低了新人培养成本。”
（用可验证的成果和具体场景说明价值，避免抽象描述）

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, 2, 8, 4]
功能：
遍历列表，对每个元素执行以下操作：
若为最后一个元素，将其值乘以 2；
否则，若当前元素小于下一个元素，将其值加 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]
功能：
遍历列表，对每个元素执行以下操作：
若能被 3 整除，将其除以 3 并加入结果；
若为偶数，将其乘以 2 并加入结果，若该偶数大于 10 则终止循环；
若为奇数，将其加 1 并加入结果。
当遇到12（偶数且大于 10）时，循环提前终止。

（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]
功能：
合并两个有序数组成一个新的有序数组。nums1的前m个元素和nums2的前n个元素为有效数据，其余位置用 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]))

答：
运行结果：3
功能：
遍历列表，对偶数索引位置的元素求和，对奇数索引位置的元素求差。若累计值小于 0，则重置为 0。最终返回累计值。
计算过程：5 -3 +2 -7 +1 = -2，但每次累计值小于 0 时重置为 0，因此最终结果为3（5-3+2-0+1）。

（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]
功能：
将列表中的偶数按升序排列，奇数按降序排列，最终合并为一个新列表。

（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, 4, 8]
功能：
从列表头部弹出元素：

若为奇数，直接加入结果列表；
若为偶数，将其乘以 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]))

答：
运行结果：[(3, 7), (2, 8)]
功能：
找出列表中所有和为 10 的不重复元素对（i < j），每个元素仅参与一次配对。例如，虽然5+5=10，但因索引相同被忽略；3与7配对后，7不再参与后续配对。

（8）编写程序，反素数

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

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

答：

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 reverse_number(n):
    """反转一个数的各位数字"""
    return int(str(n)[::-1])

def is_palindrome(n):
    """判断一个数是否为回文数"""
    return str(n) == str(n)[::-1]

def generate_emirps(count):
    """生成指定数量的反素数"""
    emirps = []
    num = 10  # 从两位数开始
    while len(emirps) < count:
        reversed_num = reverse_number(num)
        if (is_prime(num) and 
            is_prime(reversed_num) and 
            not is_palindrome(num)):
            emirps.append(num)
        num += 1
    return emirps

# 生成前100个反素数
emirps = generate_emirps(100)

# 格式化输出，每行10个
for i in range(0, len(emirps), 10):
    print(' '.join(f"{num:<5d}" for num in emirps[i:i+10]))

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

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

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

答：

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

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

# 计算并输出p≤31的所有梅森素数
max_p = 31
mersenne_primes = generate_mersenne_primes(max_p)

print("p≤31的所有梅森素数：")
for p, prime in mersenne_primes:
    print(f"当 p = {p} 时，2^{p} - 1 = {prime}")

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

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

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

并输出测试结果：

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

答：

def calculate_sequence_sum(i):
    """计算数列m(i) = 1/2 + 2/3 + ... + i/(i+1)的和"""
    total = 0.0
    for n in range(1, i + 1):
        total += n / (n + 1)
    return total

# 输出表头
print("i\t\tm(i)")

# 输出i从1到20的结果
for i in range(1, 21):
    result = calculate_sequence_sum(i)
    # 格式化输出，保留三位小数
    print(f"{i}\t\t{result:.3f}")

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

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

答：

def generate_combinations():
    """生成由1、2、3、4组成的无重复数字的三位数"""
    combinations = []
    for hundreds in range(1, 5):
        for tens in range(1, 5):
            if tens == hundreds:
                continue  # 跳过重复数字
            for ones in range(1, 5):
                if ones == hundreds or ones == tens:
                    continue  # 跳过重复数字
                combinations.append(hundreds * 100 + tens * 10 + ones)
    return combinations

# 生成所有符合条件的三位数
combinations = generate_combinations()

# 输出结果
print(f"能组成{len(combinations)}个互不相同且无重复数字的三位数：")
print(" ".join(map(str, combinations)))

（12）编写程序，计算e

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

答：

def calculate_e(precision=100):
    """计算自然常数e的近似值，precision指定计算的项数"""
    e = 1.0
    factorial = 1
    
    for i in range(1, precision + 1):
        factorial *= i  # 计算i的阶乘
        e += 1 / factorial  # 累加级数的每一项
    
    return e

# 计算e的近似值（默认计算100项）
e_approx = calculate_e()

# 输出结果，保留15位小数
print(f"e的近似值: {e_approx:.15f}")

（13）编写程序，完全数

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

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

输入输出描述

输入一个正整数

输出该数是否为完全数

示例1

输入：

6

输出：

Yes

示例2

输入：

9

输出：

No

答：

def is_perfect_number(n):
    """判断一个数是否为完全数"""
    if n < 1:
        return False  # 完全数定义为正整数
    
    divisor_sum = 0
    # 优化：只需检查到sqrt(n)
    for i in range(1, int(n ** 0.5) + 1):
        if n % i == 0:
            divisor_sum += i
            # 避免重复添加平方根对应的因子
            if i != 1 and i != n // i:
                divisor_sum += n // i
    
    return divisor_sum == n

# 读取输入
n = int(input())

# 判断并输出结果
print("Yes" if is_perfect_number(n) else "No")