【2014 第五届蓝桥杯 Java 大学 B组个人笔记记录】

爱喝阔落的猫

已于 2022-03-31 16:22:05 修改

阅读量169

点赞数

分类专栏：蓝桥杯文章标签：蓝桥杯

于 2022-03-29 21:47:14 首次发布

本文链接：https://blog.csdn.net/qq_43520227/article/details/123816802

版权

蓝桥杯专栏收录该内容

18 篇文章 1 订阅

订阅专栏

2014 第五届蓝桥杯 Java 大学 B组个人笔记记录

A 武功秘籍
B 切面条
C 猜字母
D 大衍数列
E 圆周率
F 奇怪的分式
G 扑克序列
H 分糖果
I 地宫取宝
J 矩阵翻硬币

A 武功秘籍

答案: 7

/**
 * 
 * @author Tmac1
 *
标题：武功秘籍

    小明到X山洞探险，捡到一本有破损的武功秘籍（2000多页！当然是伪造的）。他注意到：书的第10页和第11页在同一张纸上，但第11页和第12页不在同一张纸上。
    小明只想练习该书的第81页到第92页的武功，又不想带着整本书。请问他至少要撕下多少张纸带走？
这是个整数，请通过浏览器提交该数字，不要填写任何多余的内容。
   //答案:7页
 */
public class _01武功秘籍 {

	//10,11 //12,13
	//10和11在一页那么 81肯定和82不在一页  
	//81//82,83//84,85//86,87/88,89//90,91//92 93
	
}

B 切面条

答案：1025

标题：切面条

    一根高筋拉面，中间切一刀，可以得到2根面条。
    如果先对折1次，中间切一刀，可以得到3根面条。
    如果连续对折2次，中间切一刀，可以得到5根面条。
    那么，连续对折10次，中间切一刀，会得到多少面条呢？
答案是个整数，请通过浏览器提交答案。不要填写任何多余的内容。
 */
public class _02切面条 {
	//前三个数据不足以得到规律  应该再推出一个 4的情况
	//0,2 //1,3 //2,5 //3,9 //4,17  //10,1025
	//解题思路:2^10+1=1024+1=1025   (2^n)+1
	
}

在这里插入图片描述

C 猜字母

答案：q


import java.util.ArrayList;
import java.util.Arrays;

/**
 * 
 * @author Tmac1
 *
标题：猜字母

    把abcd...s共19个字母组成的序列重复拼接106次，得到长度为2014的串。

    接下来删除第1个字母（即开头的字母a），以及第3个，第5个等所有奇数位置的字母。

    得到的新串再进行删除奇数位置字母的动作。如此下去，最后只剩下一个字母，请写出该字母。

答案是一个小写字母，请通过浏览器提交答案。不要填写任何多余的内容。
 */
public class _03 {
	public static void main(String[] args) {
		String string = "";
		for (int i = 0; i < 106; i++) {
			for (int j = 0; j < 19; j++) {
				string += (char) (97 + j);
			}

		}
		ArrayList<String> list = new ArrayList<String>();

		for (int i = 0; i < string.length(); i++) {
			list.add(string.charAt(i) + "");
		}
		while (list.size() > 1) {

			for (int i = list.size()-1 ; i >= 0; i--) {
				if (i % 2 == 0) {
					list.remove(i);
				}
			}

		}
		System.out.println(list.get(0));

	}
}

D 大衍数列

答案：i%2==0


/**
 * 
 * @author Tmac1
 *
标题：大衍数列

    中国古代文献中，曾记载过“大衍数列”, 主要用于解释中国传统文化中的太极衍生原理。

    它的前几项是：0、2、4、8、12、18、24、32、40、50 ...

    其规律是：对偶数项，是序号平方再除2，奇数项，是序号平方减1再除2。

    以下的代码打印出了大衍数列的前 100 项。

for(int i=1; i<100; i++)
{
	if(________________)  //填空
		System.out.println(i*i/2);
	else
		System.out.println((i*i-1)/2);
}

    请填写划线部分缺失的代码。通过浏览器提交答案。

注意：不要填写题面已有的内容，也不要填写任何说明、解释文字。

 */
public class _04大衍数列 {

	public static void main(String[] args) {
		for(int i=1; i<100; i++)
		{
			if(i%2==0)  //填空
				System.out.println(i*i/2);
			else
				System.out.println((i*i-1)/2);
		}
	}
}

E 圆周率

答案：4.0/(x-1)


/**
 * 
 * @author Tmac1
 *
    数学发展历史上，圆周率的计算曾有许多有趣甚至是传奇的故事。其中许多方法都涉及无穷级数。
    图1.png中所示，就是一种用连分数的形式表示的圆周率求法。
    下面的程序实现了该求解方法。实际上数列的收敛对x的初始值 并不敏感。	
    结果打印出圆周率近似值（保留小数点后4位，并不一定与圆周率真值吻合）。
 */
