第六届蓝桥杯JavaA组解析(2015年)
Posted nuist__NJUPT
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了第六届蓝桥杯JavaA组解析(2015年)相关的知识，希望对你有一定的参考价值。
第六届蓝桥杯JavaA组解析(2015年)
- 1-熊怪吃核桃
- 森林里有一只熊怪，很爱吃核桃，不过它有哥习惯，每次会把找到的核桃分成相等的两份
- 吃掉一份，留一份，如果不能等分，熊怪就会扔掉一个核桃再分，第二天再继续这个过程，
- 直到最后剩余一个核桃，直接丢掉。
- 有一天，熊怪发现了1543哥核桃，请问它在吃核桃的过程中，一共要丢掉多少核桃。
/**
* 1-熊怪吃核桃
* 森林里有一只熊怪，很爱吃核桃，不过它有哥习惯，每次会把找到的核桃分成相等的两份
* 吃掉一份，留一份，如果不能等分，熊怪就会扔掉一个核桃再分，第二天再继续这个过程，
* 直到最后剩余一个核桃，直接丢掉。
* 有一天，熊怪发现了1543哥核桃，请问它在吃核桃的过程中，一共要丢掉多少核桃。
*/
public class Main
public static void main(String[] args)
int num = 1543;
int count = 1 ; //最后一个直接丢掉
while(num > 1)
if(num > 1)
if(num % 2 ==1)
count++;
num /= 2 ;
else
break ;
System.out.println(count);
- 2.星系炸弹
- 在X星系的广袤空间中漂浮着许多X星人造炸弹，用来作为宇宙的路标，每个炸弹都可以设置多少天之后爆炸
- 比如:阿尔法炸弹2015年1月1日放置，定时为15天，则它在2015年1月16日爆炸.
- 有一个贝塔炸弹,2014年11月9日放置，定时为1000天，请你计算它爆炸的准确日期
- 请填写该日期，格式为yyyy-mm-dd 即4位年份2位月份2位日期。比如:2015-02-19请严格按照格式书写。不能出现其它文字或符号。
/**
* 2.星系炸弹
* 在X星系的广袤空间中漂浮着许多X星人造炸弹，用来作为宇宙的路标，每个炸弹都可以设置多少天之后爆炸
* 比如:阿尔法炸弹2015年1月1日放置，定时为15天，则它在2015年1月16日爆炸.
* 有一个贝塔炸弹,2014年11月9日放置，定时为1000天，请你计算它爆炸的准确日期
*
* 请填写该日期，格式为yyyy-mm-dd 即4位年份2位月份2位日期。比如:2015-02-19请严格按照格式书写。不能出现其它文字或符号。
*
*/
public class Main
public static void main(String[] args)
int t = 1000 - 365 - 366 - 21 - 31;
int month = 1;
while(t > 0)
switch (month)
case 1: case 3: case 5: case 7: case 8:case 10: case 12: t -= 31; month ++ ; break;
case 2: t -= 28; month++; break;
case 4: case 6: case 9: case 11: t-= 30; month++; break;
System.out.println("2017-"+ "0" + (month-1) + "-" + "0" + (t+31) );
- 3.九数分三组，1~9的数字可以组成3个3位数，设为A,B,C
- 现在要求满足如下关系：
- B = 2 * A
- C = 3 * A
- 请写出A的所有可能答案，数字间按空格排列，数字按照升序排列
import java.util.Arrays;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
/**
* 3.九数分三组，1~9的数字可以组成3个3位数，设为A,B,C
* 现在要求满足如下关系：
* B = 2 * A
* C = 3 * A
* 请写出A的所有可能答案，数字间按空格排列，数字按照升序排列
*/
public class Main
public static boolean equal(int a, int b, int c)
int x1 = a / 100;
int y1 = (a / 10) % 10 ;
int z1 = a % 10 ;
int x2 = b / 100;
int y2 = (b / 10) % 10 ;
int z2 = b % 10 ;
int x3 = c / 100;
int y3 = (c / 10) % 10 ;
int z3 = c % 10 ;
int [] res = x1,x2,x3,y1,y2,y3,z1,z2,z3 ;
Arrays.sort(res);
String s = "" ;
for(int i=0; i<res.length; i++)
s += res[i] ;
if(s.equals("123456789"))
return true ;
else
return false ;
public static void main(String[] args)
Set<Integer> set = new TreeSet<>() ;
for(int i=100; i<=999; i++)
for( int j=100; j<=999; j++)
for(int k=100; k<=999; k++)
if((j == 2*i) && (k == 3*i))
if(equal(i,j,k))
set.add(i);
Iterator<Integer> iterator = set.iterator() ;
while(iterator.hasNext())
System.out.print(iterator.next() + " ");
- 4-循环节长度
- 两个整数做除法，有时候会产生循环小数，其循环部分称为循环节，
- 下面方法可以求出循环节的长度，仔细阅读代码，填写空白处的代码
import java.util.Vector;
/**
* 4-循环节长度
* 两个整数做除法，有时候会产生循环小数，其循环部分称为循环节，
* 下面方法可以求出循环节的长度，仔细阅读代码，填写空白处的代码
*/
public class Main
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() - v.indexOf(n) ;
public static void main(String[] args)
System.out.println(f(11,13));
5.打印菱形：略
- 6.加法变乘法
- 我们都知道1+2+3+…+49=1225
- 我们现在要求将其中的不相邻的两个加号变成乘号，使得结果等于2015
- 寻找另一个答案，把位置靠左的乘号左边的那个数字提交。
/**
* 6.加法变乘法
* 我们都知道1+2+3+...+49=1225
* 我们现在要求将其中的不相邻的两个加号变成乘号，使得结果等于2015
* 寻找另一个答案，把位置靠左的乘号左边的那个数字提交。
*/
public class Main
public static void main(String[] args)
for(int i=1; i<=46; i++)
for(int j=i+2; j<=48; j++)
if(i*(i+1)+j*(j+1)-(i+i+1)-(j+j+1) == 2015-1225)
System.out.println(i + " " + j);
- 7.牌型种数
- 小明被劫持到X赌城,被迫与其它三人玩牌，
- 一副扑克牌，去掉大小王，共52张，均匀的发给4个人，每个人13张，
- 这时候小明的脑子里突然冒出一个问题：如果不考虑花色，只考虑点数，也不考虑自己得到牌的先后顺序，
- 自己手里能拿到的初始牌型组合有多少种呢？
/**
* 7.牌型种数
* 小明被劫持到X赌城,被迫与其它三人玩牌，
* 一副扑克牌，去掉大小王，共52张，均匀的发给4个人，每个人13张，
* 这时候小明的脑子里突然冒出一个问题：如果不考虑花色，只考虑点数，也不考虑自己得到牌的先后顺序，
* 自己手里能拿到的初始牌型组合有多少种呢？
*/
public class Main
static int count = 0;
/**
*
* @param k 牌型的种类数，1-13
* @param cnt 一共抽了多少张牌
*/
public static void f(int k, int cnt)
if(k>13 || cnt>13)
return ;
if(k==13 && cnt==13)
count ++ ;
for(int i=0; i<5; i++) //每种牌型出现的次数为0-4次
f(k+1, cnt+i) ;
public static void main(String[] args)
f(0, 0) ;
System.out.println(count);
- 8.移动距离
- X星球的居民小区楼房全是一样的，并且按矩阵样式排列，其楼房编号为1，2，3…
- 当排满一行时，从下一行相邻的楼往反方向排。
- 我们已知两个楼号m和n，需要求出它们之间的最短移动距离，不能沿着斜线方向移动，
- 输入为3个整数，w,m,n，空格分开，都在1-10000范围内，
- w为排号宽度，m,n为待计算的楼号，要求输出一个数，表示m和n之间的最短移动距离。
import java.util.Scanner;
/**
* 8.移动距离
* X星球的居民小区楼房全是一样的，并且按矩阵样式排列，其楼房编号为1，2，3...
* 当排满一行时，从下一行相邻的楼往反方向排。
* 我们已知两个楼号m和n，需要求出它们之间的最短移动距离，不能沿着斜线方向移动，
* 输入为3个整数，w,m,n，空格分开，都在1-10000范围内，
* w为排号宽度，m,n为待计算的楼号，要求输出一个数，表示m和n之间的最短移动距离。
*/
public class Main
/**题目本身没有考算法，但是逻辑性比较强,当然就是行列对应相减取绝对值后求和
* 主要的难点在于根据行数求出对应的列数。
*/
public static void main(String[] args)
Scanner input = new Scanner(System.in);
int w = input.nextInt();
int m = input.nextInt();
int n = input.nextInt();
int rm = m % w == 0 ? m / w : m / w + 1;
int rn = n % w == 0 ? n / w : n / w + 1;
int cm, cn;
if (rm % 2 == 0)
cm = rm * w - m + 1;
else
cm = w - (rm * w - m);
if(rn % 2 == 0)
cn = rn * w - n + 1 ;
else
cn = w - (rn * w - n) ;
System.out.println(Math.abs((rm-rn))+ Math.abs(cm-cn));
- 9.垒筛子 (递归法)
- 赌圣atm晚年迷恋上垒骰子，就是把筛子一个垒在另一个上边，不能歪歪扭扭，要垒成方柱体
- 经过长期观察，atm发现了稳定筛子的奥秘，有些数字的面贴合着会相互排斥，
- 我们先来规范一下筛骰子：1的对面是4；2的对面是5；3的对面是6
- 假设有m组互斥现象，每组中的那两个数字面紧贴在一起，骰子就不能稳定的垒起来
- atm想计算一下一共有多少种不同的可能的垒骰子的方式
- 两种垒骰子方式相同，当且仅当这两种方式中对应高度的骰子的对应数字的朝向都相同，
import java.util.Scanner;
/**
* 9.垒筛子
* 赌圣atm晚年迷恋上垒骰子，就是把筛子一个垒在另一个上边，不能歪歪扭扭，要垒成方柱体
* 经过长期观察，atm发现了稳定筛子的奥秘，有些数字的面贴合着会相互排斥，
* 我们先来规范一下筛骰子：1的对面是4；2的对面是5；3的对面是6
* 假设有m组互斥现象，每组中的那两个数字面紧贴在一起，骰子就不能稳定的垒起来
* atm想计算一下一共有多少种不同的可能的垒骰子的方式
* 两种垒骰子方式相同，当且仅当这两种方式中对应高度的骰子的对应数字的朝向都相同，
*
*/
public class Main
static int [] op = new int [7] ;
static long count = 0 ;
static int mod = 1000000007 ;
static boolean [][] conflict = new boolean [7][7] ;
public static void init() //初始化对面
op[1] = 4;
op[2] = 5;
op[3] = 6;
op[4] = 1;
op[5] = 2;
op[6] = 3;
/**
* 上层定好骰子朝上数字为up的情况下，垒好cnt个骰子的方案数
* @param up 上面
* @param cnt 还有cnt个骰子要组合
* @return
*/
public static long f(int up, int cnt)
long ans = 0 ;
if(cnt == 0) //n个骰子都已经定位，递归出口
return 4 ;
for(int up1=1; up1<=6; up1++)//下层递归
if(conflict[op[up]][up1]) //冲突不可选为上面
continue;
ans = (ans + f(up1, cnt-1)) % mod ;
return ans ;
public static void main(String[] args)
Scanner input = new Scanner(System.in) ;
init() ;
int n = input.nextInt() ; //骰子数
int m = input.nextInt() ; //行数
for(int i=0; i<m; i++)
int a = input.nextInt() ;
int b = input.nextInt() ;
conflict[op[a]][b] = true ;
conflict[op[b]][a] = true ;
for(int up=1; up<=6; up++)
count = (count + 4 * f(up, n-1)) % mod ;
System.out.println(count);
9.垒筛子 (动态规划法)
import java.util.Scanner;
public class Main1
static long mod = 1000000007;
static int [] op = new int [7] ;
static long [][] dp = new long [2][7] ; //第i层j朝上的合法方案数
static void init()
op[1] = 4 ;
op[2] = 5 ;
op[3] = 6 ;
op[4] = 1 ;
op[5] = 2 ;
op[6] = 3 ;
static boolean [][] conflict = new boolean[7][7] ;
public static void main(String[] args)
Scanner input = new Scanner(System.in) ;
init() ;
int n = input.nextInt() ; //以上是关于第六届蓝桥杯JavaA组解析(2015年)的主要内容，如果未能解决你的问题，请参考以下文章