【面经】美团-后端开发工程师实习-2021.3.19

笔试是统一的 2021-03-13 16:00-18:00 周六，无论是否内推都需要参加。
笔试分为 4 道算法题和 1 道专项题。不细讲

---

一面 2021.3.19 周五 15.00~16.00

此次面试是17号约了周四上午，但是面试官有一些紧急的事情，推迟到周五下午

1. 首先讲了一下字节跳动西瓜视频实习项目，然后问了点问题，期间遇到的一些问题以及怎么解决的，
2. 然后讲了一下字节跳动基础架构实习项目，他说对这个蛮感兴趣，我就敞开说了一下我负责的部分，以及期间解决的一些第三方库toolkit的不兼容bug。
3. 没问啥基础问题，直接开始两道算法，题库找了一些题

• 算法题1，二叉树的层次遍历，然后按照层次输出

二叉树的层次遍历

Tip：一般层次遍历可以利用队列实现，这里不太行，因为需要识别层次的转换
一开始写的急，出了很多的bug，他让我慢点，我说没找到调试的地方，就点运行来着，他说好像是没调试的地方，可以让我多提交几次。最后写完运行通过。
思想：利用列表，每次遍历列表，然后把 不是 空 的 child 加入新的列表中。每层完毕后，存储该层节点的值。然后继续遍历下一层。

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

#
# 
# @param root TreeNode类 
# @return int整型二维数组
class Solution:
    def levelOrder(self , root):
        # write code here
        if root is None:
            return []
        res = []
        next_nodes = [root]
        while len(next_nodes) > 0:
            new_next_nodes = []
            for node in next_nodes:
                if node.left:
                    new_next_nodes.append(node.left)
                if node.right:
                    new_next_nodes.append(node.right)
            res.append([n.val for n in next_nodes])
            next_nodes = new_next_nodes
            # print(res)
        return res
    
if __name__ == "__main__":
    root = TreeNode(3)
    root.left = TreeNode(9)
    root.right = TreeNode(20)
    
    node = root.left
    node.left = TreeNode(15)
    node.right = TreeNode(7)
    
    S = Solution()
    print(S.levelOrder(root))

• 算法题2，链表环入口查找

链表环入口查找

Tips：定义两个指针，快指针每次走两步，慢指针一次走一步，当环存在时，则快指针一定会追上慢指针；
追上时使其中一个指针指向链头，然后两个指针同时走，则再次追上时指针的位置为环开始的位置

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

#
#
# @param head ListNode类
# @return ListNode类
#
class Solution:
    def detectCycle(self, head):
        # write code here
        if head is None:
            return None
        l, f = head, head
        while f is not None and f.next is not None:
            l = l.next
            f = f.next.next
            if l == f:
                l = head
                while f != l:
                    f = f.next
                    l = l.next
                return l
        return None

if __name__ == "__main__":
    s = Solution()

    nodes = [1, 2, 3, 4, 5]
    A = ListNode(1)
    cur = A
    for n in nodes[1:]:
        cur.next = ListNode(n)
        cur = cur.next

    res = s.detectCycle(A)
    if res:
        print("True! {}".format(res.val))
    else:
        print("False!")

    nodes = [1, 2, 3, 4, 5]
    A = ListNode(1)
    cur = A
    for n in nodes[1:]:
        cur.next = ListNode(n)
        cur = cur.next
    cur.next = A.next
    s = Solution()
    res = s.detectCycle(A)
    if res:
        print("True! {}".format(res.val))
    else:
        print("False!")

    nodes = [3, 2, 0, -4]
    A = ListNode(1)
    cur = A
    for n in nodes[1:]:
        cur.next = ListNode(n)
        cur = cur.next
    cur.next = A.next
    s = Solution()
    res = s.detectCycle(A)
    if res:
        print("True! {}".format(res.val))
    else:
        print("False!")

    nodes = [0, 1]
    A = ListNode(0)
    cur = A
    for n in nodes[1:]:
        cur.next = ListNode(n)
        cur = cur.next
    cur.next = A
    s = Solution()
    res = s.detectCycle(A)
    if res:
        print("True! {}".format(res.val))
    else:
        print("False!")

输出
False!
True! 2
True! 2
True! 0

