头像

我是菜鸟




离线:1天前



2021届秋招面经

刚巧在b站看到了y总的视频,也来参加一下这个活动,hh

大概说一下本人情况,本人本科研究生都是211学校,没实习经历,找的都是开发岗。今年6月份才从b站背包九讲中了解到acwing,被y总的黑眼圈折服,hh。然后y总的算法基础课真的很重要!!熟练掌握后面试时基本没有太大问题,强烈推荐。自己也在秋招时陆陆续续面试了几家公司,比较幸运的都拿到了意向书,记录了一些印象深刻的点,也没在别的地方分享,就写到acwing,回报一下社区,hh

字节

字节一面

  1. 先说项目。
  2. 手撸双线程打印一个数组中的内容,交替打印。
  3. 其他一些基础知识,进线程之类的。
  4. C语言中带有double变量的的结构体的大小。
  5. http报文头结构。
  6. http和https的区别。
    算法题:1. 对称二叉树;2. 螺旋矩阵。

字节二面

  1. 继续询问之前http报文头结构,以及不同的状态码对应的什么错误。
  2. 内核空间和用户空间的区别。
  3. 进程间的通信方法,线程间的通信方法。
  4. 管道和消息队列的不同。
    算法题:1. 利用rand() % 5来生成rand() % 7的功能。2. 长度为N的字符串删掉K个字符,使得字典序最大(单调栈)。3. 链表排序(归并排序,还有一种非递归的没答上来)。

字节三面

  1. 聚集索引,覆盖索引什么意思?
  2. http是不是无连接的?使用什么来保证连接状态?服务器端有没有类似的东西(Session)。
  3. 说一说常用的http方法,put和post的区别是什么?
  4. 头条刷新过程中发生了什么?详细说一下。
  5. 头条推荐算法,如何保证去掉内容重复的信息。
  6. B树,B+树,B+好在哪里?
    算法题:1. sql语句,找出某一列最大的那一行(子查询)。2. 根据后序遍历,中序遍历构建树,并层序遍历出来。
    智力题:赛马问题

百度

百度一面

  1. 网络分层是怎么分的?为什么要分层。
  2. TCP和UDP的区别。
  3. 静态成员函数和普通的成员函数有什么区别,编译器层面呢?
  4. 写了段代码,问哪个是顶层const,哪个是底层const。
  5. 怎么修改代码,使得能够使用底层const修改指向的变量。
  6. 什么是多态?
  7. 虚函数是怎么实现的?虚函数表是在哪里存储?
  8. 构造函数和析构函数可以是虚函数吗?为什么?
  9. 不继承的话,析构函数需不需要是虚函数?
  10. 如果抛出异常后,智能指针所指向的对象会析构掉吗?
  11. 常用的进程间通信方法。
  12. 同一进程中的线程,哪些区域是独立的,哪些区域是共享的。
  13. 索引有哪些?
    算法题:1. 求最大数对之差。 2. Leetcode 矩形的最小面积

百度二面

  1. fork和vfork的区别。
  2. malloc的底层实现原理。
  3. 内核态和用户态的区别。
  4. 进程的内存空间分布。
  5. 堆和栈的区别。
  6. static变量存储在哪一个区域。
  7. 引用和指针的区别。
  8. 说说对纯虚函数的理解。
  9. 智能指针。
  10. io通信有哪些?说一说select,poll,epoll的区别。
  11. 进程的通信,管道和消息队列都是两次拷贝,说说零拷贝。
  12. TCP的time_wait和close_wait的状态,如何使得服务器能一直处于last_ack状态。
    算法题:1. 去除链表中倒数第N个结点。 2. Leetcode 第3题。 3. 划分数组,使得两部分的和最接近。

百度三面

聊了聊项目,说了说项目中最大的收获。
然后问了一个场景题:如果不给你任何数据,如何统计出一个国家的新生儿的数量。

网易互娱

网易一面

合并区间的算法题,撸完后10点开始面试。
1. TCP和UDP的区别;
2. 熟悉什么数据结构,堆怎么建立,底层实现是啥,如何初始化一个堆;
3. 进程间的调度算法,Linux中是怎么实现的;
4. 重载和重写的区别,如何重写一个函数,重载函数时,函数需要满足哪些条件?
5. 什么时候才会调用拷贝构造函数?
6. 构造函数和析构函数中能否有异常?
7. HTTP和HTTPS的区别。
8. 你喜欢玩啥游戏?我说王者荣耀,LOL这种类型的。

网易二面

和面试官聊了聊项目,面试官跟我聊项目聊了大概30分钟
1. 说说TCP的滑动窗口;
2. 操作系统中动态链接库能否有全局变量?不同的进程调用同一个全局变量是否影响?为什么?
3. 设计题:给你很多文件,文件中有ip到地区的映射,想办法很快的找出某个ip对应的地区;
4. 设计题:玩游戏时,比如LOL,你打完一句排位后,rank会更改,你说说如何设计这个结构最优。(我就说了跳表实现,他说也行,没有正确答案)。
之后就聊了聊游戏方面的东西,比如喜欢玩啥游戏等等。

腾讯

腾讯一面

