机考[11-20]

011 【查找众数及中位数】

磁盘容量排序
磁盘的容量单位常用的有M，G，T这三个等级，它们之间的换算关系为1T = 1024G，1G = 1024M，现在给定n块磁盘的容量，请对它们按从小到大的顺序进行稳定排序，例如给定5块盘的容量，1T，20M，3G，10G6T，3M12G9M排序后的结果为20M，3G，3M12G9M，1T，10G6T。注意单位可以重复出现，上述3M12G9M表示的容量即为3M+12G+9M，和12M12G相等。
输入描述:
输入第一行包含一个整数n(2 <= n <= 100)，表示磁盘的个数，接下的n行，每行一个字符串(长度大于2，小于30)，表示磁盘的容量，由一个或多个格式为mv的子串组成，其中m表示容量大小，v表示容量单位，例如20M，1T，30G，10G6T，3M12G9M。
磁盘容量m的范围为1到1024的正整数，容量单位v的范围只包含题目中提到的M，G，T三种，换算关系如题目描述。
输出描述:
输出n行，表示n块磁盘容量排序后的结果。
示例1：
输入
3
1G
2G
1024M
输出
1G
1024M
2G
说明
1G和1024M容量相等，稳定排序要求保留它们原来的相对位置，故1G在1024M之前
示例2：
输入
3
2G4M
3M2G
1T
输出
3M2G
2G4M
1T
说明
1T的容量大于2G4M，2G4M的容量大于3M2G

在这里插入代码片

012 【单词接龙】

单词接龙的规则是：可用于接龙的单词首字母必须要前一个单词的尾字母相同；当存在多个首字母相同的单词时，取长度最长的单词，如果长度也相等，则取字典序最小的单词；已经参与接龙的单词不能重复使用。
现给定一组全部由小写字母组成单词数组，并指定其中的一个单词作为起始单词，进行单词接龙，请输出最长的单词串，单词串是单词拼接而成，中间没有空格。
输入描述:
输入的第一行为一个非负整数，表示起始单词在数组中的索引K，0 <= K < N ；
输入的第二行为一个非负整数，表示单词的个数N；
接下来的N行，分别表示单词数组中的单词。
输出描述:
输出一个字符串，表示最终拼接的单词串。
示例1：
输入
0
6
word
dd
da
dc
dword
d
输出
worddwordda
说明
先确定起始单词word，再接以d开头的且长度最长的单词dword，剩余以d开头且长度最长的有dd、da、dc，则取字典序最小的da，所以最后输出worddwordda。
示例2：
输入
4
6
word
dd
da
dc
dword
d
输出
dwordda
说明
先确定起始单词dword，剩余以d开头且长度最长的有dd、da、dc，则取字典序最小的da，所以最后输出dwordda。
备注:
单词个数N的取值范围为[1, 20]；
单个单词的长度的取值范围为[1, 30]；

在这里插入代码片

013 【第k个排列】

给定参数n，从1到n会有n个整数：1,2,3,…,n，这n个数字共有 n! 种排列。
按大小顺序升序列出所有排列情况，并一一标记，当 n = 3 时, 所有排列如下：
“123”
“132”
“213”
“231”
“312”
“321”
给定 n 和 k，返回第 k 个排列。
输入描述:
输入两行，第一行为n，第二行为k，给定 n 的范围是 [1,9]，给定 k 的范围是[1,n!]。
输出描述:
输出排在第k位置的数字。
示例1：
输入
3
3
输出
213
说明
3的排列有123 132 213…，那么第3位置的为213
示例2：
输入
2
2
输出
21
说明
2的排列有12 21，那么第2位置的为21

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int ni = sc.nextInt();//[1,9]
        int kLine = sc.nextInt();//[1,n!]
        List<Integer> list = new ArrayList<>();
        for (int i = 1; i <= ni; i++) {
            list.add(i);
        }
        int idx = ni;
        StringBuilder sb = new StringBuilder();
        kLine--;//数组中，存在下标0，顾--
        while (list.size()>0){
            int total = 1;
            for (int i = idx-1; i > 0; i--) {
                total *= i;
            }
            int index = kLine/total;
            kLine = Math.max(kLine - total, 0);
            int res = list.get(index);
            sb.append(res);
            list.remove(index);
            idx--;
        }
        System.out.println(sb);
    }
}

014 【斗地主之顺子】