4. 让我问他一些问题
   一面面试官：美团大数据平台，分为实时部分和离线部分，这边的组是实时部分

   • 主要工作包含：日志收集，业务方的日志上报到kafka收集，根据业务需求同步到hive等地方；业务方利用这边开发的组件，比如flink之类的实时数据聚合组件。是面向公司内部 ToB 的。
   • 旁边的组是负责实时引擎的，实时计算
   • 美团后端技术栈：C++，python，java

5. 补一个舍友面试问到的题
   10亿数据找到一个数

二面 2021.3.22 周一 16.00~17.00

此次面试是22号上午 hr 联系，直接定了下午4点

1. 面试官首先自己介绍了一下，是个小姐姐，在美团大数据平台工作
2. 自我介绍
3. 问了一下实习的两个项目，讲了很多细节，大概花了半小时。着重问了缓存机制，以及为什么这么做，有没有验证，自己的优化达到了什么效果？
4. 两段实习自己的感受怎么样，觉得哪段更体验更好或者收获更大？
   我觉得都好，简单阐述了一下为什么：第一次扩大自己的眼界，第二次是了解一些底层实现方式，并在生活中有所理解。
5. 面试官问了一个开放性问题：如果让你实现一个定时器，你怎么实现（就是业务方有很多定时需求，你怎么去实现调度，比如 Linux 的 crontab 怎么实现的）
   我大概说了一下 crontab 的实现方式，其实是按照分的粒度去轮训。
   面试官问：那如果轮训达不到需求呢？比如你的定时任务很多（我也说了一下，如果一分钟都轮训不完本次要执行的，那么之后的定时就得延时了）
   然后我提出生产者跟消费者，生产者负责发送要执行的任务到消息队列，消费者拿到就去执行，并监听消息队列。
   面试官着重问生产者的实现细节？过程中继续复杂化：如果有一些任务是每隔5分钟执行呢？如果有一些任务是每隔俩小时执行呢？如果有一些任务是最近五天执行，之后就不执行了呢？
   我最终的思想是：分层级存一个列表，每个元素是一个队列，每个队列分为“分钟”“小时”“天”等，比如分的队列里面，存3600个列表，表示每个分钟要执行的任务，小时的队列里面存24个列表，表示每个小时要执行的任务。每次遍历分级队列列表，然后去弹出顶部的任务列表，发到消息队列之后再添加到队尾。

参考：
定时器有几种实现方式？

• 算法三 最大路径是多少

最大路径

首先问了怎么存这个数据结构，每个节点的实际物理节点是几个之类的。然后需要自己写数据定义，并传入函数
同时问了一下怎么实现，考虑后先说一下自己的思路再实现。

class TNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None


# coding=utf-8

class Solution:
    def __init__(self):
        self.cache = {}

    def A(self, head):
        return self.get_max_path(head, 0, 0)

    def get_max_path(self, node, i, j):
        lm, rm = 0, 0
        cache = self.cache
        name = str(i) + "-" + str(j)
        if name in cache:
            return cache[name]

        if node.left is not None:
            lm = self.get_max_path(node.left, i + 1, j)
        if node.right is not None:
            rm = self.get_max_path(node.right, i + 1, j + 1)
        cache[name] = max(lm, rm) + node.val
        # print(i, j, cache[name])
        return cache[name]


if __name__ == "__main__":
    nodes = [[7], [3, 8], [8, 1, 0], [2, 7, 4, 4], [4, 5, 2, 6, 5]]
    cache_node = {}
    for i, nv in enumerate(nodes):
        for j, v in enumerate(nv):
            cache_node[str(i) + "-" + str(j)] = TNode(v)
    for i, nv in enumerate(nodes):
        for j, v in enumerate(nv):
            n, ln, rn = str(i) + "-" + str(j), str(i + 1) + "-" + str(j), str(i + 1) + "-" + str(j + 1)
            node = cache_node[n]
            if ln in cache_node:
                node.left = cache_node[ln]
            if rn in cache_node:
                node.right = cache_node[rn]
    head = cache_node["0-0"]
    s = Solution()
    print(s.A(head))

HR面 2021.3.24 周五 10.00

HR简单电话聊了一下，5分钟左右，问了一下大概的情况，问我的入职时间，我有啥别的问题。
我问了一下，我是不是进入的就是大数据部门（是的，面试官可能一个就是我的leader，一个就是我的总管）
然后问了一下基础情况：
美团在望京，实习工资每天300，晚上9.30之后打车报销，晚上8点之后有餐补30，别的没了，对于北京的同学没有房补
Offer去申请了，大概需要2~3天