2024 蓝桥打卡Day38

看真题考点讲解

代码练习

数位排序

package THL_0410;

import java.util.*;

public class NumericalSorting {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);  // 创建一个 Scanner 对象来读取输入

        int n = s.nextInt();  // 读取一个整数 n，表示接下来会输入 n 个数值
        int[][] f = new int[n][2];  // 创建一个二维数组 f，每个元素有两个值：数值和数位之和

        // 循环读取 n 个数值并计算数位之和
        for (int i = 0; i < n; i++) {
            f[i][0] = i + 1;  // 数值从 1 开始，存储在 f[i][0] 中
            String x = f[i][0] + "";  // 将数值转换为字符串以便逐位相加
            for (char a : x.toCharArray()) {
                f[i][1] += a - '0';  // 逐位相加得到数位之和，存储在 f[i][1] 中
            }
        }

        // 使用 Arrays.sort 对二维数组 f 进行排序
        // 按照数位之和升序排序，如果数位之和相同，则按照数值升序排序
        Arrays.sort(f, (o1, o2) -> o1[1] == o2[1] ? o1[0] - o2[0] : o1[1] - o2[1]);

        int m = s.nextInt();  // 读取一个整数 m，表示查询第 m 小的数

        // 输出排序后的第 m 个数的数值
        System.out.println(f[m - 1][0]);
    }
}

阶乘累计和

package THL_0410;

import java.util.*;

public class FactorialCumulativeSum {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        long res = 1;  // 用于存储当前数字的阶乘初始值为1
        long mod = (long) 1e9;  // 取模的值为 10 的 9 次方
        long sum = 0;  // 用于存储累加和的初始值为0

        // 循环从1到100
        for (int i = 1; i <= 100; i++) {
            // 计算当前数字的阶乘，乘以之前的阶乘结果
            res = (res * i) % mod;  // 更新 res 为 (res * i) % mod
            sum = (sum + res) % mod;  // 更新 sum 为 (sum + res) % mod
            System.out.println(sum);  // 打印当前的累加和
        }
    }
}

句子反转

package THL_0410;

import java.util.Scanner;

public class SentenceReversal {

    public static void main(String[] args) {
        // 创建 Scanner 对象来获取用户输入
        Scanner sc = new Scanner(System.in);
        // 读取用户输入的字符串
        String s = sc.nextLine();
        // 将字符串转换为字符数组
        char[] c = s.toCharArray();
        // 创建两个 StringBuilder 对象，一个用于存储结果，另一个用于存储当前单词或数字
        StringBuilder str = new StringBuilder();
        StringBuilder a = new StringBuilder();

        // 从字符串末尾开始遍历字符数组
        for (int i = c.length - 1; i >= 0; i--) {
            // 如果当前字符是空格，则说明一个单词或数字结束
            if (c[i] == ' ') {
                // 如果当前单词或数字不为空，则处理并添加到结果中
                if (a.length() != 0) {
                    // 如果当前单词或数字的首字符是数字，则将其逆序
                    int k = a.charAt(0) - '0';
                    if (k >= 0 && k <= 9) {
                        a.reverse();
                    }
                }
                // 将当前单词或数字添加到结果中，并加上空格
                str.append(a.toString() + " ");
                // 重置当前单词或数字的 StringBuilder
                a = new StringBuilder();
            } else {
                // 如果当前字符不是空格，则将其添加到当前单词或数字的 StringBuilder 中
                char x = c[i];
                // 如果是字母，则转换为大写
                if ((x >= 'a' && x <= 'z') || (x >= 'A' && x <= 'Z')) {
                    x = (char) (x ^ 32);
                }
                // 将字符插入到当前单词或数字的 StringBuilder 的开头
                a.insert(0, x);
            }
        }

        // 处理最后一个单词或数字
        if (a.length() != 0) {
            // 如果最后一个单词或数字的首字符是数字，则将其逆序
            int k = a.charAt(0) - '0';
            if (k >= 0 && k <= 9) {
                a.reverse();
            }
        }
        // 将最后一个单词或数字添加到结果中
        str.append(a);

        // 打印最终结果
        System.out.println(str);
    }
}

k倍区间序列

package THL_0410;

import java.util.*;

public class SequenceKTimesInterval {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        
        // 读取输入的整数n和k
        int n = scan.nextInt(); // 输入的整数个数
        int k = scan.nextInt(); // k 用来判断能否被整除
        
        int[] f = new int[k]; // 用于存储和为k的倍数的子序列个数
        f[0] = 1; // 初始情况下和为0的子序列有1个，即空子序列
        long res = 0, sum = 0; // res用于存储结果，sum用于计算当前子序列的和

        // 循环读取输入的整数，计算子序列和能被k整除的数量
        for (int i = 0; i < n; i++) {
            int x = scan.nextInt(); // 读取下一个整数
            sum += x; // 更新当前子序列的和
            res += f[(int) (sum % k)]; // 更新结果，加上和为(sum % k)的子序列数量
            f[(int) (sum % k)]++; // 更新和为(sum % k)的子序列数量
        }

        System.out.println(res); // 输出结果
    }
}