网易2019实习生招聘编程题

一、牛牛找工作

为了找到自己满意的工作，牛牛收集了每种工作的难度和报酬。牛牛选工作的标准是在难度不超过自身能力值的情况下，牛牛选择报酬最高的工作。在牛牛选定了自己的工作后，牛牛的小伙伴们来找牛牛帮忙选工作，牛牛依然使用自己的标准来帮助小伙伴们。牛牛的小伙伴太多了，于是他只好把这个任务交给了你。

输入描述:

每个输入包含一个测试用例。
每个测试用例的第一行包含两个正整数，分别表示工作的数量N(N<=100000)和小伙伴的数量M(M<=100000)。
接下来的N行每行包含两个正整数，分别表示该项工作的难度Di(Di<=1000000000)和报酬Pi(Pi<=1000000000)。
接下来的一行包含M个正整数，分别表示M个小伙伴的能力值Ai(Ai<=1000000000)。
保证不存在两项工作的报酬相同。

输出描述:

对于每个小伙伴，在单独的一行输出一个正整数表示他能得到的最高报酬。一个工作可以被多个人选择。

输入例子1:

3 3 
1 100 
10 1000 
1000000000 1001 
9 10 1000000000

输出例子1:

100 
1000 
1001

代码：

未通过，至今未找到错误，欢迎点评。

public class LookForWork{

	public static void main(String[] args){
		java.util.Scanner scanner=new java.util.Scanner(System.in);
		//System.out.println("please input work sum N and friends M");
		int N=scanner.nextInt();//工作总量
		int M=scanner.nextInt();//朋友数量
		int[] Di=new int[N];//记录工作难度
		int[] Pi=new int[N];//记录报酬
		int[] Ai=new int[M];//朋友能力
		//System.out.println("please input degree Di and reward Pi:");
		for(int i=0;i<N;i++){
			Di[i]=scanner.nextInt();
			Pi[i]=scanner.nextInt();
		}
		//System.out.println("please input degree:");
		for(int j=0;j<M;j++)
			Ai[j]=scanner.nextInt();
		for(int i=0;i<N-1;i++){
			for(int j=i+1;j<N;j++){
				if(Di[i]>Di[j]){
					int flag=Di[i];
					Di[i]=Di[j];
					Di[j]=flag;
					int flag1=Pi[i];
					Pi[i]=Pi[j];
					Pi[j]=flag1;
				}
			}
		}
		for(int i=0;i<N-1;i++){
			for(int j=i+1;j<N;j++){
				if(Pi[i]==Pi[j])
					return;
			}
		}
		for(int i=0;i<M;i++){
			if(Ai[i]<Di[0])
				break;
			for(int j=1;j<N;j++){
				if(Ai[i]<Di[j]){					
					System.out.println(maxPi(Pi,j-1));
					break;
				}
				if(j==N-1)
					System.out.println(maxPi(Pi,N-1));
			}
		}
	}
	public static int maxPi(int[]a,int m){
		int flag=0;
		for(int i=0;i<=m;i++){
			if(flag<a[i]){
				flag=a[i];
			}
		}
		return flag;
	}
}

二、被三整出

时间限制：1秒

空间限制：32768K

小Q得到一个神奇的数列: 1, 12, 123,...12345678910,1234567891011...。

并且小Q对于能否被3整除这个性质很感兴趣。

小Q现在希望你能帮他计算一下从数列的第l个到第r个(包含端点)有多少个数可以被3整除。 

输入描述:

输入包括两个整数l和r(1 <= l <= r <= 1e9), 表示要求解的区间两端。

输出描述:

输出一个整数, 表示区间内能被3整除的数字个数。

输入例子1:

2 5

输出例子1:

3

例子说明1:

12, 123, 1234, 12345...
其中12, 123, 12345能被3整除。

代码：

注释掉的是超时的。

public class DivideForThree{

