亚马逊面试经历 |第 132 组(适用于 SDE 实习生)

最近有幸参加了亚马逊的实习生面试，分享一下面试经历和面试题目，希望对正在准备亚马逊面试的程序员们有所帮助。

面试流程

面试流程分为三轮：

第一轮(在线编程)

• 在线编程，时间限制 75 分钟。
• 数据结构、算法题目。

第二轮(技术面)

• 二面技术面试，约 45 分钟 - 1 个小时。
• 面试题目包括数据结构、算法和操作系统。

第三轮(面试官面)

• 三面面试，约 45 分钟 - 1 个小时。
• 面试官面试，题目包括机器学习、系统设计、产品设计等。

面试题目

这里列出了几个我遇到的面试题目，可能并不是全部，仅供参考。

在线编程第一轮

1. 判断给出的链表是否为回文

只需要遍历一次链表，时间复杂度 O(n)。

class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None

def is_palindrome(head: ListNode) -> bool:
    if not head or not head.next:
        return True
    slow = fast = head
    stack = []
    while fast and fast.next:
        stack.append(slow.val)
        slow = slow.next
        fast = fast.next.next
    if fast:
        slow = slow.next
    while slow:
        if stack.pop() != slow.val:
            return False
        slow = slow.next
    return True

2. 计算在无向图中一条路径的平均批发成本

使用 Floyd 算法求最短路径，时间复杂度 O(n^3)。

# 计算所有节点间的最短距离
def floyd(graph):
    for k in range(len(graph)):
        for i in range(len(graph)):
            for j in range(len(graph)):
                graph[i][j] = min(graph[i][j], graph[i][k] + graph[k][j])

# 计算一条路径的平均批发成本
def calc_cost(graph, path):
    total = 0
    cnt = len(path) - 1
    for i in range(cnt):
        total += graph[path[i]][path[i+1]]
    return float(total) / cnt

技术面第二轮

1. 在一个长度为 n 的数组中查找缺失的数字

可以用异或 XOR 操作快速解决，时间复杂度 O(n)。

def find_missing_number(nums):
    n = len(nums)
    val = 0
    for i in range(n):
        val ^= nums[i] ^ (i + 1)
    return val

2. 实现一个 LRU 缓存

使用哈希表和双向链表实现，时间复杂度 O(1)。

class LRUNode:
    def __init__(self, key=None, val=None):
        self.key = key
        self.val = val
        self.prev = None
        self.next = None

class LRUCache:
    def __init__(self, capacity: int):
        self.capacity = capacity
        self.cache = {}
        self.head = LRUNode()
        self.tail = LRUNode()
        self.head.next = self.tail
        self.tail.prev = self.head

    def get(self, key: int) -> int:
        if key not in self.cache:
            return -1
        node = self.cache[key]
        self.remove(node)
        self.add(node)
        return node.val

    def put(self, key: int, value: int) -> None:
        if key in self.cache:
            node = self.cache[key]
            node.val = value
            self.remove(node)
            self.add(node)
        else:
            node = LRUNode(key, value)
            self.cache[key] = node
            self.add(node)
            if len(self.cache) > self.capacity:
                node = self.tail.prev
                self.remove(node)
                del self.cache[node.key]

    # 把节点添加到头部
    def add(self, node):
        head_next = self.head.next
        self.head.next = node
        node.prev = self.head
        node.next = head_next
        head_next.prev = node

    # 把节点从链表中删除
    def remove(self, node):
        node.prev.next = node.next
        node.next.prev = node.prev

面试官面第三轮

1. 怎么保证账号密码的安全

推荐使用哈希函数和盐值，可以增加密码破解的难度。同时可以限制密码长度和尝试次数，并及时监测抵御攻击。

2. 如何处理突发流量

可以使用权重负载均衡、消息队列等技术，可以抗压并提高系统的吞吐量。还可以调整资源配置和进行系统优化。

总结

亚马逊实习生面试主要考察数据结构、算法和编程能力。需要充分准备。

希望以上面试经历和面试题目对大家有所帮助。