蓝桥杯专题-真题版含答案-【扑克牌排列】【放麦子】【纵横放火柴游戏】【顺时针螺旋填入】

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

👉关于作者

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

CSDN-芝麻粒儿

👉实践过程

😜扑克牌排列

下面代码模拟了一套扑克牌(初始排序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]

import java.util.ArrayList;
public class Squeezer {
	public static void main(String args[]){
		ArrayList<String> list=new ArrayList();
		list.add("K");
		list.add("Q");
		list.add("J");
		list.add("10");
		list.add("9");
		list.add("8");
		list.add("7");
		list.add("6");
		list.add("5");
		list.add("4");
		list.add("3");
		list.add("2");
		list.add("A");
		ArrayList<String> out=new ArrayList<String>();
		out.add(list.get(0));
		list.remove(0);
		while(list.size()>0){
			out.add(list.get(0));
			list.remove(0);
			out.add(out.get(0));
			out.remove(0);
		}
		int i=out.size()-1;
		while(i>0){
			System.out.print(out.get(i--)+",");
		}
	    System.out.print(out.get(0));
   }
}

😜放麦子

你一定听说过这个故事。国王对发明国际象棋的大臣很佩服,
问他要什么报酬,大臣说:请在第1个棋盘格放1粒麦子,
在第2个棋盘格放2粒麦子,在第3个棋盘格放4粒麦子,
在第4个棋盘格放8粒麦子,…后一格的数字是前一格的两倍,
直到放完所有棋盘格(国际象棋共有64格)。
国王以为他只是想要一袋麦子而已,哈哈大笑。
当时的条件下无法准确计算,但估算结果令人吃惊:即使全世界都铺满麦子也不够用!
请你借助计算机准确地计算,到底需要多少粒麦子。

package Question1_9;
import java.math.BigInteger;
publicclass Question9 {
	publicstaticvoid main(String[] args) {
		BigInteger total=new BigInteger("0"); 
		BigInteger base=new BigInteger("2");
		for (int i = 0; i < 64; i++) {
			total=total.add(base.pow(i));
			//System.out.println(total);
		}
		System.out.println(total);
		System.out.println(base.pow(64).add(new BigInteger("-1")));
		
	}
}
运行结果:
18446744073709551614

import java.math.BigInteger;  
public class Demo03 {  
    public static void main(String[] args) {  
        BigInteger bi = new BigInteger("0");  
        for(int i=0;i<64;i++){  
            bi = bi.add(BigInteger.valueOf((long)(Math.pow(2, i))));  
        }  
        System.out.println(bi);  
    }  
} 

😜纵横放火柴游戏

这是一个纵横火柴棒游戏。如图[1.jpg],在3x4的格子中,游戏的双方轮流放置火柴棒。其规则是:

  1. 不能放置在已经放置火柴棒的地方(即只能在空格中放置)。
  2. 火柴棒的方向只能是竖直或水平放置。
  3. 火柴棒不能与其它格子中的火柴“连通”。所谓连通是指两根火柴棒可以连成一条直线,
    且中间没有其它不同方向的火柴“阻拦”。
    例如:图[1.jpg]所示的局面下,可以在C2位置竖直放置(为了方便描述格子位置,图中左、下都添加了标记),
    但不能水平放置,因为会与A2连通。同样道理,B2,B3,D2此时两种方向都不可以放置。但如果C2竖直放置后,
    D2就可以水平放置了,因为不再会与A2连通(受到了C2的阻挡)。
    在这里插入图片描述
  4. 游戏双方轮流放置火柴,不可以弃权,也不可以放多根。直到某一方无法继续放置,则该方为负(输的一方)。
    游戏开始时可能已经放置了多根火柴。
    你的任务是:编写程序,读入初始状态,计算出对自己最有利的放置方法并输出。
    如图[1.jpg]的局面表示为:
    00-1
    -000
    0100
    即用“0”表示空闲位置,用“1”表示竖直放置,用“-”表示水平放置。
    【输入、输出格式要求】
    用户先输入整数 n(n<100), 表示接下来将输入 n 种初始局面,每种局面占3行(多个局面间没有空白行)。
    程序则输出:每种初始局面情况下计算得出的最佳放置法(行号+列号+放置方式)。
    例如:用户输入:
    2
    0111
    -000
    -000
    1111
    0010
    则程序可以输出:
    00-
    211
    不难猜出,输出结果的含义为:
    对第一个局面,在第0行第0列水平放置
    对第二个局面,在第2行第1列垂直放置
    注意:
    行号、列号都是从0开始计数的。
    对每种局面可能有多个最佳放置方法(解不唯一),只输出一种即可。
    例如,对第一个局面,001 也是正解;最第二个局面,201也是正解。
