2015届蓝桥杯 Java C组 省赛试题及答案_第15届蓝桥杯答案

因为今年3月份要参加这一届的蓝桥杯比赛，为此刷真题并写下一些文章留些记录，不管最后的成绩如何，我努力了！加油！！！

结果填空1

隔行变色

题目

Excel 表的格子很多，为了避免把某行的数据和相邻行混淆，可以采用隔行变色的样式。
小明设计的样式为：第1行蓝色，第2行白色，第3行蓝色，第4行白色，…
现在小明想知道，从第21行到第50行一共包含了多少个蓝色的行。

请你直接提交这个整数，千万不要填写任何多余的内容。

思路

由题可知，颜色的变化是由行号的奇偶性来判断的，所以我们只需要在给定的范围内循环一下，在循环中加入一个 if判断是奇是偶，因为题目只需要输出蓝色行的个数，我们就可以判断它是否为奇数，若是奇数则次数加1即可.

答案

15

代码

  import java.util.Scanner;

public class _01 {

	public static void main(String[] args) {
		Scanner s1 = new Scanner(System.in);
		int start = s1.nextInt();
		int end = s1.nextInt();
		int count = 0;
		for (int i = start; i <= end; i++) {
			if (i % 2 != 0) {
				count++;
			}
		}
		System.out.println(count);
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

立方尾不变

题目

有些数字的立方的末尾正好是该数字本身。
比如：1,4,5,6,9,24,25,…

请你计算一下，在10000以内的数字中（指该数字，并非它立方后的数值），符合这个特征的正整数一共有多少个。

请提交该整数，不要填写任何多余的内容。

思路

一开始我想的很简单，就是单纯的拿10000的 for 循环中判断 i == Math.pow(i, 3) % 10 ,之后看见题目中举得例子不止我用上面代码测试出的5这个结果,发现他的结尾不一定是就是最后一位啊,应该 i 是几位它的结尾就该留几位,为了解决这个问题,我想到的是用 String 的 length 方法,详情请看代码.

答案

36

代码

public class Main {

	public static void main(String[] args) {
		int count = 0;
		for (int i = 1; i <= 10000; i++) {
			String str = "" + i;
			int yu = 1;
			for (int j = 0; j < str.length(); j++) {
				yu *= 10;
			}
			if (i == Math.pow(i, 3) % yu) {
				count++;
			}
		}
		System.out.println(count);
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

无穷分数

题目

无穷的分数，有时会趋向于固定的数字。

请计算【图1.jpg】所示的无穷分数，要求四舍五入，精确到小数点后5位，小数位不足的补0。

请填写该浮点数，不能填写任何多余的内容。

思路

首先,很明显一看到这个题目我就想到了用递归做,但是细看了题目以后,发现有点看不懂了,他为什么没有规定出口值?那他不还要一直循环下去嘛?那这结果怎么求嘛?无奈之下,从网上查找了答案,才清楚这题目的意思,原来它的结果会随着运算的次数越多,会越来越精确一个值,我们只需要把那个大约值求出来即可.

答案

0.58198

代码

public class Main {

	public static void main(String[] args) {
		System.out.printf("%.5f", FS(1));
	}

	public static double FS(double n) {
		if (n >= 100) {
			return n;
		} else {
			return n / (n + FS(n + 1));
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

代码填空

循环节长度

题目

两个整数做除法，有时会产生循环小数，其循环部分称为：循环节。
比如，11/13=6=>0.846153846153… 其循环节为[846153] 共有6位。
下面的方法，可以求出循环节的长度。

请仔细阅读代码，并填写划线部分缺少的代码。

	public static int f(int n, int m)
	{
		n = n % m;
		Vector v = new Vector();

		for(;;)
		{
			v.add(n);
			n *= 10;
			n = n % m;
			if(n==0) return 0;
			if(v.indexOf(n)>=0)  _________________________________ ;  //填空
		}
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

注意，只能填写缺少的部分，不要重复抄写已有代码。不要填写任何多余的文字。

思路

这道题,一上来其实已经想到了如何解决,但是自己太蠢,唉,服了!!!一上来我就把代码放到eclipse中运行,把需要填空的地方我改成了让它输出 v.indexOf ,果不其然答案就在其中,看到结果一直在循环0-5,这不就是答案了嘛,然后我就使劲想啊想啊,想不懂怎么把他们搞出来,总想着把5能取出来最后加1啥的乱七八糟的东西,无奈毫无进展,只好从网上寻找答案,当看到答案时心都凉了一半,这么简单为啥就是想不到…

答案

return v.size();

代码

import java.util.Vector;

public class Main {

	public static void main(String[] args) {
		System.out.println(f(11, 13));
	}

	public static int f(int n, int m) {
		n = n % m;
		Vector v = new Vector();

		for (;;) {
			v.add(n);
			n *= 10;
			n = n % m;
			if (n == 0)
				return 0;
			if (v.indexOf(n) >= 0) {
				return v.size();
			}
		}
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

格子中输出

题目

stringInGrid方法会在一个指定大小的格子中打印指定的字符串。
要求字符串在水平、垂直两个方向上都居中。
如果字符串太长，就截断。
如果不能恰好居中，可以稍稍偏左或者偏上一点。

下面的程序实现这个逻辑，请填写划线部分缺少的代码。

	public static void stringInGrid(int width, int height, String s)
	{
		if(s.length()>width-2) s = s.substring(0,width-2);
		System.out.print("+");
		for(int i=0;i<width-2;i++) System.out.print("-");
		System.out.println("+");

		for(int k=1; k<(height-1)/2;k++){
			System.out.print("|");
			for(int i=0;i<width-2;i++) System.out.print(" ");
			System.out.println("|");
		}

		System.out.print("|");

		String ff = _______________________________________________________;  //填空
		System.out.print(String.format(ff,"",s,""));

		System.out.println("|");

		for(int k=(height-1)/2+1; k<height-1; k++){
			System.out.print("|");
			for(int i=0;i<width-2;i++) System.out.print(" ");
			System.out.println("|");
		}

		System.out.print("+");
		for(int i=0;i<width-2;i++) System.out.print("-");
		System.out.println("+");
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

对于题目中数据，应该输出：

+------------------+
|                  |
|     abcd1234     |
|                  |
|                  |
+------------------+
1
2
3
4
5
6

（如果出现对齐问题，参看【图1.jpg】）

思路

一开始遇到这题一脸蒙,首先时不知道String.format的作用,查了API和网上资料搜索之后才知道，这个就是C语言的输出格式嘛，但是当我试了一下填入 “%s%s%s” 虽然值是在格子中输出出来了，但是并没有居中，这可咋整？然后直接在网上查找原题，但看到的都是C语言版的不过也看出了一下名堂，在 %s 中间居然可以添加一个整数来控制它前面的空格数，然后我就将其更改为 “%” + (width - s.length()) / 2 + “s%s%” + (width - s.length()) / 2 + “s”; ，谁知运行后还是显示不对，原来是我忘了两边还有一个 | 也要算进去。

答案

"%" + (width - s.length() - 2) / 2 + “s%s%” + (width - s.length() - 2) / 2 + “s”;

代码

public class Main {

	public static void main(String[] args) {
		stringInGrid(20, 6, "abcd1234");
	}

	public static void stringInGrid(int width, int height, String s) {
		if (s.length() > width - 2)
			s = s.substring(0, width - 2);
		System.out.print("+");
		for (int i = 0; i < width - 2; i++)
			System.out.print("-");
		System.out.println("+");

		for (int k = 1; k < (height - 1) / 2; k++) {
			System.out.print("|");
			for (int i = 0; i < width - 2; i++)
				System.out.print(" ");
			System.out.println("|");
		}

		System.out.print("|");

		String ff = "%" + (width - s.length() - 2) / 2 + "s%s%" + (width - s.length() - 2) / 2 + "s";// 填空
		System.out.print(String.format(ff, "", s, ""));

		System.out.println("|");

		for (int k = (height - 1) / 2 + 1; k < height - 1; k++) {
			System.out.print("|");
			for (int i = 0; i < width - 2; i++)
				System.out.print(" ");
			System.out.println("|");
		}

		System.out.print("+");
		for (int i = 0; i < width - 2; i++)
			System.out.print("-");
		System.out.println("+");
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

结果填空题2

奇妙的数字

题目

小明发现了一个奇妙的数字。它的平方和立方正好把0~9的10个数字每个用且只用了一次。
你能猜出这个数字是多少吗？

请填写该数字，不要填写任何多余的内容。

思路

看到这题目想到的就是 for 循环遍历数字，然后计算它的平方和立方再去判断它们刚好使用0-9这10个数各一次。
一开始我计算他们的平方和立方时选择的是使用Math.pow()这个方法，但是它返回值是double类型的，之后求它的长度时会有影响，所以我还是改成了最传统的相乘，多说无益，直接上代码吧。

答案

69

代码

public class Main {

	public static void main(String[] args) {
		for (int i = 0; i < 100; i++) {
			int pf = i * i;
			int lf = i * i * i;
			String str = pf + " " + lf;
			if (PD(str) && (String.valueOf(pf).length() + String.valueOf(lf).length() == 10)) {
				System.out.println(i);
				break;
			}
		}
	}

	public static boolean PD(String str) {
		if (str.contains("1") && str.contains("2") && str.contains("3") && str.contains("4") && str.contains("5")
				&& str.contains("6") && str.contains("7") && str.contains("8") && str.contains("9")
				&& str.contains("0")) {
			return true;
		}
		return false;
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

加法变乘法

题目

我们都知道：1+2+3+ … + 49 = 1225
现在要求你把其中两个不相邻的加号变成乘号，使得结果为2015

比如：
1+2+3+…+10*11+12+…+27*28+29+…+49 = 2015
就是符合要求的答案。

请你寻找另外一个可能的答案，并把位置靠前的那个乘号左边的数字提交（对于示例，就是提交10）。

注意：需要你提交的是一个整数，不要填写任何多余的内容。

思路

一开始我想到的方法就是建立一个数组，然后靠两个不相邻的两组相乘数减去这两组数的相加之后的和，让其结果等于2015-1225即可，但之后我一直遇到的问题就是结果不一样，我还在哪儿找了半天原因，但感觉自己的想法真的没有错误啊，为啥答案就是不一样？然后找网上的答案，才发现完全可以直接两个 for 循环嵌套即可，完全没必要在搞个数组画蛇添足了，看了一下他们的代码，和我的想法一样啊为啥我的就是错的？整了半天终于找出了原因，因为我数组是从0开始赋值的，最后答案要加1就正确了。。。。

代码

public class Main {

	public static void main(String[] args) {
		end: for (int i = 1; i <= 47; i++) {
			for (int j = 3; j < 49; j++) {
				if (i * (i + 1) + j * (j + 1) - i - (i + 1) - j - (j + 1) == 2015 - 1225) {
					if (i == 10) {
						continue;
					}
					System.out.println(i);
					break end;
				}
			}
		}
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

移动距离

题目

X星球居民小区的楼房全是一样的，并且按矩阵样式排列。其楼房的编号为1,2,3…
当排满一行时，从下一行相邻的楼往反方向排号。
比如：当小区排号宽度为6时，开始情形如下：

1 2 3 4 5 6
12 11 10 9 8 7
13 14 15 …

我们的问题是：已知了两个楼号m和n，需要求出它们之间的最短移动距离（不能斜线方向移动）

输入为3个整数w m n，空格分开，都在1到10000范围内
要求输出一个整数，表示m n 两楼间最短移动距离。

例如：
用户输入：
6 8 2
则，程序应该输出：
4

再例如：
用户输入：
4 7 20
则，程序应该输出：
5

资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。

思路

这道题乍一看很简单，但是开始做之后就开始各种问题出现，我感觉不做过多解释了吧，这题需要去理解我就直接呈上我的代码了。

代码

public class Main {
	public static void main(String[] args) {
		Scanner s1 = new Scanner(System.in);
		int w = s1.nextInt();
		int m = s1.nextInt();
		int n = s1.nextInt();
		int cha = 0, newNum = 0, sum = 0;
		int max1 = initMax(w, Math.min(m, n));
		int min1 = max1 - 5;
		int max2 = initMax(w, Math.max(m, n));
		int min2 = max2 - 5;
		if (isJI(w, max1)) {
			cha = Math.min(m, n) - min1;
		} else {
			cha = max1 - Math.min(m, n);
		}
		if (isJI(w, max2)) {
			newNum = min2 + cha;
		} else {
			newNum = max2 - cha;
		}
		System.out.println(max1 + " " + max2);
		System.out.println(Math.abs(Math.max(m, n) - newNum) + " " + (max2 / max1 - 1));
		sum = Math.abs(Math.max(m, n) - newNum) + max2 / max1 - 1;
		System.out.println(sum);
	}

	public static int initMax(int w, int n) {
		int tmp = w;
		while (w < n) {
			w += tmp;
		}
		return w;
	}

	public static boolean isJI(int w, int n) {
		if (n / w % 2 != 0) {
			return true;
		}
		return false;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

打印大X

题目

小明希望用星号拼凑，打印出一个大X，他要求能够控制笔画的宽度和整个字的高度。
为了便于比对空格，所有的空白位置都以句点符来代替。

要求输入两个整数m n，表示笔的宽度，X的高度。用空格分开(0<m<n, 3<n<1000, 保证n是奇数)
要求输出一个大X

例如，用户输入：
3 9
程序应该输出：

***.....***
.***...***.
..***.***..
...*****...
....***....
...*****...
..***.***..
.***...***.
***.....***
1
2
3
4
5
6
7
8
9

（如有对齐问题，参看【图1.jpg】）

再例如，用户输入：
4 21
程序应该输出

****................****
.****..............****.
..****............****..
...****..........****...
....****........****....
.....****......****.....
......****....****......
.......****..****.......
........********........
.........******.........
..........****..........
.........******.........
........********........
.......****..****.......
......****....****......
.....****......****.....
....****........****....
...****..........****...
..****............****..
.****..............****.
****................****
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

（如有对齐问题，参看【图2.jpg】）

资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。

思路

这种打印类型的题目都得靠找规律去完成，像本题因为他是一个上下对称图形，所以我们可以分开为上下两半完成即可，比赛中我们只需将所有精力放在上半部分，当我们把上半部分完成后就可以，下半部分只需要复制一下再改几个值即可。

代码

class Main {

	public static void main(String[] args) {
		Scanner s1 = new Scanner(System.in);
		// 笔的宽度
		int m = s1.nextInt();
		// x的高度
		int n = s1.nextInt();

		// 列数
		int y = m + n - 1;
		// 上半段
		for (int a = 0; a < (n + 1) / 2; a++) {
			int count = (y - 2 * m) - a * 2;
			for (int i = 0; i < a; i++) {
				System.out.print(".");
			}
			for (int i = 0; i < m; i++) {
				System.out.print("*");
			}
			for (int i = count - 1; i >= 0; i--) {
				System.out.print(".");
			}
			if (count >= 0) {
				for (int i = 0; i < y - (2 * a + m) - count; i++) {
					System.out.print("*");
				}
			} else {
				for (int i = 0; i < y - (2 * a + m); i++) {
					System.out.print("*");
				}
			}
			for (int i = 0; i < a; i++) {
				System.out.print(".");
			}
			System.out.println();
		}

		// 下半段
		for (int a = (n + 1) / 2 - 1; a >= 0; a--) {
			int count = (y - 2 * m) - a * 2;
			for (int i = 0; i < a; i++) {
				System.out.print(".");
			}
			for (int i = 0; i < m; i++) {
				System.out.print("*");
			}
			for (int i = count - 1; i >= 0; i--) {
				System.out.print(".");
			}
			if (count >= 0) {
				for (int i = 0; i < y - (2 * a + m) - count; i++) {
					System.out.print("*");
				}
			} else {
				for (int i = 0; i < y - (2 * a + m); i++) {
					System.out.print("*");
				}
			}
			for (int i = 0; i < a; i++) {
				System.out.print(".");
			}
			System.out.println();
		}
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

垒骰子

题目

赌圣atm晚年迷恋上了垒骰子，就是把骰子一个垒在另一个上边，不能歪歪扭扭，要垒成方柱体。
经过长期观察，atm 发现了稳定骰子的奥秘：有些数字的面贴着会互相排斥！
我们先来规范一下骰子：1 的对面是 4，2 的对面是 5，3 的对面是 6。
假设有 m 组互斥现象，每组中的那两个数字的面紧贴在一起，骰子就不能稳定的垒起来。 atm想计算一下有多少种不同的可能的垒骰子方式。
两种垒骰子方式相同，当且仅当这两种方式中对应高度的骰子的对应数字的朝向都相同。
由于方案数可能过多，请输出模 10^9 + 7 的结果。

不要小看了 atm 的骰子数量哦～

「输入格式」
第一行两个整数 n m
n表示骰子数目
接下来 m 行，每行两个整数 a b ，表示 a 和 b 不能紧贴在一起。

「输出格式」
一行一个数，表示答案模 10^9 + 7 的结果。

「样例输入」
2 1
1 2

「样例输出」
544

「数据范围」
对于 30% 的数据：n <= 5
对于 60% 的数据：n <= 100
对于 100% 的数据：0 < n <= 10^9, m <= 36

资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 2000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。

思路

动态规划题。。。。不会不会不会，递归都有时候绕不出来的我，对动态规划充满了阴影，但没办法呀，去网上找资料死磕了。

代码

这题我选择先放放再刷其他题了，但在此处提供自认为写得很详细的一位博主的文章，有时间可以去看看研究。

JacobKong_Dev的简书

原文博客地址：https://noahcode.cn/

欢迎大家收藏我的博客，我会努力更新更多的作品的，给自己加个油！