机考[61 -70]

061 【寻找身高相近的小朋友】

小明今年升学到小学一年级，来到新班级后发现其他小朋友们身高参差不齐，然后就想基于各小朋友和自己的身高差对他们进行排序，请帮他实现排序。
输入描述:
第一行为正整数H和N，0<H<200，为小明的身高，0<N<50，为新班级其他小朋友个数。
第二行为N个正整数H1-HN，分别是其他小朋友的身高，取值范围0<Hi<200（1<=i<=N），且N个正整数各不相同。
输出描述:
输出排序结果，各正整数以空格分割。和小明身高差绝对值最小的小朋友排在前面，和小明身高差绝对值最大的小朋友排在最后，如果两个小朋友和小明身高差一样，则个子较小的小朋友排在前面。
示例1
输入
100 10
95 96 97 98 99 101 102 103 104 105
输出
99 101 98 102 97 103 96 104 95 105
说明
小明身高100，班级学生10个，身高分别为95 96 97 98 99 101 102 103 104 105，按身高差排序后结果为：99 101 98 102 97 103 96 104 95 105。

public class ZT61 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[] input = sc.nextLine().split(" ");
        int myHigh = Integer.parseInt(input[0]);
        int count = Integer.parseInt(input[1]);
        String[] students = sc.nextLine().split(" ");
        List<Student> list = new ArrayList<>();
        for (int i = 0; i < count; i++) {
            int highTemp = Integer.parseInt(students[i]);
            list.add(new Student(highTemp, Math.abs(myHigh - highTemp)));
        }
        list.sort(null);
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i).high + " ");
        }
        System.out.println();
    }
    private static class Student implements Comparable<Student>{
        private int high;
        private int gap;

        public Student(int high, int gap) {
            this.high = high;
            this.gap = gap;
        }

        @Override
        public int compareTo(Student stu) {
            if (stu.gap != this.gap){
                return this.gap - stu.gap ;
            }else {
                return this.high - stu.high ;
            }
        }
    }
}

062 【寻找相同子串】

给你两个字符串 t 和 p ，要求从 t 中找到一个和 p 相同的连续子串，并输出该字串第一个字符的下标。
输入描述:
输入文件包括两行，分别表示字符串 t 和 p ，保证 t 的长度不小于 p ，且 t 的长度不超过1000000，p 的长度不超过10000。
输出描述:
如果能从 t 中找到一个和 p 相等的连续子串，则输出该子串第一个字符在t中的下标（下标从左到右依次为1,2,3,…）；如果不能则输出”No”；如果含有多个这样的子串，则输出第一个字符下标最小的。
示例1
输入
AVERDXIVYERDIAN
RDXI
输出
4

public class ZT62 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String search = sc.nextLine();
        String target = sc.nextLine();
        if (!search.contains(target)){
            System.out.println("no");
            return;
        }
        int i = search.indexOf(target);
        System.out.println(i+1);
    }
}

063 【一种字符串压缩表示的解压】

有一种简易压缩算法：针对全部由小写英文字母组成的字符串，将其中连续超过两个相同字母的部分压缩为连续个数加该字母，其他部分保持原样不变。例如：字符串“aaabbccccd”经过压缩成为字符串“3abb4cd”。 请您编写解压函数，根据输入的字符串，判断其是否为合法压缩过的字符串，若输入合法则输出解压缩后的字符串，否则输出字符串“!error”来报告错误。
输入描述:
输入一行，为一个ASCII字符串，长度不会超过100字符，用例保证输出的字符串长度也不会超过100字符
输出描述:
若判断输入为合法的经过压缩后的字符串，则输出压缩前的字符串；若输入不合法，则输出字符串“!error”。
示例1
输入
4dff
输出
ddddff
说明
4d扩展为dddd，故解压后的字符串为ddddff
示例2
输入
2dff
输出
!error
说明
两个d不需要压缩，故输入不合法
示例3
输入
4d@A
输出
!error
说明
全部由小写英文字母组成的字符串压缩后不会出现特殊字符@和大写字母A，故输入不合法

