贝壳笔试2019/8/10

秋招：试卷只有4个笔试题，其他题型没有

ac:100 27 36 27

第一道

给出n个正整数，要求找出相邻两个数字中差的绝对值最小的一对数字，如果有差的绝对值相同的，则输出最前面的一对数。

2<n<=100，正整数都在10^16范围内

输入
输入包含2行，第一行为n，第二行是n个用空格分隔的正整数。

输出
输出包含一行两个正整数，要求按照原来的顺序输出

样例输入
9
1 3 4 7 2 6 5 12 32
样例输出
3 4

import java.util.Scanner;

public class First {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		long a,b,abs = 10000000000000000l,x = 0,y = 0;
		a = sc.nextLong();
		for(int i = 0; i < n - 1; i++) {
			b = sc.nextLong();
			if(Math.abs(b -a) < abs) {
				x = a;
				y = b;
				abs = Math.abs(b -a);
			}
			a = b;
		}
		
		System.out.println(x + " " + y);
	}
	
}

第二道

小希偶然得到了传说中的月光宝盒,然而打开月光宝盒需要一串密码。虽然小希并不知道密码具体是什么，
但是月光宝盒的说明书上有着一个长度为 n (2 <= N <= 50000)的序列 a (-10^9 <= a[i] <= 10^9)的范围内。
下面写着一段话：密码是这个序列的最长的严格上升子序列的长度(严格上升子序列是指，子序列的元素是严格递增的，
例如: [5,1,6,2,4]的最长严格上升子序列为[1,2,4])，请你帮小希找到这个密码。

输入
第1行：1个数N，N为序列的长度(2<=N<=50000)

第2到 N+1行：每行1个数，对应序列的元素(-10^9 <= a[i] <= 10^9)

输出
一个正整数表示严格最长上升子序列的长度

样例输入
8
5
1
6
8
2
4
5 
10
样例输出
5

第一次：忘了是思路错了，还是咋了，忘记了。。。总而言之，有问题

import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class Second {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int[] arra = new int[n];
		for(int i = 0; i < n; i++) {
			arra[i] = sc.nextInt();
		}
		Set<Integer> set = new HashSet<Integer>();
		int lastNum,size = 0,count = 0;
		for(int i = 0; i < n; i++) {
			if(set.contains(i)) {
				continue;
			}
			set.add(i);
			
			lastNum = arra[i];
			count = 1;
			for(int j = i + 1; j < n; j++) {
				if(lastNum < arra[j] && (!set.contains(j))) {
					lastNum = arra[j];
					set.add(j);
					count++;
				}
			}
			size = size > count? size : count;
		}
		
		System.out.println(size);
	}
	
}

第二次：

import java.util.Scanner;

public class Second2 {
	
	private static int size = 0;
	private static int[] arra;

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		arra = new int[n];
		for(int i = 0; i < n; i++) {
			arra[i] = sc.nextInt();
		}
		
		for(int i = 0; i < n; i++) {
			func(i,1);
		}
		
		
		System.out.println(size);
		
	}
	
	public static void func(int a,int count) {
		if(a + 1 == arra.length) {
			size = size < count ? count : size;
		}
		
		for(int i = a + 1; i < arra.length; i++) {
			if(arra[a] < arra[i]) {
				func(i, count + 1);
			}
		}
	}
	
}

第三道

举重大赛开始了，为了保证公平，要求比赛的双方体重较小值要大于等于较大值的90%，那么对于这N个人最多能进行多少场比赛呢，任意两人之间最多进行一场比赛。

输入
第一行N，表示参赛人数（2<=N<=10^5）

第二行N个正整数表示体重（0<体重<=10^8）

输出
一个数，表示最多能进行的比赛场数

样例输入
5
1 1 1 1 1
样例输出
10

import java.util.Arrays;
import java.util.Scanner;

public class Third {
	
	private static int count = 0;

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		long[] arra = new long[n];
		for(int i = 0; i < n; i++) {
			arra[i] = sc.nextInt();
		}
		Arrays.sort(arra);
		full(arra.length - 1,arra);
		System.out.println(count);
		
	}
	
	public static void full(int a, long[] arra) {
		if(a == 0) {
			return ;
		}
		
		float x = arra[a] * 0.9f;
		for(int i = a - 1; i >= 0; i--) {
			if(arra[i] >= x) {
				count++;
			} else {
				break;
			}
		}
		
		full(a - 1, arra);
		
	}
	
}

第四道

小C在做一种特殊的服务器负载测试，对于一个请求队列中的请求，每一个请求都有一个负荷值，为了保证服务器稳定，请求队列中的请求负荷必须按照先递增后递减的规律(仅递增，仅递减也可以)，比如[ 1，2，8，4，3 ]，[ 1，3，5 ]和[ 10 ]这些是满足规律的，还有一些不满足的，比如[ 1，2，2，1 ]，[ 2，1，2 ]和[ 10，10 ]。现在给你一个请求队列，你可以对请求的负荷值进行增加，要求你调整队列中请求的负荷值，使数组满足条件。最后输出使队列满足条件最小的增加总和。

输入
输入有两行，第一行是N (1≤n≤5000) ，代表请求队列中的请求数量。

第二行有N个数字 a1,a2…an  (1≤ai≤10^9)。Ai是第i个请求的负荷值。

输出
输出这个最小增加总和

样例输入
5
1 4 3 2 5
样例输出
6

提示
样例解释，此时合法队列为[1,4,5,6,5]，最小增加和为6

代码略。。。。