Python作业5

1.技术面试题

（1）解释 Linux 中的符号链接和硬链接

符号链接（软链接）是文件系统中的特殊文件，存储的是指向目标文件或目录的路径。其 inode 与目标文件不同，仅作为指针存在。删除源文件后，链接文件仍存在但失效（显示 “broken link”）。软链接优势在于可跨文件系统、指向目录，常用于系统配置（如/usr/bin/python指向实际解释器）。硬链接通过 inode 实现，多个文件名指向同一物理数据块。所有硬链接共享文件属性（如权限、时间戳），删除任一链接仅减少引用计数，直至为 0 才释放磁盘空间。硬链接无法跨越文件系统（因 inode 编号局部唯一），也不能指向目录（避免循环引用）。常用于系统文件备份（如/bin/ls与/usr/bin/ls可能为同一文件的硬链接）。

（2）Linux 使用的进程间通信方式有哪些？

管道（Pipe）：半双工，数据单向流动。匿名管道（|）用于父子进程，通过pipe()系统调用创建，返回读写文件描述符。
命名管道（FIFO）通过mkfifo创建，存储为文件系统节点，支持无关进程通信。
消息队列：内核维护的消息链表，按类型存储读取。优点是异步通信、无需进程同步，缺点是容量受限（取决于系统配置）。
共享内存：映射同一块物理内存到多个进程地址空间，通过shmget和shmat实现。速度最快（无需复制数据），但需信号量或互斥锁控制并发访问。
信号量：计数器控制多进程对共享资源的访问。P 操作（减少计数）获取资源，V 操作（增加计数）释放资源，用于实现生产者 - 消费者模型。
套接字（Socket）：支持跨主机通信，分为流式（TCP）和数据报（UDP）。客户端通过connect()连接服务器，服务器通过listen()和accept()响应。
信号：异步通知机制，如SIGINT（Ctrl+C）、SIGKILL（强制终止）。通过kill命令或raise()函数发送，进程通过信号处理函数捕获。

（3）什么是TCP 三次握手与四次挥手？

三次握手（建立连接）：
1.客户端向服务器发送 SYN 包（seq=x），进入 SYN_SENT 状态，请求建立连接。
2. 服务器收到 SYN 后，发送 SYN+ACK 包（seq=y, ack=x+1），进入 SYN_RECV 状态。
3. 客户端收到 SYN+ACK 后，发送 ACK 包（seq=x+1, ack=y+1），进入 ESTABLISHED 状态；服务器收到 ACK 后也进入该状态。

四次挥手（关闭连接）：
1.客户端发送 FIN 包（seq=u），请求关闭发送通道，进入 FIN_WAIT_1 状态。
5. 服务器收到 FIN 后，发送 ACK 包（seq=v, ack=u+1），进入 CLOSE_WAIT 状态。此时客户端无法发送数据，但可接收。
6. 服务器发送 FIN 包（seq=w, ack=u+1），请求关闭接收通道，进入 LAST_ACK 状态。
7. 客户端收到 FIN 后，发送 ACK 包（seq=u+1, ack=w+1），进入 TIME_WAIT 状态（持续 2MSL 确保 ACK 到达）；服务器收到 ACK 后关闭连接。

（4）ARP 协议的作用及工作原理

ARP（地址解析协议）工作在数据链路层，用于将 IP 地址解析为物理 MAC 地址。
工作流程：
1.主机 A 需向主机 B（IP 地址已知）发送数据，先检查本地 ARP 缓存（arp -a查看）。
2. 若缓存无 B 的 MAC 地址，A 广播 ARP 请求包（包含自身 MAC 和 IP，以及目标 IP）。
3. 网络中所有设备接收请求，目标 IP 主机 B 识别后，单播 ARP 响应包（包含自身 MAC）。
4. 主机 A 更新 ARP 缓存（默认 TTL 20 分钟），并发送数据帧。
ARP 欺骗：攻击者伪造 ARP 响应包，将自己的 MAC 绑定到合法 IP，导致流量劫持。防御措施包括静态 ARP 绑定和 ARP 监控工具（如arpwatch）。

（5）详细阐述快速排序算法

分治算法，平均时间复杂度 O(nlogn)。核心步骤：选择基准元素（如首尾或随机值），通过分区操作将数组分为两部分，左侧元素≤基准，右侧≥基准，递归排序子数组。原地排序，空间 O (logn)，但最坏情况（如已排序数组）退化为 O (n²)。优化策略包括随机化基准、三数取中法、小数组用插入排序。适用于大规模数据，是标准库排序函数（如 C++ std::sort）的基础。