public class ZT63 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String input = sc.nextLine();
        StringBuilder res = new StringBuilder();
        for (int i = 0; i < input.length(); i++) {
            char ch = input.charAt(i);
            int times = 1;
            StringBuilder count = new StringBuilder();
            if ((ch>= '0' && ch<= '9') ){//34a
                for (int j = i; j < input.length(); j++) {
                    ch = input.charAt(j);
                    if (ch>= '0' && ch<= '9'){
                        count.append(input.charAt(j));
                        i++;
                        continue;
                    }
                    break;
                }
                times = Integer.parseInt(count.toString());
                if (times<= 2){
                    System.out.println("!error");
                    return;
                }
            }
            ch = input.charAt(i);//下一个元素
            if (ch>= 'a' && ch<= 'z'){
                while (times > 0 ){
                    res.append(ch);
                    times--;
                }
            }else {
                System.out.println("!error");
                return;
            }
        }
        System.out.println(res);
    }
}

064 【英文输入法】

主管期望你来实现英文输入法单词联想功能。需求如下：
依据用户输入的单词前缀，从已输入的英文语句中联想出用户想输入的单词，按字典序输出联想到的单词序列，如果联想不到，请输出用户输入的单词前缀。
注意：
英文单词联想时，区分大小写
缩略形式如”don’t”，判定为两个单词，”don”和”t”
输出的单词序列，不能有重复单词，且只能是英文单词，不能有标点符号
输入描述:
输入为两行。
首行输入一段由英文单词word和标点符号组成的语句str；
接下来一行为一个英文单词前缀pre。
0 < word.length() <= 20
0 < str.length <= 10000
0 < pre <= 20
输出描述:
输出符合要求的单词序列或单词前缀，存在多个时，单词之间以单个空格分割
示例1
输入
I love you
He
输出
He
说明
从用户已输入英文语句”I love you”中提炼出“I”、“love”、“you”三个单词，接下来用户输入“He”，从已输入信息中无法联想到任何符合要求的单词，因此输出用户输入的单词前缀。
示例2
输入
The furthest distance in the world, Is not between life and death, But when I stand in front of you, Yet you don’t know that I love you.
f
输出
front furthest
说明
从用户已输入英文语句”The furthest distance in the world, Is not between life and death, But when I stand in frontof you, Yet you dont know that I love you.”中提炼出的单词，符合“f”作为前缀的，有“furthest”和“front”，按字典序排序并在单词间添加空格后输出，结果为“front furthest”。

public class ZT64 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String input = sc.nextLine();
        String target = sc.nextLine();
        List<String> list = new ArrayList<>();
        StringBuilder word = new StringBuilder();
        for (int i = 0; i < input.length(); i++) {
            char ch = input.charAt(i);
            if ((ch >= 'a' && ch <= 'z') || ( ch>= 'A' && ch<= 'Z') ){
                word.append(ch);
            }else {
                list.add(word.toString());
                word = new StringBuilder();
            }
        }
        List<String> res = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            if (list.get(i).startsWith(target)) {
                res.add(list.get(i));
            }
        }
        Collections.sort(res);
        if (res.size() > 0){
            for (int i = 0; i < res.size(); i++) {
                System.out.print(res.get(i) + " ");
            }
            System.out.println();
        }else {
            System.out.println(target);
        }
    }
}

065 【用户调度问题】

在通信系统中，一个常见的问题是对用户进行不同策略的调度，会得到不同的系统消耗和性能。
假设当前有n个待串行调度用户，每个用户可以使用A/B/C三种不同的调度策略，不同的策略会消耗不同的系统资源。请你根据如下规则进行用户调度，并返回总的消耗资源数。
规则：
1、相邻的用户不能使用相同的调度策略，例如，第1个用户使用了A策略，则第2个用户只能使用B或者C策略。
2、对单个用户而言，不同的调度策略对系统资源的消耗可以归一化后抽象为数值。例如，某用户分别使用A/B/C策略的系统消耗分别为15/8/17。
3、每个用户依次选择当前所能选择的对系统资源消耗最少的策略（局部最优），如果有多个满足要求的策略，选最后一个。
输入描述:
第一行表示用户个数n
接下来每一行表示一个用户分别使用三个策略的系统消耗resA resB resC
输出描述:
最优策略组合下的总的系统资源消耗数
示例1
输入
3
15 8 17
12 20 9
11 7 5
输出
24
说明
1号用户使用B策略，2号用户使用C策略，3号用户使用B策略。系统资源消耗: 8 + 9 + 7 = 24。
备注:
所有策略对系统的资源消耗均为正整数，n < 1000

