蓝桥杯专题-真题版含答案-【扑克牌排列】【取球博弈】【古堡算式】【泊松分酒】

Unity3D特效百例	案例项目实战源码	Android-Unity实战问题汇总
游戏脚本-辅助自动化	Android控件全解手册	再战Android系列
Scratch编程案例	软考全系列	Unity3D学习专栏
蓝桥系列	ChatGPT和AIGC

👉关于作者

专注于Android/Unity和各种游戏开发技巧，以及各种资源分享（网站、工具、素材、源码、游戏等）
有什么需要欢迎底部卡片私我，获取更多支持，交流让学习不再孤单。

👉实践过程

😜扑克牌排列

下面代码模拟了一套扑克牌（初始排序A~K，共13张）的操作过程。
操作过程是：
手里拿着这套扑克牌，从前面拿一张放在后面，再从前面拿一张放桌子上，再从前面拿一张放在后面，…
如此循环操作，直到剩下最后一张牌也放在桌子上。
下面代码的目的就是为了求出最后桌上的牌的顺序。
初始的排列如果是A,2,3…K，则最后桌上的顺序为：
[2, 4, 6, 8, 10, Q, A, 5, 9, K, 7, 3, J]
请分析代码逻辑，并推测划线处的代码。

package Question1_9;
import java.util.Arrays;
import java.util.List;
import java.util.Vector;
public class Question7 {
	public static List moveCard(List src) {
		if (src == null)
			return null;
		List dst = new Vector();
		for (;;) {
			if (src.size()==0)
				       break;      // 填空
			src.add(src.remove(0));
			dst.add(src.remove(0));                // 填空
		}
		return dst;
	}
public static void main(String[] args) {
		List a = new Vector();
		a.addAll(Arrays.asList("A", "2", "3", "4", "5", "6", "7", "8", "9",
				"10", "J", "Q", "K"));
		
		System.out.println(moveCard(a));
	}
}
运行结果：
[2, 4, 6, 8, 10, Q, A, 5, 9, K, 7, 3, J]

😜取球博弈

今盒子里有n个小球，A、B两人轮流从盒中取球，每个人都可以看到另一个人取了多少个，
也可以看到盒中还剩下多少个，并且两人都很聪明，不会做出错误的判断。
我们约定：
每个人从盒子中取出的球的数目必须是：1，3，7或者8个。
轮到某一方取球时不能弃权！
A先取球，然后双方交替取球，直到取完。
被迫拿到最后一个球的一方为负方（输方）
请编程确定出在双方都不判断失误的情况下，对于特定的初始球数，A是否能赢？
程序运行时，从标准输入获得数据，其格式如下：
先是一个整数n(n<100)，表示接下来有n个整数。然后是n个整数，每个占一行（整数<10000），表示初始球数。
程序则输出n行，表示A的输赢情况（输为0，赢为1）。
例如，用户输入：
4
1
2
10
18
则程序应该输出：
0
1
1
0

package Question10_19;
import java.util.Scanner;
publicclass Question18Think2MustRemember {
	publicstaticbooleanarray[]=newboolean[10020];
	publicstaticvoid main(String[] args) {
		array[0]=true;
		for (int i = 1; i <array.length; i++) {
			array[i]=(i>=8&&!array[i-8])||(i>=7&&!array[i-7])||(i>=3&&!array[i-3])||(i>=1&&!array[i-1]);
		}
		Scanner scanner=new Scanner(System.in);
		int n=scanner.nextInt();
		int total;
		scanner.nextLine();
		while ((n--)>0) {
			total=scanner.nextInt();
			System.out.println(array[total]?1:0);
		}
	}
}
运行结果：
4
1
2
10
18
输出结果:
0
1
1
0

😜古堡算式

福尔摩斯到某古堡探险，看到门上写着一个奇怪的算式：
ABCDE * ? = EDCBA
他对华生说：“ABCDE应该代表不同的数字，问号也代表某个数字！”
华生：“我猜也是！”
于是，两人沉默了好久，还是没有算出合适的结果来。
请你利用计算机的优势，找到破解的答案。
把 ABCDE 所代表的数字写出来。

Public  class TDemo02_two {
	Public static void main(String[] args){
		for(int i=10000;i<100000;i++){
			int a = i/10000;
			int b = i%10000/1000;
			int c = i%10000%1000/100;
			int d = i%10000%1000%100/10;
			int e = i%10;
			if(a==b||a==c||a==d||a==e||b==c||b==d||b==e||c==d||c==e||d==e){
				continue;
			}
			int y = e*10000+d*1000+c*100+b*10+a;
			if(y%i==0){
				System.out.println(i+"*"+y/i+"="+y);
			}
		}
	}
}
运行结果：
21978*4=87912

😜泊松分酒

