8.10晚贝壳笔试的四个算法题
1.输入一个数组，求相邻两个数差值绝对值的最小值，按原数组的顺序输出这两个数（用空格隔开）。（第一个题目没有复制题目，用自己的语言组织的）
输入描述:第一行输入数组的大小，第二行输入数组的各个值，用空格隔开
例如：
输入：5
2，4，3，7，5
输出：4 3
参考代码：
package com.lx.eurekaclient.action;
import java.util.Scanner;
/**
* @Description
* @auther lx
* @create 2019-08-10 19:04
*/
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n;
long[] m;
while(scanner.hasNextInt()){
n = scanner.nextInt();
m = new long[n];
for (int i = 0; i < n; i++) {
m[i] = scanner.nextLong();
}
System.out.println(numbersOfMin(n,m));
}
}
private static String numbersOfMin(int n, long[] m) {
long[] res = new long[2];
long min = Integer.MAX_VALUE;
for (int i = 0; i < n - 1; i++) {
if(Math.abs(m[i] - m[i+1]) < min){
min = Math.abs(m[i] - m[i+1]);
res[0] = m[i];
res[1] = m[i+1];
}
}
return res[0] + " " + res[1];
}
}
2.小希偶然得到了传说中的月光宝盒,然而打开月光宝盒需要一串密码。虽然小希并不知道密码具体是什么，但是月光宝盒的说明书上有着一个长度为 n (2 <= N <= 50000)的序列 a (-10^9 <= a[i] <= 10^9)的范围内。下面写着一段话：密码是这个序列的最长的严格上升子序列的长度(严格上升子序列是指，子序列的元素是严格递增的，例如: [5,1,6,2,4]的最长严格上升子序列为[1,2,4])，请你帮小希找到这个密码。
输入描述:第一行输入序列的大小，第二行输入序列的各个值，用空格隔开
输入描述:输出最长严格上升子序列的大小
例如：
输入 ： 8
5 1 6 8 2 4 5 10
输出： 5
参考代码：
package com.lx.eurekaclient.action;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
/**
* @Description
* 时间限制：C/C++语言 1000MS；其他语言 3000MS
* 内存限制：C/C++语言 131072KB；其他语言 655360KB
* 题目描述：
* 小希偶然得到了传说中的月光宝盒,然而打开月光宝盒需要一串密码。
* 虽然小希并不知道密码具体是什么，但是月光宝盒的说明书上有着一个长度为 n
* (2 <= N <= 50000)的序列 a (-10^9 <= a[i] <= 10^9)的范围内。下面写着一段话：密
* 码是这个序列的最长的严格上升子序列的长度(严格上升子序列是指，子序列的元素是严格
* 递增的，例如: [5,1,6,2,4]的最长严格上升子序列为[1,2,4])，请你帮小希找到这个密码。
*
* 输入 8
* 5 1 6 8 2 4 5 10
* 输出 5
* @auther lx
* @create 2019-08-10 19:04
*/
public class Main222 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n;
long[] m;
while(scanner.hasNextLong()){
n = scanner.nextInt();
m = new long[n];
for (int i = 0; i < n; i++) {
m[i] = scanner.nextLong();
}
System.out.println(lengthOfMax(n,m));
}
}
private static int lengthOfMax(int n, long[] m) {
List<Long> list = new ArrayList<>();
int max = 1;
list.add(m[0]);
for (int i = 1; i < n; i++) {
if(!list.isEmpty() && m[i] > list.get(list.size() - 1))
list.add(m[i]);
else{
max = Math.max(max,list.size());
while (!list.isEmpty() && m[i] <= list.get(list.size() - 1)){
list.remove(list.size()-1);
}
list.add(m[i]);
}
}
max = Math.max(max,list.size());
System.out.println("list = " + list);
return max;
}
}
3.举重大赛开始了，为了保证公平，要求比赛的双方体重较小值要大于等于较大值的90%，那么对于这N个人最多能进行多少场比赛呢，任意两人之间最多进行一场比赛。
输入描述:第一行输入比赛的人数，第二行输入比赛人数分别的体重值，用空格隔开
输入描述:输出最长严格上升子序列的大小
例如：
输入 ： 5
1 1 1 1 1
输出： 10
参考代码：
package com.lx.eurekaclient.action;
import java.util.Arrays;
import java.util.Scanner;
/**
* @Description
* 题目描述：
* 举重大赛开始了，为了保证公平，要求比赛的双方体重较小值要大于等于较大值的
* 90%，那么对于这N个人最多能进行多少场比赛呢，任意两人之间最多进行一场比赛。
* 输入 5
* 1 1 1 1 1
* 输出 10
* @auther lx
* @create 2019-08-10 19:04
*/
public class Main333 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n;
int[] m;
while(scanner.hasNextInt()){
n = scanner.nextInt();
m = new int[n];
for (int i = 0; i < n; i++) {
m[i] = scanner.nextInt();
}
System.out.println(count(n,m));
}
}
private static int count(int n, int[] m) {
int res = 0;
Arrays.sort(m);
for (int i = 0; i < n; i++) {
double temp = m[i]/0.9;
int j = i+1;
while(j < n && m[j] <= temp){
res++;
j++;
}
}
return res;
}
}
4.小C在做一种特殊的服务器负载测试，对于一个请求队列中的请求，每一个请求都有一个负荷值，为了保证服务器稳定，请求队列中的请求负荷必须按照先递增后递减的规律(仅递增，仅递减也可以)，比如[ 1，2，8，4，3 ]，[ 1，3，5 ]和[ 10 ]这些是满足规律的，还有一些不满足的，比如[ 1，2，2，1 ]，[ 2，1，2 ]和[ 10，10 ]。 现在给你一个请求队列，你可以对请求的负荷值进行增加，要求你调整队列中请求的负荷值，使数组满足条件。最后输出使队列满足条件最小的增加总和。
输入描述:第一行输入队列的大小，第二行输入队列的所有负荷值，用空格隔开
输入描述:输出满足条件最小的增加总和
例如：
输入 ： 5
2 5 3 2 4
输出： 6
参考代码：
package com.lx.eurekaclient.action;
import java.util.Scanner;
/**
* @Description
* 题目描述：
* 小C在做一种特殊的服务器负载测试，对于一个请求队列中的请求，
* 每一个请求都有一个负荷值，为了保证服务器稳定，请求队列
* 中的请求负荷必须按照先递增后递减的规律(仅递增，仅递减也可以)，
*比如[ 1，2，8，4，3 ]，[ 1，3，5 ]和[ 10 ]这些是满足规律的，
* 还有一些不满足的，比如[ 1，2，2，1 ]，[ 2，1，2 ]和[ 10，10 ]。
* 现在给你一个请求队列，你可以对请求的负荷值进行增加，
* 要求你调整队列中请求的负荷值，使数组满足条件。最后输出使队列满足条件最小的增加总和。
*
* 输入 5 2 5 3 2 4
* 输出 6
* @auther lx
* @create 2019-08-10 19:04
*/
public class Main444 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n;
int[] m;
while (scanner.hasNextInt()) {
n = scanner.nextInt();
m = new int[n];
for (int i = 0; i < n; i++) {
m[i] = scanner.nextInt();
}
System.out.println(minIncre(n, m));
}
}
private static int minIncre(int n, int[] mm) {
int[] m = new int[n];
int res = Integer.MAX_VALUE, i = 0;
for (int j = 0; j < n; j++) {//假设j为队列的最大值的下标
int thre = j, min = 0;//thre为顶峰节点的下标,min表示每次循环的最小值
for (int p = 0; p < n; p++) {
m[p] = mm[p];
}
for (int k = 1; k <= thre; k++) {//最大值左边必须递增
int temp = m[k - 1];
if(m[k] <= temp){
min += temp - m[k] + 1;
m[k] = temp + 1;
}
}
for (int k = n - 1; k > thre; k--) {//最大值右边必须递减
int temp = m[k - 1];
if(m[k] >= temp){
min += m[k] - temp + 1;
m[k - 1] = m[k] + 1;
}
}
if(min < res)
res = min;
}
return res;
}
}
1433
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
