蓝桥杯十一届 7月C组省赛真题

试题 A: 指数计算

本题总分：5 分
【问题描述】

请计算：7 ^ 2020 mod 1921，其中 A mod B 表示 A 除以 B 的余数。
【答案提交】
这是一道结果填空题，你只需要算出结果后提交即可。本题的结果为一个
整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
【解答】
方案一：
结果：480
使用java的bigInter对象来计算。

public static void main(String[] args) {
		// TODO Auto-generated method stub
		BigInteger a=new BigInteger("7");
		BigInteger m=new BigInteger("1921");
		System.out.println(a.pow(2020).mod(m).toString()); 
	}

---

试题 B: 解密

本题总分：5 分
【问题描述】
小明设计了一种文章加密的方法：对于每个字母 c，将它变成某个另外的
字符 Tc。下表给出了字符变换的规则：

例如，将字符串 YeRi 加密可得字符串 EaFn。
小明有一个随机的字符串，加密后为
EaFnjISplhFviDhwFbEjRjfIBBkRyY
（由 30 个大小写英文字母组成，不包含换行符），请问原字符串是多少？
（如果你把以上字符串和表格复制到文本文件中，请务必检查复制的内容
是否与文档中的一致。在试题目录下有一个文件 str.txt，第一行为上面的字符
串，后面 52 行依次为表格中的内容。）
【答案提交】
这是一道结果填空题，你只需要算出结果后提交即可。本题的结果为一个
只包含 30 个大小写英文字母的字符串，在提交答案时只填写这个字符串，填写
多余的内容将无法得分。
【解答】
答案：YeRikGSunlRzgDlvRwYkXkrGWWhXaA
注意点：是通过加密后的字符串得到原字符串。
似乎这种文本解析txt文本的题出现率还是挺高的。

public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc=new Scanner(System.in);
		HashMap<String, String> map=new HashMap<String, String>();
		for (int i = 0; i < 52; i++) {
			String key=sc.next();
			String val=sc.next();
			map.put(val,key);//把加密后的字符串当做key
		}
		String m="EaFnjISplhFviDhwFbEjRjfIBBkRyY";
		for (int i = 0; i < m.length(); i++) {
			System.out.print(map.get(m.charAt(i)+""));
		}
	}

---

试题 C: 跑步训练

本题总分：10 分
【问题描述】
小明要做一个跑步训练。
初始时，小明充满体力，体力值计为 10000。如果小明跑步，每分钟损耗
600 的体力。如果小明休息，每分钟增加 300 的体力。体力的损耗和增加都是
均匀变化的。
小明打算跑一分钟、休息一分钟、再跑一分钟、再休息一分钟……如此循
环。如果某个时刻小明的体力到达 0，他就停止锻炼。
请问小明在多久后停止锻炼。为了使答案为整数，请以秒为单位输出答案。
答案中只填写数，不填写单位。
【答案提交】
这是一道结果填空题，你只需要算出结果后提交即可。本题的结果为一个
整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
【解答】
答案：3880
600体力/1分钟
10体力/1秒钟
第一次作答：错误
原因，没有考虑到当体力小于600的同时下一次为休息时间，可以补充体力。

public static void main(String[] args) {
		// TODO Auto-generated method stub
		int pow=10000;
		int i=0;
		for (; pow>=600; i++) {
			if (i%2==0) {
				pow-=600;
			}else {
				pow+=300;
			}
			//System.out.println(i+"  "+pow);
		}
		int result=i*60+(pow/10);
		System.out.println(result);
	}

修改后如下

public static void main(String[] args) {
		// TODO Auto-generated method stub
		int pow=10000;
		int i=0;
		for (; pow>=600 || (pow<600 && i%2!=0); i++) {
			if (i%2==0) {
				pow-=600;
			}else {
				pow+=300;
			}
		}
		int result=i*60+(pow/10);
		System.out.println(result);
	}

---

试题 D: 合并检测

