24点游戏

最新推荐文章于 2021-05-11 17:31:12 发布
最新推荐文章于 2021-05-11 17:31:12 发布
阅读量222 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/galaxyku/article/details/116571974
版权

24点纸牌游戏

题目：

24点游戏是经典的纸牌益智游戏。
常见游戏规则：
从扑克中每次取出4张牌。使用加减乘除，第一个能得出24者为赢。（其中，J代表11，Q代表12，K代表13，A代表1），按照要求编程解决24点游戏。
基本要求： 随机生成4个代表扑克牌牌面的数字字母，程序自动列出所有可能算出24的表达式，用擅长的语言（C/C++/Java或其他均可）实现程序解决问题。
1.程序风格良好(使用自定义注释模板)
2.列出表达式无重复。
提高要求：用户初始生命值为一给定值（比如3），初始分数为0。随机生成4个代表扑克牌牌面的数字或字母，由用户输入包含这4个数字或字母的运算表达式（可包含括号），如果表达式计算结果为24则代表用户赢了此局。
1. 程序风格良好(使用自定义注释模板)
2.使用计时器要求用户在规定时间内输入表达式，如果规定时间内运算正确则加分，超时或运算错误则进入下一题并减少生命值（不扣分）。
3.所有成绩均可记录在TopList.txt文件中。

概要设计

在这里插入图片描述

代码：

import java.util.HashMap;
import java.util.Map;
import java.util.Random;


