https://blog.csdn.net/weixin_43428283/article/details/127361330
https://blog.csdn.net/fengyuyeguirenenen/article/details/125245803
https://blog.csdn.net/pengzongjy/category_12114900.html
https://blog.csdn.net/misayaaaaa/article/details/126965954

入门

HJ7 取近似值

// https://www.nowcoder.com/practice/3ab09737afb645cc82c35d56a5ce802a
// 描述
//     写出一个程序，接受一个正浮点数值，输出该数值的近似整数值。如果小数点后数值大于等于 0.5 ,向上取整；小于 0.5 ，则向下取整。
//     数据范围：保证输入的数字在 32 位浮点数范围内
// 输入描述：
//     输入一个正浮点数值
// 输出描述：
//     输出该数值的近似整数值
// 输入：5.5
// 输出：6
// 说明：
//     0.5>=0.5，所以5.5需要向上取整为6
// 输入：2.499
// 输出：2
// 说明：0.499<0.5，2.499向下取整为2   
import java.util.Scanner;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNext()) {
            int result = 0;
            double a = in.nextDouble();
            // 获取小数后第一位数字，判断是否大于等于5
            int b = (int)(a * 10) % 10;
            if(b >= 5){
                result = (int)a + 1;
            }else{
                result = (int)a;
            }
            System.out.println(result);
        }
    }
}

HJ9 提取不重复的整数

// https://www.nowcoder.com/practice/253986e66d114d378ae8de2e6c4577c1
// 描述
//     输入一个 int 型整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。
//     保证输入的整数最后一位不是 0 。
//     数据范围： 1 ≤ n ≤ 10^8
// 输入描述：
//     输入一个int型整数
// 输出描述：
//     按照从右向左的阅读顺序，返回一个不含重复数字的新的整数
// 输入：9876673
// 输出：37689  
import java.util.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextInt()) { // 注意 while 处理多个 case
            int a = in.nextInt();
            // HashSet元素乱序
            // LinkedHashSet保证元素添加顺序（！！！）
            // TreeSet元素按自然顺序排序
            Set<Character> set = new LinkedHashSet<>();
            String str = String.valueOf(a);
            for(int i = str.length() - 1; i >= 0; i--){
                set.add(str.charAt(i));
            }
            str = "";
            for(Character ch : set){
                str = str + ch;
            }
            System.out.println(Integer.parseInt(str));
        }
    }
}

HJ46 截取字符串

// https://www.nowcoder.com/practice/a30bbc1a0aca4c27b86dd88868de4a4a
// 描述
//     输入一个字符串和一个整数 k ，截取字符串的前k个字符并输出
//     数据范围：字符串长度满足 1 \le n \le 1000 \1≤n≤1000  ， 1 \le k \le n \1≤k≤n 
// 输入描述：
//     1.输入待截取的字符串
//     2.输入一个正整数k，代表截取的长度
// 输出描述：
//     截取后的字符串
// 输入：abABCcDEF
//       6
// 输出：abABCc   
import java.util.Scanner;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNext()) { // 注意 while 处理多个 case
            String str = in.next();
            int num = in.nextInt();
            StringBuilder result = new StringBuilder();
            for(int i = 0; i < num; i++){
                result = result.append(str.charAt(i));
            }
            System.out.println(result);
        }
    }
}

55555 - HJ58 输入n个整数，输出其中最小的k个

// https://www.nowcoder.com/practice/69ef2267aafd4d52b250a272fd27052c
// 描述
//      输入n个整数，找出其中最小的k个整数并按升序输出
//      本题有多组输入样例
//      数据范围：1 ≤ n ≤ 1000，输入的整数满足1 ≤ val ≤ 10000 
// 输入描述：
//      第一行输入两个整数n和k
//      第二行输入一个整数数组
// 输出描述：
//      从小到大输出最小的k个整数，用空格分开
// 输入：5 2
//      1 3 5 7 2
// 输出：1 2
import java.util.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextLine()) {
            // 必须使用nextLine，而不是next
            String a = in.nextLine，而不是next();
            String b = in.nextLine();
            String[] as = a.split(" ");
            int nums = Integer.parseInt(as[0]);
            int k = Integer.parseInt(as[1]);
            // 字符串数组 转 整数数组
            String[] str = b.split(" ");
            int[] ints = new int[str.length];
            for(int i = 0; i < str.length; i++){
                ints[i] = Integer.parseInt(str[i]);
            }
            Arrays.sort(ints);
            for(int i = 0; i < k && i < nums; i++){
                System.out.print(ints[i] + " ");
            }
        }
    }
}