本题总分：10 分
【问题描述】
新冠疫情由新冠病毒引起，最近在 A 国蔓延，为了尽快控制疫情，A 国准
备给大量民众进病毒核酸检测。
然而，用于检测的试剂盒紧缺。
为了解决这一困难，科学家想了一个办法：合并检测。即将从多个人（k
个）采集的标本放到同一个试剂盒中进行检测。如果结果为阴性，则说明这 k
个人都是阴性，用一个试剂盒完成了 k 个人的检测。如果结果为阳性，则说明
至少有一个人为阳性，需要将这 k 个人的样本全部重新独立检测（从理论上看，
如果检测前 k 1 个人都是阴性可以推断出第 k 个人是阳性，但是在实际操作中
不会利用此推断，而是将 k 个人独立检测），加上最开始的合并检测，一共使用
了 k + 1 个试剂盒完成了 k 个人的检测。
A 国估计被测的民众的感染率大概是 1%，呈均匀分布。请问 k 取多少能
最节省试剂盒？
【答案提交】
这是一道结果填空题，你只需要算出结果后提交即可。本题的结果为一个
整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
【解答】
答案：10
这像是一个数学题，感染率百分之一，均匀分布，也就是求100个人找到一个人的方案中k取多少合适。
可以发现k和测试盒之间的关系f(k)是测试盒数量， f(k)=100/k+k;这个我应该学过，但是忘记该怎么运用了。
用for循环递增k，可以得到f(k)最小时，k为多少。

public static void main(String[] args) {
		// TODO Auto-generated method stub
		for (double i = 1; i <=100; i++) {
			System.out.println(i+" "+(100/i+i));
		}
	}

部分结果如下

6.0 22.666666666666668
7.0 21.285714285714285
8.0 20.5
9.0 20.11111111111111
10.0 20.0 
11.0 20.090909090909093
12.0 20.333333333333336
13.0 20.692307692307693
14.0 21.142857142857142

通过观察可以得出k=10时，f(k)最小

---

试题 E: REPEAT 程序

本题总分：15 分
【问题描述】
附件 prog.txt 中是一个用某种语言写的程序。
其中 REPEAT k 表示一个次数为 k 的循环。循环控制的范围由缩进表达，
从次行开始连续的缩进比该行多的（前面的空白更长的）为循环包含的内容。
例如如下片段：
REPEAT 2:
A = A + 4
​ REPEAT 5:
REPEAT 6:
A = A + 5
​A = A + 7
​ A = A + 8
A = A + 9

A = A + 4 所在的行到 A = A + 8 所在的行都在第一行的
循环两次中。
REPEAT 6: 所在的行到 A = A + 7 所在的行都在 REPEAT 5: 循环中。
A = A + 5 实际总共的循环次数是 2 × 5 × 6 = 60 次。
请问该程序执行完毕之后，A 的值是多少？
【答案提交】
这是一道结果填空题，你只需要算出结果后提交即可。本题的结果为一个
整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
【解答】
答案：241830
第一次作答：错误
所有题做完后与别人的对照，有些人的答案为241830，其做法是读取文件内容。
我感觉题目应该是我下面代码所描述的样子。
(在看了txt文件后)是我做错了，没有仔细看题，题目中呈现的是代码片段，全部的代码再txt文件中。

public static void main(String[] args) {
		// TODO Auto-generated method stub
		int A=0;
		for (int i = 0; i <2; i++) {
			A=A+4;
			for (int j = 0; j <5; j++) {
				for (int k = 0; k <6; k++) {
					A=A+5;
				}
				A=A+7;
			}
			A=A+8;
		}
		A=A+9;
		System.out.println(A); //403
	}

第二次作答：
无。。。

别人代码：

