网易2018秋招Java开发岗编程题

最新推荐文章于 2022-05-08 10:45:21 发布

menghefang

最新推荐文章于 2022-05-08 10:45:21 发布

阅读量370

点赞数

分类专栏：算法/数据结构/AC题文章标签：网易编程 java

本文链接：https://blog.csdn.net/menghefang/article/details/77651925

版权

算法/数据结构/AC题专栏收录该内容

1 篇文章 0 订阅

订阅专栏

网易2018秋招Java开发岗编程题

疯狂队列

时间限制：1秒
空间限制：32768K
小易老师是非常严厉的,它会要求所有学生在进入教室前都排成一列,并且他要求学生按照身高不递减的顺序排列。有一次,n个学生在列队的时候,小易老师正好去卫生间了。
学生们终于有机会反击了,于是学生们决定来一次疯狂的队列,他们定义一个队列的疯狂值为每对相邻排列学生身高差的绝对值总和。由于按照身高顺序排列的队列的疯狂值是最小的,
他们当然决定按照疯狂值最大的顺序来进行列队。现在给出n个学生的身高,请计算出这些学生列队的最大可能的疯狂值。小易老师回来一定会气得半死。
输入描述:
输入包括两行,第一行一个整数n(1 ≤ n ≤ 50),表示学生的人数
第二行为n个整数h[i](1 ≤ h[i] ≤ 1000),表示每个学生的身高

输出描述:
输出一个整数,表示n个学生列队可以获得的最大的疯狂值。

如样例所示:
当队列排列顺序是: 25-10-40-5-25, 身高差绝对值的总和为15+30+35+20=100。
这是最大的疯狂值了。

输入例子1:
5
5 10 25 40 25

输出例子1:
100

public class CrazyQueue {
	public static void main(String[] args){
		Scanner scanner = new Scanner(System.in);
		int size = Integer.parseInt(scanner.nextLine().trim());
		String strh = scanner.nextLine();
		String[] strhcut = strh.split("\\s");
		int[] h = new int[size];
		for(int i=0;i<size;i++){
			h[i] = Integer.parseInt(strhcut[i]);
		}
		BubbleSortH(h,size);
		MaxGap(h,size);
	}
	
	private static void MaxGap(int[] h,int size){
		int p = (int) Math.ceil(size/2);
		int q = p+1;
		int m = 0,n = size-1;
		
		
	}
	
	private static void BubbleSortH(int[] h,int size){
		int temp;
		for(int i=0;i<size;i++){
			for(int j=0;j<size-i-1;j++)
			{
				if(h[j]>h[j+1]){
					temp = h[j+1];
					h[j+1] = h[j];
					h[j] = temp;
				}
			}
		}

	}

}

交错01串

时间限制：1秒
空间限制：32768K
如果一个01串任意两个相邻位置的字符都是不一样的,我们就叫这个01串为交错01串。例如: “1”,“10101”,"0101010"都是交错01串。
小易现在有一个01串s,小易想找出一个最长的连续子串,并且这个子串是一个交错01串。小易需要你帮帮忙求出最长的这样的子串的长度是多少。
输入描述:
输入包括字符串s,s的长度length(1 ≤ length ≤ 50),字符串中只包含’0’和’1’

输出描述:
输出一个整数,表示最长的满足要求的子串长度。

输入例子1:
111101111

输出例子1:
3

public class zichuan {
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		String str = sc.nextLine();
		int size = 1;
		int maxsize = 0;
		//匹配01这样的子串，或者10
		char [] stringArr = str.toCharArray(); //注意返回值是char数组
		for(int i = 0;i<str.length();i++){
			for(int j = i+1;j<str.length();j++){
				if(stringArr[j-1] != stringArr[j]){
					size++;
					if (j == str.length()-1){
						if(size > maxsize)
							maxsize = size;
						size = 0;
						break;
					}
					continue;
				}
				else
					if(size > maxsize)
						maxsize = size;
					size = 1;
			}
		}
		if(size > maxsize)
			maxsize = size;
		System.out.println(maxsize);	
	}
}

等差数列

