meta买它vo面经 | phone 面经 - 面试辅助面试代面 OA,VO辅助代做 Hackerrank|Codesignal代做

在这篇文章中，我将详细分享我在 META 面试中的经历和感受。这次面试经历包括了多轮技术面试，涵盖了数据结构与算法、系统设计、机器学习等多个方面的考察。META 对候选人有着严格的要求，不仅需要扎实的编程基础，还要求具备深厚的设计思维和解决问题的能力。在面对这些高难度的面试题时，如何快速思考、正确应对，显得尤为重要。希望通过我的面经分享，能够帮助正在准备 META 或其他科技公司面试的朋友们更好地了解面试流程和考察重点。

如果你正在为技术面试感到困扰，欢迎使用我们的面试代面服务。我们提供全面的面试辅导、OA代做、代码代写等服务，由经验丰富的行业专家团队为你量身定制面试方案，帮助你轻松应对大厂面试，成功拿下心仪的 offer！想要了解更多，欢迎添加微信 leetcode-king。

微信二维码

面试题目整理

1. 寻找最接近目标值的数对

知识点：数组, 双指针, 排序数组
问题描述：给定一个递增排序的整数数组 int[] sortedArray 和一个目标值 int target，需要找到数组中两个数的和最接近目标值的数对。
示例：
- 输入：sortedArray = [1, 2, 4, 5, 6, 8, 10], target = 10
- 输出：(4, 5)

def findClosestPair(sortedArray, target):
    left, right = 0, len(sortedArray) - 1
    closestPair = None
    closestDiff = float('inf')

    while left < right:
        currSum = sortedArray[left] + sortedArray[right]
        currDiff = abs(currSum - target)

        if currDiff < closestDiff:
            closestDiff = currDiff
            closestPair = (sortedArray[left], sortedArray[right])

        if currSum < target:
            left += 1
        elif currSum > target:
            right -= 1
        else:
            return closestPair  # Found exact match

    return closestPair

2. 二叉树的后序遍历迭代器

知识点：二叉树, 栈, 迭代器
问题描述：设计一个后序遍历的二叉树迭代器，支持以下操作：
- next(): 返回二叉树的下一个节点的值，按照后序遍历的顺序。
- hasNext(): 如果二叉树中还有节点没有遍历完，返回 true，否则返回 false。

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

class PostorderIterator:
    def __init__(self, root):
        self.stack = []
        self.prev = None
        self.push_left_subtree(root)
    def push_left_subtree(self, node):
        while node:
            self.stack.append(node)
            node = node.left

    def hasNext(self):
        return len(self.stack) > 0

    def next(self):
        while self.hasNext():
            curr = self.stack[-1]
            if curr.right and self.prev != curr.right:
                self.push_left_subtree(curr.right)
            else:
                self.prev = self.stack.pop()
                return self.prev.val
        raise StopIteration()

3. 文件路径简化

知识点：字符串处理, 栈, 路径简化
问题描述：给定一个包含文件路径的字符串，该路径可能包括 .（当前目录）和 ..（上一级目录），请编写一个函数，简化这个路径并返回简化后的绝对路径。
示例：
- 输入："/a/b/c/./../"
- 输出："/a/b"

def simplifyPath(path):
    stack = []
    for part in path.split('/'):
        if part == '..':
            if stack:
                stack.pop()
        elif part and part != '.':
            stack.append(part)
    return '/' + '/'.join(stack)

4. 子数组和是否等于目标值

知识点：数组, 前缀和, 哈希表
问题描述：给定一个整数数组 int[] nums 和一个目标值 int target，判断数组中是否存在一个连续的子数组，其元素和等于目标值。
示例：
- 输入：nums = [1, 2, 3, 4, 5], target = 9
- 输出：true（因为子数组 [2, 3, 4] 的和为 9）

def hasSubarraySum(nums, target):
    prefixSum = 0
    seen = {0: -1}  # Store prefix sums and their indices

    for i, num in enumerate(nums):
        prefixSum += num
        if prefixSum - target in seen:
            return True  # Found a subarray with the target sum
        seen[prefixSum] = i

    return False

5. 括号删除使其有效

知识点：栈, 字符串处理, 有效括号
问题描述：给定一个只包含括号的字符串，设计一个算法，最少删除字符使得剩余的字符串成为一个有效的括号组合。
示例：
- 输入："))()()()(( "
- 输出："()()()"