上来就直接让撸4道题:
1. 原地反转字符串;
2. 查找二叉树中是否存在节点和为某一值的路径;
3. 旋转数组中的最小值;
4. 写一个程序,根据输入,自己建一棵树,同时根据输入,查询m次,每次查询两个结点的最近公共祖先。
撸题大概撸了40分钟,然后给面试官进行了讲解,第4题能过样例,但是时间复杂度过高,仅过了整个数据的20%,面试官让我进行优化,我跟他说,直接预处理,遍历一遍树的同时,记录某一结点左右子树两边结点的最近公共祖先就是该结点。
然后面试官改了下第三题,旋转数组中包含重复元素时,怎么做,然后撸了代码。第1,2题大概讲了讲思路,代码也相对简单。
之后问了问我基础知识,涉及的较宽泛,但不深,说了说MySQL和Redis的一些简单的知识,最后说了说项目就结束了。

腾讯二面

和第一面一样,上来直接撸3道题:
1. 输入一个无符号整数,然后按位逆序输出字符串,返回char*,后来让重新修改接口函数;
2. 二叉树求最大深度,先写了递归版,之后让改写成非递归版;
3. 经典动态规划:编辑距离
说了说项目,攻克的难点;然后两道设计题:
1. 给你两个文件,里面有千万个微信号,如何找出都存在的微信号?
2. 给你一个千万个微信好的文件,找出重复次数最多的前k个微信号。
基础知识问的不多:
1. 说一说select和poll和epoll的区别
一道组合概率题:
1. 给你52张牌,从中取出4张,为AAKK的概率是多少?

腾讯三面

  1. 按照STL中string的用法,自己设计一个,写出其构造函数,析构函数,拷贝构造函数,拷贝赋值运算符,c_str()函数(返回const char *)。
  2. 设计一个Timer,需要满足海量并发要求,秒级,通知定期建立网络连接,且为单进程单线程。
  3. 聊了聊项目就结束了,三面时间很快,大概40分钟左右。

腾讯HR面试

  1. 自我介绍;
  2. 自己的优点和缺点;
  3. 家里父母干什么的?有女朋友吗?对城市的要求?
  4. 大学期间自己做的号召力的事;
  5. 有啥兴趣爱好;
  6. 手上有几个offer,你怎么选择?
  7. 为什么选择WXG,你很喜欢玩游戏,为什么不去IEG?

阿里

阿里一面

算法题:
1. 机器人动态规划,求路径总和,包括有障碍的方格,简单的动态规划;
2. 设计一个数组,其有3个操作,保证每一个操作时间复杂度都为O(1):
a. 设置某一位置的值;
b. 设置全部数组的值;
c. 查询某一位置的值。
其他问题:
1. 问了问手上有几个offer,怎么选择?
2. 问了问几个基础问题,具体忘记了。

阿里二面

  1. 自我介绍
  2. 说了说和项目相关的东西;
  3. 一台机器第一次连接到交换机时发送什么包?包中MAC地址源地址和目的地址是什么?什么协议?
  4. 算法题:螺旋矩阵,顺时针打印

阿里三面

  1. 简单的聊了聊,说了说项目;
  2. 讨论了一下自己软件工程这个专业中学到了什么?
  3. 总结说要先有自己的方向,自己的定位,认真思考未来科技方向的发展。

阿里HR面

  1. 聊了聊项目;
  2. 问了问项目中的收获;
  3. 手上有几个offer,如何选择;
  4. 总共时间20分钟,很快。

华为

华为一面

  1. 撸题:全排列(先没有重复数字的全排列,之后改写成有重复数字的全排列,记得要去重);
  2. 讲了讲笔试的3道题,每道题的思路,想法;
  3. 讲了讲项目相关,然后考了几个基础,具体忘记了。

华为二面

  1. 聊了聊项目,讨论了一些项目中的细节;
  2. 算法题:给你一段代码,把注释去掉,包括//,//这种,注意字符串中的”…”的//和/**/符号不要去掉;
  3. 考了考基础知识。

华为三面

  1. 单纯的聊项目,抓细节抓的很细;
  2. 你觉得华为怎么样?家里人觉得华为怎么样?
  3. 最近看过什么书?有学到什么东西?


活动打卡代码 AcWing 872. 最大公约数

我是菜鸟
1个月前
#include <iostream>

using namespace std;

int main(){
    int n;
    cin >> n;
    while(n --){
        int a, b;
        cin >> a >> b;
        if(a < b) swap(a, b);
        while(a % b != 0){
            int raw_a = a;
            a = b;
            b = raw_a % b;
        }
        cout << b << endl;
    }

    return 0;
}


活动打卡代码 AcWing 870. 约数个数

我是菜鸟
1个月前

注意ans类型要long long,这样保证单次乘法不会越界

#include <iostream>
#include <vector>
#include <unordered_map>

using namespace std;
const int prime = 1e9 + 7;