HJ101 输入整型数组和排序标识，对其元素按照升序或降序进行排序

// https://www.nowcoder.com/practice/dd0c6b26c9e541f5b935047ff4156309
// 描述
//         输入整型数组和排序标识，对其元素按照升序或降序进行排序
//         数据范围：1 ≤ n ≤ 1000，元素大小满足0 ≤ val ≤ 100000 
// 输入描述：
//         第一行输入数组元素个数
//         第二行输入待排序的数组，每个数用空格隔开
//         第三行输入一个整数0或1。0代表升序排序，1代表降序排序
// 输出描述：
//         输出排好序的数字
// 输入：8
//       1 2 4 9 3 55 64 25
//       0
// 输出：1 2 3 4 9 25 55 64
// 输入：5
//      1 2 3 4 5
//      1
// 输出：
//      5 4 3 2 1
import java.util.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextLine()) {
            // 必须都使用in.nextLine()接收参数才行，不能一个使用in.nextLine()，其他使用in.next()
            int nums = Integer.parseInt(in.nextLine());
            String str = in.nextLine();
            int flag = Integer.parseInt(in.nextLine());
            // 字符串数组 转 整数数组
            String[] strs = str.split(" ");
            // 此处必须使用包装类，否则无法使用Arrays.sort进行降序排列
            Integer[] ints = new Integer[nums];     
            for (int i = 0; i < nums; i++) {
                ints[i] = Integer.parseInt(strs[i]);
            }
            if (flag == 0) {
                Arrays.sort(ints);
            } else {
                Arrays.sort(ints, (o1, o2) -> o2 - o1);
            }
            for (int i = 0; i < nums; i++) {
                System.out.print(ints[i] + " ");
            }
        }
    }
}

简单

HJ1 字符串最后一个单词的长度

// https://www.nowcoder.com/practice/8c949ea5f36f422594b306a2300315da
// 描述
//     计算字符串最后一个单词的长度，单词以空格隔开，字符串长度小于5000。（注：字符串末尾不以空格为结尾）
// 输入描述：
//     输入一行，代表要计算的字符串，非空，长度小于5000。
// 输出描述：
//     输出一个整数，表示输入字符串最后一个单词的长度。
// 示例1
//     输入：hello nowcoder
//     输出：8
//     说明：最后一个单词为nowcoder，长度为8
import java.util.Scanner;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        String[] st = str.split(" ");
        int len1 = st[st.length - 1].length();
        System.out.println(len1);
    }
}

HJ2 计算某字符出现次数

// https://www.nowcoder.com/practice/a35ce98431874e3a820dbe4b2d0508b1
// 描述
//     写出一个程序，接受一个由字母、数字和空格组成的字符串，和一个字符，然后输出输入字符串中该字符的出现次数。（不区分大小写字母）
//     数据范围： 1 \le n \le 1000 \1≤n≤1000 
// 输入描述：
//     第一行输入一个由字母、数字和空格组成的字符串，第二行输入一个字符（保证该字符不为空格）。
// 输出描述：
//     输出输入字符串中含有该字符的个数。（不区分大小写字母）
// 输入：ABCabc
//       A
// 输出：2
import java.util.Scanner;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        String s = sc.nextLine();
        int count = 0;
        for(int i = 0; i < str.length(); i++){
            if(s.equalsIgnoreCase(str.charAt(i) + "")){
                count++;
            }
        }
        System.out.println(count);
    }
}

