2015第六届蓝桥杯省赛JAVA A组真题解析（带源码及解析）

电玩女神 2022-11-18 04:33 218阅读 0赞

## [蓝桥杯历年真题及解析][Link 1]. ##

### 目录： ###

*   *  蓝桥杯历年真题及解析.
     *   *  A：怪熊吃核桃（难度：★）
         *   *  题目：
             *  分析：
             *  代码：
         *  B：星系炸弹（难度：★★）
         *   *  题目：
             *  分析：
             *  代码：
         *  C：九数分三组（难度：★）
         *   *  题目：
             *  分析：
             *  代码：
         *  D：循环节长度（难度：★★）
         *   *  题目：
             *  分析：
             *  代码：
         *  E：打印菱形（难度：★★★）
         *   *  题目：
             *  分析：
             *  代码：
         *  F：加法变乘法（难度：★★★★）
         *   *  题目：
             *  分析：
             *  代码：
         *  G：牌型种数（难度：★★★）
         *   *  题目：
             *  分析：
             *  代码：
         *  H：移动距离（难度：★★★★）
         *   *  题目：
             *  分析：
             *  代码：
         *  I：垒骰子（难度：★★★★★）
         *   *  题目：
             *  分析：
             *  代码：
         *  J：灾后重建（难度：★★★★★）
         *   *  题目：
             *  分析：
             *  代码：
 *  算法交流群：

### A：怪熊吃核桃（难度：★） ###

#### 题目： ####

森林里有一只熊怪，很爱吃核桃。不过它有个习惯，每次都把找到的核桃分成相等的两份，吃掉一份，留一份。如果不能等分，熊怪就会扔掉一个核桃再分。第二天再继续这个过程，直到最后剩一个核桃了，直接丢掉。

有一天，熊怪发现了1543个核桃，请问，它在吃这些核桃的过程中，一共要丢掉多少个核桃。

#### 分析： ####

模拟运算过程即可。  
答案=5

#### 代码： ####

满分

public class A怪熊吃核桃 { 
    	public static void main(String[] args) { 
    		int num=1543;
    		int ans=0;
    		while(num!=0){ 
    			if(num%2!=0)
    			ans++;
    			num/=2;
    			
    		}
    		System.out.println(ans);
    	}
    }

### B：星系炸弹（难度：★★） ###

#### 题目： ####

在X星系的广袤空间中漂浮着许多X星人造“炸弹”，用来作为宇宙中的路标。  
每个炸弹都可以设定多少天之后爆炸。  
比如：阿尔法炸弹2015年1月1日放置，定时为15天，则它在2015年1月16日爆炸。  
有一个贝塔炸弹，2014年11月9日放置，定时为1000天，请你计算它爆炸的准确日期。

请填写该日期，格式为 yyyy-mm-dd 即4位年份2位月份2位日期。比如：2015-02-19

#### 分析： ####

模拟时间，一天天的往上加即可。  
答案=2017-08-05

#### 代码： ####

满分

import java.util.Scanner;
    
    public class B星系炸弹 { 
        static int arr[]={ 0,31,28,31,30,31,30,31,31,30,31,30,31};
        static void check(int x){ 
            if((x%4==0&&x%100!=0)||x%400==0)arr[2]=29;
            else arr[2]=28;
        }
        static String to(int x){ 
            if(x>9)return x+"";
            else return "0"+x;
        }
        public static void main(String[] args) { 
    // Scanner sc=new Scanner(System.in);
    // while(sc.hasNext()){ 
    // int year=sc.nextInt();
    // int mounth=sc.nextInt();
    // int day=sc.nextInt();
    // int n=sc.nextInt();
        	int year=2014,mounth=11,day=9,n=1000;
                boolean first=true;
                while(n>0){ 
                    check(year);
                    for(int i=(first?mounth:1);i<13;i++){ 
                        for(int j=(i==mounth&&first?day:1);j<=arr[i];j++){ 
                            if(n==0)System.out.println(year+"-"+to(i)+"-"+to(j));
                            n--;
                        }
                        first=false;
                    }
                    year++;
                }
    // }
        }
    }

### C：九数分三组（难度：★） ###

#### 题目： ####

