蓝桥杯题库——部分简单题题解（Java）

一、划分位数求解型

01数位倍数

解题思路：

**1.分析题目：**题目要求关键在于求每个数位的和，所以我们考虑将每个数位单独分离出来，然后用判断语句计数。

2.分离要点： 因为题目要从1找到202504，遂考虑先用for循环遍历数字，然后将每个数 i 赋值给num，再通过while 循环计算它的各个数位之和。在while循环中，每次通过num%10 获取num 的最后一位数字(分离数位的关键)并累加到sum中，然后通过num=num/10去掉num 的最后一位数字，直到num变为 0(通过这种方式筛查1--202504中的所有数字)，此时sum 就是该数的各个数位之和。

**3.输出结果：**最后输出sum即为答案。

完整代码：

复制代码

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        int count = 0;
        for (int i = 1; i <= 202504; i++) {
            int num = i; 
            int sum = 0; 
            while (num > 0) {
                sum += num % 10; 
                num = num / 10; 
            }
            if (sum % 5 == 0) { 
                count++;
            }
        }
        System.out.print(count);
        scan.close();
    }
}

02好数

解题思路1：（暴力版）

1.关键拆分步骤： 拆分数字的各个位数，对于每个数 i，通过取余和整除运算，分别得到它的个位（a）、十位（b）、百位（c）、千位（d）、万位（e）、十万位（f）、百万位（g）上的数字。

2.判断是否为好数：

当数 i 小于等于 10 时,直接判断个位数字 a 是否为奇数（a % 2 != 0），如果是，说明是 "好数"，count 加 1。
当数 i 小于等于 100 时，判断十位数字 b 是否为偶数（b % 2 == 0）且个位数字 a 是否为奇数（a % 2 != 0），如果是，count 加 1。
以此类推，对于三位数、四位数等更多位数的数，按照 "奇数位上的数字是奇数，偶数位上的数字是偶数" 的规则，分别判断各位数字是否符合条件，若都符合，count 加 1。

完整代码：

复制代码

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        int N=scan.nextInt();
        int count=0;
        for(int i=0;i<N;i++){
          int a=i%10;
          int b=i/10%10;
          int c=i/100%10;
          int d=i/1000%10;
          int e=i/10000%10;
          int f=i/100000%10;
          int g=i/1000000%10;
        
        if (i<=10 && a%2!=0){
          count++;
        }else if(i<=100 && b%2==0 && a%2!=0){
          count++;
        }else if(i<=1000 && c%2!=0 && b%2==0 && a%2!=0){
          count++;
        }else if(i<=10000 && d%2==0 && c%2!=0 && b%2==0 && a%2!=0){
          count++;
        }else if(i<=100000 && e%2!=0 && d%2==0 && c%2!=0 && b%2==0 && a%2!=0){
          count++;
        }else if(i<=1000000 && f%2==0 && e%2!=0 && d%2==0 && c%2!=0 && b%2==0 && a%2!=0){
          count++;
        }else if(i<=10000000 && g%2!=0 && f%2==0 && e%2!=0 && d%2==0 && c%2!=0 && b%2==0 && a%2!=0){
          count++;
        }
        }
        System.out.println(count);
        scan.close();
    }
}

解题思路2：

1.内层逐位判断：验证 "好数" 规则

用while循环逐位提取数字i的每一位：通过num % 10获取当前最低位，仍然通过num = num / 10移除已判断的低位。

用digitPos记录当前数位（从 1 开始，对应个位为 "第 1 位"），动态判断：

若digitPos为奇数（个位、百位等），则要求当前位digit为奇数，否则标记为 "非好数" 并跳出循环；

若digitPos为偶数（十位、千位等），则要求当前位digit为偶数，否则标记为 "非好数" 并跳出循环。

2.统计结果：累计符合条件的数量

若某个数字i通过所有位的判断（isGood保持true），则count计数加 1，最终输出count即为结果。

完整代码：

复制代码

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int N = scan.nextInt();
        int count = 0;
        
        for (int i = 1; i < N; i++) { // 遍历1到N-1的数
            int num = i;
            int digitPos = 1; // 记录当前数位（从个位开始，即第1位）
            boolean isGood = true; // 标记是否为好数
            
            while (num > 0) {
                int digit = num % 10; // 提取当前位（先个位，再十位...）
                
                // 判断当前位是否符合规则：奇数位为奇数，偶数位为偶数
                if (digitPos % 2 == 1) { // 奇数位（1、3、5...）
                    if (digit % 2 == 0) { // 若为偶数则不符合
                        isGood = false;
                        break;
                    }
                } else { // 偶数位（2、4、6...）
                    if (digit % 2 == 1) { // 若为奇数则不符合
                        isGood = false;
                        break;
                    }
                }
                
                num = num / 10; // 移除已判断的位
                digitPos++; // 数位+1（下一位是更高位）
            }
            
            if (isGood) {
                count++;
            }
        }
        
        System.out.println(count);
        scan.close();
    }
}