HJ4 字符串分隔

// https://www.nowcoder.com/practice/d9162298cb5a437aad722fccccaae8a7
// 描述
//     • 输入一个字符串，请按长度为8拆分每个输入字符串并进行输出；
//     • 长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。
// 输入描述：
//     连续输入字符串(每个字符串长度小于等于100)
// 输出描述：
//     依次输出所有分割后的长度为8的新字符串
// 输入：abc
// 输出：abc0000
import java.util.Scanner;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        int len = str.length();
        if (len % 8 == 0) {
            for (int i = 0; i < len; i = i + 8) {
                System.out.println(str.substring(i, i + 8));
            }
        } else {
            int temp = len % 8;
            for (int i = 0; i < 8 - temp; i++) {
                str = str + "0";
            }
            len = str.length();
            for (int i = 0; i < len; i = i + 8) {
                System.out.println(str.substring(i, i + 8));
            }
        }
    }
}

55555 - HJ5 进制转换

// https://www.nowcoder.com/practice/8f3df50d2b9043208c5eed283d1d4da6
import java.util.Scanner;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNext()) {
            String str = in.next();
            // 八进制数以数字0开头、十六进制以0x开头
            if(str.charAt(0) == '0'){
                int number = Integer.parseInt(str.substring(2), 16);
                System.out.println(number);
            }else {
                int number = Integer.parseInt(str, 16);
                System.out.println(number);
            } 
        }
    }
}

55555 - HJ6 质数因子

// https://www.nowcoder.com/practice/196534628ca6490ebce2e336b47b3607
// 描述：功能:输入一个正整数，按照从小到大的顺序输出它的所有质因子（重复的也要列举）（如180的质因子为2 2 3 3 5 ）
// 输入描述：输入一个整数
// 输出描述：按照从小到大的顺序输出它的所有质数的因子，以空格隔开。
// 示例1
// 输入：180
// 输出：2 2 3 3 5
import java.util.Scanner;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextInt()) {
            long num = in.nextLong();
            // 一个正整数只有一个质因子是大于其平方根，这个质因子就是它本身
            long k = (long) Math.sqrt(num);
            for (long i = 2; i <= k; i++) {
                while (num % i == 0) {
                    System.out.print(i + " ");
                    num = num / i;
                }
            }
            System.out.println(num == 1 ? "": num + "");
        }
    }
}

55555 - HJ8 合并表记录

// https://www.nowcoder.com/practice/de044e89123f4a7482bd2b214a685201
import java.util.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNext()){
            int nums = in.nextInt();
            // HashMap执行结果未按照index升序
            // Map<Integer, Integer> map = new HashMap<>();     
            // TreeMap默认按照key进行升序排序，也可以自定义排序规则
            Map<Integer, Integer> map = new TreeMap<>();
            for (int i = 0; i < nums; i++) {
                int key = in.nextInt();
                int value = in.nextInt();
                // map.put(key, map.getOrDefault(key, 0) + value);
                if (map.containsKey(key)){
                    map.put(key, map.get(key) + value);
                }else {
                    map.put(key, value);
                }
            }
            // 遍历输出方式一：
            // for(Integer key : map.keySet()){
            //     System.out.println(key + " " + map.get(key));
            // }
            // 遍历输出方式二：
            for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
                System.out.println(entry.getKey() + " " + entry.getValue());
            }
        }
    }
    public void test() {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextLine()) {
            int nums = Integer.parseInt(in.nextLine());
            // 使用数组会报错内存溢出
            // int[] result = new int[11111112];
            Map<Integer, Integer> map = new TreeMap<>();
            for(int i = 0; i < nums; i++){
                String b = in.nextLine();
                String[] strs = b.split(" ");
                int key = Integer.parseInt(strs[0]);
                int value = Integer.parseInt(strs[1]);
                // result[index] = result[index] + value;
                if (map.containsKey(key)){
                    map.put(key, map.get(key) + value);
                }else {
                    map.put(key, value);
                }
            }
            for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
                System.out.println(entry.getKey() + " " + entry.getValue());
            }  
        }
    }
}