int main(){
    int n;
    cin >> n;
    // 底数,指数
    unordered_map<int, int> hash;
    while(n --){
        int x;
        cin >> x;
        for(int i = 2; i <= x / i; ++ i){
            if(x % i == 0){
                int t = 0;
                while(x % i == 0){
                    t ++;
                    x /= i;
                }
                hash[i] += t;
            }
        }
        if(x > 1) hash[x] ++;
    }

    long long ans = 1;
    for(auto item : hash){
        //cout << item.first << ": " << item.second << endl;
        ans = ans * (item.second + 1) % prime;
    }

    cout << ans << endl;

    return 0;
}


活动打卡代码 AcWing 869. 试除法求约数

我是菜鸟
1个月前

好久不打卡了

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main(){
    int n;
    cin >> n;
    while(n --){
        int x;
        cin >> x;
        vector<int> ans;
        for(int i = 1; i <= x / i; ++ i){
            if(x % i == 0){
                if(i != x / i){
                    ans.push_back(i);
                    ans.push_back(x / i);
                }else ans.push_back(i);
            }
        }
        sort(ans.begin(), ans.end());
        for(auto i : ans) cout << i << " ";
        cout << endl;
    }

    return 0;
}



我是菜鸟
2个月前
class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        if(tokens.empty()) return 0;
        stack<int> stk;
        for(int i = 0; i < tokens.size(); ++ i){
            if(tokens[i] == "*"){
                int a = stk.top();
                stk.pop();
                int b = stk.top();
                stk.pop();
                stk.push(a * b);
            }else if(tokens[i] == "/"){
                int a = stk.top();
                stk.pop();
                int b = stk.top();
                stk.pop();
                stk.push(b / a);
            }else if(tokens[i] == "+"){
                int a = stk.top();
                stk.pop();
                int b = stk.top();
                stk.pop();
                stk.push(a + b);
            }else if(tokens[i] == "-"){
                int a = stk.top();
                stk.pop();
                int b = stk.top();
                stk.pop();
                stk.push(b - a);
            }else{
                stk.push(stoi(tokens[i]));
            }
        }
        return stk.top();
    }
};


活动打卡代码 LeetCode 148. 排序链表

我是菜鸟
2个月前
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* sortList(ListNode* head) {
        if(!head || !head->next) return head;
        int n = 0;
        for(auto p = head; p; p = p->next) n ++;
        int mid = n / 2 - 1;
        auto pre = head;
        for(int i = 0; i < mid; ++ i) pre = pre->next;
        auto second = pre->next;
        pre->next = NULL;
        auto left = sortList(head);
        auto right = sortList(second);
        auto dummy = new ListNode(0);
        auto cur = dummy;
        while(left && right){
            if(left->val <= right->val) {
                cur = cur->next = left;
                left = left->next;
            }else{
                cur = cur->next = right;
                right = right->next;
            }
        }
        if(left) cur->next = left;
        if(right) cur->next = right;
        return dummy->next;
    }
};



我是菜鸟
2个月前

感觉有反转链表那味儿了,主要原因是找到合适位置的前一个结点,且下一个结点的位置提前保存。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* insertionSortList(ListNode* head) {
        if(!head || !head->next) return head;
        auto dummy = new ListNode(0);
        auto cur = dummy;
        auto p = head;
        while(p){
            // 寻找合适的位置
            auto q = dummy;
            while(q->next && q->next->val <= p->val) q = q->next;
            auto _ne = p->next;
            p->next = q->next;
            q->next = p;
            p = _ne;
        }
        return dummy->next;
    }
};


活动打卡代码 LeetCode 146. LRU缓存机制

我是菜鸟
2个月前
class LRUCache {
    list<pair<int, int>> l_cache;
    unordered_map<int, list<pair<int, int>>::iterator> hash;
    int cap;
public:
    LRUCache(int capacity) {
        cap = capacity;
    }

    int get(int key) {
        if(!hash.count(key)) return -1;
        auto item = *hash[key];
        l_cache.erase(hash[key]);
        l_cache.push_front(item);
        hash[key] = l_cache.begin();
        return item.second;
    }

    void put(int key, int value) {
        if(!hash.count(key)) {
            if(l_cache.size() == cap){
                hash.erase(l_cache.back().first);
                l_cache.pop_back();
            }
            l_cache.push_front({key, value});
            hash[key] = l_cache.begin();
        }else{
            l_cache.erase(hash[key]);
            l_cache.push_front({key, value});
            hash[key] = l_cache.begin();
        }
    }
};

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache* obj = new LRUCache(capacity);
 * int param_1 = obj->get(key);
 * obj->put(key,value);
 */



我是菜鸟
2个月前
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        auto p = root;
        vector<int> ans;
        stack<TreeNode*> stk;
        while(p || stk.size()){
            while(p){
                ans.push_back(p->val);
                stk.push(p);
                p = p->right;
            }
            p = stk.top();
            stk.pop();
            p = p->left;
        }
        reverse(ans.begin(), ans.end());
        return ans;
    }
};



我是菜鸟
2个月前
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode*> stk;
        vector<int> ans;
        auto p = root;
        while(p || stk.size()){
            while(p){
                ans.push_back(p->val);
                stk.push(p);
                p = p->left;
            }
            p = stk.top();
            stk.pop();
            p = p->right;
        }
        return ans;
    }
};