def minRemoveToMakeValid(s):
    stack = []
    to_remove = set()

    for i, char in enumerate(s):
        if char == '(':
            stack.append(i)
        elif char == ')':
            if stack:
                stack.pop()
            else:
                to_remove.add(i)

    to_remove = to_remove.union(set(stack))  # Add unmatched '(' indices
    return ''.join(char for i, char in enumerate(s) if i not in to_remove)

6. 对比两个链表中的字符串

知识点：链表, 字符串比较, 双指针
问题描述：给定两个链表，每个链表的节点存储一个字符串。要求比较这两个链表中的所有字符串，判断它们是否相同，且要求不使用额外的空间。
示例：
- 输入：
  - a = ['he'] -> ['ll'] -> ['o'] -> null
  - b = ['hell'] -> ['o'] -> null
- 输出：true
- 输入：
  - a = ['hel'] -> ['ll'] -> ['o'] -> [''] -> [''] -> null
  - b = ['hell'] -> ['o'] ->

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

def compareLinkedListStrings(a, b):
    a_curr, b_curr = a, b
    a_index, b_index = 0, 0

    while a_curr or b_curr:
        if a_index == len(a_curr.val):
            a_curr = a_curr.next
            a_index = 0
        if b_index == len(b_curr.val):
            b_curr = b_curr.next
            b_index = 0

        if not a_curr or not b_curr or a_curr.val[a_index] != b_curr.val[b_index]:
            return False

        a_index += 1
        b_index += 1

    return True

7. 在整数数组中找到可以将数组一分为二的位置

知识点：数组, 前缀和, 平衡点
问题描述：给定一个整数数组 int[] nums，需要找到一个索引 i，使得数组 nums 在这个索引处被分成两个子数组，且这两个子数组的元素和相等。
示例：
- 输入：nums = [1, 7, 3, 6, 5, 6]
- 输出：3 （因为在索引 3 处，左侧子数组 [1, 7, 3] 和右侧子数组 [5, 6] 的和都为 11）

def findPivotIndex(nums):
    total_sum = sum(nums)
    left_sum = 0

    for i, num in enumerate(nums):
        if left_sum == total_sum - left_sum - num:
            return i
        left_sum += num

    return n -1  # No such pivot index exists

8. 能够看到海的房屋

知识点：数组, 单调栈
问题描述：给定一个整数数组，数组中的每个元素代表房屋的高度，假设最右边是海，要求返回能够看到海的房屋的索引。
示例：
- 输入：heights = [4, 2, 3, 1]
- 输出：[0, 2, 3] （因为只有这些位置的房屋可以看到海）

def canSeeOcean(heights):
    stack = []
    result = []

    for i, height in enumerate(heights):
        while stack and heights[stack[-1]] <= height:
            stack.pop()
        stack.append(i)

    return stack

9. 处理 cd 命令后的最终路径

知识点：字符串处理, 栈
问题描述：给定当前的文件路径（pwd），再给定多个 cd 命令（如 "cd /foo"、"cd ../dir1/./dir2" 等），返回经过这些 cd 命令后的最终路径。
示例：
- 输入：pwd = "/home/user", commands = ["cd /foo", "cd ../dir1/./dir2"]
- 输出："/dir1/dir2"

def processCdCommands(pwd, commands):
    stack = pwd.split('/')
    if stack[0] == '':
        stack.pop(0)  # Remove leading empty string if present

    for command in commands:
        parts = command.split(' ')[1].split('/')
        for part in parts:
            if part == '..':
                if stack:
                    stack.pop()
            elif part and part != '.':
                stack.append(part)

    return '/' + '/'.join(stack)

10. 找到数组中缺失的数字

知识点：数组, 哈希表, 缺失数字
问题描述：给定一个数组，其中的元素为 0 到 100 之间的整数（可能包含重复），需要返回一个包含所有在 0 到 100 范围内但不在输入数组中的数字的数组。
示例：
- 输入：[0, 1, 2, 50, 75, 100]
- 输出：[3, 4, 5, ..., 49, 51, ..., 74, 76, ..., 99]