public class ZT65 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int count = Integer.parseInt(sc.nextLine());
        List<List<Integer>> lists = new ArrayList<>();
        for (int i = 0; i < count; i++) {
            String[] input = sc.nextLine().split(" ");
            List<Integer> list = new ArrayList<>();
            for (int j = 0; j < 3; j++) {
                list.add(Integer.parseInt(input[j]));
            }
            lists.add(list);
        }
        //执行策略
        int pre = -1;
        int total = 0;
        for (int i = 0; i < lists.size(); i++) {
            List<Integer> list = lists.get(i);
            int min = Integer.MAX_VALUE;
            if (i == 0){
                for (int j = 0; j < 3; j++) {
                    if (min >= list.get(j)){
                        min = list.get(j);
                        pre = j;
                    }
                }
            }else {
                int tem = 0;
                for (int j = 0; j < 3; j++) {
                    if (j != pre && min >= list.get(j)){
                        min = list.get(j);
                        tem = j;
                    }
                }
                pre = tem;
            }
            total += min;
        }
        System.out.println(total);
    }
}

066 【用连续自然数之和来表达整数】

一个整数可以由连续的自然数之和来表示。给定一个整数，计算该整数有几种连续自然数之和的表达式，且打印出每种表达式。
输入描述:
一个目标整数T (1 <=T<= 1000)
输出描述:
该整数的所有表达式和表达式的个数。如果有多种表达式，输出要求为：
1.自然数个数最少的表达式优先输出
2.每个表达式中按自然数递增的顺序输出，具体的格式参见样例。在每个测试数据结束时，输出一行”Result:X”，其中X是最终的表达式个数。
示例1
输入
9
输出
9=9
9=4+5
9=2+3+4
Result:3
说明
整数 9 有三种表示方法，第1个表达式只有1个自然数，最先输出，第2个表达式有2个自然数，第2次序输出，第3个表达式有3个自然数，最后输出。每个表达式中的自然数都是按递增次序输出的。
数字与符号之间无空格
示例2
输入
10
输出
10=10
10=1+2+3+4
Result:2

public class ZT66 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int sum = sc.nextInt();
        int n = 1;
        while (n< sum/2){
            if (2* sum % n == 0 && (2* sum/n -n +1) %2 == 0 && (2* sum/n -n +1)/2 > 0){
                int x1 = (2* sum/n -n +1)/2;
                System.out.print(sum + "=");
                for (int i = 0; i <n ; i++) {
                    if (i == n-1){
                        System.out.print(x1++);
                    }else {
                        System.out.print(x1++ + "+");
                    }
                }
                System.out.println();
            }
            n++;
        }
    }
}
//输入
//2*sum = n(2x + n-1) n 取[1,sum]

067 【找车位】

停车场有一横排车位，0代表没有停车，1代表有车。至少停了一辆车在车位上，也至少有一个空位没有停车。
为了防剐蹭，需为停车人找到一个车位，使得距停车人的车最近的车辆的距离是最大的，返回此时的最大距离。
输入描述:
1、一个用半角逗号分割的停车标识字符串，停车标识为0或1，0为空位，1为已停车。
2、停车位最多100个。
输出描述:
输出一个整数记录最大距离。
示例1
输入
1,0,0,0,0,1,0,0,1,0,1
输出
2
说明
当车停在第3个位置上时，离其最近的的车距离为2（1到3）。
当车停在第4个位置上时，离其最近的的车距离为2（4到6）。
其他位置距离为1。
因此最大距离为2。

public class ZT67 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[] input = sc.nextLine().split(",");
        int[] arr = new int[input.length];
        for (int i = 0; i < input.length; i++) {
            arr[i] = Integer.parseInt(input[i]);
        }
        int max = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == 1){
                continue;
            }
            max = Math.max(max,calcDis(arr,i));
        }
        System.out.println(max);
    }
    //1,0,0,0,1,0,0,1
    private static int calcDis(int[] arr,int idx){
        int left = 0;
        int right = 0;
        for (int i = 0; i < idx; i++) {
            if (arr[i] == 1){
                left = i;
            }
        }
        for (int i = idx; i < arr.length; i++) {
            if (arr[i] == 1){
                right =i;
                break;
            }
        }
        return Math.min(idx - left,right - idx);
    }
}

068 【找出符合要求的字符串子串】

