2015年省赛题_环节长度两个整数做除法,有时会产生循环小数,其循环部分称为:循环节。比如,11

题目列表：

1. 隔行变色
2. 立方尾不变
3. 无穷分数
4. 循环节长度
5. 格子中输出
6. 奇妙的数字
7. 加法变乘法
8. 移动距离
9. 打印大X
10. 垒骰子（未做）

一、隔行变色

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

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

这题直接看代码吧……
代码块：

public class _1隔行变色 {
	public static void main(String[] args){
		
		int cnt = 0;
		for(int i = 21; i <= 50; i++){
			if(i%2==0){
				cnt++;
			}
		}
		System.out.println(cnt);
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13

二、立方尾不变

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

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

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

代码块（解法一）：

public class _2立方尾不变 {
	public static void main(String[] args){
		
		int cnt = 0;
		
		for(long i = 1; i < 10000; i++){
			if(i<10){
				if(i*i*i%10 == i)cnt++;
			}else if(i<100){
				if(i*i*i%100 == i)cnt++;
			}else if(i<1000){
				if(i*i*i%1000 == i)cnt++;
			}else if(i<10000){
				if(i*i*i%10000 == i)cnt++;
			}
		}
		
		System.out.println(cnt);
	}
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

代码块（解法二）：

public class C2 {
	public static void main(String[]args) {
		
		int ans = 0;
		for(int i = 1; i <= 10000; i++) {
			int pin = i*i;
			if((pin+"").length()>(i+"").length()) {
				pin = Integer.valueOf((pin+"").substring((pin+"").length()-(i+"").length(), (pin+"").length()));
			}
			int li = pin*i;
			if((li+"").length()>(i+"").length()) {
				li = Integer.valueOf((li+"").substring((li+"").length()-(i+"").length(), (li+"").length()));
			}
			if(li==i) {
//				System.out.println(i);
				ans++;
			}
		}
		
		System.out.println(ans);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

三、无穷分数

Answer：0.58198
无穷的分数，有时会趋向于固定的数字。
请计算【图1.jpg】所示的无穷分数，要求四舍五入，精确到小数点后5位，小数位不足的补0。

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

思路：由后向前思考
数字大小虽然不同，但是经过题目描述的操作后，都会趋向于一个答案

代码块：

import java.math.BigDecimal;
import java.math.BigInteger;
public class _3无穷分数 {
	public static void main(String[] args){

		BigDecimal fn = new BigDecimal("1");//fn = 1;
		//System.out.println(fn);
		
		for(int i = 100; i >= 1; i--){
			//bd = i（i转化为BigInteger在转化为BigDecimal）
			BigDecimal bd = new BigDecimal(BigInteger.valueOf(i));
			/*
			 fn = bd / (fn+bd)
			  如下：
			 fn = 100/101
			 fn = 99/(99+(100/101))
			 */
			fn = bd.divide(fn.add(bd),5,BigDecimal.ROUND_HALF_UP);//四舍五入
		}
		
		//System.out.println(fn.toPlainString());//BigDecimal转化为字符串
		System.out.println(fn);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

解法二：

public class C3 {
	public static void main(String[]args) {
		
		f(1000);
		System.out.printf("%.7f",(1/d));
	}
	
	static double d;
	static double t = 1002;
	static void f(int n) {
		if(n==0)return;
		d = n + (n+1)/t;
		t = d;
		f(n-1);
	}
}

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

四、循环节长度

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

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

import java.util.Vector;
public class _4循环节长度 {
	public static void main(String[] args){
		//System.out.println(50%13);
		System.out.println(f(11,13));
	}
	
	public static int f(int n, int m)//11/13
	{
		n = n % m;	
		Vector v = new Vector();
		
		for(;;)
		{
			//比如，11/13=6=>0.846153846153.....  其循环节为[846153] 共有6位。
			v.add(n);//11 6 8 2 7 5 11
			n *= 10;
			n = n % m;
			if(n==0) return 0;
			if(v.indexOf(n)>=0){//判断n在v中是否存在
				return v.size()-v.indexOf(n);
				// _________________________________ ;  //填空
			}
		}
	}
}
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

五、格子中输出

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

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.jpg】）

六、奇妙的数字

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

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

思路：
从1开始判断，把每位数字的平方和立方都放进一个字符串中，判断字符串转化为字符数组，并使用set方法进行判断
代码块：

import java.util.HashSet;
import java.util.Set;
public class _6奇妙的数字 {
	public static void main(String[] args){
		 
		for(int i = 1; i < 1000000; i++){
			String s = (i*i)+""+(i*i*i);
			if(check(s)){
				System.out.println(i+" "+(i*i)+" "+(i*i*i));
			}
		}
	}
	
	//使用set去重
	static boolean check(String s){
		if(s.length() != 10)return false;
		
		Set<Character> set = new HashSet<Character>();
		for(int i = 0; i < s.length(); i++){
			set.add(s.charAt(i));
		}
		
		return set.size() == 10;
	}
}
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

七、加法变乘法

Answer: 16

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

比如：
1+2+3+…+1011+12+…+2728+29+…+49 = 2015
就是符合要求的答案。

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

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

思路：
两个不相邻的加号变乘号，使得结果为2015，得到：
1225 减去两个不相邻的加号两边的四个数在加上它们的乘积，最后会等于2015。
假设这四个数字分别为：a1, a2, b1, b2 那么：
1225 - (a1+a2) - (b1+b2) + a1×a2+b1×b2 = 2015

通过上面的等式得出下面的代码：
代码块：

public class _7加法变乘法 {
	public static void main(String[] args){
		
		int sum;
		for(int i = 1; i < 50; i++){//10 11
			for(int j = i; j < 50; j++){//27 28
				
				sum = 1225 - (i+i+1) - (j+j+1);//1225 - 21 - 55 = 1149
				if(2015 == sum + (i*(i+1) + (j*(j+1)))){//1149+110+756=1403
					System.out.println(i+" "+j+"!");
				}
				
			}
		}
	}

}
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

解题过程：

所以，解决这道题，只需高中数学知识就可以了~

代码块：

import java.util.Scanner;
public class _8移动距离 {
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		//接收用户输入的数字
		int w = sc.nextInt();
		int m = sc.nextInt();
		int n = sc.nextInt();
		int max = Math.max(w, Math.max(m, n));
		//根据题意将1~max赋值给二维数组a
		int k = 1;
		int[][]a = new int[max][w];
		for(int i = 0; i < max; i++){
			if(i % 2  != 0){
				for(int j = w-1; j >= 0; j--){
					a[i][j] = k;
					k++;
				}
			}else if(i%2==0){
				for(int j = 0; j < w; j++){
					a[i][j] = k;
					k++;
				}
			}
		}
		//从数组a中找到n和m，并算出对应的行和列
		int x1 = 0, y1 = 0;
		int x2 = 0, y2 = 0;
		for(int i = 0; i < max; i++){
			for(int j = 0; j < w; j++){
				if(a[i][j] == m){
					x1 = i;
					y1 = j;
				}
				if(a[i][j] == n){
					x2 = i;
					y2 = j;
				}
			}
		}
		//通过两点之间的距离关系，打印答案
		System.out.println(Math.abs(x1-x2)+Math.abs(y1-y2));
	}
}

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

九、打印大X

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

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

例如，用户输入：
3 9(w = 11)
程序应该输出：

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

再例如，用户输入：
4 21(w = 24)
程序应该输出

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

思路：
这题与打印十字架那道题相类似，都是可以使用递归分别打印；
第一次循环打印四个角，以后每次循环一次都向内打印，一次类推
如果没看懂，可以查看如下代码：

代码块：
解法一：

import java.util.Scanner;
public class _9打印大X {
	static char[][]a;
	static int m = 0;
	static int h = 0;
	static int w = 0;
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		
		m = sc.nextInt();//m：表示笔的宽度
		h = sc.nextInt();//h：表示x的高度；宽度=h-m-1
		
		w = h+m-1;
		a = new char[h][w];
		for(int i = 0; i < h; i++){
			for(int j = 0; j < w; j++){
				a[i][j] = '.';
			}
		}
		
		int start = 0;
		f(start);
		
		for(int i = 0; i < h; i++){
			for(int j = 0; j < w; j++){
				System.out.print(a[i][j]);
			}
			System.out.println();
		}
	}

	
	static void f(int start){
		//打印第一行和最后一行
		for(int i = start; i < start+m; i++){
			if(start >= w/2)return;
			
			a[start][i] = '*';//上左
			a[h-1-start][i] = '*';//下左
			a[start][w-1-i] = '*';//上右
			a[h-1-start][w-1-i] = '*';//下右
				
			f(start+1);
		}
		
	}
}
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

解法二：

import java.util.Scanner;
public class _9打印大XP {
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		
		int m = sc.nextInt();//m：表示笔的宽度
		int h = sc.nextInt();//h：表示x的高度；宽度=h-m-1
		
		int w = h+m-1;//宽
		//将.赋值到数组a中
		char[][]a = new char[h][w];
		for(int i = 0; i < h; i++){
			for(int j = 0; j < w; j++){
				a[i][j] = '.';
			}
		}
		
		//自左上到右下
		for(int i = 0; i < h; i++){
			for(int j = i; j < i+m; j++){
				a[i][j] = '*';
			}
		}
		//自右上到左下
		for(int i = 0; i < h; i++){
			for(int j = w-1-i; j >= w-(i+m); j--){
				a[i][j] = '*';
			}
		}
		
		for(int i = 0; i < h; i++){
			for(int j = 0; j < w; j++){
				System.out.print(a[i][j]);
			}
			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

十、垒骰子

赌圣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，否则按无效代码处理。