第七届蓝桥杯大赛个人赛省赛（软件类）Java 大学C组 真题及部分解析
A 有奖猜谜
小明很喜欢猜谜语。
最近，他被邀请参加了X星球的猜谜活动。每位选手开始的时候都被发给777个电子币。
规则是：猜对了，手里的电子币数目翻倍，
猜错了，扣除555个电子币, 扣完为止。小明一共猜了15条谜语。
战果为：vxvxvxvxvxvxvvx
其中v表示猜对了，x表示猜错了。请你计算一下，小明最后手里的电子币数目是多少。
请填写表示最后电子币数目的数字。
解析：由题意已知初始电子币，战果序列；判断在 v 时，电子币*2；在 x 时，电子币-555.
使用字符串进行存储战果序列，在 for 循环中进行 if 判断，最后输出剩余电子币。
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
long n=777;
String s="vxvxvxvxvxvxvvx";
for (int i = 0; i <15; i++) {
if (s.charAt(i)=='v') {
n*=2;
}else {
n-=555;
}
}
System.out.println(n);
}
}B 煤球数目
有一堆煤球，堆成三角棱锥形。具体：
第一层放1个，
第二层3个（排列成三角形），
第三层6个（排列成三角形），
第四层10个（排列成三角形），
....
如果一共有100层，共有多少个煤球？请填表示煤球总数目的数字。
解析：由于第一层和第二层为第一个形成的三角形，且是固定的个数组成，所以在程序开始前，可直接定义煤球总数为4；由题意得出 第一层到第二层相差为2，第二层到第三层相差为3，第三层到第四层相差为4，由此得出每两层之间的差数在自增，也可看待为前一层的煤球数量 加 所求的层数即为该层的煤球数量。例：第四层的煤球数 = 第三层煤球数 + 4，第三层煤球数 = 第二层煤球数 + 3
程序设计为：直接定义sum = 4，a 代表每一层的数量 ，这里先加了第一二层的煤球数量，所以a可直接定义为3，因为for循环将从第三层开始，而第三层煤球数 = 第二层煤球数 + 3；用for循环来计算每一层煤球数，所以for循环起始为3，终止为100。
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
long sum=4;//前两层为四个
int a=3;//第二层为三个
//从第三层开始累加
for (int i = 3; i <= 100; i++) {
a+=i;
sum+=a;
}
System.out.println(sum);
}
}C 平方怪圈
如果把一个正整数的每一位都平方后再求和，得到一个新的正整数。
对新产生的正整数再做同样的处理。如此一来，你会发现，不管开始取的是什么数字，
最终如果不是落入1，就是落入同一个循环圈。请写出这个循环圈中最大的那个数字。
请填写该最大数字。
解析：有题意可直接简单除暴的解题，因为该题只需要提交最大的数字。由于1的平方就是1 ，所以直接从2开始即可，而最终不是为1，就是循环圈，只需要定义循环大小为100看看是否已经满足循环圈。
程序设计：使用一个while循环，循环次数为100，在while循环中，每次循环调用外部函数对这个正整数进行每一位都平方后再求和，并存下最大值；存取最大值可采用三元表达式 max = a > max?a:max 表示 a 与 max 进行比较，若 a > max 则 max = a，若 a < max 则 max = max。把每次进行平方和后的数字与max进行比较，可得到最大值，最后输出这个max即可。
s.charAt(i)-'0' 该表达式表示把字符转换为整型。利用ASCII码的计算得出该字符对应的数字。
注：对于对整数的分解，也可使用比较常见的 while循环 配合 /10 %10 来分解。
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
int a=2;//起始为2
int k=0;//计数器
int max=0;
while (k<100) {
//System.out.println(a);
a=extract(a);
max=a>max?a:max;
k++;
}
System.out.println(max);
}
private static int extract(int a) {
// TODO Auto-generated method stub
String s=a+"";//整数转字符串
int sum=0;
for (int i = 0; i < s.length(); i++) {
sum+=(s.charAt(i)-'0')*(s.charAt(i)-'0');//把每一位平方求和
}
return sum;
}
}D 骰子游戏
我们来玩一个游戏。
同时掷出3个普通骰子（6个面上的数字分别是1~6）。
如果其中一个骰子上的数字等于另外两个的和，你就赢了。下面的程序计算出你能获胜的精确概率（以既约分数表示）
解析：这题是代码填空题，由题目和所给代码来看，这题非常简单易懂，但往往这样的题我们都会忽略了细节，骰子是1~6二for循环起始为0，若只是简单的 i == j + k || j == i + k || k == i + j 运行程序所得为23/108。
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
int n=0;
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 6; j++) {
for (int k = 0; k < 6; k++) {
if(i==j+k||j==i+k||k==i+j)n++;//填空位置
}
}
}
int m=gcd(n,6*6*6);//最大公约数
System.out.println(n/m+"/"+6*6*6/m);//约分
}
private static int gcd(int a, int b) {
// TODO Auto-generated method stub
if(b==0)return a;
return gcd(b,a%b);
}
}
如果把所给代码拿到编译器里并修改循环起始条件为1，终止为6，运行结果为 5/24。
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
int n=0;
for (int i = 1; i <= 6; i++) {
for (int j = 1; j <= 6; j++) {
for (int k = 1; k <= 6; k++) {
if(i==j+k||j==i+k||k==i+j)n++;//填空位置
}
}
}
int m=gcd(n,6*6*6);//最大公约数
System.out.println(n/m+"/"+6*6*6/m);//约分
}
private static int gcd(int a, int b) {
// TODO Auto-generated method stub
if(b==0)return a;
return gcd(b,a%b);
}
}
所以该位置正确的填写方式应该是 i == j + k + 1 || j == i + k + 1 || k == i + j +1
i，j，k起始为0，那在判断结果上加上1即可。
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
int n=0;
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 6; j++) {
for (int k = 0; k < 6; k++) {
if(i==j+k+1||j==i+k+1||k==i+j+1)n++;//填空位置
} //ijk起始位0，所以要加上1来表示，两边同时减去1
}
}
int m=gcd(n,6*6*6);//最大公约数
System.out.println(n/m+"/"+6*6*6/m);//约分
}
private static int gcd(int a, int b) {
// TODO Auto-generated method stub
if(b==0)return a;
return gcd(b,a%b);
}
}
E 分小组
9名运动员参加比赛，需要分3组进行预赛。
有哪些分组的方案呢？我们标记运动员为 A,B,C,... I
下面的程序列出了所有的分组方法。该程序的正常输出为：
ABC DEF GHI
ABC DEG FHI
ABC DEH FGI
ABC DEI FGH
ABC DFG EHI
ABC DFH EGI
ABC DFI EGH
ABC DGH EFI
ABC DGI EFH
ABC DHI EFG
ABC EFG DHI
ABC EFH DGI
ABC EFI DGH
ABC EGH DFI
ABC EGI DFH
ABC EHI DFG
ABC FGH DEI
ABC FGI DEH
ABC FHI DEG
ABC GHI DEF
ABD CEF GHI
ABD CEG FHI
ABD CEH FGI
ABD CEI FGH
ABD CFG EHI
ABD CFH EGI
ABD CFI EGH
ABD CGH EFI
ABD CGI EFH
ABD CHI EFG
ABD EFG CHI
..... (以下省略，总共560行)。
public class Main {
public static String remain(int[] a)
{
String s = "";
for(int i=0; i<a.length; i++){
if(a[i] == 0) s += (char)(i+'A');
}
return s;
}
public static void f(String s, int[] a)
{
for(int i=0; i<a.length; i++){
if(a[i]==1) continue;
a[i] = 1;
for(int j=i+1; j<a.length; j++){
if(a[j]==1) continue;
a[j]=1;
for(int k=j+1; k<a.length; k++){
if(a[k]==1) continue;
a[k]=1;
System.out.println(s+" "+(char)(i+'A')+(char)(i+'A')+(char)(k+'A')+" "+remain(a) ); //填空位置
a[k]=0;
}
a[j]=0;
}
a[i] = 0;
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] a = new int[9];
a[0] = 1;
for(int b=1; b<a.length; b++){
a[b] = 1;
for(int c=b+1; c<a.length; c++){
a[c] = 1;
String s = "A" + (char)(b+'A') + (char)(c+'A');
f(s,a);
a[c] = 0;
}
a[b] = 0;
}
}
}
F 凑算式
B DEF
A + --- + ------- = 10
C GHI
这个算式中A~I代表1~9的数字，不同的字母代表不同的数字。比如：
6+8/3+952/714 就是一种解法，
5+3/1+972/486 是另一种解法。这个算式一共有多少种解法？
解析：这里我直接用了暴力破解，简单除暴，没考虑效率，因为这题只需要提交数字结果。直接用9个for循环嵌套吗，并且使9个数字不相同，把算式打开为 (10 - A) * C* GHI = B * GHI + C * DEF。
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
int k=0;
for (int a = 1; a <=9; a++) {
for (int b = 1; b <=9; b++) {
if (a==b) continue;
for (int c = 1; c <=9; c++) {
if(c==a||c==b)continue;
for (int d = 1; d <=9; d++) {
if(d==a||d==b||d==c)continue;
for (int e = 1; e <=9; e++) {
if(e==a||e==b||e==c||e==d)continue;
for (int f = 1; f <=9; f++) {
if(f==a||f==b||f==c||f==d||f==e)continue;
for (int g = 1; g <=9; g++) {
if(g==a||g==b||g==c||g==d||g==e||g==f)continue;
for (int h = 1; h <=9; h++) {
if(h==a||h==b||h==c||h==d||h==e||h==f||h==g)continue;
for (int i = 1; i <=9; i++) {
if(i==a||i==b||i==c||i==d||i==e||i==f||i==g||i==h)continue;
int x=d*100+e*10+f;
int y=g*100+h*10+i;
if ((10-a)*(c*y)==b*y+c*x) {
System.out.println(a+"+"+b+"/"+c+"+"+x+"/"+y+"="+"10");
k++;
}
}
}
}
}
}
}
}
}
}
System.out.println(k);
}
}G 搭积木
小明最近喜欢搭数字积木，
一共有10块积木，每个积木上有一个数字，0~9。搭积木规则：
每个积木放到其它两个积木的上面，并且一定比下面的两个积木数字小。
最后搭成4层的金字塔形，必须用完所有的积木。下面是两种合格的搭法：
0
1 2
3 4 5
6 7 8 90
3 1
7 5 2
9 8 6 4请你计算这样的搭法一共有多少种？
解析：这题同样，直接暴力破解，用10个for循环代表，判断上一层的数字小于下一层即可。
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
int k=0;
for (int a = 0; a <=9; a++) {
for (int b = 0; b <=9; b++) {
for (int c = 0; c <=9; c++) {
for (int d = 0; d <=9; d++) {
for (int e = 0; e <=9; e++) {
for (int f = 0; f <=9; f++) {
for (int g = 0; g <=9; g++) {
for (int h = 0; h <=9; h++) {
for (int i = 0; i <=9; i++) {
for (int j = 0; j <=9; j++) {
if(a!=b && a!=c && a!=d && a!=e && a!=f && a!=g && a!=h && a!=i && a!=j &&
b!=c && b!=d && b!=d && b!=e && b!=f && b!=g && b!=h && b!=i && b!=j &&
c!=d && c!=e && c!=f && c!=g && c!=h && c!=i && c!=j &&
d!=e && d!=f && d!=g && d!=h && d!=i && d!=j &&
e!=f && e!=g && e!=h && e!=i && e!=j &&
f!=g && f!=h && e!=i && e!=j &&
g!=h && g!=i && g!=j &&
h!=i && h!=j &&
i!=j){
//每个积木放到其它两个积木的上面，并且一定比下面的两个积木数字小
if(a<b && a<c && b<d && b<e && c<e && c<f && d<g && d<h && e<h && e<i && f<i && f<j){
k++;
}
}
}
}
}
}
}
}
}
}
}
}
System.out.println(k);
}
}
H 冰雹数
任意给定一个正整数N，
如果是偶数，执行： N / 2
如果是奇数，执行： N * 3 + 1生成的新的数字再执行同样的动作，循环往复。
通过观察发现，这个数字会一会儿上升到很高，
一会儿又降落下来。
就这样起起落落的，但最终必会落到“1”
这有点像小冰雹粒子在冰雹云中翻滚增长的样子。比如N=9
9,28,14,7,22,11,34,17,52,26,13,40,20,10,5,16,8,4,2,1
可以看到，N=9的时候，这个“小冰雹”最高冲到了52这个高度。输入格式：
一个正整数N（N<1000000）
输出格式：
一个正整数，表示不大于N的数字，经过冰雹数变换过程中，最高冲到了多少。例如，输入：
10
程序应该输出：
52再例如，输入：
100
程序应该输出：
9232资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
解析：对输入数字进行偶数或奇数不同的操作，并对得出的结果再次进行相应操作。使用while循环进行重复操作，并存储在这个循环中得到的最大数值。但是由题目可知 9 的冲击高度为52，而对于案例 10 的冲击高度也为52。若只使用while循环式无法满足 10 的冲击高度为52的，由此得出，该程序应该是从输入的数字开始到 1 进行冰雹结算。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int max=0;
for (int i = n; i >0; i--) {
int t=i;
while(t>1) {
if (t%2==0) {
t/=2;
}else {
t=3*t+1;
}
max=max>t?max:t;
}
}
System.out.println(max);
}
}I 四平方和
四平方和定理，又称为拉格朗日定理：
每个正整数都可以表示为至多4个正整数的平方和。
如果把0包括进去，就正好可以表示为4个数的平方和。比如：
5 = 0^2 + 0^2 + 1^2 + 2^2
7 = 1^2 + 1^2 + 1^2 + 2^2
（^符号表示乘方的意思）对于一个给定的正整数，可能存在多种平方和的表示法。
要求你对4个数排序：
0 <= a <= b <= c <= d
并对所有的可能表示法按 a,b,c,d 为联合主键升序排列，最后输出第一个表示法
程序输入为一个正整数N (N<5000000)
要求输出4个非负整数，按从小到大排序，中间用空格分开例如，输入：
5
则程序应该输出：
0 0 1 2再例如，输入：
12
则程序应该输出：
0 2 2 2再例如，输入：
773535
则程序应该输出：
1 1 267 838资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 3000ms
解析：结合题目，从所给的案例里 5 = 0^2 + 0^2 + 1^2 + 2^2 7 = 1^2 + 1^2 + 1^2 + 2^2 要求的是输出的四个数字的平方相加等于输入的数字。并对abcd四个数升序排序即 0 <= a <= b <= c <= d。
程序设计：直接使用4个for循环进行查找，由于数字为升序排序，所以循环下一层的起始为上一层循环的值；对于所查找的值不可能超过输入数字本身，且最大为输入数字开根。
例 4 = 0^2 + 0^2 + 0^2 + 2^2。所以循环条件为 <= Math.sprt(n)。
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int max=(int)Math.sqrt(n);//开根
for (int a = 0; a <=max; a++) {
for (int b = a; b <=max; b++) {
for (int c = b; c <=max; c++) {
for (int d = c; d <=max; d++) {
if (a*a+b*b+c*c+d*d==n) {
System.out.println(a+" "+b+" "+c+" "+d);
return;
}
}
}
}
}
}
}