	/*public static void main(String[] args){
		//System.out.println("please input section N and M");
		java.util.Scanner scanner=new java.util.Scanner(System.in);
		int N=scanner.nextInt();
		int M=scanner.nextInt();
		while(M<N)
			return;
		String[] str=new String[M+100];
		int[] record=new int[M+100];
		String str1="";
		for(int i=1;i<=N;i++){
			str1+=i;
		}
		int flag=0;
		str[N]=str1;
		record[N]=Integer.parseInt(str1);
		if(record[N]%3==0)
			flag++;
		for(int i=N+1;i<=M;i++){
			str[i]=str[i-1]+i;
			record[i]=Integer.parseInt(str[i]);
			if(record[i]%3==0)
				flag++;
		}
		System.out.println(flag);
	}
	*/
	public static void main(String[] args){
		java.util.Scanner scanner=new java.util.Scanner(System.in);
		int N=scanner.nextInt();
		int M=scanner.nextInt();
		int flag=0;
		while(true){
			switch(N%3){
				case 0:
					flag++;
					N++;
					break;
				case 1:
					N++;
					break;
				case 2:
					flag++;
					N++;
					break;
				default:
					N++;
					break;
			}
			if(N>M)
				break;
		}
		System.out.println(flag);
	}
}

三、[编程题] 安置路灯

时间限制：1秒

空间限制：32768K

小Q正在给一条长度为n的道路设计路灯安置方案。

为了让问题更简单,小Q把道路视为n个方格,需要照亮的地方用'.'表示, 不需要照亮的障碍物格子用'X'表示。

小Q现在要在道路上设置一些路灯, 对于安置在pos位置的路灯, 这盏路灯可以照亮pos - 1, pos, pos + 1这三个位置。

小Q希望能安置尽量少的路灯照亮所有'.'区域, 希望你能帮他计算一下最少需要多少盏路灯。 

输入描述:

输入的第一行包含一个正整数t(1 <= t <= 1000), 表示测试用例数
接下来每两行一个测试数据, 第一行一个正整数n(1 <= n <= 1000),表示道路的长度。
第二行一个字符串s表示道路的构造,只包含'.'和'X'。

输出描述:

对于每个测试用例, 输出一个正整数表示最少需要多少盏路灯。

输入例子1:

2
3
.X.
11
...XX....XX

输出例子1:

1
3

代码：

public class LandLamp{

	public static void main(String[] args){
		java.util.Scanner scanner=new java.util.Scanner(System.in);
		int sum=scanner.nextInt();//测试用例
		while(sum>0){
			int flag=0;
			int landLength=scanner.nextInt();//道路长度
			//接收nextInt结束时的enter，做为nextLine的接收符。
			scanner.nextLine();
			String str=scanner.nextLine();//输入道路情况
			for(int i=0;i<str.length();){
				if(str.charAt(i)=='.'){
					flag++;
					i=i+3;
					continue;
				}
				if(str.charAt(i)=='X'){
					i=i+1;
				}
			}
			System.out.println(flag);
			sum--;
		}
	}
}

四、[编程题] 迷路的牛牛

时间限制：1秒

空间限制：32768K

牛牛去犇犇老师家补课，出门的时候面向北方，但是现在他迷路了。虽然他手里有一张地图，但是他需要知道自己面向哪个方向，请你帮帮他。

输入描述:

每个输入包含一个测试用例。
每个测试用例的第一行包含一个正整数，表示转方向的次数N(N<=1000)。
接下来的一行包含一个长度为N的字符串，由L和R组成，L表示向左转，R表示向右转。

输出描述:

输出牛牛最后面向的方向，N表示北，S表示南，E表示东，W表示西。

输入例子1:

3
LRR

输出例子1:

E

代码：

public class LoseRoad{

	public static void main(String[] args){
		java.util.Scanner scanner=new java.util.Scanner(System.in);
		int N=scanner.nextInt();
		String str=scanner.next();
		int left=0;
		int right=0;
		for(int i=0;i<N;i++){
			if(str.charAt(i)=='L'){
				left++;
			}
			else if(str.charAt(i)=='R'){
				right++;
			}
		}
		if(left>right){
			int flag=left-right;
			switch(flag%4){
				case 0:
					System.out.println("N");
					break;
				case 1:
					System.out.println("W");
					break;
				case 2:
					System.out.println("S");
					break;
				case 3:
					System.out.println("E");
					break;
				default:
					break;
			}
		}
		else if(left<right){
			int flag=right-left;
			switch(flag%4){
				case 0:
					System.out.println("N");
					break;
				case 1:
					System.out.println("E");
					break;
				case 2:
					System.out.println("S");
					break;
				case 3:
					System.out.println("W");
					break;
				default:
					break;
			}
		}
		else{
			System.out.println("N");
		}
	}
}