时间限制：1秒
空间限制：32768K
如果一个数列S满足对于所有的合法的i,都有S[i + 1] = S[i] + d, 这里的d也可以是负数和零,我们就称数列S为等差数列。
小易现在有一个长度为n的数列x,小易想把x变为一个等差数列。小易允许在数列上做交换任意两个位置的数值的操作,并且交换操作允许交换多次。但是有些数列通过交换还是不能变成等差数列,小易需要判别一个数列是否能通过交换操作变成等差数列
输入描述:
输入包括两行,第一行包含整数n(2 ≤ n ≤ 50),即数列的长度。
第二行n个元素x[i](0 ≤ x[i] ≤ 1000),即数列中的每个整数。

输出描述:
如果可以变成等差数列输出"Possible",否则输出"Impossible"。

输入例子1:
3
3 1 2

输出例子1:
Possible

public class dengcha {

	public static void main(String[] args){
		
		Scanner sc = new Scanner(System.in);
		
		int length = Integer.parseInt(sc.nextLine().trim());
		String strb = sc.nextLine();
		String[] strbcut = strb.split("\\s");
		int[] b =new int[length];          
		for (int m = 0; m < length; m++) {  
		    b[m] = Integer.parseInt(strbcut[m]);//将字符串数组转换成int数组  
		}  
        isOrNot(b);
        sc.close();   	
	}
	private static void Sort(int[] b){
		int temp=0;  
        for (int i = 0; i < b.length; i++) {  
            for (int j = 0; j < b.length-i-1; j++) {  
                if(b[j]>b[j+1]){  
                    temp=b[j];  
                    b[j]=b[j+1];  
                    b[j+1]=temp;  
                }  
            }  
        }
	}
	private static void isOrNot(int[] b){		       
        int dengcha = 0;
        int cha;
        for(int j = 1;j<b.length;j++){
        	if (j == 1)
        		dengcha = b[j] - b[j-1];
        	cha = b[j] - b[j-1];
        	if(cha == dengcha)
        		continue;
        	else{
        		System.out.print("Impossible");
        		System.exit(0);
        	}  		
        }
        System.out.print("Possible");
	}
}

独立的小易

时间限制：1秒
空间限制：32768K
小易为了向他的父母表现他已经长大独立了,他决定搬出去自己居住一段时间。一个人生活增加了许多花费: 小易每天必须吃一个水果并且需要每天支付x元的房屋租金。当前小易手中已经有f个水果和d元钱,小易也能去商店购买一些水果,商店每个水果售卖p元。小易为了表现他独立生活的能力,希望能独立生活的时间越长越好,小易希望你来帮他计算一下他最多能独立生活多少天。
输入描述:
输入包括一行,四个整数x, f, d, p(1 ≤ x,f,d,p ≤ 2 * 10^9),以空格分割

输出描述:
输出一个整数, 表示小易最多能独立生活多少天。

输入例子1:
3 5 100 10

输出例子1:
11

public class days {

	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		int x = sc.nextInt();
		int f = sc.nextInt();
		int d = sc.nextInt();
		int p = sc.nextInt();
		int days = maxlive(x,f,d,p);
		System.out.println(days);
	}
	
	public static int maxlive(int x,int f,int d,int p){
		int day = 0;
		if(f>d/x)
			day = d/x;
		else
			day = (d-f*x)/(p+x)+f;
		return day;
		
	}
}

操作序列

时间限制：2秒
空间限制：32768K
小易有一个长度为n的整数序列,a_1,…,a_n。然后考虑在一个空序列b上进行n次以下操作:
1、将a_i放入b序列的末尾
2、逆置b序列
小易需要你计算输出操作n次之后的b序列。
输入描述:
输入包括两行,第一行包括一个整数n(2 ≤ n ≤ 2*10^5),即序列的长度。
第二行包括n个整数a_i(1 ≤ a_i ≤ 10^9),即序列a中的每个整数,以空格分割。

输出描述:
在一行中输出操作n次之后的b序列,以空格分割,行末无空格。

输入例子1:
4
1 2 3 4

输出例子1:
4 2 1 3

public class nizhixulie {
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		int size = Integer.parseInt(sc.nextLine().trim());
		String stra = sc.nextLine();
		String[] strcut = stra.split("\\s");//用空格将其分割成字符串数组  
		int[] a_i =new int[size];  
		
