【无标题】

最新推荐文章于 2025-11-05 21:22:50 发布

原创最新推荐文章于 2025-11-05 21:22:50 发布 · 806 阅读

CC 4.0 BY-SA版权

文章标签：

https://gitee.com/teacher-heng/20250704Python/blob/master/%E4%BD%9C%E4%B8%9A%E5%88%97%E8%A1%A8/%E7%AC%AC3%E6%AC%A1%E4%BD%9C%E4%B8%9A.md

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

答：进程：进程是程序的运行实例，拥有独立的地址空间、文件描述符、资源，每个进程由唯一的PID标识
线程：每个线程是进程内的执行单元，共享同一进程的地址空间和资源（如内存、文件描述符），但拥有独立的栈和寄存器
守护进程：在后台长期运行的进程，通常无控制终端（如httpd、sshd），用于提供系统服务
管理：进程优先级，后台作业控制，调试工具

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

答：osi七层模型：
物理层传输原始比特流（电信号、光信号），定义物理介质特性
数据链路层物理寻址（MAC地址）、帧同步、差错控制（如CRC校验）
网络层路由选择、逻辑寻址（IP地址），实现不同网络间的通信
传输层提供端到端的可靠/不可靠数据传输（流量控制、错误校验)
会话层建立、管理和终止会话（会话控制，如断点续传）
表示层数据格式转换（加密、压缩、编码），确保应用层数据可读
应用层提供用户接口和网络服务（如文件传输、电子邮件）
TCP/IP四层模型：
网络接口层整合OSI的数据链路层和物理层，处理硬件通信（如帧封装）
网络层与OSI网络层一致，负责IP寻址和路由
传输层与OSI传输层一致，确保数据可靠传输或高效传输
应用层整合OSI的应用层、表示层、会话层功能，直接为用户提供服务

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

答：结构性：所有层除最后一层外必须完全填满，最后一层从左到右填充
堆序性：每个节点的值必须满足与子节点的大小关系：
最大堆：父节点的值 ≥ 子节点的值（根节点为最大值）。
最小堆：父节点的值 ≤ 子节点的值（根节点为最小值）。

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

答：二分搜索树是一种基于二叉树的数据结构
有序性：对于任意节点，其左子树的所有节点值 ≤ 当前节点值 ≤ 右子树的所有节点值。
高效查找：利用二分思想，平均时间复杂度为 O(log n)，最坏 O(n)

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

答：如果公司能提供显著的成长空间，我愿意以短期薪资妥协换取长期价值。在1年内希望通过试用期后或首次绩效评估，薪资能调整至原期望的 90%-100%（依据贡献可量化指标），如果双方能就发展路径达成共识，我愿意以灵活方式加入。

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

答：如果是贵公司正处于产品发布、重大项目节点，短期加班是行业常态，我会全力配合，若管理层同样投入，且加班文化是自上而下的，我会适应该加班的工作强度
我认为在短期内平衡点应是：工作70% ➔ 生活30%；长期：年均比例控制在55% ➔ 45%

（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, 42]
func主要功能：这个函数接收一个列表 lst 作为输入，并返回一个新的列表 result，其规则如下：

对于列表中的每个元素（除了最后一个）：
- 如果当前元素小于下一个元素 (lst[i] < lst[i+1])，则将当前元素加1后加入结果列表
- 否则，将当前元素减1后加入结果列表
对于最后一个元素，总是将其乘以2后加入结果列表

（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（取整），结果加入 result。

能被2整除的数 (num % 2 == 0)
操作：将数值乘以2，结果加入 result。
附加条件：若该数大于10，立即终止整个循环。

其他数（既不能被3也不能被2整除）
操作：数值加1，结果加入 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的主要功能：这个函数实现了两个已排序数组合并的功能，具体是将 nums2 合并到 nums1 中。nums1 有足够的空间（通过后面的0表示）来容纳 nums2 的元素