public class Solution {
	//定义随机产生的四个数
		static int data[] = new int[4];
		//转换后的num1，num2,num3,num4
		static int reData[]=new int [4];
		static String dataString[] = new String[4];
		//用来判断是否有解
		static boolean flag = false;
		//存放操作符
		static char[] op = { '+', '-', '*', '/' };
		private static Object key;
		public static void main(String[] args) {
		// TODO Auto-generated method stub
		Random rand = new Random();
		System.out.println("下列随机给出四个数字，列出计算结果为24的表达式:");
		for(int i=0;i<4;i++){
			data[i]=rand.nextInt(13)+1;//随机生成四个int型数

			if(data[i]==1){
				System.out.println("A");//如果随机生成的数为1，则显示为扑克牌牌面中的A
			}
			else if(data[i]==11){
				System.out.println("J");//如果随机生成的数为11，则显示为扑克牌牌面中的J
			}
			else if(data[i]==12){
				System.out.println("Q");//如果随机生成的数为12，则显示为扑克牌牌面中的Q
			}
			else if(data[i]==13){
				System.out.println("K");//如果随机生成的数为13，则显示为扑克牌牌面中的K
			}
			else
			System.out.println(data[i]);
			}
		System.out.println("可能的结果有：");
		calculate();

	}
public static int cal(int count1, int count2, char operator) {
		if (operator == '+') {
	    	return count1 + count2;
	    }
	    else if (operator == '-') {
	    	return count1 - count2;
	    }
	    else if (operator == '*') {
	    	return count1 * count2;
	    }
	    else if ((operator == '/' )&& (count2 != 0) && (count1%count2==0)) {
	    	return count1 / count2;
	   	}
	    else {
	    	return -1;
	    }
	}
	public static void calculate(){

		Map<Integer, Integer> map = new HashMap<Integer, Integer>();
		//存放数字，用来判断输入的4个数字中有几个重复的，和重复的情况
		for (int i = 0; i < data.length; i++) {
			if(map.get(data[i]) == null){
				map.put(data[i], 1);
			}
			else {
				map.put(data[i], map.get(data[i]) + 1);
			}
		}
		if(map.size() == 1){
			//如果只有一种数字，此时只有一种排列组合，如1，1，1，1
			calculation(data[0], data[1],data[2],data[3]);
		}
		else if(map.size()==2){
			//如果只有2种数字，有2种情况，如2，2,4,4和2，2，2,4
			int index = 0;//用于数据处理
			int state = 0;//判断是哪种情况
			for (Integer key : map.keySet()) {
				if(map.get(key) == 1){
					//如果是有1个数字和其他3个都不同，将data变为 data[0]=data[1]=data[2]，
					//将不同的那个放到data[3]，方便计算
					data[3] = key;
					state = 1;
				}
				else if(map.get(key)==2){
					//如果是两两相同的情况，将data变为data[0]=data[1],data[2]=data[3]的情况
					data[index++]=key;
					data[index++]=key;
				}
				else{
					data[index++]=key;
				}
			}
			//列出2种情况的所有排列组合，并分别计算
			if(state == 1){
				calculation(data[3],data[1],data[1],data[1]);
				calculation(data[1],data[3],data[1],data[1]);
				calculation(data[1],data[1],data[3],data[1]);
				calculation(data[1],data[1],data[1],data[3]);
			}
			if(state==0){
				calculation(data[1],data[1],data[3],data[3]);
				calculation(data[1],data[3],data[1],data[3]);
				calculation(data[1],data[3],data[3],data[1]);
				calculation(data[3],data[3],data[1],data[1]);
				calculation(data[3],data[1],data[3],data[1]);
				calculation(data[3],data[1],data[1],data[3]);
			}
		}
		else if(map.size()==3){
			//有3种数字的情况
			int index = 0;
			for (Integer key : map.keySet()) {
				if(map.get(key) == 2){
					//将相同的2个数字放到data[2]=data[3]
					data[2] = key;
					data[3] = key;
				}
				else {
					data[index++] = key;
				}
			}
			//排列组合，所有情况
			calculation(data[0],data[1],data[3],data[3]);
			calculation(data[0],data[3],data[1],data[3]);
			calculation(data[0],data[3],data[3],data[1]);
			calculation(data[1],data[0],data[3],data[3]);
			calculation(data[1],data[3],data[0],data[3]);
			calculation(data[1],data[3],data[3],data[0]);
			calculation(data[3],data[3],data[0],data[1]);
			calculation(data[3],data[3],data[1],data[0]);
			calculation(data[3],data[1],data[3],data[0]);
			calculation(data[3],data[0],data[3],data[1]);
			calculation(data[3],data[0],data[1],data[3]);
			calculation(data[3],data[1],data[0],data[3]);
		}
		else if(map.size() == 4){
			//4个数都不同的情况
			calculation(data[0],data[1],data[2],data[3]);
			calculation(data[0],data[1],data[3],data[2]);
			calculation(data[0],data[2],data[1],data[3]);
			calculation(data[0],data[2],data[3],data[1]);
			calculation(data[0],data[3],data[1],data[2]);
			calculation(data[0],data[3],data[2],data[1]);
			calculation(data[1],data[0],data[2],data[3]);
			calculation(data[1],data[0],data[3],data[2]);
			calculation(data[1],data[2],data[3],data[0]);
			calculation(data[1],data[2],data[0],data[3]);
			calculation(data[1],data[3],data[0],data[2]);
			calculation(data[1],data[3],data[2],data[0]);
			calculation(data[2],data[0],data[1],data[3]);
			calculation(data[2],data[0],data[3],data[1]);
			calculation(data[2],data[1],data[0],data[3]);
			calculation(data[2],data[1],data[3],data[0]);
			calculation(data[2],data[3],data[0],data[1]);
			calculation(data[2],data[3],data[1],data[0]);
			calculation(data[3],data[0],data[1],data[2]);
			calculation(data[3],data[0],data[2],data[1]);
			calculation(data[3],data[1],data[0],data[2]);
			calculation(data[3],data[1],data[2],data[0]);
			calculation(data[3],data[2],data[0],data[1]);
			calculation(data[3],data[2],data[1],data[0]);
		}
		if(flag==false)
			System.out.println("这四张牌面数字无法经过运算得到24！");
	}

public static void calculation(int num1, int num2, int num3, int num4){

		for (int i = 0; i < 4; i++){
			//第1次计算，先从四个数中任意选择两个进行计算
			char operator1 = op[i];
			int firstResult = cal(num1, num2, operator1);//先选第一，和第二个数进行计算
			int midResult = cal(num2, num3, operator1);//先选第二和第三两个数进行计算
			int tailResult = cal(num3,num4, operator1);//先选第三和第四俩个数进行计算
			for (int j = 0; j < 4; j++){
				//第2次计算，从上次计算的结果继续执行，这次从三个数中选择两个进行计算
				char operator2 = op[j];
				int firstMidResult = cal(firstResult, num3, operator2);
				int firstTailResult = cal(num3,num4,operator2);
				int midFirstResult = cal(num1, midResult, operator2);
				int midTailResult= cal(midResult,num4,operator2);
				int tailMidResult = cal(num2, tailResult, operator2);
				for (int k = 0; k < 4; k++){
					//第3次计算，也是最后1次计算，计算两个数的结果，如果是24则输出表达式
					char operator3 = op[k];
					//在以上的计算中num1，num2,num3,num4都是整型数值，但若要输出为带有A，J,Q,K的表达式，则要将这四个数都变为String类型，下同
					if(cal(firstMidResult, num4, operator3) == 24){
						reData[0]=num1;
						reData[1]=num2;
						reData[2]=num3;
						reData[3]=num4;
						for(int p=0;p<4;p++){
							if(reData[p]==1){
								dataString[p]="A";}
							if(reData[p]==2){
								dataString[p]="2";}
							if(reData[p]==3){
								dataString[p]="3";}
							if(reData[p]==4){
								dataString[p]="4";}
							if(reData[p]==5){
								dataString[p]="5";}
							if(reData[p]==6){
								dataString[p]="6";}
							if(reData[p]==7){
								dataString[p]="7";}
							if(reData[p]==8){
								dataString[p]="8";}
							if(reData[p]==9){
								dataString[p]="9";}
							if(reData[p]==10){
								dataString[p]="10";}
							if(reData[p]==11){
								dataString[p]="J";}
							if(reData[p]==12){
								dataString[p]="Q";}
							if(reData[p]==13){
								dataString[p]="k";}
						}
						System.out.println("((" + dataString[0] + operator1 + dataString[1] + ")"
								+ operator2 + dataString[2] + ")" + operator3 + dataString[3]);
						flag = true;//若有表达式输出，则将说明有解，下同
					}
					if(cal(firstResult, firstTailResult, operator3) == 24){
						System.out.println("(" + dataString[0] + operator1 + dataString[1] + ")"
								+ operator3 + "(" + dataString[2] + operator2 + dataString[3] + ")");
						flag = true;
					}
					if(cal(midFirstResult, num4, operator3) == 24){
						reData[0]=num1;
						reData[1]=num2;
						reData[2]=num3;
						reData[3]=num4;
						for(int p=0;p<4;p++){
							if(reData[p]==1){
								dataString[p]="A";}
							if(reData[p]==2){
								dataString[p]="2";}
							if(reData[p]==3){
								dataString[p]="3";}
							if(reData[p]==4){
								dataString[p]="4";}
							if(reData[p]==5){
								dataString[p]="5";}
							if(reData[p]==6){
								dataString[p]="6";}
							if(reData[p]==7){
								dataString[p]="7";}
							if(reData[p]==8){
								dataString[p]="8";}
							if(reData[p]==9){
								dataString[p]="9";}
							if(reData[p]==10){
								dataString[p]="10";}
							if(reData[p]==11){
								dataString[p]="J";}
							if(reData[p]==12){
								dataString[p]="Q";}
							if(reData[p]==13){
								dataString[p]="k";}
						}
						System.out.println("(" + dataString[0] + operator2 + "(" + dataString[1]
								+ operator1 + dataString[2] + "))" + operator3 + dataString[3]);
						flag = true;
					}
					if(cal(num1,midTailResult, operator3) == 24){
						reData[0]=num1;
						reData[1]=num2;
						reData[2]=num3;
						reData[3]=num4;
						for(int p=0;p<4;p++){
							if(reData[p]==1){
								dataString[p]="A";}
							if(reData[p]==2){
								dataString[p]="2";}
							if(reData[p]==3){
								dataString[p]="3";}
							if(reData[p]==4){
								dataString[p]="4";}
							if(reData[p]==5){
								dataString[p]="5";}
							if(reData[p]==6){
								dataString[p]="6";}
							if(reData[p]==7){
								dataString[p]="7";}
							if(reData[p]==8){
								dataString[p]="8";}
							if(reData[p]==9){
								dataString[p]="9";}
							if(reData[p]==10){
								dataString[p]="10";}
							if(reData[p]==11){
								dataString[p]="J";}
							if(reData[p]==12){
								dataString[p]="Q";}
							if(reData[p]==13){
								dataString[p]="k";}
						}
						System.out.println(" " + dataString[0] + operator3 + "((" + dataString[1]
								+ operator1 + dataString[2] + ")" + operator2 + dataString[3] + ")");
						flag = true;
					}
					if(cal(num1,tailMidResult,operator3) == 24){
						reData[0]=num1;
						reData[1]=num2;
						reData[2]=num3;
						reData[3]=num4;
						for(int p=0;p<4;p++){
							if(reData[p]==1){
								dataString[p]="A";}
							if(reData[p]==2){
								dataString[p]="2";}
							if(reData[p]==3){
								dataString[p]="3";}
							if(reData[p]==4){
								dataString[p]="4";}
							if(reData[p]==5){
								dataString[p]="5";}
							if(reData[p]==6){
								dataString[p]="6";}
							if(reData[p]==7){
								dataString[p]="7";}
							if(reData[p]==8){
								dataString[p]="8";}
							if(reData[p]==9){
								dataString[p]="9";}
							if(reData[p]==10){
								dataString[p]="10";}
							if(reData[p]==11){
								dataString[p]="J";}
							if(reData[p]==12){
								dataString[p]="Q";}
							if(reData[p]==13){
								dataString[p]="k";}
						}
						System.out.println(" " + dataString[0] + operator3 + "(" + dataString[1]
								+ operator2 + "(" + dataString[2] + operator1 + dataString[3] + "))");
						flag = true;
					}
				}
			}
		}
	}
}

