二十四点JAVA算法

24点游戏java课程设计一、课程目标知识目标：1. 学生能理解“24点游戏”的规则及算法原理，掌握其与Java编程语言的结合方式。

2. 学生能运用Java编程语言实现基础的数据类型、运算符、循环和条件语句，解决24点游戏的计算问题。

3. 学生了解并掌握数组的创建和使用，实现对24点游戏牌组的管理。

技能目标：1. 学生通过编写Java程序，培养解决问题的能力，提高逻辑思维能力。

2. 学生学会使用集成开发环境（IDE）进行Java代码编写、调试和运行，提高实际操作能力。

3. 学生能够运用所学知识，创新性地设计并实现24点游戏的扩展功能。

情感态度价值观目标：1. 学生通过编程解决实际问题，增强对计算机编程的兴趣和热情，培养积极的学习态度。

2. 学生在小组合作中，学会沟通、协作和分享，培养团队精神和责任感。

3. 学生在探索和解决问题的过程中，培养面对挑战、勇于尝试的精神，树立自信心。

本课程针对初中或高中年级的学生，结合他们对编程知识有一定了解和兴趣的特点，以24点游戏为载体，让学生在实践过程中掌握Java编程基础，提高编程能力和解决问题的能力。

课程要求教师注重启发式教学，关注学生个体差异，鼓励创新思维和团队合作，确保学生在完成课程学习后能够达到上述目标。

二、教学内容1. Java基本语法和数据类型：回顾Java基本语法规则，重点讲解整数、浮点数、布尔类型等基础数据类型及其在24点游戏中的应用。

教材章节：第一章 Java语言概述，第二章 基本数据类型与运算符。

2. Java控制结构：讲解条件语句（if-else，switch-case）和循环语句（for，while，do-while），引导学生通过控制结构实现对24点游戏算法的逻辑设计。

教材章节：第三章 控制结构。

3. 数组的使用：介绍数组的定义、初始化和使用，教授如何使用数组存储和管理24点游戏的牌组。

教材章节：第四章 数组。

4. 方法与对象：通过编写方法实现24点游戏的功能模块，初步了解面向对象编程思想，如定义类、创建对象等。

经典24点程序算法一、概述算24点：任意给定四个整数，用加、减、乘、除以及适当的括号连接，无论顺序，使计算结果为24，也可能根本就无解。

如何用程序简单实现找到算式是程序初学者关注的问题，百度上可以搜到许多这样的文章，有递归法、回溯法、穷举法。

但穷举法最为简单、易于理解。

二、算法穷举法就是把四个数字的所有运算式进行尝试计算，要设法把所有排列一点不差地穷举出，一、是四个整数位置的排列，用0,1,2,3表示位置，排列是不能重复的，所以有P(4,4)种情况，即4！=4*3*2*1=24种；二、是三个运算符的变化，每个运算符为+-*/ ，可以相同，所以，有4*4*4=64种; 三、三个运算符的优先级，就是括号位置的变化，可能性为P(3,3)-1=6-1=5种；所以，表达式的可能性为：24*64*5=7680种，C语言程序把这么多表达式都计算一遍，几乎不到1毫秒毫不费劲, 可见电脑的运行速度之快。

四个数位置的排列，可用四重循环实现，四个循环变量i1,i2,i3,i4对应数组下标的变化, 不许它们之间相等，四个数放在数组v[0]、v[1]、v[2]、v[3]:for (int i1=0;i1<4;i1++)for (int i2=0;i2<4;i2++)if (i2!=i1) // 循环变量不许相同for (int i3=0;i3<4;i3++)if (i3!=i2 && i3!=i1) // 循环变量不许相同，&& 是“并且” for (int i4=0;i4<4;i4++)if (i4!=i3 && i4!=i2 && i4!=i1) // 循环变量不许相同{// v[i1],v[i2],v[i3],v[i4] 就是排列的结果，共有4!=24 种｝三个运算符的变化，可用三重循环实现，三个循环变量 f1,f2,f3对应位置的变化,允许相同，运算符放在数组op[0]、op[1]、op[2]、op[3]中:for (int f1=0;f1<4;f1++) // 三重循环对运算符穷举for (int f2=0;f2<4;f2++)for (int f3=0;f3<4;f3++) // 运算符 f1,f2,f3{// op[f1],op[f2],op[f3]就是排列结果，共有4*4*4=64 种}上面两种排列组合后，四个数及运算符排列顺序就是形如：a ① b ② c ③ d v[i1],op[f1],v[i2],op[f2],v[i3],op[f3],v[i4]但运算符有优先级，一般是用括号表示。

java实现24点纸牌游戏本⽂题⽬为⼤家分享了java实现24点纸牌游戏的具体代码，供⼤家参考，具体内容如下题⽬24点游戏是经典的纸牌益智游戏。

常见游戏规则：从扑克中每次取出4张牌。

使⽤加减乘除，第⼀个能得出24者为赢。

（其中，J代表11，Q代表12，K代表13，A代表1），按照要求编程解决24点游戏。

基本要求：随机⽣成4个代表扑克牌牌⾯的数字字母，程序⾃动列出所有可能算出24的表达式，⽤擅长的语⾔（C/C++/Java 或其他均可）实现程序解决问题。