public static void main(String[] args) {
		//代码来自：https://www.cnblogs.com/a1439775520/p/13255671.html#index5
		//文件在  https://files.cnblogs.com/files/a1439775520/C大学B组.zip
		//文件末尾加了0，用于结束循环
		  int[] layer = new int[10000];
	        int[] count = new int[10000];
	        Scanner sc = new Scanner(System.in);
	        int pointer = 0, result = 0, curCount = 1;
	       sc.nextLine();
	        layer[pointer] = -1; count[pointer] = 1;
	        while (sc.hasNext()) {
	            String ss = sc.nextLine();
	            if (ss.equals("0")){
	                break;
	            }
	            char[] s = ss.toCharArray();
	            int n = s.length, p = 0;
	            while (s[p] == ' ') p++; // 统计缩进
	            // 判断是不是在一层，如果当前层数小于上一次的层数，循环的次数就要除上一次的循环数
	            while (layer[pointer] >= p) curCount /= count[pointer--];
	            if (s[n - 1] == ':') { // 当前行是循环
	                //k为循环的次数
	                int k = s[n - 2] - '0';
	                //循环又往里走了一层
	                pointer = pointer + 1;
	                //w为循环次数
	                curCount *= k;
	                //a放的是当前层数是多少个空格
	                //b放地是当前循环的次数
	                layer[pointer] = p;count[pointer] = k;
	            } else {
	                //证明这个是A加值，k为A加的值
	                int k = s[n - 1] - '0';
	                //w是循环的次数
	                result += k * curCount;
	            }
	        }
	        System.out.println(result);
	}

---

试题 F: 分类计数

时间限制: 1.0s 内存限制: 512.0MB 本题总分：15 分
【问题描述】
输入一个字符串，请输出这个字符串包含多少个大写字母，多少个小写字
母，多少个数字。
【输入格式】
输入一行包含一个字符串。
【输出格式】
输出三行，每行一个整数，分别表示大写字母、小写字母和数字的个数。
【样例输入】
1+a=Aab
【样例输出】
131
【评测用例规模与约定】
对于所有评测用例，字符串由可见字符组成，长度不超过 100。
【解答】

public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc=new Scanner(System.in);
		String str=sc.next();
		int A=0;//大写
		int a=0;//小写
		int n=0;//数字
		for (int i = 0; i < str.length(); i++) {
			char item=str.charAt(i);
			if (item>='A'&&item<='Z') {
				A++;
				continue;
			}
			if (item>='a'&&item<='z') {
				a++;
				continue;
			}
			if (item>='0'&&item<='9') {
				n++;
				continue;
			}
		}
		System.out.println(A);
		System.out.println(a);
		System.out.println(n);
	}

---

试题 G: 整除序列

时间限制: 1.0s 内存限制: 512.0MB 本题总分：20 分
【问题描述】
有一个序列，序列的第一个数是 n，后面的每个数是前一个数整除 2，请输
出这个序列中值为正数的项。
【输入格式】
输入一行包含一个整数 n。
【输出格式】
输出一行，包含多个整数，相邻的整数之间用一个空格分隔，表示答案。
【样例输入】
20
【样例输出】
20 10 5 2 1
【评测用例规模与约定】
对于 80% 的评测用例，1 ≤ n ≤ 109。
对于所有评测用例，1 ≤ n ≤ 1018。
【解答】

public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		while (n>0) {
			System.out.print(n+" ");
			n=n/2;
		}
	}

---

试题 H: 走方格

时间限制: 1.0s 内存限制: 512.0MB 本题总分：20 分
【问题描述】
在平面上有一些二维的点阵。
这些点的编号就像二维数组的编号一样，从上到下依次为第 1 至第 n 行，
从左到右依次为第 1 至第 m 列，每一个点可以用行号和列号来表示。
现在有个人站在第 1 行第 1 列，要走到第 n 行第 m 列。只能向右或者向下
走。
注意，如果行号和列数都是偶数，不能走入这一格中。
问有多少种方案。
【输入格式】
输入一行包含两个整数 n, m。
【输出格式】
输出一个整数，表示答案。
【样例输入】
3 4
【样例输出】
2
【样例输入】
6 6
【样例输出】
0
【评测用例规模与约定】
对于所有评测用例，1 ≤ n ≤ 30, 1 ≤ m ≤ 30。
【解答】
可以使用动态规划