public class _05圆周率 {
public static void main(String[] args) {

	double x = 111; 
	for(int n = 10000; n>=0; n--){
		int i = 2 * n + 1;// x+1=4/pi  -> pi=
		x = 2 + (i*i / x);
	}
	
	System.out.println(String.format("%.4f", 4.0/(x-1)));
}
}

F 奇怪的分式

答案：14


/**
 * 
 * @author Tmac1
 *
标题：奇怪的分式

    上小学的时候，小明经常自己发明新算法。一次，老师出的题目是：8/20 ==2/5 
    1/4 乘以 8/5 
    小明居然把分子拼接在一起，分母拼接在一起，答案是：18/45 （参见图1.png） 
    老师刚想批评他，转念一想，这个答案凑巧也对啊，真是见鬼！
    对于分子、分母都是 1~9 中的一位数的情况，还有哪些算式可以这样计算呢？
    请写出所有不同算式的个数（包括题中举例的）。
    显然，交换分子分母后，例如：4/1 乘以 5/8 是满足要求的，这算做不同的算式。
    但对于分子分母相同的情况，2/2 乘以 3/3 这样的类型太多了，不在计数之列!
注意：答案是个整数（考虑对称性，肯定是偶数）。请通过浏览器提交。不要书写多余的内容。
 */
public class _06 {
	//解题思路：这里应该枚举而不是全排列因为这里两个分式的分子分母实可以重复的
	//没有说两个分式之间不可以重复所以进行枚举，用乘法法则做更好

	public static void main(String[] args) {
		int count=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++) {
					for (int d = 1; d <=9; d++) {
						if (c==d) {
						continue;
						}
						int e=a*10+c;
						int f=b*10+d;
						if (a*c*f==b*d*e) {
			                  count++;		
			                  System.out.println(a+"/"+b+"x"+c+"/"+d+"="+e+"/"+f);
						}
					}
				}
			}
		}
		System.out.println(count);
	}
}

G 扑克序列

答案：2342A3A4


import java.util.Set;
import java.util.TreeSet;

/**
 * 
 * @author Tmac1
 *
标题：扑克序列

    A A 2 2 3 3 4 4， 一共4对扑克牌。请你把它们排成一行。
    要求：两个A中间有1张牌，两个2之间有2张牌，两个3之间有3张牌，两个4之间有4张牌。

    请填写出所有符合要求的排列中，字典序最小的那个。

例如：22AA3344 比 A2A23344 字典序小。当然，它们都不是满足要求的答案。


请通过浏览器提交答案。“A”一定不要用小写字母a，也不要用“1”代替。字符间一定不要留空格。

 */
public class _07扑克序列 {
	//全排列 2342A3A4 TreeSet字典排序
	static Set<String> set=new TreeSet<String>();
	public static void main(String[] args) {
		char arr[]= {'A','A','2','2','3','3','4','4'};
		dfs(arr,0);
		for (String x:set) {
			System.out.println(x);
			break;
		}
	
		
	}

	private static void dfs(char[] arr, int k) {
		// TODO Auto-generated method stub
		if (arr.length==k) {
			String string=new String(arr);
			check(string);
		}else {
			for (int i = k; i < arr.length; i++) {
				char t=arr[i];
				arr[i]=arr[k];
				arr[k]=t;
				dfs(arr, k+1);
				t=arr[i];
				arr[i]=arr[k];
				arr[k]=t;
			}
		}
	}

	private static void check(String arr) {
		// TODO Auto-generated method stub
		if (arr.lastIndexOf('A') - arr.indexOf('A') == 2 && arr.lastIndexOf('2') - arr.indexOf('2') == 3
				&& arr.lastIndexOf('3') - arr.indexOf('3') == 4 && arr.lastIndexOf('4') - arr.indexOf('4') == 5) {
			set.add(arr);
		}

	}

}

H 分糖果

自己写的复杂模拟


import java.util.Arrays;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

/**
 * 
 * @author Tmac1
 *
 *         标题：分糖果
 * 
 *         有n个小朋友围坐成一圈。老师给每个小朋友随机发偶数个糖果，然后进行下面的游戏： 每个小朋友都把自己的糖果分一半给左手边的孩子。
 *         一轮分糖后，拥有奇数颗糖的孩子由老师补给1个糖果，从而变成偶数。 反复进行这个游戏，直到所有小朋友的糖果数都相同为止。
 *         你的任务是预测在已知的初始糖果情形下，老师一共需要补发多少个糖果。
 * 
 *         【格式要求】
 * 
 *         程序首先读入一个整数N(2<N<100)，表示小朋友的人数。 接着是一行用空格分开的N个偶数（每个偶数不大于1000，不小于2）
 *         要求程序输出一个整数，表示老师需要补发的糖果数。
 * 
 *         例如：输入 3 
 *         2 2 4 程序应该输出： 4
 * 
 *         资源约定： 峰值内存消耗（含虚拟机） < 256M CPU消耗 < 1000ms
 * 
 * 
 *         请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
 * 
 *         所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。 注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
 *         注意：主类的名字必须是：Main，否则按无效代码处理。
 * 
 */