在斗地主扑克牌游戏中， 扑克牌由小到大的顺序为：3,4,5,6,7,8,9,10,J,Q,K,A,2，玩家可以出的扑克牌阵型有：单张、对子、顺子、飞机、炸弹等。
其中顺子的出牌规则为：由至少5张由小到大连续递增的扑克牌组成，且不能包含2。
例如：{3,4,5,6,7}、{3,4,5,6,7,8,9,10,J,Q,K,A}都是有效的顺子；而{J,Q,K,A,2}、 {2,3,4,5,6}、{3,4,5,6}、{3,4,5,6,8}等都不是顺子。
给定一个包含13张牌的数组，如果有满足出牌规则的顺子，请输出顺子。
如果存在多个顺子，请每行输出一个顺子，且需要按顺子的第一张牌的大小（必须从小到大）依次输出。
如果没有满足出牌规则的顺子，请输出No。
输入描述:
13张任意顺序的扑克牌，每张扑克牌数字用空格隔开，每张扑克牌的数字都是合法的，并且不包括大小王：
2 9 J 2 3 4 K A 7 9 A 5 6
不需要考虑输入为异常字符的情况
输出描述:
组成的顺子，每张扑克牌数字用空格隔开：
3 4 5 6 7
示例1：
输入
2 9 J 2 3 4 K A 7 9 A 5 6
输出
3 4 5 6 7
说明
13张牌中，可以组成的顺子只有1组：3 4 5 6 7
示例2：
输入
2 9 J 10 3 4 K A 7 Q A 5 6
输出
3 4 5 6 7
9 10 J Q K A
说明
13张牌中，可以组成2组顺子，从小到大分别为：3 4 5 6 7 和 9 10 J Q K A
示例3：
输入
2 9 9 9 3 4 K A 10 Q A 5 6
输出
No
说明
13张牌中，无法组成顺子

public class ZT13 {
    private static boolean flag = false;
    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 < arr.length; i++) {
            String tem = input[i];
            if (tem.equals("A")){
                arr[i] = 14;
            }else if (tem.equals("J")){
                arr[i] = 11;
            }else if (tem.equals("Q")){
                arr[i] = 12;
            }else if (tem.equals("K")){
                arr[i] = 13;
            }else {
                arr[i] = Integer.parseInt(tem);
            }
        }
        Arrays.sort(arr);
        //查找可以连成5张的顺子
        int start = 0;
        int temp = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == 2){//2不能顺子
                continue;
            }
            if (start == 0){//初始化
                start = arr[i];
                temp = arr[i];
                continue;
            }
            if (arr[i] == temp){//对子等
                continue;
            }
            if (arr[i] == temp+1){
                temp = arr[i];
            }else {//不能连上了
                if (temp - start >= 4){
                    print(start,temp);
                }
                start = 0;
                temp = 0;
            }
        }
        if (temp - start >= 4){
            print(start,temp);
        }
        if (!flag){
            System.out.println("NO");
        }
    }
    
    private static void print(int start,int end){
        flag = true;
        for (int j = start; j <= end ; j++) {
            if (j == 14){
                System.out.print("A ");
            }else if (j == 11){
                System.out.print("J ");
            }else if (j == 12){
                System.out.print("Q ");
            }else if (j == 13){
                System.out.print("K ");
            }else {
                System.out.print(j + " ");
            }
        }
        System.out.println();
    }
}

015 【非严格递增连续数字序列】

输入一个字符串仅包含大小写字母和数字，求字符串中包含的最长的非严格递增连续数字序列的长度（比如12234属于非严格递增连续数字序列）。
输入描述:
输入一个字符串仅包含大小写字母和数字，输入的字符串最大不超过255个字符。
输出描述:
最长的非严格递增连续数字序列的长度
示例1：
输入
abc2234019A334bc
输出
4
说明
2234为最长的非严格递增连续数字序列，所以长度为4。

public class ZT15 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String input = sc.nextLine();
        char[] chars = input.toCharArray();
        int start = 0;
        int end = 0;
        int max = 0;
        char tem = ' ';
        for (int i = 0; i < chars.length; i++) {
            char ch = chars[i];
            if (ch>= '0' && ch<='9'){
                if (start == 0){
                    start = i;
                    end = i;
                    tem = ch;
                    continue;
                }
                if (ch == tem + 1 || ch == tem){
                    tem = ch;
                    end++;
                }else {
                    max = Math.max(max,end - start+1);
                    start = 0;
                    end = 0;
                    tem = ' ';
                }
            }else {
                max = Math.max(max,end - start+1);
                start = 0;
                end = 0;
                tem = ' ';
            }
        }
        System.out.println(max);
    }
}

016 【分班】

