2020秋招笔试题总结（华为、360、京东、中兴、快手、字节跳动、阿里、拼多多、腾讯、VIVO）~持续更新

目录

1.华为

1.1全量和已占用字符集合

1.2解析逻辑字符串

1.3比特块

1.4文本解析

1.5社交软件好友度

2.360

2.1表面积

2.2寻找子串

2.3散步

3.京东

3.1最多能完成排序的块

3.2考场安排

4.中兴

4.1工资按频次排序

4.2维克多博士问题

5.快手

5.1可以升级的版本号

5.2计算累计平方和

5.3合并两个内容流

5.4好序列

6字节跳动

6.1豆油瓶

6.2求圆形花园不相交的路

6.3 2048

7.阿里

7.1小明和他的朋友们

8.拼多多

8.1小梅的扑克游戏

8.2骰子期望

8.3乘法表第K大的数

---

1.华为

1.1全量和已占用字符集合

始定两个字符集合, 一个为全量字符集, 一个为已占用字符集。
已占用的字符集合中的字符不能再使用，要求输出剩余可用字符集。

输入描述：

输入为一个字行串，字符串中包括了全量字符集和已占用字符集。两个字符集使用@连接。@前的字符集为全量字符集，@后的字符集合为已占用字符集。
已占用字符集中的字符一定是全量字符集中的字符。

字符集中的字符跟字符之间使用英文逗号分隔。

字符集中的字符表示为字符加数字,字符跟数字使用英文冒号分隔,比如a:1,表示1个a字符。字符只考虑英文字母,区分大小写,数字只考虑正整形,数量不超过 100,如果一个字符都没被占用,@标识仍然存在,例如a:3,b:5,c:2@

输出描述：

可用字符集。输出带回车换行

示例输入：

a:3,b:5,c:2@a:1,b:2

示例输出：

a:2,b:3,c:2

题解：

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map.Entry;
import java.util.Scanner;

public class main {
    public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    String str=scan.nextLine();
    String[] tmp=str.split("@");
    if(tmp.length<2){
        System.out.println(tmp[0]);
        return;//作者：无人机大佬朱志斌
    }
    String[] arryOne=tmp[0].split(",");
    String[] arryTwo=tmp[1].split(",");
    HashMap map=new LinkedHashMap();
  
    for(int i=0;i entry:map.entrySet()){
        if(entry.getValue()>0){
            result=result+entry.getKey();
            result=result+":";
            result=result+entry.getValue();
            result=result+",";}
        }
        char[] tmpThree=result.toCharArray();
        String res="";
        for(int i=0;i

1.2解析逻辑字符串

 

输入描述：

1.测试用例中间无空格,无需考虑空格。
2.测试用例表达式中只会出现如下字符: "0"，"1"，"("，")"，"&"，"|"，"!"。

3.测试用例所给的输入都是合法输入,无需要考底非法输入。

4.测试用例表达式长度不会超过 128 个字符。

5.括号可以重复嵌套。

例如：
1|(1&0)           返回值:1
1&0|0&1         返回值:0
!0&1|0             返回值:1
((!0&1))|0        返回值:1

输出描述：

   输出逻辑运算后的最终结果:0 或者1

1.3比特块

在一个int型整数（对应的比特流）中查找某个比特块（本题固定为5，即二进制“101”）出现的次数及首次出现位置,说明：
1.输入次数和首次出现的位置中间用空格隔开。
2.位置从0 开始,即最右边位置为 0,向左依次增加。
3.如果该int型整数中没有找到该比特块,次数返回0,位置返回-1。
4.比特位允许重复使用,如 10101 中间的比特1 可以与前面的01 组成 101,也可以与后面的 10 组成 101。

输入描述：

一个任意的十进制 int 型整数

输出描述：

在输入整数对应的二进制比特流中,比特块(101)出现的次数和首次出现的位置,次数和位置分别以十进制 int 型整数表示,中间用空格隔开

示例输入：

21

示例输出：

2 0

代码1（不确定是否AC，如有问题，求大神斧正）

import java.util.Scanner;

public class Main{
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while(in.hasNext()){
            int cur = in.nextInt();

            //将整数转化为二进制数
            String binStr = Integer.toBinaryString(cur);//作者：海思安全总工程师程昱婷博士

            //求字符串中的子串
            int count=0;
            int firstIndex=-1;
            
            //方法1：从前往后（当101首次出现，flag置false，则不记录以后出现的位置）
//            boolean flag = false;
//            for(int i = 0; i  2; i--){
                if(binStr.substring(i-3,i).equals("101")){
                    count++;
                    firstIndex=i-3;
                }
            }
            System.out.println(count+" "+firstIndex);
        }
    }
}