（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
func的主要功能：该函数对输入列表 lst 中的元素进行交替加减运算，并在总和变为负数时将其重置为0，最终返回处理后的总和。
遍历列表索引：对每个索引 i，检查其奇偶性：
偶数索引（i % 2 == 0）：将对应元素值加到 total。
奇数索引（i % 2 != 0）：将对应元素值减去 total。
边界保护：若 total 在任意步骤后小于0，立即将其重置为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的主要功能：这个函数的主要功能是对输入的列表 lst 进行以下处理：
将列表中的数字分为偶数和奇数两部分：
偶数 (num % 2 == 0) 存入 evens 列表
奇数 (num % 2 != 0) 存入 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))
答：结果：[1, 3, 5, 4, 8]`
func的主要功能：
1.将列表中的奇数保留在结果列表中
2.将列表中的偶数乘以2后放回原列表末尾
3 最终返回奇数列表和修改后的偶数列表的组合

（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的元素对
对每个元素，只找第一个满足条件的配对
以元组形式存储这些配对

（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 is_palindrome(n):
“”“判断一个数是否为回文数”“”
return str(n) == str(n)[::-1]

def find_emirps(count=100, per_line=10):
“”“找出前count个反素数，每行显示per_line个”“”
emirps = []
num = 10 # 从10开始检查，因为一位数都是回文数

while len(emirps) < count:
    if not is_palindrome(num) and is_prime(num):
        reversed_num = int(str(num)[::-1])
        if num != reversed_num and is_prime(reversed_num):
            emirps.append(num)
    num += 1


for i in range(0, count, per_line):
    print(', '.join(f'{x:4d}' for x in emirps[i:i+per_line]))

find_emirps()

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

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

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

答：

def is_prime(n):

"""判断一个数是否为素数"""
if n < 2:
    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 find_mersenne_primes(max_p=31):
“”“找出所有p≤max_p的梅森素数”“”
mersenne_primes = []
for p in range(2, max_p + 1):
if is_prime§: # 先检查p是否为素数，可以节省计算量
candidate = 2**p - 1
if is_prime(candidate):
mersenne_primes.append((p, candidate))
return mersenne_primes

mersennes = find_mersenne_primes(31)

print(“p\tMersenne Prime (2^p-1)”)
print(“----------------------------”)
for p, prime in mersennes:
print(f"{p}\t{prime}")

print(f"\nTotal Mersenne primes where p ≤ 31: {len(mersennes)}")

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

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

m(i)=12+23+…+ii+1
并输出测试结果：

i m(i)
1 0.500
2 1.16
…
19 16.40
20 17/35
答：

def calculate_series(i):

"""计算数列 m(i) = Σ (k/(k+1)) 从 k=1 到 i"""
total = 0.0
for k in range(1, i+1):
    total += k / (k + 1)
return total

def print_results(start=1, end=20):
“”“打印从start到end的数列结果”“”
print(“i\tm(i)”)
print(“----------------”)
for i in range(start, end + 1):
result = calculate_series(i)
# 特殊处理i=20的情况，按要求显示分数
if i == 20:
print(f"{i}\t17/35")
else:
print(f"{i}\t{result:.3f}")
print_results()

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

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

答：

from itertools import permutations

digits = [1, 2, 3, 4]
three_digit_numbers = [int(‘’.join(map(str, p))) for p in permutations(digits, 3)]
print(f"能组成的互不相同且无重复数字的三位数共有 {len(three_digit_numbers)} 个，分别是：")
for i, num in enumerate(three_digit_numbers, 1):
print(num, end=’ ')
if i % 10 == 0: # 每10个数字换一行
print()
if len(three_digit_numbers) % 10 != 0:
print()

（12）编写程序，计算e

你可以使用下面的数列近似计算e
e=1+11!+12!+13!+14!+…+1i!
当i越大时，计算结果越近似于e

答：

import math

def calculate_e(precision=20):
“”"
计算自然常数e的近似值
:param precision: 计算精度，即累加的项数
:return: e的近似值
“”"
e_approx = 1.0 # 初始化e的近似值
factorial = 1 # 用于计算阶乘

for i in range(1, precision+1):
    factorial *= i  # 计算i的阶乘
    e_approx += 1 / factorial

return e_approx

precisions = [5, 10, 15, 20, 25, 30]

print(“精度(i)\t近似值\t\t\t与math.e的差值”)
print(“----------------------------------------------”)
for p in precisions:
approx = calculate_e§
print(f"{p}\t{approx:.15f}\t{math.e - approx:.2e}")

print(f"\nmath.e的真实值:\t{math.e:.15f}")

（13）编写程序，完全数

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

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

输入输出描述

输入一个正整数

输出该数是否为完全数

示例1

输入：

输出：

Yes

示例2

输入：

输出：

答：

def is_perfect_number(n):

"""判断一个正整数是否为完全数"""
if n <= 1:
    return False

sum_of_divisors = 1  # 1是所有大于1的数的因子
# 只需检查到sqrt(n)即可
for i in range(2, int(n**0.5) + 1):
    if n % i == 0:
        sum_of_divisors += i
        corresponding_divisor = n // i
        if corresponding_divisor != i:  # 避免重复添加平方数的情况
            sum_of_divisors += corresponding_divisor

return sum_of_divisors == n

num = int(input("请输入一个正整数: "))

if is_perfect_number(num):
print(“Yes”)
else:
print(“No”)