使用Java怎么制作一个24点游戏

发布时间:2021-05-13 16:30:54 作者:Leah
来源:亿速云 阅读:146

本篇文章给大家分享的是有关使用Java怎么制作一个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文件中。

二、算法分析

用户需要提前输入4个数,作为凑成24点的基数,构成arr数组,从而求解目标数T=24。

在数arr中,首先取两个数与操作符集合进行组合,分别得到一组表达式,对于新得到的每个表达式,都可以和原集合中剩下的元素,组合成新的集合组,将每次得到的表达式,都用"()"包住,以保证计算先后顺序。

对集合中所有元素进行两两组合,并与剩余元素形成新的集合。由此,我们得到了一组元素为k-1个的集合组

对新集合组中的每一个集合,重复以上1-3步,可得到一组包含k-2个元素的集合组...以此类推,最后会得到一组集合,其中每个集合都只包含一个元素,这个就是我们合成的最终表达式.对第四步得到的表达式集合进行求解,判断其是否等于目标数24,将符合条件的过滤出来,即得到所有满足条件的表达式。

三、概要设计

主函数程序流程图

使用Java怎么制作一个24点游戏

四、代码

package Game;

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

public class Compute {
	//定义随机产生的四个数
	static int number[] = new int[4];
	//转换后的num1,num2,num3,num4
	static int m[]=new int [4];
	static String n[] = new String[4];
	//用来判断是否有解
	static boolean flag = false;
	//存放操作符
	static char[] operator = { '+', '-', '*', '/' };
	private static Object key;
	
