蓝桥杯Java打卡 筛选条件 省赛B组题【2024.03.21更新】

P8752 [蓝桥杯 2021 省 B2] 特殊年份

题目 P8752 [蓝桥杯 2021 省 B2] 特殊年份

题解

import java.util.Scanner;

public class SpecialYear {

	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
		int[] num = new int[5];
		for(int i=0;i<5;i++) {
			num[i]=sc.nextInt();
		}
		int sum = 0;
		for(int i=0;i<5;i++) {
			int gw = num[i]%10;
			int sw = num[i]/10%10;
			int bw = num[i]/100%10;
			int qw = num[i]/1000;
			if(qw==sw&&gw==bw+1) {
				sum++;
			}
			
		}
		System.out.println(sum);
	}
}

P8780 [蓝桥杯 2022 省 B] 刷题统计

题目 P8780 [蓝桥杯 2022 省 B] 刷题统计

题解

import java.util.Scanner;

public class StatisticsOfQuestions {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        long a = sc.nextLong();  // 输入a
        long b = sc.nextLong();  // 输入b
        long n = sc.nextLong();  // 输入n
        sc.close();

        long sum = 0;  // 用来统计做了几道题
        long c = a * 5 + b * 2;  // 一整周做的题
        long d = n / c;  // 有几个完整的周
        long day = 0;  // 统计天数
        long r = n % c;  // 除去前面完整的周，最后剩下的不满一整周做的题总数

        // 判断是否周五前是否满足
        for (int i = 1; i <= 5; i++) {
            sum += a;
            if (sum < r) {
                day++;
            } else {
                day++;
                break;
            }
        }

        if (sum < r) {
            // 判断到周六和周日哪一天满足要求
            for (int j = 1; j <= 2; j++) {
                sum += b;
                if (sum < r) {
                    day++;
                } else {
                    day++;
                    break;
                }
            }
        }

        System.out.println(d * 7 + day);  // d就是前面完整的周有d周，day为最后不满一整周的天数
    }
}

P8711 [蓝桥杯 2020 省 B1] 整除序列

题目 P8711 [蓝桥杯 2020 省 B1] 整除序列

题解

import java.util.Scanner;

public class DivisibleSequence {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		long num = sc.nextLong();
		System.out.print(num+" ");
		while(num!=1) {
			num = num/2;
			System.out.print(num+" ");
			
		}
	}
}

P8680 [蓝桥杯 2019 省 B] 特别数的和

题目 P8680 [蓝桥杯 2019 省 B] 特别数的和

题解

import java.util.Scanner;

public class SumOfSpecialNumbers {
	public static void main(String[] args) {
		/**在循环中，int b = i; 将当前数字 i 赋值给变量 b。然后进入 while 循环，该循环会一直执行直到 b 的值变为 0。
		  *每次循环迭代中，int a = b % 10; 会取 b 的个位数赋值给 a，然后检查这个个位数是否为 2、0、1 或 9。
		  *如果是，就进行计数和求和。接着执行 b /= 10;，这个操作会将 b 的值除以 10，自动去除了最右边的一位数，然后将结果赋给 b。
		  *这样就可以继续下一次循环，直到 b 的值变成 0。
		  *这种方式能够确保每次处理的数字都是去除了前置的 0 的。因为整数除以 10 会去掉最右边的一位数，而前置的 0 在整数除法中会被忽略。
		  *所以，这段代码可以正确地规避前置为 0 的情况，确保每一位数都被正确地检查，并计算了满足条件的数字的和。
		 */
		Scanner sc= new Scanner(System.in);
		int num =sc.nextInt();//当num=40时
		int sum = 0;
		for (int i = 1; i <=num; i++) {
			int b = i;//b=39
			while(b!=0){
				int a = b%10; //a=b%10=9 
				if( a==2 || a==0 || a==1 || a==9 ){
					sum = sum + i;
					break;
				}
			b/=10; //b=b/10=3
			}
		}
		System.out.println(sum);
	}
}

P9240 [蓝桥杯 2023 省 B] 冶炼金属

题目 P9240 [蓝桥杯 2023 省 B] 冶炼金属

题解

import java.util.Arrays;
import java.util.Scanner;

public class SmeltingMetal {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt(); // 输入冶炼记录的数目
        int[] min = new int[n]; // 存储每次冶炼的最小熔炼次数
        int[] max = new int[n]; // 存储每次冶炼的最大熔炼次数

        // 读取每条冶炼记录，计算最小和最大熔炼次数
        for (int i = 0; i < n; i++) {
            int a = scanner.nextInt(); // 本次投入的普通金属数量
            int b = scanner.nextInt(); // 冶炼出的特殊金属数量
            // 计算本次冶炼的最小熔炼次数：(a / (b + 1)) + 1
            min[i] = (a / (b + 1)) + 1;
            // 计算本次冶炼的最大熔炼次数：a / b
            max[i] = a / b;
        }

