本科及以上2023届毕业生，计算机、数学、电子信息、通信工程等满足岗位需求的理工科相关专业

*国内：2022年9月-2023年8月毕业生，国内以毕业证为准

*海外：2022年9月-2023年12月毕业生，中国港澳台及海外地区以学位证为准

网申/内推 — 笔试 — 面试 — Offer — 签约 — 入职（签约后可参与实习）

7月20日 网申启动

8月02日 空中宣讲会

8月18日 技术成长共探讨在线直播

9月01日 研发-前端专场在线直播

9月15日 研发-后端专场在线直播

9月28日 网申截止

08月中旬  开始线上面试

10月中旬  发放Offer&签约

*如遇日程调整，以最新通知为准

8月10日19:00 -西安、南京、合肥、武汉等

9月05日19:00 -成都、重庆、广州、深圳、长沙、哈尔滨等

9月20日19:00 -北京、上海、杭州、厦门、济南等

1）以上为建议的国内主要地区最佳笔试场次，海外将根据简历投递时间就近安排

2）每场考试前24小时停止创建笔试入口，如错过最佳场次将安排顺延（共3场）

客户端：

各方向试题均由选择题+编程题构成

作答总时长为90min，开考后即进入倒计时模式

笔试通知将在开考前 1周，陆续以短信 +邮件的方式送达

单选：

给出ip和掩码，计算网络号
排序算法，各种的复杂度，稳定性，二分法比较次数
Java代码判断执行结果
图的基础知识
a = 2 | 24 ，这个原来是或运算啊，我当时没看出来，梦错答案了啊！！

多选：

排序问题
数据库引擎，日志。有道题问执行了delete后，执行下列那个语句磁盘不会删除
其他的忘了，有挺多不确定的

第一题：

找132模式的匹配，有一个数组，找出遵循以下规则的个数，有下标索引i，j，k满足条件：

    i < j < k 并且 nums[i] < nums[k] < nums[j]

例子：

    [-1,3,2,0]

    3

    解释：满足条件的有[-1, 3, 2] [-1,3,0] [-1,2,0]


暴力解法：
public class Solution1 {

    public int find132Pattern (int[] nums) {
        int len = nums.length;
        int count = 0;
        // 第一个数
        for (int i = 0; i < len-2; i++) {
            // 第二个数
            for (int j = i+1; j < len-1; j++) {
                // 第三个数
                for (int k = j+1; k < len; k++) {
                    if (nums[i] < nums[k] && nums[k] < nums[j]) {
                        count++;
                    }
                }
            }
        }
        return count;
    }

    public static void main(String[] args) {
        int[] nums = {-1, 3, 2, 0};
        int res = new Solution1().find132Pattern(nums);
        System.out.println(res);
    }
} 

第二题

给你个数组，滑动窗口大小，滑动窗口步长。求每个窗口中最大值

例子：

    [1,3,-1,-3,5,3,6,7],3,2

    [3, 5, 6 ,7]

解释：[1,3-1] 中最大值3，[-1,-3,5] 中最大值5，[5,3,6] 中最大值6，[6,7] 中最大值7


解法：

import java.util.Arrays;

public class Solution2 {

    public int[] slideWindow(int[] nums, int windowSize, int step) {
        int left = 0;
        int right = windowSize-1;
        int resLen = 0;
        // 如果是偶数
        if (nums.length % 2 == 0) {
            resLen = nums.length / step;
        } else { // 如果是奇数
            resLen = (nums.length+1)/step;
        }
        int[] res = new int[nums.length / step];
        int resIndex = 0;
        while (left < nums.length) {
            findMax(nums, left, right,res,resIndex);
            left += step;
            right += step;
            resIndex++;
        }
        return res;
    }

    private void findMax(int[] nums, int left, int right, int[] res, int resIndex) {
        int max = Integer.MIN_VALUE;
        for (int i = left; i <= right; i++) {
            if (i == nums.length) {
                break;
            }
            max = Math.max(max, nums[i]);
        }
        res[resIndex] = max;
    }


    //[1,3,-1,-3,5,3,6,7],3,2
    //[1,3,-1,-3,5,3,6,7],3,1
    public static void main(String[] args) {
        int[] nums = {1,3,-1,-3,5,3,6,7};
        int[] res = new Solution2().slideWindow(nums, 3, 2);
        System.out.println(Arrays.toString(res));
    }
}
	

		
	

给你一棵树，树上每个节点要么是红色要么是黑色，根节点为1。每个节点的权重值为根节点到该节点路径上红色节点个数和蓝色节点个数的差的绝对值。求所有节点权重值之和。
输入数据第一行是节点个数
第二行是每个节点的颜色 比如 RBR
然后N-1行是边的关系 比如 1 2 这样

建树，dfs模拟即可。

代码

import java.util.List;
import java.util.Scanner;

class ListNode{
    long val;
    ListNode next;
    public  ListNode(long val, ListNode next){
        this.val = val;
        this.next = next;
    }
}

