贝壳笔试----编程题

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 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;
    }


}