public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();//行
		int m=sc.nextInt();//列
		int [][]grid=new int[n+1][m+1];
		
		for (int i = 2; i <=n; i++) {
			grid[i][1]=1;
		}
		for (int i = 2; i <=m; i++) {
			grid[1][i]=1;
		}
		for (int i = 2; i <=n; i++) {
			for (int j = 2; j <=m; j++) {
				if (i%2!=0 || j%2!=0) {
					grid[i][j]+=(grid[i-1][j]+grid[i][j-1]);
				}
			}
		}
		System.out.println(grid[n][m]);
		
	}

---

试题 I: 字符串编码

时间限制: 1.0s 内存限制: 512.0MB 本题总分：25 分
【问题描述】
小明发明了一种给由全大写字母组成的字符串编码的方法。对于每一个大
写字母，小明将它转换成它在 26 个英文字母中序号，即 A → 1, B → 2, … Z →
26。
这样一个字符串就能被转化成一个数字序列：
比如 ABCXYZ → 123242526。
现在给定一个转换后的数字序列，小明想还原出原本的字符串。当然这样
的还原有可能存在多个符合条件的字符串。小明希望找出其中字典序最大的字
符串。
【输入格式】
一个数字序列。
【输出格式】
一个只包含大写字母的字符串，代表答案
【样例输入】
123242526
【样例输出】
LCXYZ
【评测用例规模与约定】
对于 20% 的评测用例，输入的长度不超过 20。
对于所有评测用例，输入的长度不超过 200000。
【解答】
不会。。。

别人的代码：

public static void main(String[] args) {
		// 代码来自： https://blog.csdn.net/WAITFORYOU_/article/details/107172829
		 Scanner sc = new Scanner(System.in);
		 
	        String s = sc.next();
	        sc.close();
	        StringBuilder sb = new StringBuilder();
	        int len = s.length();
	        char[] num = s.toCharArray();
	        for (int i = 0; i < len; i++) {
	            //1开头
	            if (num[i] == '1') {
	                //第i+2位是否为0，如果为0，当前位就不能和i+1位合并成一个字母
	                if (i < len - 2) {
	                    //不为0
	                    if (num[i + 2] != '0') {
//	                        System.out.println((num[i]-'0') * 10 + num[i + 1] + 'A' -1 -'0' );
	                        sb.append((char) ((num[i] - '0') * 10 + num[i + 1] + 'A' - 1 - '0'));
	                        ++i;
	                        // 为0，当前位就不能和i+1位合并成一个字母，（如果合成字母，剩下一个0没办法转换）
	                    } else {
	                        sb.append((char) (num[i] - '0' + 'A' - 1));
	                    }
	                    //i+2已超过尽头
	                } else {
	                    //看i+1位是否存在
	                    if (i < len - 1) {

	                        sb.append((char) ((num[i] - '0') * 10 + num[i + 1] + 'A' - 1 - '0'));
	                        //不存在，第i位为最后一位
	                    } else {
	                        sb.append((char) (num[i] - '0' + 'A' - 1));
	                    }
	                    break;
	                }
	                //2开头
	            } else if (num[i] == '2') {
	                //看存不存在下一位
	                if (i < len - 1) {
	                    //看下一位是不是小于6，因为字母的大小不能超过26
	                    if (num[i + 1] <= '6') {
	                        //看第i+2位是否存在
	                        if (i < len - 2) {
	                            //看第i+2位是否=0
	                            if (num[i + 2] != '0') {
	                                sb.append((char) ((num[i] - '0') * 10 + num[i + 1] + 'A' - 1 - '0'));
	                                ++i;
	                                // 为0，当前位就不能和i+1位合并成一个字母，（如果合成字母，剩下一个0没办法转换）
	                            } else {
	                                sb.append((char) (num[i] - '0' + 'A' - 1));
	                            }
	                            //不存在的话，就直接添加就行
	                        } else {
	                            sb.append((char) ((num[i] - '0') * 10 + num[i + 1] + 'A' - 1 - '0'));
	                            break;
	                        }
	                        //如果大于6，证明不能和后一位合并
	                    } else {
	                        sb.append((char) (num[i] - '0' + 'A' - 1));
	                    }
	                    //不存在下一位，这一位就直接放进去
	                } else {
	                    sb.append((char) (num[i] - '0' + 'A' - 1));
	                }
	                //如果大于2的话，就直接添加就行，字母没有2以上开头的
	            } else {
	                sb.append((char) (num[i] - '0' + 'A' - 1));
	            }
	        }
	        System.out.println(sb.toString());
	    }

	    public static char getUppLetter(int num) {
	        System.out.println((char) (num));
	        return (char) (num);
	    }