HJ10 字符个数统计

// https://www.nowcoder.com/practice/eb94f6a5b2ba49c6ac72d40b5ce95f50
import java.util.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNext()) { // 注意 while 处理多个 case
            String str = in.next();
            Set<Character> set = new HashSet<>();
            for(int i = 0; i < str.length(); i++){
                char ch = str.charAt(i);
                set.add(ch);
            }
            System.out.println(set.size());
        }
    }
}

HJ11 数字颠倒

// https://www.nowcoder.com/practice/ae809795fca34687a48b172186e3dafe
import java.util.Scanner;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextInt()) { // 注意 while 处理多个 case
            int num = in.nextInt();
            String str = String.valueOf(num);
            for(int i = str.length() - 1; i >= 0; i--){
                System.out.print(str.charAt(i));
            }
        }
    }
}

HJ12 字符串反转

// https://www.nowcoder.com/practice/e45e078701ab4e4cb49393ae30f1bb04
import java.util.Scanner;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNext()) { // 注意 while 处理多个 case
            String str = in.next();
            for(int i = str.length() - 1; i >= 0; i--){
                System.out.print(str.charAt(i));
            }
        }
    }
}

HJ13 句子逆序

// https://www.nowcoder.com/practice/48b3cb4e3c694d9da5526e6255bb73c3
import java.util.Scanner;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 必须使用hasNextLine，而不能使用hasNext，使用hasNext，只会读取第一个字符串
        while (in.hasNextLine()) {
            String str = in.nextLine();
            String[] strs = str.split(" ");
            for(int i = strs.length - 1; i >= 0; i--){
                System.out.print(strs[i] + " ");
            }
        }
    }
}

55555 - HJ14 字符串排序

// https://www.nowcoder.com/practice/5af18ba2eb45443aa91a11e848aa6723
import java.util.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNext()) {
            List<String> list = new ArrayList<>();
            int num = in.nextInt();
            for(int i = 0; i < num; i++){
                String str = in.next();
                list.add(str);
            }
            // 按照字典序排列
            Collections.sort(list);
            // 按照字典序逆序排列
            Collections.sort(list, (o1, o2) -> o2.compareTo(o1));
            for(String str : list){
                System.out.println(str);
            } 
        }
    }
}

55555 - HJ15 求int型正整数在内存中存储时1的个数

进行转换 - 1

https://blog.csdn.net/besto229/article/details/75796033
https://blog.csdn.net/u012027907/article/details/77683813

// https://www.nowcoder.com/practice/440f16e490a0404786865e99c6ad91c9
import java.util.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextInt()) {
            int number = in.nextInt();
            // 将十进制数转换为二进制数
            String binary = Integer.toBinaryString(number);
            // 将十进制数转换为八进制数
            String octal = Integer.toOctalString(number);
            // 将十进制数转换为十六进制数
            String hex = Integer.toHexString(number);
            // 将其他进制数转换为十进制数，2表示需转换的字符串为二进制
            int num = Integer.parseInt("100", 2);   // 4
            int count = 0;
            for(int i = 0; i < binary.length(); i++){
                if(binary.charAt(i) == '1') count++;
            }
            System.out.println(count);
        }
    }
    // 方法二：
    public void test() {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextInt()) {
            int number = in.nextInt();
            //【1】需要一个长度为32的int数组来存储结果二进制
            int[] bit = new int[32];
            //【2】循环，把原始数除以2取得余数，这个余数就是二进制数，原始的数等于商。
            //  商如果不能再除以二，结束循环。
            int i = 0;
            while(number > 1){
                // 获取除以2的余数
                int b = number % 2;
                // 数字除以2的商 赋值给当前数字
                number = number / 2;
                bit[i++] = b;
                if(number < 2){
                    // 已经不能再把数除以2，就把该数直接放到数组的下一位
                    bit[i+1] = number;
                }
            }
            //【3】翻转数组，得到的才是最终二进制数组（此处求1的个数可以进行翻转，直接求值）
            for(int j = 0; j < bit.length / 2; j++){
                // 第一个数的值设置为最后一个数的值
                // 第二次的时候，i是1，把第二个数的值，赋值为倒数第二个
                int temp = bit[j];
                bit[j] = bit[bit.length - 1 - j];
                bit[bit.length - 1 - j] = temp;
            }
            int count = 0;
            for(int k = 0; k < bit.length; k++){
                if(bit[k] == 1) count++;
            }
            System.out.println(count);
        }
    }
}

