蓝桥杯专题-真题版含答案-【扑克牌排列】【放麦子】【纵横放火柴游戏】【顺时针螺旋填入】
发布时间：2023年12月17日
| 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]
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.jpg]所示的局面下，可以在C2位置竖直放置（为了方便描述格子位置，图中左、下都添加了标记），
但不能水平放置，因为会与A2连通。同样道理，B2，B3，D2此时两种方向都不可以放置。但如果C2竖直放置后，
D2就可以水平放置了，因为不再会与A2连通（受到了C2的阻挡）。
- 游戏双方轮流放置火柴，不可以弃权，也不可以放多根。直到某一方无法继续放置，则该方为负（输的一方）。
游戏开始时可能已经放置了多根火柴。
你的任务是：编写程序，读入初始状态，计算出对自己最有利的放置方法并输出。
如图[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
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。 如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：chenni525@qq.com进行投诉反馈，一经查实，立即删除！
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。 如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：chenni525@qq.com进行投诉反馈，一经查实，立即删除！
最新文章
- Python教程
- 深入理解 MySQL 中的 HAVING 关键字和聚合函数
- Qt之QChar编码（1）
- MyBatis入门基础篇
- 用Python脚本实现FFmpeg批量转换
- 【flink番外篇】15、Flink维表实战之6种实现方式-初始化的静态数据
- Elasticsearch简介
- 2024年Java SpringBoot 计算机软件毕业设计题目推荐
- （2）(2.4) CRSF/ELRS Telemetry
- 《如何制作类mnist的金融数据集》——1.数据集制作思路
- 44、BatchNorm 为什么可以和卷积融合？
- 电影主题HTM5网页设计作业成品——爱影评在线电影(10页面)使用dreamweaver制作采用DIV+CSS进行布局
- Day3 多益单字纪录
- 恒悦sunsite博客2023年总结及2024年展望
- 【Spring实战】14 Web表单校验