改进优点：

对比维度	逐位动态判断	固定位数判断（暴力）
1. 通用性	不限制数字位数，无论是 1 位、3 位还是 10 位数字，都能正常判断，适配任意 N（如 N=100000000 时仍可运行）。	仅覆盖 1 到 7 位数字（通过`a-g`固定变量提取位），若 N 超过 10000000（8 位及以上），会漏判或错判。
2. 可维护性	逻辑集中，若 "好数" 规则修改（如 "奇数位为偶数"），仅需修改`if`条件中的判断（如把`digit%2==0`和`digit%2==1`互换），改动成本极低。	规则修改需逐个修改 7 个`else if`中的判断条件（如`a%2!=0`、`b%2==0`等），改动繁琐且易出错。
3. 代码简洁性	代码行数少（约 30 行），仅用 1 个`while`循环处理所有位数，逻辑无冗余。	代码冗余（重复写 7 个位数的判断条件），且包含无效判断（如`i<=10`时仍会定义`c-g`等无用变量）。
4. 逻辑严谨性	遍历从 1 开始，精准对应 "1 到 N-1" 的统计范围，无多余判断（如 0 不会被计入，符合常规 "好数" 的统计场景）。	遍历从 0 开始，会额外判断 0（0 不符合 "好数" 规则，虽不影响结果，但属于无效计算）；且固定位数判断易因边界条件（如`i=100`时误判）出错。

03 2025

解题思路：

1. 明确目标

要统计在 1 到 20250412 范围内，满足 "数字中至少含有 1 个 0、2 个 2、1 个 5" 条件的数的个数。

2. 遍历范围

使用 for 循环从 1 遍历到 20250412，逐个检查每个数是否符合条件。

3. 统计数字出现次数

对于每个数 i，通过不断取余（%10）和整除（/ 10）的操作，依次提取其每一位数字。

定义三个变量 zero、two、five，分别用于统计当前数中 0、2、5 出现的次数。
每提取出一位数字，就判断该数字是 0、2 还是 5，并对应地增加相应变量的计数。

4. 判断是否符合条件

在提取完当前数的所有位并统计好 0、2、5 的出现次数后，检查是否满足 "至少 1 个 0、至少 2 个 2、至少 1 个 5" 的条件。如果满足，就将计数器 count 加 1。

5. 输出结果

遍历完所有数后，输出count 的值，即为满足条件的数的总个数。

完整代码：

复制代码

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        int count=0;

        for (int i=1;i<=20250412;i++){
            int num=i;
            int zero=0;
            int two=0;
            int five=0;
            
            int d1=num%10;
            if(num>0){
                if (d1==0){
                    zero++;
                }else if(d1==2){
                    two++;
                }else if(d1==5){
                    five++;
                }
            }

            num=num/10;
            int d2=num%10;
            if(num>0){
                if (d2==0){
                    zero++;
                }else if(d2==2){
                    two++;
                }else if(d2==5){
                    five++;
                }
            }
            num=num/10;
            int d3=num%10;
            if(num>0){
                if (d3==0){
                    zero++;
                }else if(d3==2){
                    two++;
                }else if(d3==5){
                    five++;
                }
            }
            num=num/10;
            int d4=num%10;
            if(num>0){
                if (d4==0){
                    zero++;
                }else if(d4==2){
                    two++;
                }else if(d4==5){
                    five++;
                }
            }
            num=num/10;
            int d5=num%10;
            if(num>0){
                if (d5==0){
                    zero++;
                }else if(d5==2){
                    two++;
                }else if(d5==5){
                    five++;
                }
            }
            num=num/10;
            int d6=num%10;
            if(num>0){
                if (d6==0){
                    zero++;
                }else if(d6==2){
                    two++;
                }else if(d6==5){
                    five++;
                }
            }
            num=num/10;
            int d7=num%10;
            if(num>0){
                if (d7==0){
                    zero++;
                }else if(d7==2){
                    two++;
                }else if(d7==5){
                    five++;
                }
            }
            num=num/10;
            int d8=num%10;
            if(num>0){
                if (d8==0){
                    zero++;
                }else if(d8==2){
                    two++;
                }else if(d8==5){
                    five++;
                }
            }
            
            if(zero>=1 && two>=2 && five>=1){
            count++;
        }
        }
        System.out.println(count);
        scan.close();
    }
}

二、字符串型

01确定字符串是否包含唯一字符

解题思路：

1.明确目标