55555 - HJ21 简单密码

// https://www.nowcoder.com/practice/7960b5038a2142a18e27e4c733855dac
import java.util.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    // 定义map容器存储按键对应数字字符的容器
    private static Map<String, String> map = new HashMap<>();
    // 静态初始化、加载map容器
    static{
        map.put("1", "1");
        map.put("abc", "2");
        map.put("def", "3");
        map.put("ghi", "4");
        map.put("jkl", "5");
        map.put("mno", "6");
        map.put("pqrs", "7");
        map.put("tuv", "8");
        map.put("wxyz", "9");
        map.put("0", "0");
    }
    public static void main(String[] args) {
       Scanner scanner = new Scanner(System.in);
       while(scanner.hasNext()){
           String str = scanner.nextLine();
           char[] chars = str.toCharArray();
           // 构造buffer容器存储转换后的字符串
           StringBuffer buffer = new StringBuffer();
           for(char ch : chars){
                //【1】小写字母转换为数字
                if(ch >= 'a' && ch <= 'z'){
                    // map容器中的key与字符进行校验并加密
                    Set<String> keys = map.keySet();
                    for(String key : keys){
                        if(key.contains(String.valueOf(ch))){
                            buffer.append(map.get(key));
                        } 
                    }
                //【2】如果是A - Y的大写字母则需要将其+32位转换成小写再向后移1位
                // 大写字母的ASCII范围：65-90
                // 小写字母的ASCII范围：97-122
                // 数字的ASCII范围：48-57
                }else if(ch >= 'A' && ch <= 'Y'){
                    char newChar = (char)(ch + 32 + 1);
                    buffer.append(newChar);
                //【2.1】如果是Z则加密成a
                }else if(ch == 'Z'){ 
                    buffer.append("a");
                //【3】数字和其它的符号都不做变换
                }else{
                    buffer.append(ch);
                }
           }
           System.out.print(buffer.toString());
       }
    }
    public void test() {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNext()) {
            char[] chars = in.next().toCharArray();
            // 明文密码
            char[] char1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789".toCharArray();
            // 明文密码 加密后的数组，根据索引与明文密码char1一一对应
            char[] char2 = "bcdefghijklmnopqrstuvwxyza222333444555666777788899990123456789".toCharArray();
            for(int i = 0; i < chars.length; i++){
                // 大写字母转小写
                if(chars[i] >= 'A' && chars[i] <= 'Z'){
                    chars[i] = char2[chars[i] - 'A'];
                // 小写字母转数字。前面是26个小写字母，所以要从索引26开始
                }else if(chars[i] >= 'a' && chars[i] <= 'z'){
                    chars[i] = char2[chars[i] - 'a' + 26];
                }
            }
            StringBuilder result = new StringBuilder();
            for(Character ch : chars){
                result.append(ch);
            }
            System.out.println(result);
        }
    }
}

HJ22 汽水瓶

// https://www.nowcoder.com/practice/fe298c55694f4ed39e256170ff2c205f
import java.util.Scanner;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextInt()) { // 注意 while 处理多个 case
            int num = in.nextInt();
            if(num == 0){
                break;
            }
            int result = 0;
            while(num > 1){
                if(num == 2){
                    num++;
                }
                // 每轮循环获取的汽水瓶数：num/3
                result = result + num / 3;
                // 每轮循环后剩余的空瓶子数：新兑换的汽水形成的空瓶子 + 当前循环剩余的空瓶子
                num = num / 3 + num % 3;
                // if(num % 3 == 0){
                //     num = num / 3;
                //     result = result + num;
                // }else if(num % 3 == 1){    
                //     result = result + num / 3;
                //     num = num / 3 + 1;
                // }else if(num % 3 == 2){  
                //     result = result + num / 3;
                //     num = num / 3 + 2;
                // }
            }
            System.out.println(result);
        }
    }
}