package Question10_19;
import java.util.Scanner;
publicclass Question13 {
	publicstaticboolean isOk(char[][] state, int i, int j) {
		if (state[i][j] == '-') {
			for (int j2 = j + 1; j2 < 4; j2++) {
				if (state[i][j2] == '-') {
					returnfalse;
				} elseif (state[i][j2] == '1') {
					returntrue;
				}
			}
			for (int j2 = j - 1; j2 >= 0; j2--) {
				if (state[i][j2] == '-') {
					returnfalse;
				} elseif (state[i][j2] == '1') {
					returntrue;
				}
			}
		} elseif (state[i][j] == '1') {
			for (int i2 = i + 1; i2 < 3; i2++) {
				if (state[i2][j] == '1') {
					returnfalse;
				} elseif (state[i2][j] == '-') {
					returntrue;
				}
			}
			for (int i2 = i - 1; i2 >= 0; i2--) {
				if (state[i2][j] == '1') {
					returnfalse;
				} elseif (state[i2][j] == '-') {
					returntrue;
				}
			}
		}
		returntrue;
	}
	privatestaticvoid jasdklf(char[][] state) {
		for (int i = 0; i < 3; i++) {
			for (int j = 0; j < 4; j++) {
				if (state[i][j] == '0') {
					state[i][j] = '-';
					if (isOk(state, i, j)) {
						System.out.println(i + "" + j + '-');
						return;
					}
					state[i][j] = '0';
					state[i][j] = '1';
					if (isOk(state, i, j)) {
						System.out.println(i + "" + j + '1');
						return;
					}
					state[i][j] = '0';
				}
			}
		}
	}
	publicstaticvoid main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt();
		scanner.nextLine();
		char[][] state = newchar[3][4];
		String s;
		while ((n--) > 0) {
			for (int i = 0; i < 3; i++) {
				s = scanner.nextLine();
				for (int j = 0; j < 4; j++) {
					state[i][j] = s.charAt(j);
				}
			}
			jasdklf(state);
		}
	}
}