def find_missing_numbers(arr):
    # Create a set for the range 0 to 100
    full_set = set(range(101))
    # Convert the input array to a set
    arr_set = set(arr)  
    # Find the difference between the full set and the array set
    missing_numbers = sorted(list(full_set - arr_set))
    return missing_numbers
# Example usage
input_array = [0, 1, 2, 50, 75, 100]
output = find_missing_numbers(input_array)
print(output)  # Output: [3, 4, 5, ..., 49, 51, ..., 74, 76, ..., 99]

11. 二叉树的左视图和右视图

知识点：树, 深度优先搜索, 广度优先搜索
问题描述：给定一个二叉树，要求输出从左侧和右侧可以看到的节点。左视图指的是从树的左边观察时可以看到的节点，右视图则是从树的右边观察时可以看到的节点。
示例：
- 输入：
```
    1
   / \
  2   3
 /     \
4       5
```
- 左视图输出：[1, 2, 4]
- 右视图输出：[1, 3, 5]

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def treeViews(root):
    if not root:
        return [], []

    left_view, right_view = [], []
    queue = [(root, 0)]

    while queue:
        node, level = queue.pop(0)
        if level == len(left_view):
            left_view.append(node.val)
        if level == len(right_view):
            right_view.append(node.val)

        if node.left:
            queue.append((node.left, level + 1))
        if node.right:
            queue.append((node.right, level + 1))

    return left_view, right_view

12. 最多连续假期天数

知识点：数组, 滑动窗口
问题描述：给定一个字符数组和一个整数 pto，数组中包含 'w'（工作日）和 'h'（假日），需要找到一个子数组，使得在至多 pto 次假期的情况下，能够得到最多的连续假期天数。
示例：
- 输入：array = ['w', 'h', 'w', 'w', 'h', 'h'], pto = 1
- 输出：4（可以将第一个 'w' 和最后一个 'w' 变为 'h'，获得最多的连续假期天数）

def maxVacationDays(array, pto):
    max_vacation = 0
    left, right = 0, 0
    pto_used = 0
    curr_vacation = 0

    while right < len(array):
        if array[right] == 'w':
            pto_used += 1

        while pto_used > pto:
            if array[left] == 'w':
                pto_used -= 1
            left += 1
            curr_vacation -= 1

        curr_vacation += 1
        max_vacation = max(max_vacation, curr_vacation)
        right += 1

    return max_vacation

13. 生成括号

知识点：回溯算法, 递归, 字符串生成
问题描述：给定一个整数 n，生成所有可能的并且有效的括号组合。有效的括号组合指的是每一个 ( 都有一个对应的 )，并且括号对的顺序是正确的。
示例：
- 输入：n = 3
- 输出：["((()))", "(()())", "(())()", "()(())", "()()()"]

def generateParenthesis(n):
    result = []

    def backtrack(s, left, right):
        if left == n and right == n:
            result.append(s)
            return
        if left < n:
            backtrack(s + '(', left + 1, right)
        if right < left:
            backtrack(s + ')', left, right + 1)

    backtrack('', 0, 0)
    return result

14. 数据流的中位数

知识点：堆, 数据结构, 在线算法
问题描述：设计一个数据结构，能够从数据流中持续读取数据并在每次读取后返回当前数据的中位数。中位数是指在数据排序后位于中间位置的数。
示例：
- 输入：[2, 3, 4]
- 输出：3
- 输入：[2, 3, 4, 5]
- 输出：3.5

import heapq

class MedianFinder:
    def __init__(self):
        self.max_heap = []  # Stores the smaller half of the numbers
        self.min_heap = []  # Stores the larger half of the numbers

    def addNum(self, num):
        if not self.max_heap or -self.max_heap[0] >= num:
            heapq.heappush(self.max_heap, -num)
        else:
            heapq.heappush(self.min_heap, num)

        # Balance the heaps
        if len(self.max_heap) > len(self.min_heap.min_heap, -heapq.heappop(self.max_heap)).max_heap, -heapq.heappop(self.min_heap))

    def findMedian(self):
        if len(self.max_heap) == len(self.min_heap):
            return (-self.max_heap[0] + self.min_heap[0]) / 2
        else:
            return -self.max_heap[0]

想要获得更多的面经？联系我们！

如果您想要了解更多的面经或获取我们的专业服务，欢迎联系我们