HJ23 删除字符串中出现次数最少的字符

// https://www.nowcoder.com/practice/05182d328eb848dda7fdd5e029a56da9
import java.util.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNext()) {
            String str = in.next();
            //【1】统计每个字母的数量
            Map<Character, Integer> map = new HashMap<>();
            for(int i = 0; i < str.length(); i++){
                int value = map.getOrDefault(str.charAt(i), 0);
                map.put(str.charAt(i), value + 1);
            }
            // //【2】找到数量最少的字符数量
            // Collection<Integer> values = map.values();
            // int min = Collections.min(values);
            // //【3】用空字符串替换该字母
            // for(Character ch : map.keySet()) {
            //     if (map.get(ch) == min){
            //         str = str.replaceAll(String.valueOf(ch), "");
            //     }
            // }
            // System.out.println(str);
            //【2】找到数量最少的字符数量
            int minConut = Integer.MAX_VALUE;
            for (int times : map.values()) {
                minConut = Math.min(minConut, times);
            }
            //【3】剔除最少数量的字符
            StringBuilder res = new StringBuilder();
            for(char ch : str.toCharArray()) {
                if (map.get(ch) != minConut) {
                    res.append(ch);
                }
            }
            System.out.println(res.toString());
            // 需要有序的map对结果进行收集
            // Map<Character, Integer> map1 = new LinkedHashMap<>();
            // map.entrySet().stream().sorted((o1, o2) -> o1.getValue() - o2.getValue())
                                    // .forEach(e -> map1.put(e.getKey(), e.getValue()));
        }
    }  
    public void test() {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNext()) {
            String str = in.next();
            //【1】统计输入字符串中每个字符的个数（小写字母有32位）
            int[] chars = new int[32];
            for(int i = 0; i < str.length(); i++){
                char ch = str.charAt(i);
                chars[ch - 'a']++;
            }
            //【2】求出字符串中字符出现最少的数量
            int min = Integer.MAX_VALUE;
            for(int num : chars){
                if(num > 0){
                    min = Math.min(min, num);
                }
            }
            //【3】外层遍历输入的字符串，内层遍历字符对应的数量
            StringBuffer result = new StringBuffer();
            for(int i = 0; i < str.length(); i++){
                for(int j = 0; j < chars.length; j++){
                    // 当遍历字符 与 数组下标对应字符相等，并且字符数量大于最小值时，加入结果集
                    if(str.charAt(i) == (char)(j + 97) && chars[j] > min){
                        result.append(str.charAt(i));
                        break;
                    }
                }
            }
            System.out.println(result.toString());
        }
    }
}

HJ31 单词倒排

// https://www.nowcoder.com/practice/81544a4989df4109b33c2d65037c5836
import java.util.Scanner;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextLine()) {
            String str = in.nextLine();
            for(int i = 0; i < str.length(); i++){
                char ch = str.charAt(i);
                if(ch >= 'a' && ch <= 'z'){
                }else if(ch >= 'A' && ch <= 'Z'){
                }else{
                    str = str.replace(ch, ' ');
                }
            }
            String[] strs = str.split(" ");
            for(int i = strs.length - 1; i >= 0; i--){
                System.out.print(strs[i].trim() + " ");
            }
        }
    }
}

HJ34 图片整理

// https://www.nowcoder.com/practice/2de4127fda5e46858aa85d254af43941
import java.util.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNext()) {
            String str = in.next();
            List<Character> list = new ArrayList<>();
            for(int i = 0; i < str.length(); i++){
                list.add(str.charAt(i));
            }
            Collections.sort(list);
            for(Character ch : list){
                System.out.print(ch);
            } 
        }
    }
}