（6）详细阐述归并排序算法

分治策略，时间复杂度稳定 O(nlogn)。递归分解数组至单元素，合并有序子数组。合并时比较元素，按序放入临时空间（空间 O (n)）。迭代实现适合链表排序，避免递归栈。优化包括原地归并（空间 O (1)）、小数组用插入排序。稳定排序，常用于外部排序（处理大数据文件）和 Java 的Arrays.sort()对对象排序。

（7）详细阐述基数排序算法

非比较排序，时间复杂度 O(d(n+k))（d 为位数，k 为基数）。按低位到高位依次分桶（如十进制按个位、十位），每轮收集后形成新序列。LSD 适合整数，MSD 适合字符串（递归处理子桶）。基数选 2^8 可优化二进制数据，需额外空间存储桶。常用于排序 IP 地址、扑克牌，不依赖元素比较，速度快但适用范围有限。

（8）详细阐述桶排序算法

分治思想，时间复杂度 O(n+k)（理想均匀分布）。将元素映射到有序桶，桶内用插入排序（适合小规模数据），合并结果。关键在桶数量与映射函数设计，若分布不均可能退化为 O (n²)。适用于分数、年龄等均匀分布数据，外部排序（大数据分块）和并行计算（各桶可并行排序）。与基数排序相比，桶排序按值域分桶，基数排序按位值分桶。

2.HR面试题

（1）你为什么选择我们公司？

选择贵公司，首先是认同公司的工作理念，其和我 “做事踏实、注重协作” 的原则一致；其次了解到团队氛围开放，新人能参与核心项目讨论，这种成长环境正是我看重的；而且贵公司在行业内的长期发展规划清晰，能给我稳定的成长平台，和我的长期职业期待完全契合。

（2）你现在手里有offer吗？

目前有两家公司在沟通，但我一直以贵公司为目标调整准备方向。比如研究了贵公司近期的公开项目目，发现团队注重 “快速响应、灵活协作”，这和我在社团中 “协调多部门落地活动” 的经验适配；而且我更认可贵公司“共同向上”的氛围，所以真心希望能加入。

（3）你认为一份 “好工作” 的核心要素是什么？如果工作内容与预期不符，你会如何调整？

好工作的核心是 “能获得正向反馈”—— 包括同事的认可、解决问题后的成就感，以及在团队中被需要的价值感。如果工作内容不符，我会先观察同事的工作方法，主动请教岗位核心目标，比如先从 “协助整理基础资料” 这类小事做好，在过程中积累信任，再逐步找到自己的适配节奏。

（4）如果领导对你的工作成果提出尖锐批评，你会如何回应？

我会先点头示意 “您说的我都记下来了”，等领导说完后说：“谢谢您愿意花时间指出问题，这能帮我少走很多弯路”。之后不会急于辩解，而是先对照批评点列清单，比如 “流程遗漏了哪些环节”，然后找有经验的前辈请教改进思路，调整后先做小范围验证，再向领导同步进度。

（5）我看你简历里写了学习能力强，你怎么证明你的学习能力强呢？

我的学习能力体现在适应新环境和总结经验上：比如参加跨校交流活动时，3 天就熟悉了全新活动规则，还帮同去的同学快速融入；另外，组织班级活动时，第一次效果一般，我总结了 “提前收集同学意见” 的方法，第二次参与度提升了 60%。

（6）如果你的室友在考试中，偷偷让你帮忙传递一个写着知识点的小纸条（现场监管不严，被发现概率低），你会帮吗？请说具体理由，不要只讲大道理。

我不会帮。之前有个朋友帮同学传纸条，虽然没被发现，但后来那位同学总找他帮忙，甚至期末复习都不认真，最后挂了科；而且如果我帮了，以后面对更重要的考试，可能会忍不住再突破底线，这种 “侥幸心理” 一旦形成，很容易出问题。

（7）你说很想进入我们公司，但你的专业和我们公司关联度不高，而且你也没有相关的实习经历。你觉得我们为什么要相信你是真心想做这个行业，而不是把这里当跳板？

我从大二就确定要做这个行业，每周都会看行业相关的访谈节目，还加入了行业爱好者社群，和大家交流行业动态；课余时间我还和同学模拟行业相关的团队协作，比如扮演不同岗位角色完成任务；我计划长期在这个行业发展，不会把这里当跳板。

（8）你的成绩在班级里处于中等水平，而我们这个岗位竞争激烈，很多应聘者成绩都很优秀。你觉得自己比他们强在哪里，值得我们录用你？