测试

在这里插入图片描述

总结

再做此题的过程中开始对四个数如何处理才能输出一个结果为24的算式有些苦恼，几经尝试结果都不太如意出现了重复使用一个数的情况，经过在网页上查找资料，将随机生成的四个数分成几类情况：不同的数有4、3、2、1个 分类处理，再计算处理；

Galaxy ?
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java 实现24点游戏
04-16
既可以实现24点游戏，也可以实现其他数值的游戏
JAVA实现24点游戏
weixin_54286751的博客
05-09 1339
“JAVA实现24点游戏”一. 内容二. 步骤1. 算法分析2. 概要设计3. 测试4. 调试5. 代码实现三. 心得体会 一. 内容 ​ 从扑克中每次取出4张牌。使用加减乘除，第一个能得出24者为赢。（其中，J代表11，Q代表12，K代表13，A代表1），按照要求编程解决24点游戏。 要求： 随机生成4个代表扑克牌牌面的数字字母，程序自动列出所有可能 二. 步骤 1. 算法分析 随机产生四个数，通过数组限制其均为不同的随机数，将所有运算顺序情况排列出来，刚开始有4个数，拿出两个数进行第一次运算，运算后得出
24点游戏Java实现
12-26
24点游戏Java实现，界面Javafx实现，一副牌中抽去大小王剩下 52 张(如果初练也可只用 1～10 这 40 张牌)，任意抽取 4 张牌 (称牌组)，用加、减、乘、除(可加括号)把牌面上的数算成 24。每张牌必须用一次且只能用 一次，如抽出的牌是 3、8、8、9，那么算式为(9-8)×8×3 或 3×8+(9-8)或(9- 8÷8)×3 等
“24点游戏”用Java实现
Chen_Yu7的博客
05-11 482
Java “24点游戏”用Java实现： 问题描述   从扑克中每次取出4张牌。使用加减乘除，第一个能得出24者为赢。（其中，J代表11，Q代表12，K代表13，A代表1），按照要求编程解决24点游戏。 基本要求： 随机生成4个代表扑克牌牌面的数字字母，程序自动列出所有可能算出24的表达式，用擅长的语言（C/C++/Java或其他均可）实现程序解决问题。 1.程序风格良好(使用自定义注释模板) 2.列出表达式无重复。 提高要求：用户初始生命值为一给定值（比如3），初始分数为0。随机生成4个代表扑克牌牌面的
Java实现24点游戏
m0_48733520的博客
05-07 321
题目描述： 24点游戏是经典的纸牌益智游戏。常见游戏规则：从扑克中每次取出4张牌。使用加减乘除，第一个能得出24者为赢。（其中，J代表11，Q代表12，K代表13，A代表1），按照要求编程解决24点游戏。 基本要求： 随机生成4个代表扑克牌牌面的数字字母，程序自动列出所有可能算出24的表达式，用擅长的语言（C/C++/Java或其他均可）实现程序解决问题。 算法分析： ①程序要求随机生成4个数字（范围为1到13）； ②用户在程序产生随...
C++实现简单24点游戏
08-24
主要为大家详细介绍了C++实现简单24点游戏，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
matlab 二十四点游戏
11-15
matlab程序，按下面要求操作：请将pukeImage文件夹和twentyfourgame_new.m放在同一路径下，然后在matlab下运行。
24点游戏swing _24点_
10-02
可以使用eclipse运行24点卡牌、游戏 自带源程序 作用是让4个数相加得24
24点游戏的24点计算器
09-09
家有小学生，学校要求练习24点游戏，有一些很难的数字组合不知道能不能算出，于是自己用python写的24点计算器执行程序（exe），输入4个数字，就能列出所有能计算24点的算式。家有小学生或自己感觉兴趣的可以下载用用...
基于Java的Android应用程序开发-24点游戏源码+详细项目说明.zip
08-09
基于Java的Android应用程序开发-24点游戏源码+详细项目说明.zip 基于Java的Android应用程序开发-24点游戏源码+详细项目说明.zip 基于Java的Android应用程序开发-24点游戏源码+详细项目说明.zip 【项目介绍】 该资源...
Java实现24点小游戏
08-26
主要为大家详细介绍了Java实现24点小游戏，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
用java编24点游戏(附源码)
05-30
用java编24点游戏，完全图形化界面，整个游戏又四个不同的版块构成，最后集成到一块，非常棒的游戏源码，值得参考。
java 24点小游戏算法
07-02
【原创】2010年全国软件专业人才设计与开发大赛决赛样题 -- 24点小游戏算法 网上找了些java实现24点小游戏的算法，看了一下，头都晕了！ 自己写了一个类，各位可以看一下思路，如果需要的话，只要实例化PointGame类并在构造方法里传递参与计算的四个数字和需要的结果就好了，然后调用getExpressions方法返回所有的表达式组合，是一个List类
[源码和文档分享]基于JAVA实现的速算24点游戏
qq_38474647的博客
12-21 278
第二章 系统需求分析 2.1 引言 对软件需求分析就是通过调查研究，建立系统的数据模型、功能模型、 行为模型，用户和开发人员在“系统必须做什么”这个问题上实现相互理解，达到共识，从而形成双方认可的软件产品的需求规格说明书。这样有益于提高软件开发过程中的能见度，便于对软件开发过程中的控制与管理，便于采用工程方法开发软件，提高软件的质量，便于开发人...
用java实现24点游戏
weixin_45819715的博客
05-10 2635
前言 用java实现24点游戏 Welocome to Xiang’s world~ 题目ღ( ´･ᴗ･` ) 24点游戏是经典的纸牌益智游戏。 常见游戏规则： 从扑克中每次取出4张牌。使用加减乘除，第一个能得出24者为赢。（其中，J代表11，Q代表12，K代表13，A代表1），按照要求编程解决24点游戏。 基本要求： 随机生成4个代表扑克牌牌面的数字字母，程序自动列出所有可能算出24的表达式，用擅长的语言（C/C++/Java或其他均可）实现程序解决问题。 1.程序风格良好(使用自定义注释模板) 2.列
java实现24点游戏
qq_35142728的博客
05-10 264
问题描述: 24点游戏是经典的纸牌益智游戏。 常见游戏规则： 从扑克中每次取出4张牌。使用加减乘除，第一个能得出24者为赢。（其中，J代表11，Q代表12，K代表13，A代表1），按照要求编程解决24点游戏。 基本要求： 随机生成4个代表扑克牌牌面的数字字母，程序自动列出所有可能算出24的表达式，用擅长的语言（C/C++/Java或其他均可）实现程序解决问题。 1.算法分析 随机生成四个数，采用穷举的方法，对每个数字和操作符进行组合，从而找到所有的情况，输出所有的表达式；若得不出24点则输出无法得出结果。
24点游戏---java编写
MTYSYS19990212的博客
05-09 3125
24点游戏前言1、 算法分析 1 .1 接收玩家结果输入与结果判定。 1.2 工具类TimeUtils、CardUtils。 1.3 数据生成与结果计算。2、 概要设计2.1 结构设计2.2 算法流程3、 测试4、 测试总结 前言 24点游戏是经典的纸牌益智游戏。 常见游戏规则： 从扑克中每次取出4张牌。使用加减乘除，第一个能得出24者为赢。 其中，J代表11，Q代表12，K代表13，A代表1 基本要求： 随机生成4个代表扑克牌牌面的数字字母，程序自动列出所有可能算出24的表
JAVA 24点游戏
gjie_me的博客
04-14 800
题目：24点游戏 题目分析： 采用判断是否是24，四张牌用a,b,c,d来代替，中间连接的运算符有3个，中间连接的运算符op1,op2，op3；a op1 b op2 c op3 d表达式，为了简化问题，先4张牌的顺序不变，运算符4种，表达式组合情况有64种，4*4*4 = 64；加上括号之后的情况，5种情况 1、(（a op1 b）op2 c)op3 d 2、（a op1 b）op2 (...
二十四点游戏Python实现
最新发布
04-29
二十四点游戏是一种数学益智游戏，目标是通过组合四个数字，使用加、减、乘、除等运算符，得到结果为24的表达式。下面是一个简单的二十四点游戏的Python实现示例： ```python import itertools def calculate...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值