import java.util.Scanner;  
import java.util.List;  
import java.util.ArrayList;  
public class Demo05 {  
    static boolean flag = false;    // 用来标记是否连通   
    static boolean flag2 = false;   // 用来标记是否没有结果, 如果没有结果输出"空";   
    // 初始化数组   
    public static void init(List<char[][]> lis,String[] s,int n){  
        for(int i=0;i<n;i++){  
            for(int j=i*3;j<i*3+3;j++){  
                lis.get(i)[j%3] = s[j].toCharArray();  
            }  
        }  
    }  
    // 创建n个数组  初始化,并存入lis   
    public static void input(List<char[][]> lis,int n){  
        Scanner scan = new Scanner(System.in);  
        for(int i=1;i<=n;i++){       // 创建数组   
            lis.add(new char[3][4]);  
        }  
        String[] s = new String[n*3];  
        for(int i=0;i<n*3;i++){  // 行到输入的数据   
            s[i] = scan.nextLine();  
        }  
        init(lis,s,n);  // 用输入的数据 初始化每个数组   
    }  
    // c='1' 检查列上侧是否连通    
    public static boolean colU(char[][] m,int i,int j,char c){  
        if(i<0){  
            flag = true;    // 都不连通   
            return flag;  
        }  
        if(m[i][j]=='0'){  
            return colU(m,i-1,j,c);  
        }else if(m[i][j]=='1'){  
            flag = false;   // 有一个 '1' 则连通   
            return flag;  
        }else if(m[i][j]=='-'){  
            flag = true;    // 有一个 '-' 则不连通   
            return flag;  
        }  
        return flag;  
    }  
    // c='1' 检查列下侧是否连通    
        public static boolean colD(char[][] m,int i,int j,char c){  
            if(i>=m.length){  
                flag = true;    // 都不连通   
                return flag;  
            }  
            if(m[i][j]=='0'){  
                return colD(m,i+1,j,c);  
            }else if(m[i][j]=='1'){  
                flag = false;   // 有一个 '1' 则连通   
                return flag;  
            }else if(m[i][j]=='-'){  
                flag = true;    // 有一个 '-' 则不连通   
                return flag;  
            }  
            return flag;  
        }  
    // c='-' 检查行左侧是否连通   
    public static boolean rowL(char[][] m,int i,int j,char c){  
        if(j<0){  
            flag = true;    // 都不连通   
            return flag;  
        }  
        if(m[i][j]=='0'){  
            return rowL(m,i,j-1,c);  
        }else if(m[i][j]=='1'){  
            flag = true;    // 有一个 '1' 则不连通   
            return flag;  
        }else if(m[i][j]=='-'){  
            flag = false;   // 有一个 '-' 则连通   
            return flag;  
        }  
        return flag;  
    }  
    // c='-' 检查行右侧是否连通   
    public static boolean rowR(char[][] m,int i,int j,char c){  
        if(j>=m[i].length){  
            flag = true;    // 都不连通   
            return flag;  
        }  
        if(m[i][j]=='0'){  
            return rowR(m,i,j+1,c);  
        }else if(m[i][j]=='1'){  
            flag = true;    // 有一个 '1' 则不连通   
            return flag;  
        }else if(m[i][j]=='-'){  
            flag = false;   // 有一个 '-' 则连通   
            return flag;  
        }  
        return flag;  
    }  
    // 当c='1'时 检查是否连通1111111111111111111   
    public static boolean check1(char[][] m, int i, int j, char c) {  
        if(colU(m,i,j,c)&&colD(m,i,j,c)){   // 是 '1' 时 检查(上下)是否连通   
            flag = true;  
        }else{  
            return false;  
        }  
        return flag;  
    }  
    // 当c='-'时 检查是否连通-------------------   
    public static boolean check2(char[][] m, int i, int j, char c) {  
        if(rowL(m,i,j,c)&&rowR(m,i,j,c)){   // 是 '-' 时 检查(左右)是否连通   
            flag = true;  
        }else{  
            return false;  
        }  
        return flag;  
    }  
    // 检测并添加元素   
    public static void calc2(char[][] m,int i,int j){  
        if(check1(m, i, j, '1')){   // 等于'1'时,行列都不连通   
            m[i][j] = '1';  // 则添加元素   
        }else if(check2(m, i, j, '-')){// 等于'-'时,行列都不连通   
            m[i][j] = '-';// 则添加元素   
        }else{  
            flag2 = true;   // 表示无结果   
        }  
    }  
    // 计算函数的入口   
    public static void calc(char[][] m){  
        for(int i=0;i<m.length;i++){  
            for(int j=0;j<m[i].length;j++){  
                if(m[i][j]=='0'){  
                    calc2(m,i,j);   // 进入检测函数   
                }  
                if(flag){  
                    String temp = i+""+j+""+m[i][j];  
                    System.out.println(temp);  
                    flag2 = false;  // 如果有元素添加,那么就不为空!下边的就不必输出"空"值   
                    break; // 如果添加过元素,则退出循环   
                }  
            }  
            if(flag){ // 如果添加过元素,则退出循环   
                flag = false;  
                break;  
            }  
        }  
        if(flag2){  // 如果无结果,则添加空   
            System.out.println("空");      
            flag2 = false;  // 修改标记位   
        }  
    }  
    // 主函数   
    public static void main(String[] args){  
        Scanner scan = new Scanner(System.in);  
        List<char[][]> lis = new ArrayList<char[][]>(); // 存放每个数组   
        System.out.print("输入整数 n(n<100):");  
        // 创建n个数组  初始化,并存入lis   
        input(lis,scan.nextInt());    
        // 计算函数的入口, 单独去每个数组去测试   
        for(int i=0;i<lis.size();i++){  
            calc(lis.get(i));     
        }  
    }  
}

😜顺时针螺旋填入

从键盘输入一个整数(1~20)
则以该数字为矩阵的大小,把1,2,3…n*n 的数字按照顺时针螺旋的形式填入其中。例如:
输入数字2,则程序输出:
1 2
4 3
输入数字3,则程序输出:
1 2 3
8 9 4
7 6 5
输入数字4,则程序输出:
1 2 3 4
12 13 14 5
11 16 15 6
10 9 8 7