分析⽤穷举法列出四个数加上三个运算符号所构成的表达式所有可能的结果算法实现import java.util.*;public class point24 {static int sum=0;static int[] sum()//产⽣随机数并显⽰的⽅法{Random rand=new Random();int r1=(1+rand.nextInt(13));int r2=(1+rand.nextInt(13));int r3=(1+rand.nextInt(13));int r4=(1+rand.nextInt(13));System.out.print("发出的牌为:");switch(r1){case 1 :System.out.print("A");break;case 11:System.out.print("J");break;case 12:System.out.print("Q");break;case 13:System.out.print("K");break;default:System.out.print(r1);break;}switch(r2){case 1 :System.out.print(" A");break;case 11:System.out.print(" J");break;case 12:System.out.print(" Q");break;case 13:System.out.print(" K");break;default:System.out.print(" "+r2);break;}switch(r3){case 1 :System.out.print(" A");break;case 11:System.out.print(" J");break;case 12:System.out.print(" Q");break;case 13:System.out.print(" K");break;default:System.out.print(" "+r3);break;}switch(r4){case 1 :System.out.println(" A");break;case 11:System.out.println(" J");break;case 12:System.out.println(" Q");break;case 13:System.out.println(" K");break;default:System.out.println(" "+r4);break;}int [] s=new int[] {r1,r2,r3,r4};return s;}static int js(int i,int j,int x)//两个数之间计算符号确认{int m=0;switch(x){case 0:m=i+j;break;case 1:m=i-j;break;case 2:m=i*j;break;case 3:m=i/j;if(i%j!=0) m=-1;//如果除不尽直接让m=-1，以便直接结束此次循环break;}return m;}static String prin(int s1,int s2,int s3,int s4,int x1,int x2,int x3)//打印解的表达式 {String ch="";switch(s1){case 1 :System.out.print("A");ch="A";break;case 11:System.out.print("J");ch="J";break;case 12:System.out.print("Q");ch="Q";break;case 13:System.out.print("K");ch="K";break;default:System.out.print(s1);ch=(String)(s1+"0");break;}switch(x1){case 0:System.out.print("+");ch+="+";break;case 1:System.out.print("-");ch+="-";break;case 2:System.out.print("*");ch+="*";break;case 3:System.out.print("/");ch+="/";break;}switch(s2){case 1 :System.out.print("A");ch+="A";break;case 11:System.out.print("J");ch+="J";break;case 12:System.out.print("Q");ch+="Q";break;case 13:System.out.print("K");ch+="K";break;default:System.out.print(s2);ch+=(String)(s2+"");break;}switch(x2){case 0:System.out.print("+");ch+="+";break;case 1:System.out.print("-");ch+="-";break;case 2:System.out.print("*");ch+="*";break;case 3:System.out.print("/");ch+="/";break;}switch(s3){case 1 :System.out.print("A");ch+="A";break;case 11:System.out.print("J");ch+="J";break;case 12:System.out.print("Q");ch+="Q";break;case 13:System.out.print("K");ch+="K";break;default:System.out.print(s3);ch+=(String)(s3+"");break;}switch(x3){case 0:System.out.print("+");ch+="+";break;case 1:System.out.print("-");ch+="-";break;case 2:System.out.print("*");ch+="*";break;case 3:System.out.print("/");ch+="/";break;}switch(s4){case 1 :System.out.println("A");ch+="A";break;case 11:System.out.println("J");ch+="J";break;case 12:System.out.println("Q");ch+="Q";break;case 13:System.out.println("K");ch+="K";break;default:System.out.println(s4);ch+=(String)(s4+"");break;}// System.out.println(" "+ch);return ch;}static String[] con(int s[])//枚举计算是否存在解{boolean flag=false;String[] ch=new String [100];int js1,js2,js3=0;for(int i = 0;i<4;i++){for(int j=0;j<4;j++){if(i!=j){for(int k=0;k<4;k++){if(i!=j&&j!=k&&i!=k){for(int l=0;l<4;l++){if(i!=j&&j!=k&&k!=l&&i!=k&&i!=l&&j!=l){for(int x1=0;x1<3;x1++){for(int x2=0;x2<3;x2++){for(int x3=0;x3<3;x3++){js1=js(s[i],s[j],x1);if(js1==-1) continue;js2=js(js1,s[k],x2);if(js2==-1) continue;js3=js(js2,s[l],x3);if(js3==-1) continue;if(js3!=-1){if(js3==24){ ch[sum]=prin(s[i],s[j],s[k],s[l],x1,x2,x3);flag=true;sum++;}}}}}}}}}}}}if(flag==false){System.out.println("不存在⼀组解使其成为\"24点\""); }return ch;}public static void main(String[] args){boolean f=false;Scanner in=new Scanner(System.in);while(!f){int [] s=sum();//产⽣4个随机纸牌con(s);//求解并打印System.out.println();System.out.println("继续 (1)or结束(0)");if(in.nextInt()==1){f=false;}else{f=true;}}}}运⾏结果随机数产⽣测试：运⾏：更多精彩游戏⼩代码，请点击阅读以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。

关于24点游戏的编程思路与基本算法24点游戏的算法，其中最主要的思想就是穷举法。

所谓穷举法就是列出4个数字加减乘除的各种可能性，包括括号的算法。

我们可以将表达式分成以下几种：首先我们将4个数设为a，b，c，d，，其中算术符号有+，-，*，/，。

其中有效的表达式有a，ab-cd，等等。

列出所有有效的表达式。

其中我们用枚举类型将符号定义成数字常量，比如用1表示+，2表示-等。

如下是我对穷举法的一种编程语言。

在编程的头部要对变量做下定义。

其中a，b，c，d的范围是1到10。

这就需要在定义变量的时候要有限制。

在vc++中的编程中，在定义控件的变量范围可以直接填写变量的最大和最小，在此编程中的最大是10，最小是1。

这就给编程写语句带来了方便。

运用C/C++语言开发工具Microsoft Visual C++ 6.0，利用它简单、明了的开发特点对课本知识进行系统的实践，并且通过对各个知识点的运用进行所需的程序编写。

首先，要充分理解每个程序涉及的算法，牢记实现算法的每一个步骤；其次，再在计算机上利用C语言编写出代码，要求结构清晰，一目了然；最后，要对程序进行优化，使程序实现优秀的运行功能。

在编写程序的过程中要充分理解并能熟练使用对应的算法，竟可能多的涉及课本中的知识点。

总之通过实行整体方案，最终使程序达到运行状态，并且实现良好的运行效果。

故做了如下的计划安排，将这项工程分为两大部分：程序的设计和程序的调试。

首先在程序的设计部分由分为几个步骤：•第一步：查阅有关归并排序算法的资料。

•第二步：设计这个项目的整体架构和算法。

•第三步：选择一门程序设计语言进行算法的描述。

其次，进行程序的调试。

设计方法和内容在做某件事时，一个好的方法往往能起到事半功倍的效果。

在这个课程的设计上，我选择了Ｃ++语言作为算法的描述语言，因为Ｃ++语言具有丰富的表达能力以及代码的高效性，并且有着良好的移植性和灵活性。

同时，采用“自顶向下，个个击破”的程序设计思路和思想，充分运用Ｃ++语言强大的功能。

24点算法的Java版和C语言版源码Java版共2个类：和== ==package num24;public class Application {double num[] = new double[4];boolean mark[] = new boolean[4];/*** 取得k个数运算，结果为result的第一个Node，比如get(24,4) * @param result* @param n* @return*/public Node get(double result, int n) {Node left = null, right = null;if (n <= 0) {return null;} .mark[i]=false;} .return null;}public void output(Node node) {if (node == null) {return;}if != null) {if ( "+") || "-")) && "*") || "/"))) { "(");output;")");}else {output;}}if (!"")) {}else {}if != null) {if ("+") || "-")) && "*") || "/"))||"+") || "-")) && "-")) ||(!"")) && "/")) ) {"(");output;")");}else {output;}}}/**** @param args*/public static void main(String[] args) { Application app=new Application();[0]=(args[0]);[1]=(args[1]);[2]=(args[2]);[3]=(args[3]);double result;Node tree=null;//while(true){result=;// if(result==break;[0]=false;[1]=false;[2]=false;[3]=false;tree=(result,4);if(tree!=null){(tree);"="+result);}else{"No!");//}}}======package num24;public class Node {public double num;String name;Node left, right = null;public Node() {num = ;name = " ";left = right = null;}public Node(double aNum){this(aNum," ",null,null);}public Node(double aNum, String aName, Node aLeft, Node aRight) { num = aNum;name = aName;left = aLeft;right = aRight;}public void delete(){if(left!=null){();}if(right!=null){}left=null; right=null; }}C 语言版//用二叉树保留表达式，输出无多余括号。

扑克24点游戏JAVA源代码1.游戏规则简介拿出一副扑克，随机发出四张扑克，要求游戏者随意组合使用+、-、×、÷四种算数方法，寻找能计算出结果为24的方案。

2.源码说明本源码由本人单独完成，使用JAVA作为编码语言，其中使用泛型、枚举，JDK版本你懂的。

下列部分截图：1.类的内部结构图：2.部分方法截图：3.测试方法截图4.结果展示：99478方片7+方片6*方片3-方片1=24.099479方片7+方片5+方片4*方片3=24.099480方片7+方片5*方片4-方片3=24.099481方片7+方片5*方片3+方片2=24.099482方片7*方片4-方片3-方片1=24.099483方片7*方片3+方片2+方片1=24.099484方片6+方片5*方片4-方片2=24.099485方片6*方片5-方片4-方片2=24.099486方片5*方片4+方片3+方片1=24.099487方片4*方片3*方片2*方片1=24.099488方片4*方片3*方片2/方片1=24.013420594276533.源码Puke24Test.java附带正文：package com.test.puke;/**** @author GuanChi* BUG说明：* 1.应该优先计算乘法(10+7/4*8)或(7/4*8+10)两种情况 * 2.组合重复情况是否需要过滤，如上面*/public class Puke24Test{public static void serviceExce(){int count = 0;Puke24Test puke24 = new Puke24Test();PokerContainer PokerContainer = puke24.new PokerContainer();java.util.TreeSet<Poker> sPokers = PokerContainer.getPokers();java.util.TreeMap<String, Poker> mPokers =puke24.getTreeMapPokersByTreeSet(sPokers);Poker[] Pokers4 = new Poker[4];for (int i = 1; i <= mPokers.size(); i++){Pokers4[0] = mPokers.get(""+i);for (int j = i+1; j <= mPokers.size(); j++){Pokers4[1] = mPokers.get(""+j);for (int k = j+1; k <= mPokers.size(); k++){Pokers4[2] = mPokers.get(""+k);for (int l = k+1; l <= mPokers.size(); l++){Pokers4[3] = mPokers.get(""+l);Expression24[] exps = calcBy4Pokers(Pokers4);for (int m = 0; m < exps.length; m++){if (null != exps[m] && 24 == exps[m].getResult()){System.out.println(""+ ++count+exps[m]);}}}}}}// 按次序获取四张牌，轮询所有组合方式，轮询所有计算方式，获取结果为24的}public static Expression24[] calcBy4Pokers(Poker[] pokers4){Expression24[] exps = new Expression24[4*4*4*4*4*4*4];int n=0;// 第一个计算符号for (byte i = 1; i <= 4; i++){// 第二个计算符号for (byte j = 1; j <= 4; j++){// 第三个计算符号for (byte k = 1; k <= 4; k++){// 第一个计算扑克牌for (int a = 1; a <= 4; a++){// 第二个计算扑克牌for (int b = a+1; b <= 4; b++){// 第二张拍的脚码不能大于4，并且不能和前面牌重复if (b>4){b=-4;}// 第三个计算扑克牌for (int c = b+1; c <= 4; c++){// 第三张拍的脚码不能大于4，并且不能和前面牌重复if (c>4){c=-4;}// 第四个计算扑克牌for (int d = c+1; d <= 4; d++){// 第四张拍的脚码不能大于4，并且不能和前面牌重复if (d>4){d=-4;}// 计算单个算式的值exps[n++] = calcByExp(pokers4[a-1],Math.convertByteType2CS(i),pokers4[b-1],Math.convertByteType2CS(j),pokers4[c-1],Math.convertByteType2CS(k),pokers4[d-1]);}}}}}}}return exps;}/*** 给定三个计算符号的顺序，把四张牌轮流各个位置，计算出结果* @param poker 第一张扑克* @param j 第一个计算符号* @param poker2 第二张扑克* @param k 第二个计算符号* @param poker3 第三张扑克* @param l 第三个计算符号* @param poker4 第四张扑克* @return 表达式* @attention ?代表未知符号在该方法注释里面*/private static Expression24 calcByExp(Poker poker, Math.CountSymbol j, Poker poker2,Math.CountSymbol k, Poker poker3, Math.CountSymbol l, Poker poker4) {double d = 0;// 当第一个计算符号为乘号或者除号的时候，先计算乘除法(如，1*2?3?4)if (j==Math.CountSymbol.MUL || j==Math.CountSymbol.DIV){d = Math.calc(poker.getNumber(),j,poker2.getNumber());//当第二个符号也为乘除法的时候，用第一次计算的值和第三个数相乘除，然后直接和第四个数字计算(如，1*2*3?4)if (k==Math.CountSymbol.MUL || k==Math.CountSymbol.DIV){d = Math.calc(d,k,poker3.getNumber());d = Math.calc(d,l,poker4.getNumber());}// 当第二个符号不为乘除法，第三个符号为乘除法的时候，先计算第三、第四个数，然后把第一次计算和这次计算结果相运算(如，1*2-3*4)else if (l==Math.CountSymbol.MUL || l==Math.CountSymbol.DIV){double d2 = Math.calc(d,l,poker4.getNumber());d = Math.calc(d,l,d2);}// 当第二个符号不为乘除法，第三个符号也不为乘除法的时候，一口气计算完毕(如，1*2+3-4)else{d = Math.calc(d,k,poker3.getNumber());d = Math.calc(d,l,poker4.getNumber());}}// 第一个符号不为乘除法的时候，第二个符号为乘除法的时候(如，1+2*3?4) else if (k==Math.CountSymbol.MUL || k==Math.CountSymbol.DIV){d = Math.calc(poker2.getNumber(),k,poker3.getNumber());d = Math.calc(d,l,poker4.getNumber());d = Math.calc(poker.getNumber(),j,d);}// 第一个符号不为乘除法的时候，第二个符号不为乘除法的时候，第三个符号为乘除法的时候(如，1+2-3*4)else if (l==Math.CountSymbol.MUL || l==Math.CountSymbol.DIV){d = Math.calc(poker3.getNumber(),l,poker4.getNumber());double d2 = Math.calc(poker.getNumber(),j,poker2.getNumber());d = Math.calc(d,k,d2);}// 第一个符号不为乘除法的时候，第二个符号不为乘除法的时候，第三个符号不为乘除法的时候(如，1+2-3+4)else{d = Math.calc(poker.getNumber(),j,poker2.getNumber());d = Math.calc(d,k,poker3.getNumber());d = Math.calc(d,l,poker4.getNumber());}Expression24 exp24 = newExpression24(poker,j,poker2,k,poker3,l,poker4);exp24.setResult(d);return 24 == d ? exp24: null;// TODO Auto-generated method stub}/*** 加减乘除24的表达式* @author GuanChi* 包含4张扑克以及中间的三个运算符号，还有计算结果*/static class Expression24{/** 第一张扑克 **/private Poker poker1;/** 第一个运算符号 **/private Math.CountSymbol countSymbols1;/** 第二张扑克 **/private Poker poker2;/** 第二个运算符号 **/private Math.CountSymbol countSymbols2;/** 第三张扑克 **/private Poker poker3;/** 第三个运算符号 **/private Math.CountSymbol countSymbols3;/** 第四张扑克 **/private Poker poker4;/** 结果 **/private double result;/*** 构造方法，初始化时必须提供4张扑克和三个运算符号* @param poker1 第一张扑克* @param countSymbols1 第一个运算符号* @param poker2 第二张扑克* @param countSymbols2 第二个运算符号* @param poker3 第三个张扑克* @param countSymbols3 第三个运算符号* @param poker4 第四个张扑克*/public Expression24(Poker poker1, Math.CountSymbol countSymbols1, Poker poker2,Math.CountSymbol countSymbols2, Poker poker3, Math.CountSymbol countSymbols3, Poker poker4){super();this.poker1 = poker1;this.countSymbols1 = countSymbols1;this.poker2 = poker2;this.countSymbols2 = countSymbols2;this.poker3 = poker3;this.countSymbols3 = countSymbols3;this.poker4 = poker4;}public void setResult(double result){this.result = result;}public double getResult(){return result;}public Poker getPoker1(){return poker1;}public void setPoker1(Poker poker1){this.poker1 = poker1;}public Math.CountSymbol getCountSymbols1(){return countSymbols1;}public void setCountSymbols1(Math.CountSymbol countSymbols1) {this.countSymbols1 = countSymbols1;}public Poker getPoker2(){return poker2;}public void setPoker2(Poker poker2){this.poker2 = poker2;}public Math.CountSymbol getCountSymbols2()return countSymbols2;}public void setCountSymbols2(Math.CountSymbol countSymbols2){this.countSymbols2 = countSymbols2;}public Poker getPoker3(){return poker3;}public void setPoker3(Poker poker3){this.poker3 = poker3;}public Math.CountSymbol getCountSymbols3(){return countSymbols3;}public void setCountSymbols3(Math.CountSymbol countSymbols3){this.countSymbols3 = countSymbols3;}public Poker getPoker4(){return poker4;}public void setPoker4(Poker poker4){this.poker4 = poker4;}/*** 打印时候需要把字符拼接成一般能看懂的格式，包含+、-、*、/的格式*/public String toString(){return new StringBuilder().append(null==this.poker1?null:""+this.poker1.getColor()+this.poker1.ge tNumber()).append(""+(this.countSymbols1==Math.CountSymbol.ADD?"+":(this.countSym bols1==Math.CountSymbol.SUB?"-":(this.countSymbols1==Math.CountSymbol.MUL?".append(null==this.poker2?null:""+this.poker2.getColor()+this.poker2.ge tNumber()).append(""+(this.countSymbols2==Math.CountSymbol.ADD?"+":(this.countSym bols2==Math.CountSymbol.SUB?"-":(this.countSymbols2==Math.CountSymbol.MUL?" *":"/")))).append(null==this.poker3?null:""+this.poker3.getColor()+this.poker3.ge tNumber()).append(""+(this.countSymbols3==Math.CountSymbol.ADD?"+":(this.countSym bols3==Math.CountSymbol.SUB?"-":(this.countSymbols3==Math.CountSymbol.MUL?" *":"/")))).append(null==this.poker4?null:""+this.poker4.getColor()+this.poker4.ge tNumber()).append("="+this.result).toString();}}/*** 从TreeSet里面获取TreeMap* @param sPokers 扑克牌TreeSet容器* @return 排列好的扑克牌TreeMap容器*/public java.util.TreeMap<String, Poker>getTreeMapPokersByTreeSet(java.util.TreeSet<Poker> sPokers){java.util.Iterator<Poker> iPokers = sPokers.iterator();java.util.TreeMap<String, Poker> mPokers = newjava.util.TreeMap<String, Poker>();int i = 0;while (iPokers.hasNext()){Poker poker = iPokers.next();// System.out.println(""+Poker.getColor()+Poker.getNumber());// 按顺序把扑克塞进map容器里面，方便拿取mPokers.put(""+ ++i, poker);}return mPokers;}/*** 扑克牌容器-牌盒子* @author GuanChi* 成员变量Pokers里面放置了一副扑克，共52张，会在第一次实例化时初始化 */class PokerContainer{/** 扑克牌容器 **/private java.util.TreeSet<Poker> tpokers = newjava.util.TreeSet<Poker>();/*** 构造方法，第一次实例化时候初始化扑克牌容器*/public PokerContainer(){super();if (0 == this.tpokers.size()){init();}}/*** 初始化扑克牌容器，把52张扑克放入牌盒子*/private void init(){// 选择1~13，分别对应扑克牌里面的A23~JQK.for (int i = 1;i <= 13; i++){// 选择四种不同的花色for (int j = 1;j <= 4; j++){Poker.Color color = null;switch (j){case 1:color = Poker.Color.黑桃;break;case 2:color = Poker.Color.红桃;break;case 3:color = Poker.Color.梅花;break;case 4:color = Poker.Color.方片;break;default:System.err.println("Error Occur!!");break;}// 给容器里面添加一张扑克牌this.tpokers.add(new Poker(color,i));}}}public java.util.TreeSet<Poker> getPokers(){return tpokers;}}/*** 扑克牌类型* @author GuanChi* 该类型包含两个成员变量：花色color和数字number**/static class Poker implements parable<Poker> {/*** 枚举类型-花色* @author GuanChi* 包含黑红梅方四种类型*/static enum Color{/** 黑桃 **/黑桃,/** 红桃 **/红桃,/** 梅花 **/梅花,/** 方片 **/方片}/** 扑克牌的大小点数 **/private int number;/** 扑克牌的花色 **/private Color color = null;/*** 初始化一张扑克牌，包含颜色和点数* @param color 颜色* @param number 点数*/public Poker(Color color, int number) {super();this.color = color;this.number = number;}public int getNumber(){return number;}public void setNumber(int number) {this.number = number;}public Color getColor(){return color;}public void setColor(Color color) {this.color = color;}public boolean equals(Object obj) {Poker Poker = (Poker)obj;return (Poker.getColor().equals(this.color)) && (Poker.getNumber() == this.number);}public int compareTo(Poker Poker){return Poker.number - this.number + Poker.color.hashCode() - this.color.hashCode();}}/*** 数学运算类型* @author GuanChi* 该类型提供基本的加减乘除运算静态方法*/static class Math{static enum CountSymbol{/** 加法 **/ADD,/** 减法 **/SUB,/** 乘法 **/MUL,/** 除法 **/DIV,/** 错误类型 **/ERROR,}static byte convertCSType2Byte(CountSymbol cs){// 初始化结果byte b = 0;// 根据符号来用Math中不同的方法switch (cs){// 加法case ADD:b = 1;break;// 减法case SUB:b = 2;break;// 乘法case MUL:b = 3;break;// 除法case DIV:b = 4;break;default:b = 0;}return b;}static CountSymbol convertByteType2CS(byte b) {// 初始化结果CountSymbol cs;// 根据符号来用Math中不同的方法switch (b){// 加法case 1:cs = Math.CountSymbol.ADD;break;// 减法case 2:cs = Math.CountSymbol.SUB;break;// 乘法case 3:cs = Math.CountSymbol.MUL;break;// 除法case 4:cs = Math.CountSymbol.DIV;break;default:return cs = CountSymbol.ERROR;}return cs;}static double calc(double d1,CountSymbol cs,double d2) {// 初始化结果double d = 0;// 根据符号来用Math中不同的方法switch (cs){// 加法case ADD:d = Math.add(d1, d2);break;// 减法case SUB:d = Math.sub(d1, d2);break;// 乘法case MUL:d = Math.mul(d1, d2);break;// 除法case DIV:d = Math.div(d1, d2);break;default:d = 0;}return d;}static double calc(int d1,CountSymbol cs,int d2){// 初始化结果double d = 0;// 根据符号来用Math中不同的方法switch (cs){// 加法case ADD:d = Math.add(d1, d2);break;// 减法case SUB:d = Math.sub(d1, d2);break;// 乘法case MUL:d = Math.mul(d1, d2);break;// 除法case DIV:d = Math.div(d1, d2);break;default:d = 0;}return d;}static double calc(double d1,CountSymbol cs,int d2) {// 初始化结果double d = 0;// 根据符号来用Math中不同的方法switch (cs){// 加法case ADD:d = Math.add(d1, d2);break;// 减法case SUB:d = Math.sub(d1, d2);break;// 乘法case MUL:d = Math.mul(d1, d2);break;// 除法case DIV:d = Math.div(d1, d2);break;default:d = 0;}return d;}static double calc(int d1,CountSymbol cs,double d2) {// 初始化结果double d = 0;// 根据符号来用Math中不同的方法switch (cs){// 加法case ADD:d = Math.add(d1, d2);break;// 减法case SUB:d = Math.sub(d1, d2);break;// 乘法case MUL:d = Math.mul(d1, d2);break;// 除法case DIV:d = Math.div(d1, d2);break;default:d = 0;}return d;}/*** 加法* @param number1 第一个运算数字* @param number2 第二个运算数字* @return 加法运算结果*/static double add(double number1, double number2) {}/*** 加法* @param number1 第一个运算数字* @param number2 第二个运算数字* @return 加法运算结果*/static int add(int number1, int number2){return number1 + number2;}/*** 加法* @param number1 第一个运算数字* @param number2 第二个运算数字* @return 加法运算结果*/static double add(int number1, double number2) {return number1 + number2;}/*** 加法* @param number1 第一个运算数字* @param number2 第二个运算数字* @return 加法运算结果*/static double add(double number1, int number2) {return number1 + number2;}/*** 减法* @param number1 第一个运算数字* @param number2 第二个运算数字* @return 减法运算结果*/static double sub(double number1, double number2) {}/*** 减法* @param number1 第一个运算数字* @param number2 第二个运算数字* @return 减法运算结果*/static int sub(int number1, int number2){return number1 - number2;}/*** 减法* @param number1 第一个运算数字* @param number2 第二个运算数字* @return 减法运算结果*/static double sub(int number1, double number2) {return number1 - number2;}/*** 减法* @param number1 第一个运算数字* @param number2 第二个运算数字* @return 减法运算结果*/static double sub(double number1, int number2) {return number1 - number2;}/*** 乘法* @param number1 第一个运算数字* @param number2 第二个运算数字* @return 乘法运算结果*/static double mul(double number1, double number2) {return number1 * number2;}/*** 乘法* @param number1 第一个运算数字* @param number2 第二个运算数字* @return 乘法运算结果*/static int mul(int number1, int number2){return number1 * number2;}/*** 乘法* @param number1 第一个运算数字* @param number2 第二个运算数字* @return 乘法运算结果*/static double mul(int number1, double number2) {return number1 * number2;}/*** 乘法* @param number1 第一个运算数字* @param number2 第二个运算数字* @return 乘法运算结果*/static double mul(double number1, int number2) {return number1 * number2;}/*** 除法* @param number1 第一个运算数字* @param number2 第二个运算数字* @return 除法运算结果*/static double div(double number1, double number2) {double d = 1;return 0 == number2 ? 0 : d * number1/ number2;}/*** 除法* @param number1 第一个运算数字* @param number2 第二个运算数字* @return 除法运算结果*/static double div(int number1, int number2){double d = 1;return 0 == number2 ? 0 : d * number1/ number2;}/*** 除法* @param number1 第一个运算数字* @param number2 第二个运算数字* @return 除法运算结果*/static double div(double number1, int number2){double d = 1;return 0 == number2 ? 0 : d * number1/ number2;}/*** 除法* @param number1 第一个运算数字* @param number2 第二个运算数字* @return 除法运算结果*/static double div(int number1, double number2){double d = 1;return 0 == number2 ? 0 : d * number1/ number2;}}/*** 卡片工厂* @author GuanChi* 提供一个工厂实例创建卡片*/// static class PokerFactory// {// private static PokerFactory instance = null;// public synchronized static PokerFactory getInstance()// {// if (null == instance)// {// instance = new PokerFactory();// }// return instance;// }//// public Poker createPoker(Color color, int number)// {// return new Poker(color, number);// }// }public static void testAdd24(){int no = 1;final byte[] PUKE_NUMBERS = {1,2,3,4,5,6,7,8,9,10,11,12,13};for (int i = 0;i < 13; i++){for (int j = i;j < 13; j++){for (int k = j;k < 13; k++){for (int l = k;l < 13; l++){int result = PUKE_NUMBERS[i] + PUKE_NUMBERS[j]+ PUKE_NUMBERS[k]+ PUKE_NUMBERS[l];if (result == 24){System.out.println(""+no+"→1:"+PUKE_NUMBERS[i] + "; 2:" + PUKE_NUMBERS[j] + "; 3:" + PUKE_NUMBERS[k] + "; 4:" + PUKE_NUMBERS[l]);no++;}}}}}}public static void testPoker52(){PokerContainer c = new Puke24Test().new PokerContainer();java.util.TreeSet<Poker> s = c.getPokers();System.out.println(s.size());}public static void testEqualsPoker(){System.out.println(new Poker(Poker.Color.方片,1).equals(new Poker(Poker.Color.黑桃,1)));}public static void testDiv(){System.out.println(Math.div(5, 3));}public static void main(String[] args){System.out.println(System.currentTimeMillis());// Puke24Test.testAdd24();// Puke24Test.testPoker52();// Puke24Test.testEqualsPoker();// Puke24Test.testDiv();Puke24Test.serviceExce();System.out.println(System.currentTimeMillis());}}。

1. 2. 3. 4. 关于#二十四点问题#的实现思路及代码实现1、问题描述：a b c d让你在a,b,c,d 之间的空中填上 +,-,*,/ 四则运算和括号，使得表达式运算结果为 24.这个问题十分有趣。

例如:5 5 5 5 = 24可以得到结果：5*5-5/5 = 24这里，我们将为简化：（简化之后的除法为下取整）((a b) c) d = 24问是否存在方案，使得填入运算符之后表达式成立。

输入格式：四个正整数 a,b,c,d 。

输出格式：如果存在运算符，那么输出 Yes，否则输出No 。

样例输入1：5 5 5 5样例输出1：No约定：1<=a,b,c,d<=92、实现思路：首先，需要定义变量用于存储四个数字，即a、b、c和d。

然后，定义函数calc()，该函数用于计算+、-、*、/四种运算的指定顺序的结果，并使用变量存储结果。

再者，使用递归的方式，列举出每种可能的运算符排序，并调用calc()函数求解。

最后，循环遍历结果，判断是否有结果等于24，如果有，则输出Yes，否则输出No。

3、代码实现#include <iostream>#include <algorithm>using namespace std;int a, b, c, d; // 存放四个数字// calc()用于计算+、-、*、/四种运算的顺序// operators用于存放当前运算符顺序// n表示已经选取的运算符个数double calc(int a, int b, int c, int d, char operators[], int n) {if(n == 4) {int num[4] = {a, b, c, d};double ans = num[0];for(int i=1;i<4;i++) {if(operators[i-1] == '+') {ans += num[i];} else if(operators[i-1] == '-') {ans -= num[i];} else if(operators[i-1] == '*') {ans *= num[i];} else if(operators[i-1] == '/') {ans /= num[i];}}return ans;}double ans = 0.0;// +operators[n] = '+';ans = calc(a, b, c, d, operators, n+1);if(ans == 24.0) return ans;// -operators[n] = '-';ans = calc(a, b, c, d, operators, n+1);if(ans == 24.0) return ans;// *operators[n] = '*';ans = calc(a, b, c, d, operators, n+1);if(ans == 24.0) return ans;// /operators[n] = '/';ans = calc(a, b, c, d, operators, n+1);if(ans == 24.0) return ans;return 0.0;}int main(){cin >> a >> b >> c >> d;char operators[3]; //存放三个运算符double ans = calc(a, b, c, d, operators, 0);if(ans == 24.0) {cout << "Yes";} else {cout << "No";}return 0;}。

java实现24点游戏代码import java.util.Arrays;import java.util.Scanner;public class Test07 {public static void main(String[] args) {Scanner scn = new Scanner(System.in);int shu[] = new int[4];for (int i = 0; i < 4; i++) {shu[i] = scn.nextInt();}// int shu[] = { 5, 9, 9, 4 };char op[] = { '+', '-', '*', '/' };A : for (int i = 0; i < 4; i++) {for (int n1 = 0; n1 < op.length; n1++) {for (int j = 0; j < 4; j++) {for (int n2 = 0; n2 < op.length; n2++) {for (int k = 0; k < 4; k++) {for (int n3 = 0; n3 < op.length; n3++) {for (int m = 0; m < 4; m++) {// 选的这4个数不能重复if (isAllTheOrgiNum(shu[i], shu[j], shu[k], shu[m], shu)) {double temp = 0;switch (op[n1]) {case '+':temp = shu[i] + shu[j];break;case '-':temp = shu[i] - shu[j];break;case '*':temp = shu[i] * shu[j];break;case '/':temp = (double) shu[i] / shu[j];break;}switch (op[n2]) {case '+':temp = temp + shu[k];break;case '-':temp = temp - shu[k];break;case '*':temp = temp * shu[k];break;case '/':temp = (double) temp / shu[k];break;}switch (op[n3]) {case '+':temp = temp + shu[m];break;case '-':temp = temp - shu[m];break;case '*':temp = temp * shu[m];break;case '/':temp = (double) temp / shu[m];break;}if (temp == 24) {System.out.println("(" + "(" + shu[i] + " " + op[n1] + " " + shu[j] + ")" + " " + op[n2] + " " + shu[k] + ")" + " " + op[n3] + " " + shu[m]); break A;}}}}}}}}}}private static boolean isAllTheOrgiNum(int i, int j, int k, int l, int[] shu) {// TODO Auto-generated method stubint[] a = { i, j, k, l };Arrays.sort(a);Arrays.sort(shu);if(a[0]==shu[0] && a[1]==shu[1] &&a[2]==shu[2] && a[3]==shu[3]) {return true;}return false;}}。

JAVA实现二十四点算法二十四点：任意给出四个数字，通过加减乘除四则运算得出值为24的算法有多少种。

我实现了一个二十四点的算法为对数字和运算符分别两次全排列。

详细代码如下：package myMath.ershisidian;import itmao.Iershidian;import java.util.ArrayList;import java.util.HashMap;import java.util.Map;import java.util.Set;/*** ITMAOO* 2011.12.23* **/public class Main {int count=-1;double sum=0.00;Main(int a,int b,int c,int d){ArrayList array=new ArrayList();array.add(a);array.add(b);array.add(c);array.add(d);rankAll(array,new ArrayList());}public static void main(String[] args) {new Main(30,24,8,12);}/******* 全排列算法一，实现数字的全排* ******/void rankAll(ArrayList array,ArrayList target){if(array.size()==0){Map<Integer,String> outs=new HashMap<Integer,String>(); double[] intArray={Double.valueOf(target.get(0).toString()), Double.valueOf(target.get(1).toString()),Double.valueOf(target.get(2).toString()),Double.valueOf(target.get(3).toString())};digui(intArray,sum,outs,count);}for(int i=0;i < array.size();i++ ){ArrayList newArray=new ArrayList(array);ArrayList newtarget=new ArrayList(target);newtarget.add(newArray.get(i));newArray.remove(i);rankAll(newArray,newtarget);}}/******* 全排列算法二，实现运算符的全排列* ******/public void digui(double[] array,double sum,Map outs,int count){count++;//处理加法，并递归调用if(count<=3){outs.put(count,"+");digui(array,sum+array[count],outs,count);// sum=sum-array[count];digui(array,sum);}//输出if(count==4&&sum==24.00){System.out.println(outs.get(0).toString()+(int)array[0]+outs.get(1).toString()+(int)ar ray[1]+outs.get(2).toString()+(int)array[2]+outs.get(3).toString()+(int)array[3]+"=24");}//处理减法，并递归调用if(count<=3){outs.remove(count);outs.put(count, "-");digui(array,sum-array[count],outs,count);}//处理乘法，并递归调用if(0<count&&count<=3){outs.remove(count);outs.put(count, "*");if(outs.get(count-1).toString().equals("+")){digui(array,sum-array[count-1]+array[count]*array[count-1],outs,count);}else if (outs.get(count-1).toString().equals("-")){digui(array,sum+array[count-1]-array[count]*array[count-1],outs,count);}else if (outs.get(count-1).toString().equals("*")){if(outs.get(count-2).toString().equals("+")){digui(array,sum-array[count-2]*array[count-1]+array[count-2]*array[count-1]*array [count],outs,count);}else if (outs.get(count-2).toString().equals("-")){digui(array,sum+array[count-2]*array[count-1]-array[count-2]*array[count-1]*array[count],outs,count);}else if (outs.get(count-2).toString().equals("*")){if(outs.get(count-3).toString().equals("+")){digui(array,array[count-3]*array[count-2]*array[count-1]*array[count],outs,count);; }else if (outs.get(count-3).toString().equals("-")){digui(array,-array[count-3]*array[count-2]*array[count-1]*array[count],outs,count); }}}}//处理除法，并递归调用if(1<count&&count<=3){outs.remove(count);outs.put(count, "/");if(outs.get(count-1).toString().equals("+")){digui(array,sum-array[count-1] + array[count-1]/array[count],outs,count);}else if (outs.get(count-1).toString().equals("-")){digui(array,sum+array[count-1] - array[count-1]/array[count],outs,count);}else if (outs.get(count-1).toString().equals("*")){if(outs.get(count-2).toString().equals("+")){digui(array,sum-array[count-2]*array[count-1]+array[count-2]*array[count-1]/array [count],outs,count);}else if (outs.get(count-2).toString().equals("-")){digui(array,sum+array[count-2]*array[count-1]-array[count-2]*array[count-1]/array [count],outs,count);}else if (outs.get(count-2).toString().equals("*")){if(outs.get(count-3).toString().equals("+")){digui(array,array[count-3]*array[count-2]*array[count-1]/array[count],outs,count);; }else if (outs.get(count-3).toString().equals("-")){digui(array,-array[count-3]*array[count-2]*array[count-1]/array[count],outs,count); }}else if (outs.get(count-2).toString().equals("/")){if(outs.get(count-3).toString().equals("+")){digui(array,array[count-3]/array[count-2]*array[count-1]/array[count],outs,count);; }else if (outs.get(count-3).toString().equals("-")){digui(array,-array[count-3]/array[count-2]*array[count-1]/array[count],outs,count); }}}else if (outs.get(count-1).toString().equals("/")){if(outs.get(count-2).toString().equals("+")){digui(array,sum-array[count-2]/array[count-1]+array[count-2]/array[count-1]/array [count],outs,count);}else if (outs.get(count-2).toString().equals("-")){digui(array,sum+array[count-2]/array[count-1]-array[count-2]/array[count-1]/array [count],outs,count);}else if (outs.get(count-2).toString().equals("*")){if(outs.get(count-3).toString().equals("+")){sum=array[count-3]*array[count-2]/array[count-1]/array[count];digui(array,sum,ou ts,count);;}else if (outs.get(count-3).toString().equals("-")){sum=-array[count-3]*array[count-2]/array[count-1]/array[count];digui(array,sum,o uts,count);}}else if (outs.get(count-2).toString().equals("/")){if(outs.get(count-3).toString().equals("+")){sum=array[count-3]/array[count-2]/array[count-1]/array[count];digui(array,sum,ou ts,count);;}else if (outs.get(count-3).toString().equals("-")){sum=-array[count-3]/array[count-2]/array[count-1]/array[count];digui(array,sum,o uts,count);}}}}}}。