1~9的数字可以组成3个3位数，设为：A,B,C, 现在要求满足如下关系：  
B = 2 \* A  
C = 3 \* A

请你写出A的所有可能答案，数字间用空格分开，数字按升序排列。

注意：只提交A的值，严格按照格式要求输出。

#### 分析： ####

从1~333进行枚举A即可，符合条件就输出。  
check过程通过HashSet判断  
答案=192 219 273 327

#### 代码： ####

满分

import java.util.HashSet;
    
    public class C九数分三组 { 
    	public static boolean check(int a,int b,int c){ 
    		HashSet<Integer> set=new HashSet<Integer>();
    		while(a!=0){ 
    			set.add(a%10);
    			set.add(b%10);
    			set.add(c%10);
    			a/=10;
    			b/=10;
    			c/=10;
    		}
    		return(!set.contains(0)&&set.size()==9);
    	}
    	public static void main(String[] args) { 
    		for(int i=123;i<333;i++){ 
    			if(check(i,i*2,i*3)){ 
    				System.out.print(i+" ");
    			}
    		}
    	}
    }

### D：循环节长度（难度：★★） ###

#### 题目： ####

两个整数做除法，有时会产生循环小数，其循环部分称为：循环节。  
比如，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)  _________________________________ ;  //填空
    		}
    	}

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

#### 分析： ####

用v的总长度减去第一次重合位置的下标即为循环节长度。  
答案=return v.size()-v.indexOf(n)

#### 代码： ####

满分

import java.util.ArrayList;
    
    public class D循环节长度 { 
    	public static int f(int n, int m)
    	{ 
    		n = n % m;	
    		ArrayList<Integer> v = new ArrayList<Integer>();
    		
    		for(;;)
    		{ 
    			v.add(n);
    			n *= 10;
    			n = n % m;
    			if(n==0) return 0;
    			if(v.indexOf(n)>=0)
    				return v.size()-v.indexOf(n);
    				//_________________________________ ; //填空
    		}
    	}
    }

### E：打印菱形（难度：★★★） ###

#### 题目： ####

给出菱形的边长，在控制台上打印出一个菱形来。  
为了便于比对空格，我们把空格用句点代替。  
当边长为8时，菱形为：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyMzI3_size_16_color_FFFFFF_t_70]  
下面的程序实现了这个功能，但想法有点奇怪。  
请仔细分析代码，并填写划线部分缺失的代码。

public class A
    { 
    	public static void f(int n)
    	{ 
    		String s = "*";
    		for(int i=0; i<2*n-3; i++) s += ".";
    		s += "*";
    	
    		String s1 = s + "\n";
    		String s2 = "";
    		
    		for(int i=0; i<n-1; i++){ 
    			//System.out.println("=>"+s);
    			s = "." + _____________________________________ + "*";  //填空
    			s1 = s + "\n" + s1;
    			s2 += s + "\n";
    		}
    		System.out.println(s1+s2);		
    	}
    	
    	public static void main(String[] args)
    	{ 
    		f(8);
    	}
    }

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

#### 分析： ####

观察发现我们需要完善s字符串，将每次生成的s字符串放在s1的两端  
所以我们即可知道每次需要对s作出一个动态的改变，  
s前面加了 " . " 所以一定是后边删除了部分，  
所以我们从开始位置截取一部分长度即可实现。  
答案=s.substring(0,s.length()-3)

#### 代码： ####

满分

public class E打印菱形
    { 
    	public static void f(int n)
    	{ 
    		String s = "*";
    		for(int i=0; i<2*n-3; i++) s += ".";
    		s += "*";
    	
    		String s1 = s + "\n";
    		String s2 = "";
    		
    		for(int i=0; i<n-1; i++){ 
    // System.out.println("=>"+s);
    			s = "." +s.substring(0,s.length()-3)+ "*"; 
    // s = "." + _____________________________________ + "*"; //填空
    			s1 = s + "\n" + s1;
    			s2 += s + "\n";
    		}
    		System.out.println(s1+s2);		
    	}
    	
    	public static void main(String[] args)
    	{ 
    		f(8);
    	}
    }

### F：加法变乘法（难度：★★★★） ###

#### 题目： ####

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

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

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

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

#### 分析： ####