public class Q2 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int root = 0;
        int n = sc.nextInt();
        System.out.println(n);
        int color[] = new int[n];
        ListNode[] Graph = new ListNode[n];
        for (int i = 0; i < n; i++) {
            Graph[i] = new ListNode(0,null);
        }
        sc.nextLine();
        String str = sc.nextLine();
        System.out.println(str);
        for (int i = 0; i < n; i++) {
            if(str.charAt(i)=='R'){
                color[i] = 1;
            }
        }
        for (int i = 0; i < n-1; i++) {
            int u = sc.nextInt()-1;
            int v = sc.nextInt()-1;
            insert(u,v,Graph);
        }
        int visited[] = new int[n];
        dfs(root,visited,0,0,color,Graph);
        long ans = 0;
        for (int i = 0; i < n; i++) {
            ans+=Graph[i].val;
        }
        System.out.println(ans);
    }


    public static void insert(int u,int v,ListNode[] G){
        ListNode vNode = new ListNode(v,G[u].next);
        G[u].next = vNode;
        ListNode uNode = new ListNode(u,G[v].next);
        G[v].next = uNode;
    }

    public static void dfs(int root,int[] visited,int red,int blue,int color[],ListNode[] G){
        visited[root] = 1;
        if(color[root]==1) red++;
        else blue++;
        G[root].val = Math.abs(red-blue);
        ListNode p = G[root].next;
        while(p!=null){
            if(visited[(int)p.val]!=1){
                dfs((int)p.val,visited,red,blue,color,G);
            }
            p = p.next;
        }
        visited[root] = 0;
    }
}

第二题

题目

股票推荐系统。每个用户可能关注几个公司，比如A,B,C，如果有另一个用户只关注了A，那么就会给他推荐B，C。这时候如果来了一个用户关注C，D，那么后来关注C的用户，都会推荐A，B，关注A的用户都会推荐BCD。
在有上面的关系后，求用户查询的时候，会给它推荐的公司的个数。
第一行给出命令的个数
然后每一行
如果第一个数字是1，代表注册，然后第二个参数是用户名字，第三个参数是用户关注的公司的个数。下一行则是用户关注的公司的名字。
如果第一个数字是2，代表查询，返回会给该用户推荐的公司数量，如果该用户没注册，则返回error

并查集模拟

代码

import java.util.*;

class UnionSet{
    List<Integer> parent;
    List<Integer> cnt;
    List<String> company;
    HashMap<String,Integer> companyMap;

    public UnionSet(){
        parent = new ArrayList<>();
        cnt = new ArrayList<>();
        company = new ArrayList<>();
        companyMap = new HashMap<>();
    }

    public void addCompany(String companyName){
        if(companyMap.containsKey(companyName)){
            return;
        }
        cnt.add(1);
        parent.add(cnt.size()-1);
        company.add(companyName);
        companyMap.put(companyName,company.size()-1);
    }

    public void union(String u,String v){
        int ufather = getParent(u);
        int vfather = getParent(v);
        if(ufather == vfather) return;
        if(cnt.get(ufather)>cnt.get(vfather)){
            parent.set(vfather,ufather);
            cnt.set(ufather,cnt.get(ufather)+cnt.get(vfather));
        }
        else{
            parent.set(ufather,vfather);
            cnt.set(vfather,cnt.get(ufather)+cnt.get(vfather));
        }
    }

    public int getParent(String cName){
        int idx = companyMap.get(cName);
        while(parent.get(idx)!=idx){
            parent.set(idx,parent.get(idx));
            idx = parent.get(idx);
        }
        return idx;
    }

    public Set<String> getSetsByCompanies(int u){
        Set<String> sets = new HashSet<>();
        for (int i = 0; i < company.size(); i++) {
            if(getParent(company.get(i))==u){
                sets.add(company.get(i));
            }
        }
        return sets;
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        HashMap<String,String[]> person = new HashMap<>();
        UnionSet us = new UnionSet();
        int ops = sc.nextInt();
        sc.nextLine();
        for (int i = 0; i < ops; i++) {
            String command = sc.nextLine();
            String commands[] = command.split(" ");
            String name = commands[1];
            if(commands[0].equals("1")){
                if(person.containsKey(name)){
                    System.out.println("error");
                    continue;
                }
                String companyStr = sc.nextLine();
                String[] companies = companyStr.split(" ");
                for (int j = 0; j < companies.length; j++) {
                    us.addCompany(companies[j]);
                    if(j>0){
                        us.union(companies[j],companies[j-1]);
                    }
                }
                person.put(name,companies);
            }
            else{
                if(person.containsKey(name)){
                    int p = us.getParent(person.get(name)[0]);
                    Set<String> sets = us.getSetsByCompanies(p);
                    System.out.println(sets.size()-person.get(name).length);
                }
                else{
                    System.out.println("error");
                }
            }
        }
    }
}

• 历经70+场面试，分享些面试经验给大家
• 秋招总结-双非本科菜狗2022秋招总结
• 【起风了，唯有努力生存】一个本硕非科班码农的后台开发之路
• 超全面的后端开发C/C++面经整理分享含参考答案 简历分享

• 干货!普通人的秋招经验分享