蓝桥杯真题_Java组别B_2020

指数计算

题目：
7 ^ 2020 mod 1921，其中 A mod B 表示 A 除以 B 的余数
思路：
这应该是很简单的一道题了，但是再写一遍就是觉得大数类考到的可能性还是很大的
代码：

import java.math.BigInteger;

public class 指数计算 {
    public static void main(String[] args) {
        BigInteger a=new BigInteger("7");
        BigInteger b=new BigInteger("1921");
        BigInteger c=a.pow(2020).remainder(b);
        System.out.println(c);
    }
}

解密

题目：
根据字母加密规则，将加密后的字符串解密
思路：
利用HashMap的键值存储方式，将加密的对应字符存储为键，然后输出值
代码：

import java.util.HashMap;
import java.util.Scanner;

public class 解密 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        HashMap<Character,Character> hashMap=new HashMap<>();
        for (int i = 0; i < 52; i++) {
            char a=sc.next().trim().charAt(0);
            //sc.next()返回一个String类型对象
            //.trim()去掉空格
            //.charAt()返回一个char型
            char b=sc.next().trim().charAt(0);
            hashMap.put(b,a);//put添加，b为键，a为值
        }
        char[] num=sc.next().toCharArray();//输入加密字符
        for (char m:num)//m必须为char型
            System.out.print(hashMap.get(m));
    }
}

跑步训练

题目：
小明要做一个跑步训练。
初始时，小明充满体力，体力值计为 10000。如果小明跑步，每分钟损耗
600 的体力。如果小明休息，每分钟增加 300 的体力。体力的损耗和增加都是均匀变化的。
小明打算跑一分钟、休息一分钟、再跑一分钟、再休息一分钟……如此循环。如果某个时刻小明的体力到达 0，他就停止锻炼。
请问小明在多久后停止锻炼。为了使答案为整数，请以秒为单位输出答案
思路：
设一个布尔变量，开始将值设为ture用来判断是否休息，设置while循环，当体力小于600时跳出循环，用最后的count*60+剩余体力/10（每秒钟消耗10体力）
代码：

public class 跑步训练 {
    public static void main(String[] args) {
        int sum=1000;
        boolean flag=true;//是否需要休息
        int count=0;
        while (sum>0){//其实循环一直进行，
            if (sum<600&&flag)
                break;//如果休息之后仍不能跑完一圈，跳出循环
            if (flag) {
                sum -= 600;
                flag=false;//需要休息
            }
            else if (!flag){
                sum+=300;
                flag=true;
            }
            count++;
        }
        System.out.println(count*60+sum/10);
        //跑一分钟消耗600，一秒钟即消耗六十
    }
}

合并检测

题目：
从多个人（k个）采集的标本放到同一个试剂盒中进行检测。如果结果为阴性，则说明这 k个人都是阴性，用一个试剂盒完成了 k 个人的检测。如果结果为阳性，则说明至少有一个人为阳性，需要将这 k 个人的样本全部重新独立检测，加上最开始的合并检测，一共使用了 k + 1 个试剂盒完成了 k 个人的检测。民众的感染率大概是 1%，呈均匀分布。请问 k 取多少能最节省试剂盒？
思路：
假定有N个人，分成K人一组，即初始需要N/K盒，N个人中有N/100个人感染，且均匀分布，即在N/K的基础上需要K*（N/100）盒，如果N不能整除K的话即为N/K+1+K*（N/100）
代码：

import java.util.Scanner;

public class 合并检测 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int sum,ans = 0;//sum为检测盒的总数
        int min=99999;
        int n=sc.nextInt();//n表示人数
        for (int k = 1; k <= n; k++) {//从1开始
            if (100%k==0)//如果能平价分组的话
                sum=n/k+k*(n/100);//分组后的组数加上患病人需要的检测盒（1%的几率）
            else
                sum=n/k+1+k*(n/100);
            if (sum<min){
                min=sum;
                ans=k;
            }
        }
        System.out.println(ans);
    }
}

分类计数

题目：
输入一个字符串，输出包含多少个大写字母，多少个小写字母，多少个数字
思路：
使用Character的实用方法，判断即可
代码：

import java.util.Scanner;

public class 分类计数 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int upp = 0, low = 0, dig = 0;
        char[] arr = sc.next().toCharArray();
        for (char m : arr) {
            if (Character.isUpperCase(m))//实用类，记好
                upp++;
            else if (Character.isLowerCase(m))
                low++;
            else if (Character.isDigit(m))
                dig++;
        }
        System.out.println(upp);
        System.out.println(low);
        System.out.println(dig);
    }
}

走方格

题目：
在平面上有一些二维的点阵。
这些点的编号就像二维数组的编号一样，从上到下依次为第 1 至第 n 行，
从左到右依次为第 1 至第 m 列，每一个点可以用行号和列号来表示。
现在有个人站在第 1 行第 1 列，要走到第 n 行第 m 列。只能向右或者向下走。
注意，如果行号和列数都是偶数，不能走入这一格中。问有多少种方案。
思路：
dfs深搜做法
只能向右和向下说明dfs的参数为（x+1，y）或（x,y+1），同时判断越界与双偶位置
代码：

import java.util.Scanner;

public class 走方格 {
    static int n, m, ans;
    static void dfs(int x,int y)
    {
        if(x > n || y > m)
            return;
        if(x%2 == 0 && y%2 == 0)
            return;
        if(x == n && y == m)
            ans++;
        dfs(x + 1,y);
        dfs(x,y+1);
        return;
    }
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        if(n%2 == 0 && m%2 == 0)
            ans = 0;//如果出口偶数行偶数列
        else
            dfs(1,1);
        System.out.println(ans);
    }
}