代码2（AC）

import java.util.Scanner;

public class bitsBlock {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while(in.hasNext()){
            int cur = in.nextInt();
            //将整数转化为二进制数
            String binStr = Integer.toBinaryString(cur);

            //求字符串中的子串
            int[] res = getNum(binStr);
            System.out.println(res[0]+" "+res[1]);
        }
    }

    public static int[] getNum(String str){
        char arr[] = str.toCharArray();
        int[] res = new int[2];
        res[1]=-1;
        boolean flag = false;
        for(int i = arr.length-1; i >=2; i--){
            if(arr[i]=='1'){
                if(arr[i-1]=='0'&&arr[i-2]=='1'){
                    res[0]++;
                    if(!flag){
                        res[1]=(arr.length-1)-i;
                    }
                    flag = true;
                }
            }
        }
        return res;
    }
}

1.4文本解析

某程序员小A,有一种表格数据需要存储在文件中。表格中的每行,由若干个字骤组成,每个字段可以是整数字符串(字符包数字字母以及特殊字符!@#￥%……&*()",）。小A 设计了一种存储格式,采用文本的方式对表格数据进行存储。文本文件中的每行,代表了表格数据中的行数据。具体格式如下：
    1、采用号分隔不同的字段(逗号前后无空格);
    2、数字直接采用 10 进制的文本存储;
    3、字符串的存储规则如下：

        1)如果字符串中包含逗号以及双引号,则字符串必须在头尾各增加一个双引号,且中间的双引号需要用连续两个双引号来表示。例如:"a,""b",表示字符串 a,"b
        2)如果字符串中末包含逗号以及双引号,则字符串不强制要求在头尾增加双引号,可直接存储。例如:abc,或者"abc"都可以。
    4、空字符串不存储任何字符,例如:a,,b中,有3 个字段,分别为a,空字符串,b;
请帮助小A 设计个算法,用来将单行文本,解析成多个字段,并输出。

输入描述：

 用于存储单行表格数据的一行文本。
  1、用手分隔不同字段的号前后一定没有空格,程序设计者无需考虑此种异常情况
  2、除数字、字母以及特殊字符!@#￥%……&*()",外,不会出现其它字符
  3、输入的数字一定是 10 进制合法正整数,不会出现负数、小数、其它进制数以及格式错误的 10 进制数

输出描述：

第一行,字符串格式是否正确,正确输出字段个数,不正确输出ERROR。
如果输入字符串格式不正确,则输出结束。

如果字符串格式正确,则输出每个字段的值,每个字段单独占一行。
数字采用 10 进制输出,字符串输出解析后的值。

空字符串输出--

示例输入：

a,,1,"b,"""

示例输出：

4

a

--

1

b,"

思路

如果首次遇到双引号，则将将flag置为真，之后除双引号之外的所有字符，包括逗号，全部保留；

如果再次遇到双引号，则将将flag置为假，恢复正常操作。

题解：（没有AC，只过了80%）