泊松是法国数学家、物理学家和力学家。他一生致力科学事业，成果颇多。
有许多著名的公式定理以他的名字命名，比如概率论中著名的泊松分布。
有一次闲暇时，他提出过一个有趣的问题，后称为：“泊松分酒”。
在我国古代也提出过类似问题，遗憾的是没有进行彻底探索，其中流传较多是：“韩信走马分油”问题。
有3个容器，容量分别为12升，8升，5升。其中12升中装满油，另外两个空着。
要求你只用3个容器操作，最后使得某个容器中正好有6升油。
下面的列表是可能的操作状态记录：
12,0,0
4,8,0
4,3,5
9,3,0
9,0,3
1,8,3
1,6,5
每行3个数据，分别表示12，8，6升容器中的油量
第一行表示初始状态，第二行表示把12升倒入8升容器后的状态，第三行是8升倒入5升，…
当然，同一个题目可能有多种不同的正确操作步骤。
本题目的要求是，请你编写程序，由用户输入：各个容器的容量，开始的状态，
和要求的目标油量，程序则通过计算输出一种实现的步骤（不需要找到所有可能的方法）。
如果没有可能实现，则输出：“不可能”。
例如，用户输入：
12,8,5,12,0,0,6
用户输入的前三个数是容器容量（由大到小），接下来三个数是三个容器开始时的油量配置，
最后一个数是要求得到的油量（放在哪个容器里得到都可以）
则程序可以输出（答案不唯一，只验证操作可行性）：
12,0,0
4,8,0
4,3,5
9,3,0
9,0,3
1,8,3
1,6,5
每一行表示一个操作过程中的油量状态。
注意：
请仔细调试！您的程序只有能运行出正确结果的时候才有机会得分！
请把所有类写在同一个文件中，调试好后，存入与【考生文件夹】下对应题号的“解答.txt”中即可。
相关的工程文件不要拷入。

package Question30_39;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
import java.util.Vector;
public class Question36TooDifficultMustRemember {
	public static List<Integer> distribute(List<Integer> capacityList,List<Integer> oilSizeList,int where,int to) {
		List<Integer>tList =new ArrayList<Integer>();
		tList.addAll(oilSizeList);
		if(oilSizeList.get(where)==0){
			return null;
		}else if (oilSizeList.get(where)>=capacityList.get(to)-oilSizeList.get(to)) {
			tList.set(to, capacityList.get(to));
			tList.set(where, oilSizeList.get(where)-(capacityList.get(to)-oilSizeList.get(to)));
			return tList;
		}else if(oilSizeList.get(where)<=capacityList.get(to)-oilSizeList.get(to)){
			tList.set(to, oilSizeList.get(to)+oilSizeList.get(where));
			tList.set(where, 0);
			return tList;
		}
		return null;
	}
	public static boolean exeForward(Set<List<Integer>>set,List<Integer> capacityList,List<Integer> oilSizeList,int NeedOilSize) {
		
//		for (List<Integer> list : set) {
//			System.out.print(list+"  ");
//		}
//		System.out.println();
		
		
		for (Integer integer : oilSizeList) {
			if(integer==NeedOilSize){
				for (List<Integer> list : set) {
				//	System.out.print(list+" ");
				//	System.out.print(list.size()+" ");
					for (Iterator iterator = list.iterator(); iterator
							.hasNext();) {
						Integer integer2 = (Integer) iterator.next();
						System.out.print(integer2);
						if(iterator.hasNext()){
							System.out.print(",");
						}else {
							System.out.print("\n");
						}
						
					}
				}
				
				return true;
			}
		}
		Vector<List<Integer>>vector=new Vector<List<Integer>>();
		vector.add(distribute(capacityList, oilSizeList, 0, 1));
		vector.add(distribute(capacityList, oilSizeList, 0, 2));
		vector.add(distribute(capacityList, oilSizeList, 1, 0));
		vector.add(distribute(capacityList, oilSizeList, 1, 2));
		vector.add(distribute(capacityList, oilSizeList, 2, 0));
		vector.add(distribute(capacityList, oilSizeList, 2, 1));
		for (int i = 0; i < vector.size(); i++) {
			if(vector.get(i)!=null){
				
				if(set.add(vector.get(i))){
					
					if(exeForward(set, capacityList, vector.get(i), NeedOilSize)==true){
						return true;
					}
					set.remove(vector.get(i));
				}
			}
		}
		return false;
	}
	public static void main(String[] args){
		Scanner scanner=new Scanner(System.in);
		Set<List<Integer>>set=new LinkedHashSet<List<Integer>>();
		List<Integer>tList=new ArrayList<Integer>();
		for (int i = 0; i < 3; i++) {
			tList.add(0);
		}
		List<Integer> capacityList=new ArrayList<>(tList);
		List<Integer> oilSizeList=new ArrayList<>(tList);
		int NeedOilSize;
		
		String ts=scanner.nextLine();
		
		String tss[]=ts.split("\\,");
		for (int i = 0; i < capacityList.size(); i++) {
			capacityList.set(i, Integer.parseInt(tss[i]));
		}
		int totalOil=0;
		for (int i = 0; i < capacityList.size(); i++) {
			oilSizeList.set(i, Integer.parseInt(tss[i+3]));
			totalOil+=Integer.parseInt(tss[i+3]);
		}
		NeedOilSize=Integer.parseInt(tss[6]);
		
		if(NeedOilSize>totalOil){
			System.out.println("不可能");
			return;
		}
		boolean posible=false;
		for (int i = 0; i < capacityList.size(); i++) {
			if(capacityList.get(i)>NeedOilSize){
				posible=true;
				break;
			}
		}
		if(posible==false){
			System.out.println("不可能");
			return;
		}
		exeForward(set, capacityList, oilSizeList, NeedOilSize);
	}
}
运行结果：
输入数据（格式为7个数字用","号隔开,例：)12,8,5,12,0,0,6
12,8,5,12,0,0,6
12	0	0	
4	8	0	
4	3	5	
9	3	0	
9	0	3	
1	8	3	
1	6	5	
记录数:(7)

👉其他

📢作者：小空和小芝中的小空
📢转载说明-务必注明来源：https://zhima.blog.csdn.net/
📢这位道友请留步??，我观你气度不凡，谈吐间隐隐有王者霸气💚，日后定有一番大作为📝！！！旁边有点赞👍收藏🌟今日传你，点了吧，未来你成功??，我分文不取，若不成功??，也好回来找我。

温馨提示：点击下方卡片获取更多意想不到的资源。