2020年10月10日12:43:50 代码补充：
思路：
通过题目可以得知需要得到字典序列较大的结果，
那么可以从头到尾遍历字符串，如果当前字符和下一个字符拼接比当前的字符大，那么就拼接，
已知 字母26个由A到Z，与之对应的数字是 1到26，
那么这题可以用贪心的方法来做，字符串存储到数组cs[]中，
如果每次比较 cs[i-1]和cs[i-1]+cs[i] ，输出其中大的一个即可。
另外需要注意比较的条件，首要条件是 拼接后可以成为一个字母，也就是在1到26之中，这样就可以得到字段序列最大的值了。

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String str=sc.next();
        char cs[]=new char[str.length()+1];
        for (int i = 0; i <str.length(); i++) {//将输入的存储到数组中，并且增加一个结尾的空元素
			cs[i]=str.charAt(i);
		}
            
        for (int i = 1; i < cs.length; i++) {
        	if ((cs[i-1]+""+cs[i]).compareTo("26")<=0 && i!=str.length()) {//如果当前与后一个小于26，则使用它
				System.out.print((char)(Integer.valueOf((cs[i-1]+""+cs[i]))+64));
				i++;//i多加一个
			}else {
				System.out.print((char)(Integer.valueOf(cs[i-1]+"")+64));
			}
		}
        
    }
    
   
			
    
}

---

试题 J: 整数小拼接

时间限制: 1.0s 内存限制: 512.0MB 本题总分：25 分
【问题描述】
给定义个长度为 n 的数组 A1, A2, · · · , An。你可以从中选出两个数 Ai 和 Aj (i 不等于 j)，然后将 Ai 和 Aj 一前一后拼成一个新的整数。例如 12 和 345 可
以拼成 12345 或 34512 。注意交换 Ai 和 Aj 的顺序总是被视为 2 种拼法，即便
是 Ai = Aj 时。
请你计算有多少种拼法满足拼出的整数小于等于 K。
【输入格式】
第一行包含 2 个整数 n 和 K。
第二行包含 n 个整数 A1, A2, · · · , An。
【输出格式】
一个整数代表答案。
【样例输入】
4 33
1 2 3 4
【样例输出】
8
【评测用例规模与约定】
对于 30% 的评测用例，1 ≤ N ≤ 1000, 1 ≤ K ≤ 108, 1 ≤ Ai ≤ 104。
对于所有评测用例，1 ≤ N ≤ 100000，1 ≤ K ≤ 1010，1 ≤ Ai ≤ 109。
【解答】

public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		int k=sc.nextInt();
		int count=0;
		List<String> arr=new ArrayList<String>();
		for (int i = 0; i <n; i++) {
			int temp=sc.nextInt();
			if (temp<k) {
				arr.add(temp+"");
			}
		}
		
		for (int i = 0; i < arr.size()-1; i++) {
			for (int j = i+1; j < arr.size(); j++) {
				int join1=Integer.parseInt((arr.get(i)+"")+(arr.get(j)+""));
				int join2=Integer.parseInt((arr.get(j)+"")+(arr.get(i)+""));
				if (join1<=k) {
					count++;
				}
				if (join2<=k) {
					count++;
				}
			}
		}
		System.out.println(count);
	}

---

总结

做错的题有 C
不会做的题 E、I
总用时：3.5小时