import java.util.Scanner;
import java.util.List;
import java.util.ArrayList;
public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        String s=sc.nextLine();
        List list=new ArrayList<>();
        StringBuilder sb=new StringBuilder();
        if(s!=null){
            boolean flag=false;//作者：外星小小朋友
            for(int i=0;i

1.5社交软件好友度

有一款社交软件 APP,假说注朋用户m人(0 友(1 度好友代表直接好友,2 度好友代表好友的好友,以此类推1<=n<=10),并按推荐值降序输出好友列表(推荐值相同的好友,按好友编号升序,其中推荐值是指关系熟活度之和,比如朋户i和j是好友，且熟悉度r[i][j]=4 ，j和k是好友且熟活度小r[j][k]=6，且i和k 不是好友即r[i][k]=0，则用户k 是用户i的2 度好友且推荐值为可r[i][j]+r[j][k]=10),如果此用户i 没有n 度好友输出-1。

输入描述：

输入一个整数T,表示有T组测试数据（0

对于每组测试数据输入2行，

第1行     输入3 个整型数 m,i,n 分别代表用户数 m,某个用户编号 i,n度好友, 即代表本组测试需要输出用户i的n度好友
第2 行    输入1 个整型数 k,接下来 3*k 个整数用空格隔开,每三个组成关系对,每个关系由3 个整型数组成 i,j,w 代表用户主和的熟悉程度,即 r[i][j]=w，没有输入的关系默认为非好友（r[i][j]=r[j][i]=0）

输出描述：

输出T行,每行对应每组测试数据的用户i的n 度好友,按推荐值降序输出,推荐值相同的好友按好友编号升序,编号间用空格隔开。如果没有n 度好友输出-1

示例输入：

2

10 5 2

13 0 3 5 0 4 9 0 6 8 0 7 5 1 2 6 1 6 1 2 9 7 3 4

  3 3 5 3 3 8 3 3 9 3 5 8 9 7 8 9

10 0 2

13 0 3 5 0 4 9 0 6 8 0 7 5 1 2 6 1 6 1 2 9 7 3 4

  3 3 5 3 3 8 3 3 9 3 5 8 9 7 8 9

示例输出：

7 0 4 9

1 5 8 9

代码：暂无 

2.360

2.1表面积

将长N*M 厘米的矩形区域划分成N行M 列(每行每列的宽度均为1 厘米),在第i行第j列的位置上叠放Ai,j个边长为1 厘米的正方体(1≤Ai,j≤100),所有正方体就组成了一个立体图形,每个正方体六个面中的一部分会被其它正方体遮挡,未被遮挡的部分的总面积即为该立体图形的表面积,那么该立体图形的表面积是多少平方厘米?

输入描述：

 第一行包含两个整数N和M,1≤N,M≤1000。
 接下来N行,每行包含M个整数,第i行的第j个整数表示 Ai,j

输出描述：

输出表面积的大小。

示例输入：

2 2

2 1

1 1

示例输出

20

题解： 

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();
        int[][] grid=new int[n][m];

        for(int i=0;igrid[i+1][j]?grid[i+1][j]:grid[i][j])*2;                 
                }
                if (j != grid[0].length - 1) {//作者：孙作者
                    //记录 j 列与 j + 1 列的邻接面积    
                    surface2+=(grid[i][j]>grid[i][j+1]?grid[i][j+1]:grid[i][j])*2;                    
                }
            }
        }
        return surface1 - surface2;
    }
}

2.2寻找子串

英语老师看你老是在英语课上和周围同学交头接耳,所以给你布置了一份额外的家庭作业来惩罚惩罚你:你有一个字符串 s,请你在s 的所有子串中,找到出现次数最多的子串,告诉老师它的出现次数。
输入

共一行,一个字符串 s,仅由英文小写字母组成,1<|s|<10000。

输出

一个正整数,表示最大出现次数。

 样例输入

aba

 样例输出

2

思路1：求出全部子串，然后统计，但是这样会内存超限；

思路2：只统计长度为1的子串即可，即判断字符串中每个char出现的次数。因为长度大于1的子串出现的次数必然小于长度大于1的子串出现的次数，故省略不计。

2.3散步

饭后散步是个很好的习惯,一天晚上,小A 在条笔直的路上散步,起点在路上某处,但是因为路上没有标识,他并不知道这个起点位于路上的哪个位置,现在将道路划分为 N-1 个等距的部分,你可以把这条路当成一个数轴,道路上的结点标记为 1~N,起点只可能是这N 个点中的一个。

但是小A 还提供了一个重要信息,他每隔一段时间就会用手机看一下自己走了多远,记作D,但是他并不记得他是朝着哪个方向走的,唯一可以确定的是,在两次看手机的间隔中他不会改变方向,每次看完手机后他可能继续向前或者回头走。

那么问题来了,已知他在散步过程中始终在 1~N 的范围内,那么符合上述条件的终点可能有多少个呢？
输入