幼儿园两个班的小朋友在排队时混在了一起，每位小朋友都知道自己是否与前面一位小朋友是否同班，请你帮忙把同班的小朋友找出来。
小朋友的编号为整数，与前一位小朋友同班用Y表示，不同班用N表示。
输入描述:
输入为空格分开的小朋友编号和是否同班标志。
比如：6/N 2/Y 3/N 4/Y，表示共4位小朋友，2和6同班，3和2不同班，4和3同班。
其中，小朋友总数不超过999，每个小朋友编号大于0，小于等于999。
不考虑输入格式错误问题。
输出描述:
输出为两行，每一行记录一个班小朋友的编号，编号用空格分开。且：
1、编号需要按照大小升序排列，分班记录中第一个编号小的排在第一行。
2、若只有一个班的小朋友，第二行为空行。
3、若输入不符合要求，则直接输出字符串ERROR。
示例1：
输入
1/N 2/Y 3/N 4/Y
输出
1 2
3 4
说明
2的同班标记为Y，因此和1同班。
3的同班标记为N，因此和1、2不同班。
4的同班标记为Y，因此和3同班。
所以1、2同班，3、4同班，输出为
1 2
3 4

public class ZT16 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[] input = sc.nextLine().split(" ");
        List<Integer> list1 = new ArrayList<>();
        List<Integer> list2 = new ArrayList<>();
        //0号是1班 剩下是2班
        int preCla = 1;
        for (int i = 0; i < input.length; i++) {
            String[] num = input[i].split("/");
            if (i == 0){
                list1.add(Integer.parseInt(num[0]));
                preCla = 1;
                continue;
            }
            if (preCla == 1){
                if (num[1].equals("Y")){
                    list1.add(Integer.parseInt(num[0]));
                }else {
                    list2.add(Integer.parseInt(num[0]));
                    preCla = 2;
                }
            }else {//N
                if (num[1].equals("Y")){
                    list2.add(Integer.parseInt(num[0]));
                }else {
                    list1.add(Integer.parseInt(num[0]));
                    preCla = 1;
                }
            }
        }
        Collections.sort(list1);
        Collections.sort(list2);
        for (int i = 0; i < list1.size(); i++) {
            System.out.print(list1.get(i) + " ");
        }
        System.out.println();
        for (int i = 0; i < list2.size(); i++) {
            System.out.print(list2.get(i) + " ");
        }
    }
}

017 【分糖果】

小明从糖果盒中随意抓一把糖果，每次小明会取出一半的糖果分给同学们。
当糖果不能平均分配时，小明可以选择从糖果盒中（假设盒中糖果足够）取出一个糖果或放回一个糖果。
小明最少需要多少次（取出、放回和平均分配均记一次），能将手中糖果分至只剩一颗
输入描述:
抓取的糖果数（<10000000000）：
15
输出描述:
最少分至一颗糖果的次数：
5
示例1：
输入
15
输出
5
备注:
解释：(1)15+1=16;(2)16/2=8;(3)8/2=4;(4)4/2=2;(5)2/2=1;

public class ZT17 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        System.out.println(handle(num));

    }
    private static int handle(int tang){
        if (tang == 1){
            return 0;
        }
        if (tang % 2 == 0){
            tang /= 2;
            //次数+1
            return handle(tang)+1;
        }
        int plus = handle(tang +1) +1;//增加一个
        int sub = handle(tang -1) +1;//减少一个
        return Math.min(plus,sub);
    }
}

018 【高矮个子排队】

现在有一队小朋友，他们高矮不同，我们以正整数数组表示这一队小朋友的身高，如数组{5,3,1,2,3}。
我们现在希望小朋友排队，以“高”“矮”“高”“矮”顺序排列，每一个“高”位置的小朋友要比相邻的位置高或者相等；每一个“矮”位置的小朋友要比相邻的位置矮或者相等；
要求小朋友们移动的距离和最小，第一个从“高”位开始排，输出最小移动距离即可。
例如，在示范小队{5,3,1,2,3}中，{5, 1, 3, 2, 3}是排序结果。{5, 2, 3, 1, 3} 虽然也满足“高”“矮”“高”“矮”顺序排列，但小朋友们的移动距离大，所以不是最优结果。
移动距离的定义如下所示：
第二位小朋友移到第三位小朋友后面，移动距离为1，若移动到第四位小朋友后面，移动距离为2；
输入描述:
排序前的小朋友，以英文空格的正整数：
4 3 5 7 8
注：小朋友<100个
输出描述:
排序后的小朋友，以英文空格分割的正整数：
4 3 7 5 8
示例1：
输入
4 1 3 5 2
输出
4 1 5 2 3
示例2：
输入
1 1 1 1 1
输出
1 1 1 1 1
说明
相邻位置可以相等
示例3：
输入
xxx
输出
[ ]
说明：
出现非法参数情况， 返回空数组
备注:
4（高）3（矮）7（高）5（矮）8（高）， 输出结果为最小移动距离，只有5和7交换了位置，移动距离都是1。