public class _08分糖果_复杂版 {
	static int k;//补发糖果数

	public static void main(String[] args) {
		Scanner kb = new Scanner(System.in);
		int n = kb.nextInt();
		int arr[] = new int[n];

		for (int i = 0; i < arr.length; i++) {
			arr[i] = kb.nextInt();
		}
		
		int b[] = new int[n];
		while (true) {
			boolean flag = true;
			panduan(arr);
			fentangguo(arr, b);
			fenfa(arr, b);
			//糖果不一样就继续分
			for (int i = 0; i < arr.length; i++) {
				if (arr[i] != arr[0]) {
					flag = false;
					break;
				}
			}
			//true也就是说所有孩子糖果数一样这时候就跳出分糖果的过程
			if (flag) {
				break;
			}
		}
		//最终输出补发糖果数
		System.out.println(k);

	}

	//分发最后一个单独处理，其他以此向前分发糖果
    private static void fenfa(int[] arr, int[] b) {
        // TODO Auto-generated method stub
        for (int i = 0; i < b.length; i++) {
            if (i==arr.length-1) {
                arr[i]+=b[0];
            }else {
                arr[i]+=b[i+1];
            }
        }

    }

    //分出去的糖果数b，也就是arr剩下的糖果数
    private static void fentangguo(int[] arr, int b[]) {
        // TODO Auto-generated method stub
        for (int i = 0; i < arr.length; i++) {
            b[i] = arr[i] / 2;
            arr[i]=b[i];
        }
    }

    //判断糖果是否为偶数，不是则变为偶数并且记录补发的糖果数
    private static void panduan(int[] arr) {
        // TODO Auto-generated method stub
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]%2!=0) {
                arr[i] = arr[i] + 1;
                k++;
            }
        }
    }


}

第二种：

//简单版

import java.util.Arrays;
import java.util.Scanner;

/**
 * 
 * @author Tmac1
 *
 *         标题：分糖果
 * 
 *         有n个小朋友围坐成一圈。老师给每个小朋友随机发偶数个糖果，然后进行下面的游戏： 每个小朋友都把自己的糖果分一半给左手边的孩子。
 *         一轮分糖后，拥有奇数颗糖的孩子由老师补给1个糖果，从而变成偶数。 反复进行这个游戏，直到所有小朋友的糖果数都相同为止。
 *         你的任务是预测在已知的初始糖果情形下，老师一共需要补发多少个糖果。
 * 
 *         【格式要求】
 * 
 *         程序首先读入一个整数N(2<N<100)，表示小朋友的人数。 接着是一行用空格分开的N个偶数（每个偶数不大于1000，不小于2）
 *         要求程序输出一个整数，表示老师需要补发的糖果数。
 * 
 *         例如：输入 3 
 *         2 2 4 程序应该输出： 4
 * 
 *         资源约定： 峰值内存消耗（含虚拟机） < 256M CPU消耗 < 1000ms
 * 
 * 
 *         请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
 * 
 *         所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。 注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
 *         注意：主类的名字必须是：Main，否则按无效代码处理。
 * 
 */
public class q2014_8 {

	public static void main(String[] args) {
		Scanner kb = new Scanner(System.in);
		int n = kb.nextInt();
		int a[] = new int[n];

		for (int i = 0; i < n; i++) {
			a[i] = kb.nextInt();
		}
		int k = 0;// 补充糖果数
		while (true) {
			int t=a[0];//存起来用来给最后分
			for (int i = 0; i <=n - 2; i++) {
				a[i] -= a[i] / 2;
				a[i] += a[i + 1] / 2;
				if (a[i] % 2 != 0) {
					k++;
					a[i]++;
				}
			}
			a[n - 1] = a[n - 1] / 2;
			a[n - 1] += t / 2;
			if (a[n - 1] % 2 != 0) {
				k++;
				a[n - 1]++;
			}
			if (check(a, n)) {
				System.out.println(k);
				return;
			}
		}
	}
	private static boolean check(int[] a,int n) {
		int t=a[0];
		for (int i = 1; i <n; i++) {
			if (a[i]!=t) {
				return false;
			}
		}
		return true;
	}

}

I 地宫取宝


import java.util.Scanner;