题目需要我们识别一个字符串里每个字符是否只出现一次，因此先第一步先读取字符串。

2.考虑识别方式

第一时间考虑到用双循环遍历，实现相互对照。因此顺势引入boolean变量isUnique，默认值为 true（表示字符默认是唯一的。

3.双重循环遍历查找

用双重 for 循环遍历所有字符：外层循环遍历每个字符（索引 i），内层循环遍历 i 之后的所有字符（索引 j）。

4.注意限定条件

题目显示忽略字母大小写，因此需要对每对字符进行

复制代码

Character.toLowerCase(str.charAt(i))

和

复制代码

Character.toLowerCase(str.charAt(j))

操作，即先转换为同一大小写（如小写）后比较，若存在位置（i != j）不同但字母相同则将 isUnique 设为 false，并立即跳出循环。

5.输出答案

根据boolean isUnique 的值输出 YES 或 NO。

涉及知识点：

字符串操作：
- length()：返回字符串的长度，用于确定循环的边界。
- charAt(int index)：返回字符串指定索引位置的字符。
字符大小写转换：Character.toLowerCase(char c)（或 toUpperCase）将字符转换为小写（或大写），确保比较时忽略大小写差异。

（ toLowerCase() 方法用于将大写字符转换为小写。

语法

复制代码

char toLowerCase(char ch)

参数

ch -- 要转换的字符。

返回值

返回转换后字符的小写形式，如果有的话；否则返回字符本身。

实例

复制代码

public class Test {
    public static void main(String args[]) {
        System.out.println(Character.toLowerCase('a'));
        System.out.println(Character.toLowerCase('A'));
    }
}

以上程序执行结果为：

a

a

）

3.双重循环与条件判断 ：通过两层 for 循环遍历所有字符对，结合 if 语句判断字符是否重复，以及控制循环的提前终止（break）。

完整代码：

复制代码

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
       String str = scan.nextLine();
        int len = str.length();
        scan.close();
        boolean isunique=true;

        for (int i = 0; i < len; i++) {
            for (int j = i+1; j < len; j++) {
                char c=Character.toLowerCase(str.charAt(i));
                char d=Character.toLowerCase(str.charAt(j));
                if ( i!=j &&c==d) {
                    isunique = false;
                    break;
                }
            }
        }
        if (isunique){
            System.out.println("YES");
        }else{
            System.out.println("NO");
        }
    }
}

02确定字符串是否是另一个的排列

解题思路：

1.明确目标

题目要求对比两段字符串排列关系，那么先找到核心条件

长度完全相同；
字符组成完全相同（每个字符的出现次数一致，顺序可不同）。

2.选择方法

使用排序比较法，即将两个字符串转为字符数组并排序，若排序后数组完全一致，则是排列。

3.将字符串转换为数组并排序

首先使用toCharArray() 将字符串转换为字符数组（便于对单个字符操作）；然后用Arrays.sort() 对字符数组升序排序（若两字符串是排列，排序后数组应完全相同）。

4.数组相等判断与结果输出：

使用Arrays.equals(s1, s2) 逐元素比较两个字符数组，若完全相同则返回 true，否则返回 false。然后根据比较结果，输出 YES（是排列）或 NO（不是排列）。

5.注意导入类：

复制代码

import java.util.Arrays;

涉及知识点：

1.字符串操作：String.toCharArray() 实现字符串与字符数组的转换。

（ toCharArray() 方法将字符串转换为字符数组。

语法

复制代码

public char[] toCharArray()

参数

返回值

字符数组。

实例

复制代码

public class Test {
    public static void main(String args[]) {
        String Str = new String("www.runoob.com");

        System.out.print("返回值 :" );
        System.out.println( Str.toCharArray() );
    }
}

以上程序执行结果为：
复制代码
返回值 :www.runoob.com

）

2.数组排序：Arrays.sort() 对字符数组的排序功能。

public static void sort(Object[] a)

对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。

本题中所使用的Arrays.sort(char[]) 即对字符数组按 ASCII 码升序排序。

3.数组比较：Arrays.equals(s1, s2) 逐元素比较两个字符数组

public static boolean equals(long[] a, long[] a2)

如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。

完整代码：

复制代码

import java.util.Scanner;
import java.util.Arrays;
// 1:无需package
// 2: 类名必须Main, 不可修改

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        String str1= scan.nextLine();
        String str2= scan.nextLine();
        scan.close();

        char[] s1 = str1.toCharArray();
        char[] s2 = str2.toCharArray();
        Arrays.sort(s1);
        Arrays.sort(s2);

        boolean issim = Arrays.equals(s1, s2);

        if (issim==true){
            System.out.println("YES");
        }else{
            System.out.println("NO");
        }
    }
}