【无标题】

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+11!+12!+13!+14!+...+1i! e=1+\frac{1}{1!}+\frac{1}{2!}+\frac{1}{3!}+\frac{1}{4!}+...+\frac{1}{i!} e=1+1!1+2!1+3!1+4!1+...+i!1
当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
 
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值