package Question20_29;
import java.util.Scanner;
publicclass Question25 {
	publicstaticvoid print(int[][] array) {
		for (int i = 0; i < array.length; i++) {
			for (int j = 0; j < array.length; j++) {
				System.out.printf("%4d",array[i][j]);
			}
			System.out.println();
		}
	}
	publicstaticvoid main(String[] args) {
		Scanner scanner=new Scanner(System.in);
		int n=scanner.nextInt();
		int array[][]=newint[n][n];
		int startIndex=0,endIndex=n-1,count=1,e=0;
		while (e<=n/2) {
			for (int i = startIndex; i <= endIndex; i++) {
				array[e][i]=count++;
			}
			for (int i = startIndex+1; i <= endIndex; i++) {
				array[i][n-1-e]=count++;
			}
			for (int i = endIndex-1; i>=startIndex; i--) {
				array[n-1-e][i]=count++;
			}
			for (int i = endIndex-1; i>startIndex; i--) {
				array[i][e]=count++;
			}
			
			startIndex++;
			endIndex--;
			e++;
		}
		print(array);
	}
}
运行结果:
输入一个整数:4
1	2	3	4	
12	13	14	5	
11	16	15	6	
10	9	8	7	

import java.util.Scanner;  
public class Demo08 {  
    public static void show(int[][] m) {  
        for(int[] x:m){  
            for(int y:x){  
                System.out.print(y+"\t");  
            }  
            System.out.println("");  
        }  
    }  
    // 顺时针螺旋   
    public static int[][] helix(int n) {  
        int[][] m = new int[n][n];  // 产生空矩阵   
        int t = n*n;    // 填充矩阵从1到n*n个数   
        int i = 0;      // 填充数字的位置(行下标)    
        int j = 0;      // 填充数字的位置(列下标)    
        int start = 0;  // 每填充一圈时用的边界(左上)   
        int end = n;    // 每填充一圈时用的边界(右下)   
        int x = 0;      // 填充左侧一竖列数字时用的起始位置(行下标)   
        int y = 0;      // 填充左侧一竖列数字时用的起始位置(列下标)   
        int count = 0;  // 标记那段程序执行,那段程序不执行   
        for(int s=1;s<=t;s++){  
            if(i==start&&j<end){ // 如果是第一行   
                m[i][j++] = s;      // 填充第一行   
            }else if(i<end-1&&count<1){   // count==0时处理   
                j = end-1;  // 列设置为右边界   
                i++;    // 行下标 下移   
            }  
            if(i>start&&i<end){  
                if(j>start){  
                    if(i==end-1){   // 到下边界了   
                        m[i][j--] = s;  // 填充下边界   
                    }else{  
                        m[i][j] = s;    // 填充右侧一竖列数字   
                    }  
                }else if(count==0){ // 只当count==0 时执行一次   
                    m[i][j] = s;    // 填充到了左下角的元素   
                    i--;        // 开始从下向上填充左侧元素(行坐标上移)   
                    x = i;      // 用新的下标x来填充左侧 (行下标)   
                    y = j;      // 用新的下标y来填充左侧 (列下标)   
                    count++;  
                }else if(x>start&&y<end){  
                        m[x--][y] = s;  // 填充左侧   
                }else if(x==start){ // 如果外圈填充完毕   
                    s--;    // 接下来填充的数字放到下一的内圈里(抵消循环的s++)   
                    start++;    // 左上角边界向内收缩 1   
                    end = --n;  // 右下角边界向内收缩 1   
                    i = start;  // 按边界的位置开始填充内圈(行下标)   
                    j = start;  // 按边界的位置开始填充内圈(列下标)   
                    x = i;  // 填充左侧一竖列数字时用的起始位置(行下标)   
                    y = j;  // 填充左侧一竖列数字时用的起始位置(列下标)   
                    count = 0;  // 恢复执行程序段的标记   
                }  
            }  
        }  
        return m;   // 返回矩阵   
    }  
    public static void main(String[] args){  
        Scanner scan = new Scanner(System.in);  
        System.out.print("输入一个整数:");  
        int n = scan.nextInt(); // 输入 n    
        int[][] m = helix(n);   // 矩阵大小为n*n   
        show(m);    // 输出矩阵   
    }  
}  

👉其他

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

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

文章来源:https://blog.csdn.net/qq_27489007/article/details/132252478
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。