五、[编程题] 数对

时间限制：1秒

空间限制：32768K

牛牛以前在老师那里得到了一个正整数数对(x, y), 牛牛忘记他们具体是多少了。

但是牛牛记得老师告诉过他x和y均不大于n, 并且x除以y的余数大于等于k。

牛牛希望你能帮他计算一共有多少个可能的数对。 

输入描述:

输入包括两个正整数n,k(1 <= n <= 10^5, 0 <= k <= n - 1)。

输出描述:

对于每个测试用例, 输出一个正整数表示可能的数对数量。

输入例子1:

5 2

输出例子1:

7

例子说明1:

满足条件的数对有(2,3),(2,4),(2,5),(3,4),(3,5),(4,5),(5,3)

代码：

超时

public class DoubleNumber{

	public static void main(String[] args){
		java.util.Scanner scanner=new java.util.Scanner(System.in);
		int N=scanner.nextInt();
		int K=scanner.nextInt();
		if(K>=N)
			return;
		int flag=0;
		for(int i=K;i<=N;i++){
			for(int j=K;j<=N;j++){
				if(i<j){
					flag+=N-j+1;
					break;
				}
				if(i==j)
					continue;
				if((i>=j)&&(i%j)>=K){
					flag++;
				}
			}
		}
		System.out.println(flag);
	}
}

六、[编程题] 矩形重叠

时间限制：1秒

空间限制：32768K

平面内有n个矩形, 第i个矩形的左下角坐标为(x1[i], y1[i]), 右上角坐标为(x2[i], y2[i])。

如果两个或者多个矩形有公共区域则认为它们是相互重叠的(不考虑边界和角落)。

请你计算出平面内重叠矩形数量最多的地方,有多少个矩形相互重叠。 

输入描述:

输入包括五行。
第一行包括一个整数n(2 <= n <= 50), 表示矩形的个数。
第二行包括n个整数x1[i](-10^9 <= x1[i] <= 10^9),表示左下角的横坐标。
第三行包括n个整数y1[i](-10^9 <= y1[i] <= 10^9),表示左下角的纵坐标。
第四行包括n个整数x2[i](-10^9 <= x2[i] <= 10^9),表示右上角的横坐标。
第五行包括n个整数y2[i](-10^9 <= y2[i] <= 10^9),表示右上角的纵坐标。

输出描述:

输出一个正整数, 表示最多的地方有多少个矩形相互重叠,如果矩形都不互相重叠,输出1。

输入例子1:

2
0 90
0 90
100 200
100 200

输出例子1:

2

代码：

编译未通过，至今不知道哪错了，欢迎指教