输入第一行包含一个正整数 N,M,N 表示道路的长度,也是数轴上点的数量,M 是小A提供的D 的数量。(N，M<=20000）
接下来有M行,每行一个正整数D,表示小A 朝着某个方向走了D 个单位。(D<=20000）

输出

输出仅包含一个整数,表示可能的起点的数量。

输入样例

10 3

5

2

6

输出样例

8

代码

import java.util.Scanner;

public class Main{
    public static void main(String[] args) {

        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();
        int[] loc=new int[m];
        int count=0;
        for (int i = 0; i < m; i++) {
            loc[i]=sc.nextInt();
        }
        for(int j=1;j<=n;j++){
            if(panduan(j,n,loc)){
                count++;
            }
        }
        System.out.println(count);
    }
    public static boolean panduan(int i,int n,int[] loc){
        boolean result=false;
        for(int j=0;j=1){
                i-=loc[j];
                result=true;
                continue;
            }else{
                result=false;
                return result;
            }
        }
        return result;
    }
}

3.京东

3.1最多能完成排序的块

参考力扣768

3.2考场安排

某校在积极推行无人监考制度,但是总有学生是不自觉的,如果将两个很熟的异性朋友放在同一个考场里,他们就会交流甚至作弊。因此一个考场中不能允许两个很熟的异性朋友存在,学校希望通过搬出一部分学生的方法来改善这一问题。但是又因为教率数量有限,因此希望个教率中容下的学生尽可能多,即需要搬出教室的学生数量尽可能少,请你输出搬出教室人数最少,且字典序最小的方案。
输入描述

输入第行有两个整数n和 m,分别表示有n 个男生和n 个女生,有m 个朋友关系。
 (1<=n<=500，1<=m<=100000
接下来m行,每行有两个整数,x和 y,表示第号男生和第y 号女生是朋友。男生的编号均为[1,n],女生的编号为[n+1,2n]

输出描述

输出第一行包含一个整数 a,表示最少需要搬出教室的人数。
输出第二行有a 个整数,即a 个需要搬出教室的人的编号,要求人数最少,且字典序最小

样例输入

2 2

3 1

1 4

样例输出

1

3 

代码

import java.util.HashMap;
import java.util.Scanner;

public class testOne {
	public static void main(String args[]){
		Scanner scan=new Scanner(System.in);
		int n=scan.nextInt();
		int m=scan.nextInt();
		n=n*2;
		HashMap count=new HashMap<>();
		int[][] relation=new int[n+1][n+1];
		for(int i=1;i<=n;i++)
			for(int j=1;j<=n;j++)
				relation[i][j]=0;
		for(int i=0;i0)
				num++;
		System.out.println(num);
		for(int i=0;i count,int n){
		int max=0;
		int maxIndex=0; 
		for(int i=0;i<=n;i++){
			if(count.get(i)!=null && count.get(i)>max){
				max=count.get(i);
				maxIndex=i;
			}
		}
		return maxIndex;
	}
	public static boolean panduan(int[][] relation,int n){
		for(int i=1;i

4.中兴

4.1工资按频次排序

给N名员工的工资清单，按照工资分布的人数降序排序，如果有两个工资的人的数目一致（大概意思就是假设3000工资有3个人，5000也是三个人），就按照工资在给定清单的顺序里面排序。

输入

20（人数）

4 1 4 4 2 1 2 3 1 9 1 2 8 7 5 6 3 4 3 6

输出

4 4 4 4 1 1 1 1 2 2 2 3 3 3 6 6 9 8 7 5

代码

/*
1.用Map来统计工资及其出现的频次，由于需要对频次相同的工资按照原来的顺序打印，所以需要使用到是LinkedHashMap，Key为工资，Value为出现频次；
2.用Map的EntrySet构造List, 并对list按照工资出现频次排序；
3.将上述List从头到尾添加至结果集List中，频次为n，则重复添加n次。
*/
public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int num=sc.nextInt();
        int[] nums=new int[num];
        for(int i=0;i salaryList=sortSalary(nums);
        for(int i:salaryList){
            System.out.print(i+" ");
        }
    }
    public static List sortSalary(int[] nums){

        //一维数组salaryList用于存放排序后的工资列表。
        List salaryList = new ArrayList();
        //freMap用于统计工资出现的凭此，key为工资，value为出现频次
        Map freMap = new LinkedHashMap();
        //二维数组tempList用于存放带频次信息的工资列表，tempList[i][0]存放工资，tempList[i][1]存放频次
        List> tempList = null;

        //统计频次
        for(int i=0;i>() {
            public int compare(Map.Entry o1, Map.Entry o2) {
                return o2.getValue()-o1.getValue();
            }
        });

        for(Map.Entry entry : tempList){
            for(int i=0;i

参考：https://blog.csdn.net/weixin_44003141/article/details/98882568

4.2维克多博士问题

https://blog.csdn.net/hongtao_6/article/details/97246319

5.快手

5.1可以升级的版本号

给定两个版本号，只有在版本号更高的时候，才可以升级。

输入

2

6.6.6 6.6.7

1 1.0

输出

true

false

代码

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int caseNum = Integer.valueOf(sc.nextLine());//sc每接收一种类型的数据就要new一个新的Scanner类
        boolean[] canUpgradeArr=new boolean[caseNum];

        for(int i=0;i

5.2计算累计平方和

参考力扣202

5.3合并两个内容流

5.4好序列

6字节跳动

6.1豆油瓶

抖音上每天都有几亿用户,如果用户A和B 互动不少于3次,我们就认为A和B 属于“豆油”,如果A和B “豆油”,B和C 的是“豆油”,那么A和C 也互为“豆油”,我们定义“豆油瓶”就是由直系和间接朋友组成的群体。

给定1个N*N 的矩阵M,代表抖音上所有用户的互动次数,如果M[i][j]=5,那么第i个和第j个用户就互动过5次,为0 的话代表没有互动其中,对i=j,即同一个用户,互动次数我们计为0.请你计算并输出发现的抖音上所有“豆油瓶”的个数。

输入

示例1：

3
0 4 0
4 0 0
0 0 0 

示例2：

3
0 4 0
4 0 6
0 6 0

输出

示例1：

2

示例2：

1

代码

import java.util.Scanner;

public class Main {

    //求无向连通子图个数
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int userNum=sc.nextInt();

        int[][] grid=new int[userNum][userNum];
        for(int i=0;i=3){
                    grid[i][j]=1;
                }
            }
        }
        
        //已经遍历过的用户
        boolean[] visited=new boolean[grid.length];
        
        int res=0;
        
        for(int i=0;i

6.2求圆形花园不相交的路

圆形花园共有n个入口，现在要修路，穿过花园，要求每个路口只能有一条路，所有路均不会相交，求所有可行的方法总数。

思路：

卡特兰数

6.3 2048

7.阿里

7.1小明和他的朋友们

代码

import java.io.*;
import java.util.*;
import java.util.Map.Entry;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Main1 {

	private static HashSet set = null;
	/** 请完成下面这个函数，实现题目要求的功能 **/
	/** 当然，你也可以不按照这个模板来作答，完全按照自己的想法来 ^-^ **/
	static String getIndexAndLongest(String users,int k) {
		if(users==null) {
			return "0 0";
		}
		set = new HashSet<>();
		for(int i=0;i iterator = set.iterator();
		while(iterator.hasNext()) {
			Integer entry = iterator.next();
			int idx = entry;
			int left = (idx+size-1)%size;
			int right = (idx+1)%size;
			int leftCount = 0;
			int rightCount  =0;
			while(users.charAt(left)=='g'&&left!=right) {
				left = (left-1+size)%size;
				leftCount++;
			}
			while(users.charAt(right)=='g'&&right!=left) {
				right = (right+1)%size;
				rightCount++;
			}
			int count = leftCount+rightCount;
			if(maxGrilentry) {
				minIdx = entry;
			}
		}
		
		return minIdx+"";
	}

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		String res;
		String _users;
		int k = 0;
		try {
			_users = in.nextLine();
			String str = in.nextLine();
			k = Integer.valueOf(str);
		} catch (Exception e) {
			_users = null;
		}
		res = getIndexAndLongest(_users,k);
		System.out.println(res);
	}
}

8.拼多多

8.1小梅的扑克游戏

产品经理小梅喜欢和他的男朋友小白一块玩扑克游戏。每一局,小梅抽取N 张扑克牌,自左向右依次排列在桌面上;小白也抽取 M(8>=N>=M=1)张扑克牌,自左向右依次排列在桌面上。

小梅需要进行N 个回合,使用手中的扑克牌,组成一个新的扑克牌的序列。每个回合,小梅有d、l、r三种策略：

----选择d时,小梅将最左边的扑克牌丢弃

----选择l时,小梅将最左边的扑克牌取出,放到新的扑克牌序列的最左边
----选择r时,小梅将最左边的扑克牌取出,放到新的扑克牌序列的最右边
N 个回合完成,新的扑克牌序列与小白的扑克牌完全一样(只考虑数字,不考虑花色),则小梅胜出
小梅向程序员小岛提了一个需求,希望了解获胜的全部方法。简化起见,扑克牌仅包含 1-9。

输入描述

首先,输入数字s,作为局数(1<=s<=10)

每一局,分别输入两行字行串,另代表小梅的抽取的扑克牌 (从左问右排列)和小白抽职到的扑克(从左向右排列)

输出描述

对于每一局,在开始和结束,分别输出 { 和 } 

输出获胜的方法,回合策的结尾出一个空格。若存在多个获胜万法,请按宇典序的升序输出。

代码

 

8.2骰子期望

 

8.3乘法表第K大的数

668. 乘法表中第k小的数

9.腾讯 

9.1求序列中子序列的和与子序列中的最小数最大乘积

https://blog.csdn.net/sr_19930829/article/details/38012777

10.VIVO

1.跳跃游戏||：参考力扣

2.约瑟夫环

3.背包问题变种：将数组分成两部分使得两部分的和的差最小 

https://blog.csdn.net/qq_26222859/article/details/69335310