虽然成绩中等，但我有很强的执行力和团队融入能力：比如社团组织大型讲座时，我负责联系嘉宾和场地，从无到有推进，提前 2 天完成所有准备工作；而且我能快速和新团队熟悉，之前参加夏令营，1 天就和同组同学配合完成了任务，这些能力能让我快速适应岗位。

3.问答题

（1）执行以下代码，输出结果是什么？

def process_list(lst):
    for i in range(len(lst)):
        if lst[i] % 2 == 0:
            lst.insert(i+1, lst[i] // 2)
    return lst

nums = [2, 3, 8]
print(process_list(nums))

输出：[2, 1, 3, 8, 4]
循环中动态插入元素导致索引错位，偶数后插入其半值。

（2）运行下列代码，输出结果是什么？

def modify_tuple(t):
    try:
        t[1] += 10
    except:
        t = (t[0], t[1]+10, t[2])
    return t

tup = (1, 5, 3)
new_tup = modify_tuple(tup)
print(tup[1] + new_tup[1])

输出：20
元组不可变，原tup不变，新元组new_tup为(1, 15, 3)，故5 + 15 = 20。

（3）以下代码的输出结果是什么？

def set_operations():
    a = {1, 2, 3}
    b = a.copy()
    a.add(4)
    b.discard(2)
    c = a - b
    b.update(c)
    return len(a & b)

print(set_operations())

输出：2
集合运算后，a = {1, 2, 3, 4}，b = {1, 3, 4}，交集长度为 2。

（4）执行下列代码后，输出结果是什么？

def string_transform(s):
    result = []
    for i, char in enumerate(s):
        if i % 2 == 0:
            result.append(char.upper())
        else:
            result.append(char.lower())
    return ''.join(result[::-1])

print(string_transform("PyThOn"))

输出：nOtHyP
字符串索引奇偶交替大小写，逆序后得到结果。

（5）运行以下代码，输出结果是什么？

def dict_processing():
    d = {'a': 1, 'b': 2, 'c': 3}
    new_d = {}
    for k, v in d.items():
        new_d[v] = k
        if v % 2 == 0:
            new_d[k.upper()] = v * 2
    return sum(new_d.keys())

print(dict_processing())

输出：19
字典键值反转并添加新键值对，最终键的和为1 + 2 + 3 + ‘B’ + 4 = 19。

（6）以下代码的输出结果是什么？

def nested_list_operation():
    matrix = [[1, 2], [3, 4], [5, 6]]
    total = 0
    for i in range(len(matrix)):
        matrix[i].append(matrix[i-1][0])
        total += sum(matrix[i])
    return total

print(nested_list_operation())

输出：39
嵌套列表操作中，每个子列表追加前一行首元素，总和为 39。 7.

（7）执行下列代码会产生什么结果？

def tuple_unpacking():
    tup = (10, 20, 30, 40)
    a, *b, c = tup
    b.append(c // a)
    return tuple(b)

print(tuple_unpacking()[1] * 2)

输出：60
转换为元组并返回：return tuple(b) 元组 (20, 30, 4)。元组的第二个元素是 30，乘以 2 后得到 60。

（8）运行以下代码，输出结果是什么？

def set_generator():
    s = set()
    for i in range(5):
        if i % 2 == 0:
            s.add(i)
        else:
            s.update(range(i))
    return sorted(s)[-2]

print(set_generator())

输出：3
集合生成后为{0, 1, 2, 3}，排序后倒数第二个元素为 3。

（9）以下代码的输出结果是什么？

def string_manipulation():
    s = "Hello World Python"
    words = s.split()
    result = []
    for word in reversed(words):
        result.append(word[1:-1] if len(word) > 2 else word)
    return ' '.join(result)

print(string_manipulation())

输出：ell orl yth
反转单词顺序并截取中间字符（长度 > 2 时）。

（10）执行下列代码后，输出结果是什么？

def dict_traversal():
    d = {'x': 5, 'y': 10, 'z': 15}
    keys = list(d.keys())
    for key in keys:
        if d[key] > 8:
            d[key.upper()] = d.pop(key)
    return len(d) + sum(d.values())

print(dict_traversal())

输出： 33
遍历字典时将值大于 8 的键（‘y’ 和 ‘z’）转为大写（‘Y’ 和 ‘Z’），字典最终包含 {‘x’:5, ‘Y’:10, ‘Z’:15}，长度 3 加值总和 30 等于 33。