双层循环尝试两个变乘号的位置即可，  
注意回溯。  
答案=16

#### 代码： ####

满分

public class F加法变乘法 { 
        public static void main(String[] args){ 
            int sum=1225;
            for(int i=1;i<47;i++){ 
                for(int j=i+2;j<49;j++){ 
                    sum-=(i+i+1+j+j+1);
                    sum+=(i*(i+1))+(j*(j+1));
                    if(sum==2015&&i!=10)System.out.println(i);
                    sum-=(i*(i+1))+(j*(j+1));
                    sum+=(i+i+1+j+j+1);
                }
            }
        }
    }

### G：牌型种数（难度：★★★） ###

#### 题目： ####

小明被劫持到X赌城，被迫与其他3人玩牌。  
一副扑克牌（去掉大小王牌，共52张），均匀发给4个人，每个人13张。  
这时，小明脑子里突然冒出一个问题：  
如果不考虑花色，只考虑点数，也不考虑自己得到的牌的先后顺序，自己手里能拿到的初始牌型组合一共有多少种呢？

请填写该整数，不要填写任何多余的内容或说明文字。

#### 分析： ####

简单DFS，  
递归枚举所有结果即可。  
注意不要计算重复。  
答案=3598180

#### 代码： ####

满分

public class G牌型种数 { 
    	public static long ans = 0;
    
    	public static void dfs(int cha, int cur) { 
    		if (cha < 0 || cur > 14)
    			return;
    		if (cha == 0) { 
    			ans++;
    			return;
    		} else { 
    			for (int i = 0; i < 5; i++) { 
    				dfs(cha - i, cur + 1);
    			}
    		}
    	}
    
    	public static void main(String[] args) { 
    		dfs(13, 1);
    		System.out.println(ans);
    	}
    }

### H：移动距离（难度：★★★★） ###

#### 题目： ####

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范围内  
w为排号宽度，m,n为待计算的楼号。  
要求输出一个整数，表示m n 两楼间最短移动距离。

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

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

#### 分析： ####

数学思维题，  
我们发现奇数楼层的数据都是从左向右排列，  
偶数层的数据都是从右往左排列。  
于是我们猜想，  
当两个数字的位置同属于奇数层或者同属于偶数层为一种情况

此时两者距离为两者纵向距离（Math.abs(m/w-n/w)）+横向距离（Math.abs(m%w-n%w)）

当两个数字的位置不同属于一种性质楼层为另外一种情况  
此时两者距离为两者纵向距离（Math.abs(m/w-n/w)）+（横向总距离-两者到两边的距离）的绝对值（Math.abs(w-1-m%w-n%w))）

#### 代码： ####

![在这里插入图片描述][20210412135032740.png]

import java.util.Scanner;
    
    public class H移动距离 { 
        public static void main(String[] args) { 
            Scanner sc=new Scanner(System.in);
            while(sc.hasNext()){ 
                int w=sc.nextInt();
                int m=sc.nextInt();
                int n=sc.nextInt();
                m--;
                n--;
                if(Math.abs(m/w-n/w)%2==0)
                    System.out.println(Math.abs(m/w-n/w)+Math.abs(m%w-n%w));
                else
                    System.out.println(Math.abs(m/w-n/w)+Math.abs(w-1-m%w-n%w));
            }
        }
    }

### I：垒骰子（难度：★★★★★） ###

#### 题目： ####

[题解链接][Link 2].

#### 分析： ####

[题解链接][Link 2].

#### 代码： ####

[题解链接][Link 2].

### J：灾后重建（难度：★★★★★） ###

#### 题目： ####

#### 分析： ####

//不会//

#### 代码： ####

# 算法交流群： #

![在这里插入图片描述][20210412145129472.png]

[Link 1]: https://blog.csdn.net/qq_43652327/article/details/104899994
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyMzI3_size_16_color_FFFFFF_t_70]: /images/20221022/d76cd39538a2411893b24bf6637269e2.png
[20210412135032740.png]: /images/20221022/90a370e7db05452bb9156404f7066213.png
[Link 2]: https://blog.csdn.net/qq_43652327/article/details/104827435
[20210412145129472.png]: /images/20221022/f83b6386458142ea85099c2f8f25d931.png