public class OverLapTriangle{
/**
*解题思路：记录求所有点，分别落入了多少个矩形里面。最多的即为重叠最多的
*矩形数。利用暴力求解法。
*/
	public static void main(String[] args){
		java.util.Scanner sc=new java.util.Scanner(System.in);
		//输入矩形总数
		//System.out.println("please input n:");
		int n=sc.nextInt();
		//数组分别记录左下、右上的坐标
		int[] x1=new int[n];
		int[] y1=new int[n];
		int[] x2=new int[n];
		int[] y2=new int[n];
		//数组记录横纵做标点数
		int[] xsum=new int[2*n];
		int[] ysum=new int[2*n];
		//输入左下横坐标
		//System.out.println("x");
		for(int i=0;i<n;i++){
			x1[i]=sc.nextInt();
			//记录横坐标
			xsum[i]=x1[i];
		}
		//输入左下纵坐标
		//System.out.println("y");
		for(int i=0;i<n;i++){
			y1[i]=sc.nextInt();
			//纪录纵坐标
			ysum[i]=y1[i];
		}
		//输入右上横坐标
		//System.out.println("x");
		for(int i=0;i<n;i++){
			x2[i]=sc.nextInt();
			//纪录横坐标
			xsum[i+n]=x2[i];
		}
		//输入右上纵坐标
		//System.out.println("y");
		for(int i=0;i<n;i++){
			y2[i]=sc.nextInt();
			//纪录纵坐标
			ysum[i+n]=y2[i];
		}
		//System.out.println("ok");
		//遍历整个横纵数组，完美暴力。
		int record=0;
		for(int x:xsum){
			for(int y:ysum){
				int flag=0;
				for(int i=0;i<n;i++){
					if(x1[i]<x && y1[i]<y && x2[i]>x && y2[i]<y)
						flag++;
				}
				record=Math.max(record,flag);
			}
		}
		int flag1=0;
		for(int i=0;i<n-1;i++){
			int flag2=0;
			for(int j=i+1;j<n;j++){
				if((x1[i]==x1[j])&&(x2[i]==x2[j])&&(y1[i]==y1[j])&&(y2[i]==y2[j])){
					flag2++;
				}
			}
			flag1=Math.max(flag1,flag2);
		}
		record=Math.max(record,flag1);
		System.out.println(record+1);
	}
}

七、[编程题] 牛牛的闹钟

时间限制：1秒

空间限制：32768K

牛牛总是睡过头，所以他定了很多闹钟，只有在闹钟响的时候他才会醒过来并且决定起不起床。从他起床算起他需要X分钟到达教室，上课时间为当天的A时B分，请问他最晚可以什么时间起床

输入描述:

每个输入包含一个测试用例。
每个测试用例的第一行包含一个正整数，表示闹钟的数量N(N<=100)。
接下来的N行每行包含两个整数，表示这个闹钟响起的时间为Hi(0<=A<24)时Mi(0<=B<60)分。
接下来的一行包含一个整数，表示从起床算起他需要X(0<=X<=100)分钟到达教室。
接下来的一行包含两个整数，表示上课时间为A(0<=A<24)时B(0<=B<60)分。
数据保证至少有一个闹钟可以让牛牛及时到达教室。

输出描述:

输出两个整数表示牛牛最晚起床时间。

输入例子1:

3 
5 0 
6 0 
7 0 
59 
6 59

输出例子1:

6 0

代码：

public class ClockForSchool{

	public static void main(String[] args){
		java.util.Scanner sc=new java.util.Scanner(System.in);
		//输入闹钟数
		//System.out.println("输入闹钟数：");
		int n=sc.nextInt();
		//纪录时、分
		int[] hour=new int[n];
		int[] second=new int[n];
		//输入所定的闹钟的时间
		//System.out.println("输入所定的闹钟时间，时、分");
		for(int i=0;i<n;i++){
			hour[i]=sc.nextInt();
			second[i]=sc.nextInt();
		}
		//输入醒来后到教室的时间
		//System.out.println("输入到教室需要的时间：");
		int x=sc.nextInt();
		//输入上课时间
		//System.out.println("输入上课时间：");
		int A=sc.nextInt();
		int B=sc.nextInt();
		for(int i=0;i<n-1;i++){
			for(int j=i+1;j<n;j++){
				if(hour[i]>hour[j]){
					int hourSum=hour[i];
					hour[i]=hour[j];
					hour[j]=hourSum;
					int secondSum=second[i];
					second[i]=second[j];
					second[j]=secondSum;
				}
				if(hour[i]==hour[j]){
					if(second[i]>second[j]){
						int hourSum=hour[i];
						hour[i]=hour[j];
						hour[j]=hourSum;
						int secondSum=second[i];
						second[i]=second[j];
						second[j]=secondSum;
					}
				}
			}
		}
		int[] summax=new int[n];
		for(int i=0;i<n;i++){
			summax[i]=60*hour[i]+second[i]+x;
		}
		int max=A*60+B;
		int recond=0;
		for(int i=0;i<n;i++){
			if(max<summax[i]){
				recond=i-1;
				break;
			}
			if(i==n-1)
				recond=n-1;
		}
		System.out.println(hour[recond]+" "+second[recond]);		
	}
}