public class ZT18 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String input = sc.nextLine();
        String[] boys = input.split(" ");
        int[] arr = new int[boys.length];
        for (int i = 0; i < boys.length; i++) {
            arr[i] = Integer.parseInt(boys[i]);
        }
        int idx = 0;
        while (idx +1 < arr.length){
            //原则奇数位大 偶数位小
            if ((idx+1) % 2 == 0){//1算奇数位 idx要小
                if (arr[idx] > arr[idx+1]){
                    int tem = arr[idx+1];
                    arr[idx +1] = arr[idx];
                    arr[idx] = tem;
                }
            }else {//0算奇数位 idx要大
                if (arr[idx] < arr[idx+1]){
                    int tem = arr[idx+1];
                    arr[idx +1] = arr[idx];
                    arr[idx] = tem;
                }
            }
            idx++;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

019 【工号不够用了怎么办】

3020年，空间通信集团的员工人数突破20亿人，即将遇到现有工号不够用的窘境。
现在，请你负责调研新工号系统。继承历史传统，新的工号系统由小写英文字母（a-z）和数字（0-9）两部分构成。新工号由一段英文字母开头，之后跟随一段数字，比如"aaahw0001",“a12345”,“abcd1”,“a00”。注意新工号不能全为字母或者数字,允许数字部分有前导0或者全为0。
但是过长的工号会增加同事们的记忆成本，现在给出新工号至少需要分配的人数X和新工号中字母的长度Y，求新工号中数字的最短长度Z。
输入描述:
一行两个非负整数 X Y，用数字用单个空格分隔。
0< X <=2^50 - 1
0< Y <=5
输出描述:
输出新工号中数字的最短长度Z
示例1
输入
260 1
输出
1
示例2
输入
26 1
输出
1
说明
数字长度不能为0
示例3
输入
2600 1
输出
2

020 【勾股数元组】

如果3个正整数(a,b,c)满足a2 + b2 = c2的关系，则称(a,b,c)为勾股数（著名的勾三股四弦五），为了探索勾股数的规律，我们定义如果勾股数(a,b,c)之间两两互质（即a与b，a与c，b与c之间均互质，没有公约数），则其为勾股数元祖（例如(3,4,5)是勾股数元祖，(6,8,10)则不是勾股数元祖）。请求出给定范围[N,M]内，所有的勾股数元祖。
输入描述:
起始范围N，1 <= N <= 10000
结束范围M，N < M <= 10000
输出描述:
a,b,c请保证a < b < c,输出格式：a b c；
多组勾股数元祖请按照a升序，b升序，最后c升序的方式排序输出；
给定范围中如果找不到勾股数元祖时，输出”NA”。
示例1：
输入
1
20
输出
3 4 5
5 12 13
8 15 17
说明
[1, 20]范围内勾股数有：(3 4 5)，(5 12 13)，(6 8 10)，(8 15 17)，(9 12 15)，(12 16 20)；其中，满足(a,b,c)之间两两互质的勾股数元祖有：(3 4 5)，(5 12 13)，(8 15 17)；按输出描述中顺序要求输出结果。
示例2：
输入
5
10
输出
NA
说明
[5, 10]范围内勾股数有：(6 8 10)；其中，没有满足(a,b,c)之间两两互质的勾股数元祖； 给定范围中找不到勾股数元祖，输出”NA”。

public class ZT20 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int i1 = sc.nextInt();//[1,10000]
        int i2 = sc.nextInt();//[n,10000]
        List<List<Integer>> lists = new ArrayList<>();
        for (int i = i1; i <= i2 ; i++) {
            for (int j = i+1; j <= i2 ; j++) {
                if (checkFlag(i,j,i2)) {
                    List<Integer> list = new ArrayList<>();
                    list.add(i);
                    list.add(j);
                    list.add((int)Math.sqrt(i*i + j*j));
                    Collections.sort(list);
                    lists.add(list);
                }
            }
        }
        //所有的勾股数都在lists里,逐个排除存在公约数的数组
        int idx = 0;
        while (idx < lists.size()){
            List<Integer> list = lists.get(idx);
            if (checkYue(list.get(0),list.get(1),list.get(2))) {
                lists.remove(idx);
                idx = 0;
            }
            idx++;
        }
        for (int i = 0; i < lists.size(); i++) {
            List<Integer> list = lists.get(i);
            System.out.println(list.get(0) + " " + list.get(1) + " "+ list.get(2));
        }
    }
    private static boolean checkFlag(int a1,int a2,int max){
        int mul = a1 *a1 + a2 * a2;
        double res = Math.sqrt(mul);
        int sub = (int) res;
        return res * res  == sub * sub && sub<= max && sub>a2;
    }

    //369 246
    private static boolean checkYue(int a1,int a2,int a3){
        for (int i = 2; i < a3; i++) {
            if (a1 % i ==0 && a2 % i == 0){
                return true;
            }else if (a1 % i == 0 && a3 % i == 0){
                return true;
            }else if (a2 % i == 0 && a3 % i == 0){
                return true;
            }
        }
        return false;
    }
}