public class q2014_9 {
	static int maze[][] = new int[50][50];
	static int n = 0;
	static int m = 0;
	static int k = 0;
	static long MOD = 1000000007;
	static long cache[][][][] = new long[50][50][15][15];

	public static void main(String[] args) {
		Scanner kb = new Scanner(System.in);
		n = kb.nextInt();
		m = kb.nextInt();
		k = kb.nextInt();

		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				maze[i][j] = kb.nextInt();
			}
		}

		// 第一个点可能是1所以得是-1
		init();
		System.out.println(dfs(0, 0, -1, 0));
	}

	static void init() {
		for (int i = 0; i < 50; i++) {
			for (int j = 0; j < 50; j++) {
				for (int j2 = 0; j2 < 15; j2++) {
					for (int k = 0; k < 15; k++) {
						cache[i][j][j2][k] = -1;
					}
				}
			}
		}
	}

	private static long dfs(int x, int y, int max, int cnt) {
		// 第一步查缓存 有的话直接用
		if (cache[x][y][max + 1][cnt] != -1) {
			return cache[x][y][max + 1][cnt];
		}
		if (x == n || y == m || cnt > k) {
			return 0;
		}
		long count = 0;
		int value = maze[x][y];
		if (x == n - 1 && y == m - 1) {// 已经面临最后一个格子
			if (cnt == k || (cnt == k - 1 && value > max)) {
				return 1;
			}
		}

		if (value > max) {// 大于可以取
			count += dfs(x + 1, y, value, cnt + 1);
			count += dfs(x, y + 1, value, cnt + 1);
		}
		// 对于价值较小或者很大的我不去取这个物品,max仍然是维持cnt不变
		count += dfs(x + 1, y, max, cnt);
		count += dfs(x, y + 1, max, cnt);

		cache[x][y][max + 1][cnt] = count % MOD;
		return count%MOD;

	}

}

J 矩阵翻硬币


import java.util.Scanner;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Scanner;

public class q2014_10 {
	// 第x行第y列被翻动的总次数？
	// 考虑第1行，第y列，y有多少真因子，就会被翻动多少次，而所有的y中，只有平方数的真因子个数为奇数（约数总是成对出现的）
	// 考虑第1列，第x行，x有多少真因子，就会被翻动多少次，而所有的x中，只有平方数的真因子个数为奇数
	// x,y硬币被翻动的次数=x真因子个数*y真因子个数，只有奇数*奇数=奇数，所以，若要x,y为反面，必须x，y都是平方数
	// 因此，反面硬币总数=m中的平方数的个数*n中平方数的个数
	// 那么在m中有多少个平方数呢？答案是sqrt(m)向下取整个，如9内有三个平方数1，4，9；16里面有4个平方数1，4，9，16；25内有5个平方数
	// 因此此题等价于求sqrt(m)*sqrt(n)，那么怎么对一个很大的数开平方呢？
	// 假设一个数的长度为length，其平方根的长度为length/2（偶数）或者length/2+1(奇数)
	// 我们可以从高位不停地试探，每一个取平方后恰好不超过目标平方数的值

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String s1 = sc.next();
		String s2 = sc.next();
		System.out.println(sqrt(s1).multiply(sqrt(s2)));
	}

	private static BigInteger sqrt(String s) {
		int length = s.length();
		int len = 0;
		if (length % 2 == 0)
			len = length / 2;
		else
			len = length / 2 + 1;
		char[] sArr = new char[len];
		Arrays.fill(sArr, '0');
		BigInteger target = new BigInteger(s);
		for (int pos = 0; pos < len; pos++) {
			for (char c = '1'; c <= '9'; c++) {
				sArr[pos] = c;// 在pos这个位置上试着填入1-9
				BigInteger pow = new BigInteger(String.valueOf(sArr)).pow(2);// 平方
				if (pow.compareTo(target) == 1)// 试探数的平方更大
				{
					sArr[pos] -= 1;
					break;
				}
			}
		}
		return new BigInteger(String.valueOf(sArr));
	}

}

参考博客一叶之修

爱喝阔落的猫

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
【2014 第五届蓝桥杯 Java 大学 B组个人笔记记录】

2014 第五届蓝桥杯 Java 大学 B组个人笔记记录A 武功秘籍B 切面条C 猜字母D 大衍数列E 圆周率F 奇怪的分式G 扑克序列H 分糖果I 地宫取宝J 矩阵翻硬币A 武功秘籍答案: 7/** * * @author Tmac1 *标题：武功秘籍小明到X山洞探险，捡到一本有破损的武功秘籍（2000多页！当然是伪造的）。他注意到：书的第10页和第11页在同一张纸上，但第11页和第12页不在同一张纸上。小明只想练习该书的第81页到第92页的武功，又不想带着整本书。请
复制链接

扫一扫