        // 对最小和最大熔炼次数数组进行排序
        Arrays.sort(min);
        Arrays.sort(max);

        // 输出结果，最小熔炼次数的最大值和最大熔炼次数的最小值
        System.out.print(min[n - 1] + " " + max[0]);
    }
}

[蓝桥杯 2013 省 B] 翻硬币

题目 [蓝桥杯 2013 省 B] 翻硬币

题解1

import java.util.Scanner;

public class FlippingCoins {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        // 从用户输入中获取两个字符串，分别表示初始状态和目标状态
        String a = sc.next();
        String b = sc.next();

        // 将两个字符串转换为字符数组，方便按索引比较每个硬币的状态
        char[] array01 = a.toCharArray();
        char[] array02 = b.toCharArray();

        // 获取数组长度（假设两个字符串的长度相同）
        int length = array01.length;

        // 用于存储最终的翻转次数
        int result = 0;

        // 遍历每个硬币的状态
        for(int i = 0; i < length; i++) {
            // 如果当前位置的硬币状态不同
            if(array01[i] != array02[i]) {
                // 从当前位置向后找到下一个不同的硬币状态
                for(int j = i + 1; j < length; j++) {
                    // 如果找到下一个不同的硬币状态
                    if(array01[j] != array02[j]) {
                        // 计算翻转次数并累加到result中
                        result += j - i ;
                        // 更新i的值，跳过已处理区间，并且跳出内层循环
                        i = j;
                        break;
                    }
                }
            }
        }

        // 输出最终的翻转次数
        System.out.println(result);
    }
}

题解2

import java.util.Scanner;

public class Main {
    static char[] aa; // 用于存储初始状态的硬币数组

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        aa = sc.next().toCharArray(); // 将第一行输入的字符串转换为字符数组，表示初始状态
        char[] bb = sc.next().toCharArray(); // 将第二行输入的字符串转换为字符数组，表示目标状态
        int count = 0; // 记录翻转次数

        // 遍历每个硬币的状态，从第一个到倒数第二个
        for (int i = 0; i < aa.length - 1; i++) {
            // 如果当前位置的硬币状态与目标状态不同
            if (aa[i] != bb[i]) {
                // 调用 reverse 方法翻转当前位置和下一个位置的硬币状态
                reverse(i);
                reverse(i + 1);
                // 翻转次数加一
                count++;
            }
        }

        // 输出最终的翻转次数
        System.out.println(count);
    }

    // 翻转指定位置的硬币状态
    private static void reverse(int i) {
        if (aa[i] == '*') aa[i] = 'o'; // 如果是星号，则翻转为圆圈
        else if (aa[i] == 'o') aa[i] = '*'; // 如果是圆圈，则翻转为星号
    }
}

P8623 [蓝桥杯 2015 省 B] 移动距离

题目 P8623 [蓝桥杯 2015 省 B] 移动距离

题解

import java.util.Scanner;

public class MovingDistance {
    static int result = 0;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int w = sc.nextInt();  // 排号宽度
        int h1 = sc.nextInt(); // 楼号 h1
        int h2 = sc.nextInt(); // 楼号 h2
        sc.close();

        // 计算行数差的绝对值
        result += Math.abs(hang(h1, w) - hang(h2, w));
        // 计算距离左边第一个数的距离之差的绝对值
        result += Math.abs(length(h1, w) - length(h2, w));
        System.out.print(result);
    }

    // 判断楼号所在的行数
    public static int hang(int h, int k) {
        if (h % k == 0) return h / k;
        else return h / k + 1;
    }

    // 计算每个楼号距离所在行的左边第一个楼号的距离
    public static int length(int h, int k) {
        if (hang(h, k) % 2 == 0) return hang(h, k) * k - h;
        else return h - 1 - (hang(h, k) - 1) * k;
    }
}

P8682 [蓝桥杯 2019 省 B] 等差数列

题目 P8682 [蓝桥杯 2019 省 B] 等差数列

题解

import java.util.Arrays;
import java.util.Scanner;

public class ArithmeticSequence {
	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
		int num = sc.nextInt();
		long[] array = new long[num];
		
		for(int i=0;i<num;i++) {
			array[i] = sc.nextLong();
		}
		Arrays.sort(array);
		long hh = abs(array[1]-array[0]); //中间变量，计算等差数列的差
		for(int i=1;i<num-1;i++) {
			if(abs(array[i+1]-array[i])<hh) {
				hh = abs(array[i+1]-array[i]);
			}
		}
		if(hh == 0) {
			System.out.println(array.length);
		}else {
			long result = (array[array.length-1]-array[0])/hh+1;
			System.out.println(result);			
		}
	}

	private static long abs(long num) {
		if(num>0) {
			return num;
		}else {
			return num*(-1);
		}
	}
}