秋招笔试题汇总
目录
华为实习笔试题（2019年4月10日）
题目一：
题目二：
题目三：
华为笔试2019.9.7笔试题反思
第一题
第二题
第三题
帆软笔试（范围区间内数组的最大乘积）
一、范围区间内数组的最大乘积
360笔试题（2019/8/31）
一、寻找子串
二、散步
科大讯飞笔试（2019/9/12）
华为实习笔试题（2019年4月10日）
题目一：
题目描述：连续输入字符串，以空格键分割，输入字符串个数为n，请按长度为8拆分每个字符串后输出新的字符串数组，输出的字符串按照升序排列。长度不是8整数的在后面补0，空字符串不处理。第一个输入的字符串为个数n，后面的为n个待处理的字符串。
测试用例：
输入：
2 abc 1234567890
1
输出：
12345678 90000000 abc00000
注意：输出的字符串按照升序排列，意思是分割后的字符串，按照每个字符串的大小进行排序，由小到大。
第一版
package IMUHERO;
import java.util.Collections;
import java.util.LinkedList;
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();
String init=scanner.nextLine().trim();//.trim用于去除符号前后的空格
LinkedListresult=new LinkedList<>();
String[]arrS=init.split(" ");
for (int i=0;i=8){
result.add(stb.substring(0,8));
stb.delete(0,8);
}
}
Collections.sort(result);
for (int j=0;j 2019.9.7修改完善：
import java.util.*;
public class DivideString {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int len = scanner.nextInt();
LinkedList list = new LinkedList<>();
for(int i=0;i res = new LinkedList<>();
while (!list.isEmpty()){
String s = list.removeFirst();
int i=0;
while ((i+1)*8 题目二：
给定一个字符串，字符串包含数字、大小写字母以及括号（包括大括号，中括号，小括号），括号可以嵌套，即括号里面可以出现数字和括号。
按照如下规则对字符串进行展开，不需要考虑括号不成对的问题，不考虑数字后面没有括号的情况，即 2a2(b)不考虑。
- 数字表示括号里的字符串重复的次数，展开后的字符串不包含括号
- 将字符串进行逆序展开
测试用例：
输入：abc3(A) -
输出：
AAAcba
解法一
//该解法存在问题
package IMUHERO;
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
String input=scanner.nextLine();
String output=getStr(input);
for (int i=output.length()-1;i>=0;i--){
System.out.print(output.charAt(i));
}
}
public static String getStr(String in){
int end=0;
StringBuilder stb=new StringBuilder();
for (int i=0;i2019.9.7修改完善版：使用两个栈 leetcode测试通过
public String decodeString(String s) {
Stack multi_stack = new Stack<>();
Stackstring_stack = new Stack<>();
StringBuffer res = new StringBuffer();
int multi = 0;
for (int i=0;i='0'&&s.charAt(i)<='9'){
multi = multi * 10 + Integer.parseInt(s.charAt(i) + ""); //用来解决十位数以上的情况
}
else if (s.charAt(i)=='['||s.charAt(i)=='{'||s.charAt(i)=='('){
string_stack.push(res.toString());
multi_stack.push(String.valueOf(multi));
multi =0;
res = new StringBuffer();
}
else if (s.charAt(i)==']'||s.charAt(i)=='}'||s.charAt(i)==')'){
StringBuffer tmp = new StringBuffer();
int cur_multi = Integer.parseInt(multi_stack.pop());
for (int j=0;j 2019.9.7 递归版本
class Solution {
Stackstack = new Stack<>(); //单纯是用来存储下一个括号的下标
public String decodeString(String s) {
return decodeString(s,0);
}
//事实上也可以自定义一个Pair类，包含(StringBuffer,index),这里就不在累述
public String decodeString(String s,int index) {
StringBuffer res = new StringBuffer();
int multi = 0;
char cArray [] = s.toCharArray();
for (int i=index;i='0'&&c<='9'){
multi = multi*10+c-'0';
}
else if (c=='['||c=='{'||c=='('){
String in = decodeString(s,i+1);
while (multi!=0){
res.append(in);
multi--;
}
i=stack.pop();
}
else if (c==']'||c=='}'||c==')'){
stack.push(i);
return res.toString();
}
else res.append(c);
}
return res.toString();
}
} 题目三：
题目三
题目描述：在N*M的地图上，每个点的海拔不同，从当前位置只能访问上下左右四个点且是没有访问过的点，此外下一步选择的点的海拔必须大于当前点。求从点A到点B一共有多少条路径，输出路数总数取余109109 10^9109。左上角的坐标为（0,0），右下角的坐标为（N-1,M-1）
测试用例：
输入：第一行为地图大小，下面n行为每个点的海拔，最后一行前两个为A坐标（x,y）,后两个为B坐标（z,v）
4 5
0 1 0 0 0
0 2 3 0 0
0 0 4 5 0
0 0 7 6 0
0 1 3 2
123456
输出：
2
---------------------
（递归）and 记忆化搜索法：
//该版本没有标记是否isVisited
package IMUHERO;
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner =new Scanner(System.in);
int n=scanner.nextInt();//标记行数
int m=scanner.nextInt();//标记列数
int highMount[][]=new int[n][m];
for (int i=0;i=0 &&i=0 &&j=0 &&i=0 &&jh[i][j]){
a=findPath(h,end,i+1,j,n,m,memo);
}
if (i>=0 &&i=0 &&j0 &&h[i-1][j]>h[i][j]){
b=findPath(h,end,i-1,j,n,m,memo);
}
if (i>=0 &&i=0 &&jh[i][j]){
c=findPath(h,end,i,j+1,n,m,memo);
}
if (i>=0 &&i=0 &&j0 &&h[i][j-1]>h[i][j]){
d=findPath(h,end,i,j-1,n,m,memo);
}
memo[i][j]=a+b+c+d;
return a+b+c+d;
}
}
2019.9.7修改完善版：
public class climpUpMap {
static int move[][] = {{-1,0},{0,1},{1,0},{0,-1}};
static int memo[][] ;
static boolean[][] isVisited;
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int rows = scanner.nextInt();
int cols = scanner.nextInt();
int [][] map = new int[rows][cols];
isVisited = new boolean[rows][cols];
memo = new int[rows][cols];
for (int i=0;i=map[x1][y1]){
System.out.println(0);
}
else {
countPath(map,x0,y0,x0,y0,x1,y1);
System.out.println(memo[x0][y0]);
}
}
private static int countPath(int [][] map ,int i,int j,int x0,int y0,int x1,int y1){
if (map[i][j]==map[x1][y1]){
return 1;
}
if (memo[i][j]!=0){
return memo[i][j];
}
isVisited[i][j] = true;
int count = 0;
for (int k=0;k<4;k++){
int newI = i+move[k][0];
int newJ = j+move[k][1];
if (newI>=0&&newI=0&&newJmap[i][j] ){
count +=countPath(map,newI,newJ,x0,y0,x1,y1)%109109;
isVisited[newI][newJ]=false;
}
}
memo[i][j] = count;
return memo[i][j];
}
}
华为笔试2019.9.7笔试题反思
第一题
输入一个数组
[ 8,7,1,2,3,4,5,2,2,5,6];
第一个数可以取[1-len/2]，然后这个数作为下标a
接下去的数是a的值arr[a]，以这个值为步数，往后走arr[a]步
求最少走多少步可以到达终点
以上数组的答案是：3
8 -> 7 ->2 ->6
解答：
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String s = scanner.nextLine();
String[] c = s.split(" ");
int res = s.length();
int tmp = -1;
if (c.length==1){
System.out.println(1);
}
else {
for (int i=1;i第二题
题目描述
dota游戏里面，召唤师可以控制冰雷火三种元素，并通过元表组合产生新的技能。现在我们修改了一张新的地图，地图中他能够控制n种元素，并且将m个元青围成-个圈组成个新技能(这m个元素通过旋转或反转，算作重复，如123、231、 312、 321、213、132都算重复) ,那么召唤师能组台多少技能
(2000>=n>=1 ,1<=m<=10000 ,由于结果可能很大，请将结果对00000007取余
输入描述:
n和m
输出描述:
组合的技能数
如：
输入：3,3
输出：[[1, 1, 1], [1, 1, 2], [1, 1, 3], [1, 2, 2], [1, 2, 3], [1, 3, 3], [2, 2, 2], [2, 2, 3], [2, 3, 3], [3, 3, 3]]
解答：（未通过，还没想到解决办法）
package IMUHERO;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
public class Main {
static LinkedList>res = new LinkedList<>();
static int count=0;
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int k = scanner.nextInt();
if (n==0||k==0) System.out.println(0);
else {
LinkedListlist = new LinkedList<>();
Combine(n,k,1,list);
System.out.println(res);
System.out.println(count);
}
}
private static void Combine(int n,int k,int start,LinkedListlist){
if (list.size()==k){
res.addLast((LinkedList)list.clone());
count = (count+1)%1000000007;
return;
}
for (int i=start;i<=n;i++){
list.addLast(i);
Combine(n,k,i,list);
list.removeLast();
}
return;
}
}
2019/9/12 使用ploya算法解决
package IMUHERO;
//华为第二题
import java.util.Scanner;
public class Main4 {
static int c ,s;
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()){
c = scanner.nextInt();
s = scanner.nextInt();
long ans = polya();
System.out.println(ans);
}
}
static int gcd(int a,int b){
return b==0?a:gcd(b,a%b);
}
static long polya(){
int i,j;
long ans =0;
for (i=0;i第三题
.题目描述
通讯行业上经常使用指标来记录某地区的业务数据，如小区用户切换请求次数的指标，小区用户切换请求成功次数的指标等。指标按类型分为基础指标和复杂指标。其中复杂指标由基础指标计算而来
如:小区用户切换成功率为复杂指标，计算公式为:小区用户切换成功率=小区用户切换请求成功次数/小区用户切换次数* 100;现在给每个指标赋予一个唯HD来替代中文描述， 使用中括号[括起来，对于公式中的常量则使用大括号0括起来;
如小区用户切换成率指标ID-1123654]、小区用户切换请求成功次数指标1D-|6598]、小区用户切换次数指标D-(6665]上述小区用户切换成功率公式可以表示为:[123654)-16598] 6665](100
要求:输入组复杂指标的计算公式以及公式中包含的基础指标的值，计算出指定指标的值并返回;
输入
[1234]=[12]+[34]*{50},[12]=[1]+[2]/{2};[1]=10,[2]=20,[34]=50;[1234]
输出：
[1234]的计算结果：2520
package IMUHERO;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Scanner;
//[1234]=[12]+[34]*{50},[12]=[1]+[2]/{2};[1]=10,[2]=20,[34]=50;[1234]
public class Main1 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String s = scanner.nextLine();
String [] sArr = s.split(";");
String [] GS = sArr[0].split(",");
String [] KV = sArr[1].split(",");
String [] Value = sArr[2].split("");
HashMap map = new HashMap();
for (int i=0;i=0;i--){
String [] keyValue = GS[i].split("=");
String key = keyValue[0].substring(1,keyValue[0].length()-1);
LinkedListlist = new LinkedList<>();
String val = keyValue[1];
for (int m=0;m
帆软笔试（范围区间内数组的最大乘积）
一、范围区间内数组的最大乘积
输入：
-3 -5 2 -4
输出
30
解析：
index从0-2,-3*-5*2=30，是连续范围内乘积最大的区间
package IMUHERO;
import java.util.Scanner;
public class Main {
private static int max3(int a,int b,int c){
return Math.max(a,Math.max(b,c));
}
private static int min3(int a,int b,int c){
return Math.min(a,Math.min(b,c));
}
private static int maxMultiply(int [] arr){
//数组长度为0最开始已经判断过，此处不需要担心
int [] maxArr = new int[arr.length];
int [] minArr = new int[arr.length];
maxArr[0] = 0;
minArr[0] = 0; //用来对负数进行处理
int res = arr[0];
for (int i=1;i360笔试题（2019/8/31）
一、寻找子串
题目有漏洞，只要判断重复的字符个数即可得出答案，直接上代码
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String s = scanner.nextLine();
TreeMap map = new TreeMap<>();
int len = s.length();
int count = 0;
for (int i = 0;icount)count=curCount+1;
}
}
System.out.println(count);
} 二、散步
解法一：
从前往后的dfs
package IMUHERO;
import java.util.Scanner;
import java.util.TreeSet;
public class Main{
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int N = scanner.nextInt();
int mes = scanner.nextInt();
int [] arr = new int[mes];
for (int i = 0;iset = new TreeSet<>(); //使用TreeSet用来去除终点重复的情况
for (int s=1;s<=N;s++){
dfs(arr,0,s,set,N);
}
System.out.println(set.size());
}
//从前往后的算法：
private static void dfs(int[]arr,int i,int s,TreeSetset,int N){
if (i==arr.length){
set.add(s);
return ;
}
if (s+arr[i]<=N){
dfs(arr,i+1,s+arr[i],set,N);
}
if (s-arr[i]>=1){
dfs(arr,i+1,s-arr[i],set,N);
}
}
} 解法二：
从后往前的算法：
package IMUHERO;
import java.util.Scanner;
import java.util.TreeSet;
public class Main{
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int N = scanner.nextInt();
int mes = scanner.nextInt();
int [] arr = new int[mes];
for (int i = 0;i=1){
if (dfs2(arr,index-1,e-arr[index],N))
return true;//剪枝，有一个成功就返回true
}
if (e+arr[index]<=N){
if (dfs2(arr,index-1,e+arr[index],N))
return true;//剪枝，有一个成功就返回
}
return false;//以上都不满足，直接返回false
}
}
科大讯飞笔试（2019/9/12）
第一题
两个大整数相加：
（据说是两行输入，但是题目实例给的是一行，无语......
不想改了，含义是一行的，只是Scanner有所不同而已）
package IMUHERO;
import java.util.Scanner;
public class Mainkeda {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String s = scanner.nextLine(); //一行内输入两个长数字
String[]sArr =s.split(" ");
String s1 = sArr[0];
char[] c1 = s1.toCharArray();
String s2 = sArr[sArr.length-1];
char[] c2 = s2.toCharArray();
int carry = 0;
int [] res = new int[Math.max(c1.length,c2.length)+1];
// int i=Math.max(c1.length,c2.length)-1;
int i=0;
for (;i=10)?1:0;
}
if (carry==1){
res[i+1]=carry;
}
for (int j=0;j 第二题：
输入：aabb
输出：2a2b
注：只含有一个字符不用输出数字，如：aabbc = > 2a2bc
package IMUHERO;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String s = scanner.nextLine();
if (s.length()==0||s==null) System.out.println("");
else {
StringBuilder stb = new StringBuilder();
for (int i=0;i