	public static void main(String[] args){
		Random rand = new Random();
		System.out.println("下列给出四个数字,使用+,-,*,/进行计算使最后计算结果为24");
		for(int i=0;i<4;i++){
			number[i]=rand.nextInt(13)+1;//随机生成四个int型数
		
			if(number[i]==1){
				System.out.println("A");//如果随机生成的数为1,则显示为扑克牌牌面中的A
			}
			else if(number[i]==11){
				System.out.println("J");//如果随机生成的数为11,则显示为扑克牌牌面中的J
			}
			else if(number[i]==12){
				System.out.println("Q");//如果随机生成的数为12,则显示为扑克牌牌面中的Q
			}
			else if(number[i]==13){
				System.out.println("K");//如果随机生成的数为13,则显示为扑克牌牌面中的K
			}
			else
			System.out.println(number[i]);
			}
		System.out.println("可能的结果有:");
		calculate();
			 
	}
	
	
	//给定2个数和指定操作符的计算
	public static int calcute(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;	        
	    }
	}
	

	//计算生成24的函数
	public static void calculate(){
		
		Map<Integer, Integer> map = new HashMap<Integer, Integer>();
		//存放数字,用来判断输入的4个数字中有几个重复的,和重复的情况
		for (int i = 0; i < number.length; i++) {			
			if(map.get(number[i]) == null){				
				map.put(number[i], 1);			
			} 
			else {				
				map.put(number[i], map.get(number[i]) + 1);			
			}		
		}
		if(map.size() == 1){
			//如果只有一种数字,此时只有一种排列组合,如5,5,5,5
			calculation(number[0], number[1],number[2],number[3]);
		}
		else if(map.size()==2){
			//如果只有2种数字,有2种情况,如1,1,2,2和1,1,1,2
			int index = 0;//用于数据处理
			int state = 0;//判断是哪种情况
			for (Integer key : map.keySet()) {
				if(map.get(key) == 1){
					//如果是有1个数字和其他3个都不同,将number变为 number[0]=number[1]=number[2],
					//将不同的那个放到number[3],方便计算
					number[3] = key;
					state = 1;
				}
				else if(map.get(key)==2){
					//如果是两两相同的情况,将number变为number[0]=number[1],number[2]=number[3]的情况
					number[index++]=key;
					number[index++]=key;
				}
				else{
					number[index++]=key;
				}
			}
			//列出2种情况的所有排列组合,并分别计算
			if(state == 1){
				calculation(number[3],number[1],number[1],number[1]);
				calculation(number[1],number[3],number[1],number[1]);
				calculation(number[1],number[1],number[3],number[1]);
				calculation(number[1],number[1],number[1],number[3]);
			}
			if(state==0){
				calculation(number[1],number[1],number[3],number[3]);
				calculation(number[1],number[3],number[1],number[3]);
				calculation(number[1],number[3],number[3],number[1]);
				calculation(number[3],number[3],number[1],number[1]);
				calculation(number[3],number[1],number[3],number[1]);
				calculation(number[3],number[1],number[1],number[3]);
			}
		}
		else if(map.size()==3){
			//有3种数字的情况
			int index = 0;			
			for (Integer key : map.keySet()) {				
				if(map.get(key) == 2){					
					//将相同的2个数字放到number[2]=number[3]				
					number[2] = key;					
					number[3] = key;				
				} 
				else {					
					number[index++] = key;				
				}
			}
			//排列组合,所有情况
			calculation(number[0],number[1],number[3],number[3]);
			calculation(number[0],number[3],number[1],number[3]);
			calculation(number[0],number[3],number[3],number[1]);
			calculation(number[1],number[0],number[3],number[3]);
			calculation(number[1],number[3],number[0],number[3]);
			calculation(number[1],number[3],number[3],number[0]);
			calculation(number[3],number[3],number[0],number[1]);
			calculation(number[3],number[3],number[1],number[0]);
			calculation(number[3],number[1],number[3],number[0]);
			calculation(number[3],number[0],number[3],number[1]);
			calculation(number[3],number[0],number[1],number[3]);
			calculation(number[3],number[1],number[0],number[3]);
		}
		else if(map.size() == 4){
			//4个数都不同的情况
			calculation(number[0],number[1],number[2],number[3]);
			calculation(number[0],number[1],number[3],number[2]);
			calculation(number[0],number[2],number[1],number[3]);
			calculation(number[0],number[2],number[3],number[1]);
			calculation(number[0],number[3],number[1],number[2]);
			calculation(number[0],number[3],number[2],number[1]);
			calculation(number[1],number[0],number[2],number[3]);
			calculation(number[1],number[0],number[3],number[2]);
			calculation(number[1],number[2],number[3],number[0]);
			calculation(number[1],number[2],number[0],number[3]);
			calculation(number[1],number[3],number[0],number[2]);
			calculation(number[1],number[3],number[2],number[0]);
			calculation(number[2],number[0],number[1],number[3]);
			calculation(number[2],number[0],number[3],number[1]);
			calculation(number[2],number[1],number[0],number[3]);
			calculation(number[2],number[1],number[3],number[0]);
			calculation(number[2],number[3],number[0],number[1]);
			calculation(number[2],number[3],number[1],number[0]);
			calculation(number[3],number[0],number[1],number[2]);
			calculation(number[3],number[0],number[2],number[1]);
			calculation(number[3],number[1],number[0],number[2]);
			calculation(number[3],number[1],number[2],number[0]);
			calculation(number[3],number[2],number[0],number[1]);
			calculation(number[3],number[2],number[1],number[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 = operator[i];
			int firstResult = calcute(num1, num2, operator1);//先选第一,和第二个数进行计算
			int midResult = calcute(num2, num3, operator1);//先选第二和第三两个数进行计算
			int tailResult = calcute(num3,num4, operator1);//先选第三和第四俩个数进行计算
			for (int j = 0; j < 4; j++){
				//第2次计算,从上次计算的结果继续执行,这次从三个数中选择两个进行计算
				char operator2 = operator[j];
				int firstMidResult = calcute(firstResult, num3, operator2);
				int firstTailResult = calcute(num3,num4,operator2);
				int midFirstResult = calcute(num1, midResult, operator2);
				int midTailResult= calcute(midResult,num4,operator2);
				int tailMidResult = calcute(num2, tailResult, operator2);
				for (int k = 0; k < 4; k++){
					//第3次计算,也是最后1次计算,计算两个数的结果,如果是24则输出表达式
					char operator3 = operator[k];
					//在以上的计算中num1,num2,num3,num4都是整型数值,但若要输出为带有A,J,Q,K的表达式,则要将这四个数都变为String类型,下同
					if(calcute(firstMidResult, num4, operator3) == 24){
						m[0]=num1;
						m[1]=num2;
						m[2]=num3;
						m[3]=num4;
						for(int p=0;p<4;p++){
							if(m[p]==1){
								n[p]="A";}
							if(m[p]==2){
								n[p]="2";}
							if(m[p]==3){
								n[p]="3";}
							if(m[p]==4){
								n[p]="4";}
							if(m[p]==5){
								n[p]="5";}
							if(m[p]==6){
								n[p]="6";}
							if(m[p]==7){
								n[p]="7";}
							if(m[p]==8){
								n[p]="8";}
							if(m[p]==9){
								n[p]="9";}
							if(m[p]==10){
								n[p]="10";}
							if(m[p]==11){
								n[p]="J";}
							if(m[p]==12){
								n[p]="Q";}
							if(m[p]==13){
								n[p]="k";}
						}
						System.out.println("((" + n[0] + operator1 + n[1] + ")" + operator2 + n[2] + ")" + operator3 + n[3]);
						flag = true;//若有表达式输出,则将说明有解,下同
					}
					if(calcute(firstResult, firstTailResult, operator3) == 24){
						System.out.println("(" + n[0] + operator1 + n[1] + ")" + operator3 + "(" + n[2] + operator2 + n[3] + ")");					
						flag = true;
					}
					if(calcute(midFirstResult, num4, operator3) == 24){
						m[0]=num1;
						m[1]=num2;
						m[2]=num3;
						m[3]=num4;						
						for(int p=0;p<4;p++){
							if(m[p]==1){
								n[p]="A";}
							if(m[p]==2){
								n[p]="2";}
							if(m[p]==3){
								n[p]="3";}
							if(m[p]==4){
								n[p]="4";}
							if(m[p]==5){
								n[p]="5";}
							if(m[p]==6){
								n[p]="6";}
							if(m[p]==7){
								n[p]="7";}
							if(m[p]==8){
								n[p]="8";}
							if(m[p]==9){
								n[p]="9";}
							if(m[p]==10){
								n[p]="10";}
							if(m[p]==11){
								n[p]="J";}
							if(m[p]==12){
								n[p]="Q";}
							if(m[p]==13){
								n[p]="k";}
						}
						System.out.println("(" + n[0] + operator2 + "(" + n[1] + operator1 + n[2] + "))" + operator3 + n[3]);
						flag = true;
					}
					if(calcute(num1,midTailResult, operator3) == 24){
						m[0]=num1;
						m[1]=num2;
						m[2]=num3;
						m[3]=num4;
						for(int p=0;p<4;p++){
							if(m[p]==1){
								n[p]="A";}
							if(m[p]==2){
								n[p]="2";}
							if(m[p]==3){
								n[p]="3";}
							if(m[p]==4){
								n[p]="4";}
							if(m[p]==5){
								n[p]="5";}
							if(m[p]==6){
								n[p]="6";}
							if(m[p]==7){
								n[p]="7";}
							if(m[p]==8){
								n[p]="8";}
							if(m[p]==9){
								n[p]="9";}
							if(m[p]==10){
								n[p]="10";}
							if(m[p]==11){
								n[p]="J";}
							if(m[p]==12){
								n[p]="Q";}
							if(m[p]==13){
								n[p]="k";}
						}
						System.out.println(" " + n[0] + operator3 + "((" + n[1] + operator1 + n[2] + ")" + operator2 + n[3] + ")");						
						flag = true;
					}
					if(calcute(num1,tailMidResult,operator3) == 24){
						m[0]=num1;
						m[1]=num2;
						m[2]=num3;
						m[3]=num4;
						for(int p=0;p<4;p++){
							if(m[p]==1){
								n[p]="A";}
							if(m[p]==2){
								n[p]="2";}
							if(m[p]==3){
								n[p]="3";}
							if(m[p]==4){
								n[p]="4";}
							if(m[p]==5){
								n[p]="5";}
							if(m[p]==6){
								n[p]="6";}
							if(m[p]==7){
								n[p]="7";}
							if(m[p]==8){
								n[p]="8";}
							if(m[p]==9){
								n[p]="9";}
							if(m[p]==10){
								n[p]="10";}
							if(m[p]==11){
								n[p]="J";}
							if(m[p]==12){
								n[p]="Q";}
							if(m[p]==13){
								n[p]="k";}
						}
						System.out.println(" " + n[0] + operator3 + "(" + n[1] + operator2 + "(" + n[2] + operator1 + n[3] + "))");						
						flag = true;
					}		
				}
			}	
		}
	}	
}

五、测试

测试用例:2 8 10 4

测试结果:

使用Java怎么制作一个24点游戏

可以看到,程序成功的生成了对应测试用例的结果,结果是正确的。

测试无法组成24点的数据:7 13 1 6

使用Java怎么制作一个24点游戏

经过多次运行, 7,13,1,6这四个数据,无法组成24点,程序输出No answer运行正确。

Java的特点有哪些

Java的特点有哪些 1.Java语言作为静态面向对象编程语言的代表,实现了面向对象理论,允许程序员以优雅的思维方式进行复杂的编程。 2.Java具有简单性、面向对象、分布式、安全性、平台独立与可移植性、动态性等特点。 3.使用Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。

以上就是使用Java怎么制作一个24点游戏,小编相信有部分知识点可能是我们日常工作会见到或用到的。希望你能通过这篇文章学到更多知识。更多详情敬请关注亿速云行业资讯频道。

推荐阅读:
  1. Java制作拼图游戏
  2. 如何用Java制作象棋游戏

免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。

java

上一篇:php和phpfpm有哪些区别

下一篇:shell 脚本中有哪些常用的内置变量

相关阅读

您好,登录后才能下订单哦!

密码登录
登录注册
其他方式登录
点击 登录注册 即表示同意《亿速云用户服务条款》