		for (int m = 0; m < size; m++) {  
			a_i[m] = Integer.parseInt(strcut[m]);//将字符串数组转换成int数组  
		}
        reverseArray(a_i);
        PrintB(size,a_i);
	}
	private static void reverseArray(int[] a) {
		int i = 0, n = a.length-1;
		while (n > 2 * i) {
			int temp = a[i];
			a[i] = a[n - i];
			a[n - i] = temp;
			i++;
		}
	}
	private static void PrintB(int size,int[] a_i){
		int p = 0,q = size -1;
		int[] b =new int[size];
		
        for(int t = 0;t < size;t+=2){
        	b[p] = a_i[t];
        	if(t+1<size){
        		b[q] = a_i[t+1];
        	}
        	if(p == q)
        		break;
        	p++;
        	q--;  	
        }
        for(int i = 0;i < size;i++){
        	System.out.print(b[i]);
        	if(i!=size-1)
        		System.out.print(" ");
        }	
	}
}

彩色的砖块

时间限制：1秒
空间限制：32768K
小易有一些彩色的砖块。每种颜色由一个大写字母表示。各个颜色砖块看起来都完全一样。现在有一个给定的字符串s,s中每个字符代表小易的某个砖块的颜色。小易想把他所有的砖块排成一行。如果最多存在一对不同颜色的相邻砖块,那么这行砖块就很漂亮的。请你帮助小易计算有多少种方式将他所有砖块排成漂亮的一行。(如果两种方式所对应的砖块颜色序列是相同的,那么认为这两种方式是一样的。)
例如: s = “ABAB”,那么小易有六种排列的结果:
“AABB”,“ABAB”,“ABBA”,“BAAB”,“BABA”,“BBAA”
其中只有"AABB"和"BBAA"满足最多只有一对不同颜色的相邻砖块。
输入描述:
输入包括一个字符串s,字符串s的长度length(1 ≤ length ≤ 50),s中的每一个字符都为一个大写字母(A到Z)。

输出描述:
输出一个整数,表示小易可以有多少种方式。

输入例子1:
ABAB

输出例子1:
2

public class zhuan {
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		String str = sc.nextLine();
		Map<Character,Integer> map=new HashMap<Character,Integer>();		
		for (int i = 0; i < str.length(); i++) 
		{            
			char item =  str.charAt(i);  
			Integer count=map.get(item);
			if(count == null)
		        count=1;
			map.put(item,count);  			           
		}

		int length = map.values().size();
		if(length == 1){
			System.out.println(1);
		}else if(length == 2){
			System.out.println(2);
		}else{
			System.out.println(0);
		}		
	}
}

堆棋子

时间限制：1秒
空间限制：32768K
小易将n个棋子摆放在一张无限大的棋盘上。第i个棋子放在第x[i]行y[i]列。同一个格子允许放置多个棋子。每一次操作小易可以把一个棋子拿起并将其移动到原格子的上、下、左、右的任意一个格子中。小易想知道要让棋盘上出现有一个格子中至少有i(1 ≤ i ≤ n)个棋子所需要的最少操作次数.

输入描述:
输入包括三行,第一行一个整数n(1 ≤ n ≤ 50),表示棋子的个数
第二行为n个棋子的横坐标x[i](1 ≤ x[i] ≤ 10^9)
第三行为n个棋子的纵坐标y[i](1 ≤ y[i] ≤ 10^9)

输出描述:
输出n个整数,第i个表示棋盘上有一个格子至少有i个棋子所需要的操作数,以空格分割。行末无空格

如样例所示:
对于1个棋子: 不需要操作
对于2个棋子: 将前两个棋子放在(1, 1)中
对于3个棋子: 将前三个棋子放在(2, 1)中
对于4个棋子: 将所有棋子都放在(3, 1)中

输入例子1:
4
1 2 4 9
1 1 1 1

输出例子1:
0 1 3 10

menghefang

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
网易2018秋招Java开发岗编程题

网易2018秋招Java开发岗编程题疯狂队列时间限制：1秒空间限制：32768K 小易老师是非常严厉的,它会要求所有学生在进入教室前都排成一列,并且他要求学生按照身高不递减的顺序排列。有一次,n个学生在列队的时候,小易老师正好去卫生间了。学生们终于有机会反击了,于是学生们决定来一次疯狂的队列,他们定义一个队列的疯狂值为每对相邻排列学生身高差的绝对值总和。由于按照身高顺序排列的队列的疯狂值是
复制链接

扫一扫