HJ35 蛇形矩阵 - 1111122222

对角线赋值

// https://www.nowcoder.com/practice/649b210ef44446e3b1cd1be6fa4cab5e
// 蛇形矩阵是由1开始的自然数依次排列成的一个矩阵上三角形。
// 例如，当输入5时，应该输出的三角形为：
//     1 3 6 10 15
//     2 5 9 14
//     4 8 13
//     7 12
//     11
// 输入描述：输入正整数N（N不大于100）
// 输出描述：输出一个N行的蛇形矩阵
// 输入：4
// 输出：
//     1 3 6 10
//     2 5 9
//     4 8
//     7
import java.util.Scanner;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextInt()) {
            int num = in.nextInt();
            int[][] result = new int[num][];
            // 初始化第一个值
            int value = 1;    
            for(int i = 0; i < num; i++){
                // 第i行有n-i个元素
                result[i] = new int[num - i];
                for(int j = 0; j <= i; j++){
                    // 对第i个对角线赋值（从左下到右上赋值：行数依次向上减少、列数依次向右增加）
                    result[i-j][j] = value;
                    value++;
                }
            }
            for(int[] rows : result){
                for(int col : rows){
                    System.out.print(col + " ");
                }  
                System.out.println();
            }
        }
    }
}

55555 - HJ37 统计每个月兔子的总数

// https://www.nowcoder.com/practice/1221ec77125d4370833fd3ad5ba72395
// 有一种兔子，从出生后第3个月起每个月都生一只兔子，小兔子长到第三个月后每个月又生一只兔子。
// 例子：假设一只兔子第3个月出生，那么它第5个月开始会每个月生一只兔子。
// 一月的时候有一只兔子，假如兔子都不死，问第n个月的兔子总数为多少？
// 输入：3
// 输出：2
// 输入：5
// 输出：5
import java.util.Scanner;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextInt()) {
            int num = in.nextInt();
            int k1 = 1;     // 第一个月，刚出生的兔子数量
            int k2 = 0;     // 第二个月，不可生育的兔子数量
            int k3 = 0;     // 第三个月，可以生育的兔子数量
            // 从第二个月开始，到第num个月结束
            for(int i = 2; i <= num; i++){
                // 每增加一个月，可以生育的兔子数量 = 先前可生育数量 + 先前不可生育数量
                k3 = k3 + k2;
                // 每增加一个月，不可生育的兔子数量 = 先前刚出生数量
                k2 = k1;
                // 每增加一个月，刚出生兔子数量 = 先前可以生育兔子数量
                k1 = k3;
            }
            System.out.println(k1 + k2 + k3);
        }
    }
}

55555 - HJ40 统计字符

// https://www.nowcoder.com/practice/539054b4c33b4776bc350155f7abd8f5
import java.util.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextLine()) {
            String str = in.nextLine();
            // HashMap是无序的，LinkedHashMap是有序的，且默认为插入顺序
            Map<String, Integer> map = new LinkedHashMap<>();
            map.put("yinwen", 0);
            map.put("kongge", 0);
            map.put("shuzi", 0);
            map.put("qita", 0);
            for(int i = 0; i < str.length(); i++){
                char ch = str.charAt(i);
                if(ch >= 'a' && ch <= 'z'){
                    map.put("yinwen", map.getOrDefault("yinwen", 0) + 1);
                }else if(ch >= 'A' && ch <= 'Z'){
                    map.put("yinwen", map.getOrDefault("yinwen", 0) + 1);
                }else if(ch >= '0' && ch <= '9'){
                    map.put("shuzi", map.getOrDefault("shuzi", 0) + 1);
                }else if(ch == ' '){
                    map.put("kongge", map.getOrDefault("kongge", 0) + 1);
                }else{
                    map.put("qita", map.getOrDefault("qita", 0) + 1);
                }
            }
            for (Map.Entry<String, Integer> entry : map.entrySet()) {
                System.out.println(entry.getValue());
            }
        }
    }
}