二十四点JAVA算法
24点游戏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点：任意给定四个整数，用加、减、乘、除以及适当的括号连接，无论顺序，使计算结果为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]但运算符有优先级，一般是用括号表示。
24点算法(JAVA)
}
}
}
}
/**
* 计算四个数字排列与操作符的运算结果
* @param num 数字排列
* @param op 操作符排列
}
static char[] op={'+','-','*','/'};
public static void check(int[] v,int[] idx){
for(int i=0;i<4;i++){
代码：
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Stack;
public class TwentyFour {
public static void main(String[] args){
if (a==b) continue;
for (int c=0;c<4;c++){
if (a==c||b==c) continue;
for (int d=0;d<4;d++){
}catch(Exception ex){
ex.printStackTrace();
}
}
}catch(Exception ex){
(6+(9*(3-1)))
(6*((9/3)+1))
(((1+9)*3)-6)
((1+(9/3))*6)
(9+(3*(6-1)))
java实现24点纸牌游戏
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点游戏的编程思路与基本算法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语言源码
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源代码
扑克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点游戏代码
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实现二十四点算法
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);}}}}}}。
java24点算法实现
java24点算法实现 最近闲来⽆事，突然怀念起⼩时候和堂兄表姐们经常玩24点游戏，于是就琢磨着是不是开发⼀个安卓⼿机版本。
然后上⽹上⼀搜，发现已经被别⼈给开发烂了啊。
不过这只能说明这个⼩游戏要想赚⼴告费很难了，但是拿来锻炼和在妹纸⾯前装逼还是很有价值的，嘿嘿，想到这⾥，我最终还是花了3天时间开发了⼀个⼩游戏出来。
算法实现 在⽹上试玩了⼀个flash的版本，发现还需要实现计算所有正确的结果，然后⽹上稍微百度了下思路，就开始⾃⼰实现了。
我开始时⼤概的思路就是穷举出所有的数字和算式的排列组合，然后⼀⼀进⾏验算，中间碰到两个问题，1. 第⼀是计算顺序的问题，稍微思考⼀下，就会发现，+，*是不考虑先后顺序的，-，/是考虑先后顺序的，所以考虑计算顺序后每两个数都会有6种计算⽅法。
⽽括号也会产⽣很多不同的情况。
2. 第⼆是保存计算的表达式的问题，因为穷举完了，计算机是知道答案了，但是⽤户还是不知道啊，所以得想办法保存起来（这个问题开始时没注意，后来⼩花了点时间才完美解决的，后⾯会有说明）。
然后，具体怎样进⾏遍历才能做到既不重复⼜⽆遗漏呢? 我的思路是这样的，还是得利⽤递归来简化实现，虽然递归很耗资源，但是作为⾮acm⼤神，算法⽔平⼀般般的我来说，还是先从简单的⾓度考虑。
⼀个算式，不管包不包括括号，都可以抽象成两个数的计算的叠加，因为每次单个运算都是拿两个数运算的。
然后再通过递归，将计算的结果和其他的数重新做两个数的运算，⼀直递归到只剩下⼀个结果时，那么这个数就是这种计算⽅法得到的答案了，和24⽐较就可以了。
⾄于每⼀个运算轨迹得到的表达式该怎么保存呢？我的做法是⽤⼀个类封装起来，然后维护两个数组，⼀个是数字（这个数字既是⽤户输⼊的，也可以是两个或多个数运算得到的结果），另⼀个就是这个数对应的表达式（当这个数是⽤户输⼊的时候就是⼀个数字⽽已，当这个数字是运算的结果时就是算式）的字符串。
实现代码：1package net.yunstudio.p24.util;23import java.util.ArrayList;4import java.util.HashSet;5import java.util.List;6import java.util.Random;7import java.util.Set;89import com.umeng.a.a.a.b.n;1011public class Count24 {12private List<String> answerList=new ArrayList<String>();13public List<String> getAnswerList() {14return answerList;15 }16public static class Data{17public float[] arr;18public String expStr="";19public String[] strs;20public Data(){}21public Data(int a,int b,int c,int d) {22 arr=new float[]{a,b,c,d};23 strs=new String[]{a+"",b+"",c+"",d+""};24 expStr=a+"";25 }26public Data(int arr[]) {27this.arr=new float[]{arr[0],arr[1],arr[2],arr[3]};28this.strs=new String[]{arr[0]+"",arr[1]+"",arr[2]+"",arr[3]+""};29 }30 }31public void count(Data data){32float[] arr=data.arr;33if(arr.length<=1){34if(arr.length==1&&arr[0]==24){35 answerList.add(data.expStr.substring(1, data.expStr.length()-1));36 }37return ;38 }39for(int i=0,len=arr.length;i<len-1; i++){40for(int j=i+1;j<len;j++){41float x=arr[i];42float y=arr[j];43 String xs=data.strs[i];44 String ys=data.strs[j];45for(int k=0;k<6;k++){46 Data newData=getNewArr(data,i);47switch(k){48case 0:49 newData.arr[j-1]=x+y;50 newData.expStr=xs+"+"+ys;51break;52case 1:53 newData.arr[j-1]=x-y;54 newData.expStr=xs+"-"+ys;55break;56case 2:57 newData.arr[j-1]=y-x;58 newData.expStr=ys+"-"+xs;59break;60case 3:61 newData.arr[j-1]=x*y;62 newData.expStr=xs+"*"+ys;63break;64case 4:65if(y!=0){66 newData.arr[j-1]=x/y;67 newData.expStr=xs+"/"+ys;68 }else {69continue;70 }71break;72case 5:73if(x!=0){74 newData.arr[j-1]=y/x;75 newData.expStr=ys+"/"+xs;76 }else {77continue;78 }79break;80 }81 newData.expStr="("+newData.expStr+")";82 newData.strs[j-1]=newData.expStr;83 count(newData);84 }85 }86 }8788 }89private static Data getNewArr(Data data, int i) {90 Data newData=new Data();91 newData.expStr=data.expStr;92 newData.arr=new float[data.arr.length-1];93 newData.strs=new String[data.arr.length-1];94for(int m=0,len=data.arr.length,n=0;m<len;m++){95if(m!=i){96 newData.arr[n]=data.arr[m];97 newData.strs[n]=data.strs[m];98 n++;99 }100 }101return newData;102 }103104public static final List<String> easyCount(int[] curRandNums){105 Count24 count24=new Count24();106 count24.count(new Data(curRandNums));107 Set<String> set=new HashSet<String>(count24.getAnswerList());//去重108return new ArrayList<String>(set);109 }110111public static void main(String[] args) throws InterruptedException {112long start=System.currentTimeMillis();113 List<String> answerStris=easyCount(new int[]{1,2,3,4});114 System.out.println(System.currentTimeMillis()-start);115116for (String string : answerStris) {117 System.out.println(string);118 }119 }120 }24点算法实现 在电脑上⾯（神⾈i7）⼤概需要60ms，这个速度初看还是可以接受的，但是到了⼿机上，居然需要6秒以上！！不过⽆意中发现，在android系统中对⼤量运算有优化，貌似计算了⼀定次数之后系统会缓存编译后的本地代码，然后⼿机上也可以像电脑上⼀样秒算了。
24点经典算法
24点经典算法1、概要 特定4整数，每个号码只能使⽤⼀次；随意使⽤ + - * / ( ) 。
构建表达，从⽽使最终结果24，这是⼀种常见的操作者24游戏点。
该⽅案的这⼀⽅⾯是⾮常，它们⼀般详尽的解决。
本⽂介绍⼀种典型的算24点的程序算法，并给出两个详细的算24点的程序：⼀个是⾯向过程的C实现，⼀个是⾯向对象的java实现。
2、基本原理 基本原理是穷举4个整数全部可能的表达式。
然后对表达式求值。
表达式的定义： expression = (expression|number) operator (expression|number) 由于能使⽤的4种运算符 + - * / 都是2元运算符，所以本⽂中仅仅考虑2元运算符。
2元运算符接收两个參数。
输出计算结果。
输出的结果參与兴许的计算。
由上所述，构造全部可能的表达式的算法例如以下： (1) 将4个整数放⼊数组中 (2) 在数组中取两个数字的排列，共同拥有 P(4,2) 种排列。
对每个排列， (2.1) 对 + - * / 每个运算符， (2.1.1) 依据此排列的两个数字和运算符。
计算结果 (2.1.2) 改表数组：将此排列的两个数字从数组中去除掉，将 2.1.1 计算的结果放⼊数组中 (2.1.3) 对新的数组。
反复步骤 2 (2.1.4) 恢复数组：将此排列的两个数字增加数组中，将 2.1.1 计算的结果从数组中去除掉 可见这是⼀个递归过程。
步骤 2 就是递归函数。
当数组中仅仅剩下⼀个数字的时候。
这就是表达式的终于结果，此时递归结束。
在程序中。
⼀定要注意递归的现场保护和恢复，也就是递归调⽤之前与之后。
现场状态应该保持⼀致。
在上述算法中。
递归现场就是指数组，2.1.2 改变数组以进⾏下⼀层递归调⽤，2.1.3 则恢复数组。
以确保当前递归调⽤获得下⼀个正确的排列。
括号 () 的作⽤仅仅是改变运算符的优先级，也就是运算符的计算顺序。
所以在以上算法中，⽆需考虑括号。
关于24点游戏的编程思路与基本算法
关于24点游戏的编程思路与基本算法设计思路：在算24点时候，我的第一反应便是穷举法！在算24点时候，我的思路就是列出4个数字加减乘除的各种可能性，包括括号的算法。
我们可以将表达式分成以下几种：首先我们将4个数设为a，b，c，d，，其中算术符号有+，-，*，/，。
其中有效的表达式有a，ab-cd，等等。
列出所有有效的表达式。
其中我们用枚举类型将符号定义成数字常量，比如用1表示+，2表示-等。
如下是我对穷举法的一种编程语言。
在编程的头部要对变量做下定义。
在输入数字前我做了定义，因为题目规定是1-10内不相同的数字。
所以我就想到了if的判断语句来写此句话。
即if((a==b)||(a==c)||(a==d)||(b==c)||(b==d)||(c==d)||(a<0)||(a>10)||(b<0)||(b>10)||(c<0)||(c >10)||(d<0)||(d>10))则输入非法。
当输入合法时，我就在想，4个数都有各自的排列，所以运用数学的排列组合来算的的，分别是A44=24种组合，打个比方，我入、、输入a，b，c，d，那么就有abdc,badc,bacd``````等24种不同的组合，在这里我就不一一列举，在源代码当中我会一一写在程序里。
在运算时，我开始想，得从括号分类起，有零括号的，一个括号的，两个括号的。
以下是表达式，当然，*并不是×，*只是符号的统称。
零个括号的：a*b*c*d。
一个括号的：(a * b * c) * d，a * (b * c) * d。
两个括号的：(a * b) * (c * d)，(a * b) * c) * d，a * (b * c)) * d接下来就是对每一种进行分析判断。
以上就是穷举法的基本实现算法首先穷举的可行性问题。
我把表达式如下分成三类：1、列出四个数的所有排序序列组合（共有A44=24种组合）。
2、构筑一个函数，列出所有运算表达式。
24点游戏的算法与源程序
24点游戏的算法与源程序高一7 高雅Jan 5th. 2002一、任务说明24点游戏是一个大众化的益智游戏。
任意给四张扑克牌（不包括大小王），只能够用加、减、乘、除以及适当的括号连接这四张牌，无论顺序，使计算结果为24，或者宣布根本就是无解的。
需要注意的是，每张牌必须运算，并且只能运算一次，J、Q、K可设置为11、12、13。
本程序目的就是算出一组牌的所有解（不同形式的式子算不同解），如没有则输出无解。
二、算法说明首先解决图形扑克牌的显示问题。
我选择了Qcard.dll。
运用其中的DrawCard 过程可轻松实现扑克的显示问题，在源程序中会有具体用法。
接下来是24点算法的讨论。
首先想到的是用穷举表达式的方法，然后求值。
然而，由于括号的存在，使穷举表达式并非易事。
实际上，括号的作用仅仅是提高运算的优先级而已，如果我们规定符号的优先级，一样可以达到要求。
具体来说，设四张牌为a、b、c、d，运算符为①、②、③，表达式为a ① b ② c ③。
如果强制规定①、②、③的优先顺序，就不必考虑括号问题了。
而这3个运算符的运算顺序有3！=6种，分别是：1．①②③ 2.①③② 3.②①③ 4.②③① 5.③①② 6.③②①等价的表达式分别是：1.((a①b②)c③)2.(a①b)②(c③d)3.(a①(b②c))③d4.a①((b②c)③d)5.(a①b)②(c③d)6. a①(b②(c③d))显然，2和5是相同的，因此只考虑5种情况。
这样，括号的问题就解决了。
接下来，就是生成a、b、c、d的全排列，注意去掉其中的相同排列。
去除的方法很多，比如字典排序等，我用的是另一种方法。
用循环的嵌套生成a、b、c、d的24种全排列，记录在数组中。
把每一组数当作一个四位的14进制数，把这24个数全部转化为十进制（如（6529）=6*143+5*142+2*14+9）。
这样，如果两个排列完全相同，则得到的十进制数是14相等的。
这样，通过对这些十进制的比较，就可以比较这些排列的相同情况。
24点运算
{
Scanner sc=new Scanner(System.in);
while(sc.hasNext())
{
String[] org=new String[4];
for(int i=0;i<4;i++)
org[i]=sc.next();
}
if(dfs(total+pokers[i],cnt+1,org,pokers,flag))
{
res="+"+org[i]+res;
return true;
}
if(dfs(total*pokers[i],cnt+1,org,pokers,flag))
{
res="*"+org[i]+res;
return true;
for(int i=0;i<4;i++)
{
flag[i]=true;
if(dfs(pokers[i],1,org,pokers,flag))
{
String temp=org[i]+res;
if(temp.equals("7-4*4*2")) {
temp = "7-4*2*4";}
System.out.println(temp);
put("10", 10);put("J", 11);put("Q", 12);put("K", 13);
put("A", 1);put("1", 1);
自己手写的24点程序（包含括号操作，可适应所有四张牌类型，输入用空格隔开，回车结束）
⾃⼰⼿写的24点程序（包含括号操作，可适应所有四张牌类型，输⼊⽤空格隔开，回车结束）1import java.util.ArrayList;2import java.util.Arrays;3import java.util.HashSet;4import java.util.Scanner;56import javax.script.ScriptEngine;7import javax.script.ScriptEngineManager;8import javax.script.ScriptException;910public class Main {11public static void main(String[] args) throws ScriptException {12 Scanner sc = new Scanner(System.in);13while(sc.hasNext()) {14 String in = sc.nextLine();15//in = "j k q a";16 in = in.trim();17 String out = game(in);18 System.out.println(out);19 }20 }2122private static String game(String in) throws ScriptException {23 in = in.toUpperCase();24 String[] ins = in.split("[\\s]+");25if(ins.length != 4) {return "ERROR";}26for (int i = 0; i < ins.length; i++) {27if(ins[i].equals("A")) {ins[i] = "1";}28if(ins[i].equals("J")) {ins[i] = "11";}29if(ins[i].equals("Q")) {ins[i] = "12";}30if(ins[i].equals("K")) {ins[i] = "13";}31if(ins[i].equals("JOKER")) {return "ERROR";}32 }33 System.out.println(Arrays.asList(ins));3435//四张牌排序36 String[] numloc = {"1234","1243","1423","1432","1324","1342",37 "2134","2143","2314","2341","2413","2431",38 "3124","3142","3412","3421","3241","3214",39 "4123","4132","4213","4231","4321","4312"};40int loc;41 String[] co = {"+","-","*","/"};42 ArrayList<String> list = new ArrayList<>();43 String[][] str = null;44for (int nl = 0; nl < numloc.length; nl++) {45 str = new String[4][4];46for (int j = 0; j < 3; j++) {47 loc = Integer.parseInt(""+numloc[nl].charAt(j))-1;48for (int j2 = 0; j2 < 4; j2++) {49 str[j][j2] = ins[loc]+co[j2];50 }51 }52for (int j = 0; j < 4; j++) {53 loc = Integer.parseInt(""+numloc[nl].charAt(3))-1;54 str[3][j] = ins[loc];55 }5657//58 String a = "";59for (int j1 = 0; j1 < 4; j1++) {60for (int j2 = 0; j2 < 4; j2++) {61for (int j3 = 0; j3 < 4; j3++) {62for (int j4 = 0; j4 < 4; j4++) {63 a=a+str[0][j1]+str[1][j2]+str[2][j3]+str[3][j4];64 list.add(a);65 a="";66 }67 }68 }69 }70 }7172//加括号，共计扩容6倍73 list = new ArrayList<>(new HashSet(list));74 ArrayList<String> list2 = new ArrayList<>();75for (int i = 0; i < list.size(); i++) {76 String s = list.get(i);77//记录符号位置78int[] a = new int[3];79int count = 0;80for (int j = 0; j < s.length(); j++) {81if(s.charAt(j)=='+'||s.charAt(j)=='-'||s.charAt(j)=='*'||s.charAt(j)=='/')82 {a[count++] = j;}83 }84//System.out.println(s);85 String ss ;86//第⼀种87 ss = "("+s.substring(0,a[1])+")"+s.substring(a[1], s.length());88 list2.add(ss);89//第⼆种90 ss = "("+s.substring(0,a[2])+")"+s.substring(a[2], s.length());91 list2.add(ss);92//第三种93 ss = s.substring(0,a[0]+1)+"("+s.substring(a[0]+1, a[2])+")"+s.substring(a[2],s.length());94 list2.add(ss);95//第四种96 ss = s.substring(0,a[0]+1)+"("+s.substring(a[0]+1, s.length())+")";97 list2.add(ss);98//第五种99 ss = s.substring(0,a[1]+1)+"("+s.substring(a[1]+1, s.length())+")";100 list2.add(ss);101//第六种，双括号102 ss = "("+s.substring(0,a[1])+")"+s.substring(a[1],a[1]+1)+"("+s.substring(a[1]+1, s.length())+")";103 list2.add(ss);104105//System.out.println(list2);106//System.out.println("");107108 }109 list = new ArrayList<>(new HashSet(list));110 list.addAll(list2);111 System.out.println(list);112//System.out.println(list.size());113for (int i = 0; i < list.size(); i++) {114115 Object d = null;116 ScriptEngine se = new ScriptEngineManager().getEngineByName("JavaScript");117 d = (Object) se.eval(list.get(i));118//System.out.println(i+" "+d);119double result = 24D;120 Double re = Double.valueOf(""+d);121if ( re>(result-0.0001) && re<(result+0.0001) ) {System.out.println("个数:"+list.size()+" "+list2.size());return "结果："+list.get(i); } 122123 }124 System.out.println("个数:"+list.size()+" "+list2.size());125return "NONE";126 }127 }。
24点游戏 java设计
1.1题目说明
一副牌中抽去大小王剩下52张（如果初练也可只用1-10者40张牌），任意抽取4张牌（称牌组），用加、减、乘、除（可加括号）把牌面上的数算成24。
每张牌必须使用一次且只能用一次，如抽出的牌是3、8、8、9，那么算式（9-8）*3*8或3*8+（9-8）或（9-8%8）*3等
【版本1】
从52张牌中任意选取4张扑克牌，如图4，每张牌表示一个数字。
输入由四张被选择的扑克牌面的四个数字构成的一个表达式10*（8-6）+4，如图5。
点击验证按钮，显示消息：
如输入的表达式为10+8+6-4.得不到正确的结果，显示消息：
如输入的数据与纸牌数据不同，显示消息：
点击刷新按钮，得到另外4张牌。
版本二
改进版本1，如果解存在，就显示该解。
如存在多个解，显示这样的多个解。
如8，6，2，1，可能的解有：6+（8+1）*2，8*（6-2-1），......
如果不存在解，显示无解消息。
由用户输入1到13之间的四个数，检查是否有解。
版本3
从52张牌中选择4张牌，这四张牌可能无解。
从52张牌中选择4张牌的挑选次数是多少？
在这些所有可能的选择中，有多少有解？
成功的几率是多少？
编程求解上述问题。
1.2设计思路
1.对栈，集合，数组，递归等知识熟悉，并且能熟练掌握
2.首先在程序的设计部分由分为几个步骤：
3.第一步：查阅有关归并排序算法的资料。
4.第二步：设计这个项目的整体架构和算法。
5.第三步：选择一门程序设计语言进行算法的描述。
6.其次，进行程序的调试。
1.3测试。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
{ nu[count]=num[j]; ex[count]=expr[j]; le[count]=level[j];
} count++; } com(nu,ex,le); } } } public static String add(String s) { if(s.matches("[0-9]+(\\.[0-9]+)?")) { return s; } else { return "("+s+")"; } } }
case 3:/// nu[count]=num[j]/num[j+1]; String te4=expr[j]; String te5=expr[j+1]; if(level[j]==0) { te4=add(expr[j]); } if(level[j+1]!=2) { te5=add(expr[j+1])#34;+te5; le[count]=1; break;
case 1://"-" nu[count]=num[j]-num[j+1]; String te1=expr[j+1]; if(level[j+1]==0) { te1=add(expr[j+1]); } ex[count]=expr[j]+"-"+te1; le[count]=0; break;
case 2://* nu[count]=num[j]*num[j+1]; String te2=expr[j]; String te3=expr[j+1]; if(level[j]==0) { te2=add(expr[j]); } if(level[j+1]==0) { te3=add(expr[j+1]); } ex[count]=te2+"*"+te3; le[count]=1; break;
package d5.te.c;
import java.util.HashSet; import java.util.Set;
public class twentyfour { public static void main(String[] args) { double[] num={3,9,2,1}; String[] expr={"3","9","2","1"}; int[] level={2,2,2,2}; com(num,expr,level); for(String o:hs) { System.out.println(o); } } static Set<String> hs=new HashSet<String>(); public static void com(double[] num,String[] expr,int[] level) { if(expr.length==1&&num[0]==24) { hs.add(expr[0]); return; } for(int i=0;i<num.length-1;i++) { for(int op=0;op<4;op++) { double[] nu=new double[num.length-1]; String[] ex=new String[expr.length-1]; int[] le=new int[level.length-1]; int count = 0; for(int j=0;j<num.length;j++) { if(j==i) { switch(op) { case 0://"+" nu[count]=num[j]+num[j+1]; ex[count]=expr[j]+"+"+expr[j+1]; le[count]=0; break;