给定两个字符串，从字符串2中找出字符串1中的所有字符，去重并按照ASCII值从小到大排序
输入字符串1：长度不超过1024
输入字符串2：长度不超过1000000
字符范围满足ASCII编码要求，按照ASCII的值由小到大排序
输入描述:
bach
bbaaccedfg
输出描述:
abc
示例1
输入
fach
bbaaccedfg
输出
acf
说明
备注:
输入字符串1 为给定字符串bach，输入字符串2 bbaaccedfg
从字符串2中找出字符串1的字符，去除重复的字符，并且按照ASCII值从小到大排序，得到输出的结果为abc。
字符串1中的字符h在字符串2中找不到不输出。

public class ZT68 {
    public static void main(String[] args) {
        Scanner sc =new Scanner(System.in);
        String target = sc.nextLine();
        String search = sc.nextLine();
        List<Character> list = new ArrayList<>();
        for (int i = 0; i < target.length(); i++) {
            Character tem = target.charAt(i);
            if (search.contains(String.valueOf(tem))) {
                list.add(tem);
            }
        }
        Collections.sort(list);
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i));
        }
        System.out.println();
    }
}

069 【找朋友】

在学校中，N个小朋友站成一队， 第i个小朋友的身高为height[i]，
第i个小朋友可以看到的第一个比自己身高更高的小朋友j，那么j是i的好朋友(要求j > i)。
请重新生成一个列表，对应位置的输出是每个小朋友的好朋友位置，如果没有看到好朋友，请在该位置用0代替。
小朋友人数范围是 [0, 40000]。
输入描述:
第一行输入N，N表示有N个小朋友
第二行输入N个小朋友的身高height[i]，都是整数
输出描述:
输出N个小朋友的好朋友的位置
示例1
输入
2
100 95
输出
0 0
说明
第一个小朋友身高100，站在队尾位置，向队首看，没有比他身高高的小朋友，所以输出第一个值为0。
第二个小朋友站在队首，前面也没有比他身高高的小朋友，所以输出第二个值为0。
示例2
输入
8
123 124 125 121 119 122 126 123
输出
1 2 6 5 5 6 0 0
说明
123的好朋友是1位置上的124
124的好朋友是2位置上的125
125的好朋友是6位置上的126
以此类推

public class ZT69 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int count = Integer.parseInt(sc.nextLine());
        String[] input = sc.nextLine().split(" ");
        int[] arr = new int[count];
        for (int i = 0; i < input.length; i++) {
           //右边第一个比自己身高高的人
            int idx = 0;
            for (int j = i+1; j < input.length; j++) {
                if (Integer.parseInt(input[i]) < Integer.parseInt(input[j])){
                    idx = j;
                    break;
                }
            }
            arr[i] = idx;
        }
        for (int i = 0; i < arr.length; i++) {
            if (i!= arr.length-1){
                System.out.print(arr[i] + " ");
            }else {
                System.out.print(arr[i]);
            }
        }
    }
}

070 【找终点】

给定一个正整数数组，设为nums，最大为100个成员，求从第一个成员开始，正好走到数组最后一个成员，所使用的最少步骤数。
要求：
1、第一步必须从第一元素开始，且1<=第一步的步长<len/2;（len为数组的长度，需要自行解析）。
2、从第二步开始，只能以所在成员的数字走相应的步数，不能多也不能少, 如果目标不可达返回-1，只输出最少的步骤数量。
3、只能向数组的尾部走，不能往回走。
输入描述:
由正整数组成的数组，以空格分隔，数组长度小于100，请自行解析数据数量。
输出描述:
正整数，表示最少的步数，如果不存在输出-1
示例1
输入
7 5 9 4 2 6 8 3 5 4 3 9
输出
2
说明
第一步： 第一个可选步长选择2，从第一个成员7开始走2步，到达9；第二步： 从9开始，经过自身数字9对应的9个成员到最后。
示例2
输入
1 2 3 7 1 5 9 3 2 1
输出
-1

public class ZT70 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[] input = sc.nextLine().split(" ");
        int firstStepMin = 2;
        int firstStepMax = input.length/2;
        int minStep = Integer.MAX_VALUE;
        int cur = 0;
        int tempStep = 0;
        for (int step = firstStepMin; step < firstStepMax; step++) {
            int target = input.length - 1;
            cur = step;
            tempStep++;
            while (cur < target){
                cur += Integer.parseInt(input[cur]);
                tempStep++;
                if (cur == target){
                    minStep = Math.min(minStep,tempStep);
                    break;
                }
                if (cur> target){
                    tempStep = 0;
                    cur = 0;
                    break;
                }
            }
        }
        if (minStep > input.length){
            System.out.println(-1);
        }else {
            System.out.println(minStep);
        }
    }
}