24点问题java的简单介绍
本篇文章给大家谈谈24点问题java，以及对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
6.6.9.10算24点怎么算
算24点的技巧:有基本算式法，特性求解法，倍数法，巧用分数法，具体解法如下：
1、基本算式法
利用2*12=24,3*8=24,4*6=24求解。一般情况下，先要看四张牌中是否有2,3,4,6,8，Q，如果有，考虑用乘法，将剩余的三个数凑成对应数。如3,3,6,10可组成（10-6/3）*3=24。如果没有2,3,4,6,8，Q，看是否能先把两个数凑成其中之一，再求解24。
2、特性求解法
1）利用0、11的运算特性求解。如（3,4，4,8）可组成3*8+4-4=24。
2）如果有两个相同的6，剩下的只要能凑成2,3,4,5都能算出24，比如6,6,3可以3*6+6=24。同理，如果有两个相同的8，剩下的只要能凑成2,3,4就能算出24。
如（2,5,8,8），（5-2）*8=24，多一个8，可以用乘法的分配律消去8，将算式改为5*8-2*8，将多余的8消去；如果有两个相同的Q，剩下的只要能凑成1,2,3就能算出24，如（9，J,Q,Q）可以12*11-12*9=24。
3、倍数法
利用24的倍数求解2*24=48,3*24=72,4*24=96,5*24=120,6*24=144想办法去凑48,72,96,120,144来求解。在具体的运算过程中，先将数乘得很大，最后再除以一个数得24。
4、巧用分数法
利用24的分数求解。先将数算成分数或小数，最后乘以一个数得24。用一个数除以一个分数，相当于乘以这个数的倒数，最后得24。
24点的口诀为见3凑8，见4凑6，见2凑12等等。
稍微特殊点的规律：2乘10+4，15+9，21+3，14+10等。
扩展资料：
“算24点”作为一种扑克牌智力游戏，还应注意计算中的技巧问题。计算时，我们不可能把牌面上的4个数的不同组合形式——去试，更不能瞎碰乱凑。这里向大家介绍几种常用的、便于学习掌握的方法：
1．利用3×8＝24、4×6＝24求解。
把牌面上的四个数想办法凑成3和8、4和6，再相乘求解。如3、3、6、10可组成（10—6÷3）×3＝24等。又如2、3、3、7可组成（7＋3—2）×3＝24等。实践证明，这种方法是利用率最大、命中率最高的一种方法。
2．利用0、11的运算特性求解。
如3、4、4、8可组成3×8＋4—4＝24等。又如4、5、J、K可组成11×（5—4）＋13＝24等。
3．在有解的牌组中，用得最为广泛的是以下六种解法：（我们用a、b、c、d表示牌面上的四个数）
①(a—b）×（c＋d）
如（10—4）×（2＋2）＝24等。
②（a＋b）÷c×d
如（10＋2）÷2×4＝24等。
③（a－b÷c）×d
如（3—2÷2）×12＝24等。
④（a＋b－c）×d
如（9＋5—2）×2＝24等。
⑤a×b＋c—d
如11×3＋l—10＝24等。
⑥（a－b）×c＋d
如（4—l）×6＋6＝24等。
游戏时，同学们不妨按照上述方法试一试。
需要说明的是：经计算机准确计算，一副牌（52张）中，任意抽取4张可有1820种不同组合，其中有458个牌组算不出24点，如A、A、A、5。
经典24点
4
4
10
10
这个难点在于先要算出一个很大的数，就是100，然后再通过减4，除4就可以得到24点：(10×10-4)÷4=24。
6
9
9
10
这个也要先算大数90，然后除6，再加9即可得24点：9×10÷6+9=24。
2
2
2
9
这个并不难，只是数字比较好玩，包含了3个2，其计算方法为：(2+9)×2+2=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 则恢复数组，以确保当前递归调用获得下一个正确的排列。
括号 () 的作用只是改变运算符的优先级，也就是运算符的计算顺序。所以在以上算法中，无需考虑括号。括号只是在输出时需加以考虑。
java程序设计：算24点
//这是我自己写的，在VC里可以运行。
#include "stdafx.h"
#includestdio.h
#includestdlib.h
static int NUMBER;
bool Game24(int const nNum, int* arr, int nLen, int nCount, char* pOperator, bool* pFlag){
if(nCount == 1){
if(*arr == nNum){
printf("((%d %c %d) %c %d) %c %d = %d\n",
arr[0],pOperator[0],arr[1],pOperator[1],arr[2],pOperator[2],arr[3],NUMBER);
if(!(*pFlag)) *pFlag = true;
}
return *pFlag;
}
for(int i = 0; i 4; ++i){
switch(i){
case 0:
pOperator[nCount - 2] = '+';
Game24(nNum - arr[nCount - 1], arr,nLen,nCount - 1,pOperator,pFlag);
break;
case 1:
pOperator[nCount - 2] = '-';
Game24(nNum + arr[nCount - 1], arr,nLen,nCount - 1,pOperator,pFlag);
break;
case 2:
pOperator[nCount - 2] = '*';
if( arr[nCount - 1] !(nNum % arr[nCount - 1]))
Game24(nNum / arr[nCount - 1], arr,nLen,nCount - 1,pOperator,pFlag);
break;
case 3:
pOperator[nCount - 2] = '/';
if(arr[nCount - 1])
Game24(nNum * arr[nCount - 1], arr,nLen,nCount - 1,pOperator,pFlag);
break;
}
}
return *pFlag;
}
int fOperating(char pOpe, int x1, int x2){
switch(pOpe){
case '+': return x1 + x2;
case '-': return x1 - x2;
case '*': return x1 * x2;
case '/': return x1 / x2;
}
}
bool fGame24(int const nNum, int* arr,char* pOperator, bool* pFlag){
int nLeft = 0,nRight = 0;
char pOpe[4] = {'+','-','*','/'};
for(int l = 0; l 4; ++l){
if(l == 3 (!arr[1] || arr[0] % arr[1])) continue;
pOperator[0] = pOpe[l];
nLeft = fOperating(pOpe[l],arr[0],arr[1]);
for(int r = 0; r 4; ++r){
if(r == 3 (!arr[3] || arr[2] % arr[3])) continue;
pOperator[2] = pOpe[r];
nRight = fOperating(pOpe[r],arr[2],arr[3]);
for(int m = 0; m 4; ++m){
if(m == 3 (!nRight || nLeft % nRight)) continue;
pOperator[1] = pOpe[m];
if(fOperating(pOpe[m],nLeft,nRight) == nNum){
printf("(%d %c %d) %c (%d %c %d) = %d\n",
arr[0],pOperator[0],arr[1],pOperator[1],arr[2],pOperator[2],arr[3],NUMBER);
if(!(*pFlag)) *pFlag = true;
}
}
}
}
return *pFlag;
}
int main(int argc, char* argv[])
{
puts("start!\nPlease input 4 numbers:");
bool* pFlag = (bool*)malloc(1);
*pFlag = false;
bool flag = 0;
int pNum[4] = {0};
int cNum[4] = {0};
int iNum[4] = {0};
char cOpe[3] = {0};
for(int i = 0; i 4; ++i)
scanf("%d",pNum[i]);
puts("So, what number do you want:");
scanf("%d",NUMBER);
puts("************************************");
for(iNum[0] = 0; iNum[0] 4; ++iNum[0]){
for(iNum[1] = 0; iNum[1] 4; ++iNum[1]){
if(iNum[1] == iNum[0]) continue;
for(iNum[2] = 0; iNum[2] 4; ++iNum[2]){
if(iNum[2] == iNum[0] || iNum[2] == iNum[1]) continue;
for(iNum[3] = 0; iNum[3] 4; ++iNum[3]){
if(iNum[3] == iNum[0] || iNum[3] == iNum[1] || iNum[3] == iNum[2]) continue;
for(int i = 0; i 4; ++i) cNum[i] = pNum[iNum[i]];
if(Game24(NUMBER,cNum,4,4,cOpe,pFlag)) flag = true;
if(fGame24(NUMBER,cNum,cOpe,pFlag)) flag = true;
}
}
}
}
free(pFlag);
if(!flag) printf("No way can be found.\n");
puts("************************************\nEnd!");
system("pause");
return 0;
}
算24点 java代码
C的代码要吗？我对java不是很熟，我试着用java写下吧。给我点时间！
package test.cardgame;
public class BinaryTreeNode
{
private BinaryTreeNode leftSon=null;
private BinaryTreeNode rightSon=null;
private BinaryTreeNode parent=null;
private double data=0;
private int sign=-1;
public int getSign()
{
return sign;
}
public void setSign(int sign)
{
this.sign = sign;
}
public BinaryTreeNode(BinaryTreeNode parent,BinaryTreeNode leftSon,BinaryTreeNode rightSon)
{
this.parent=parent;
this.leftSon=leftSon;
this.rightSon=rightSon;
}
public BinaryTreeNode()
{
}
public BinaryTreeNode getLeftSon()
{
return leftSon;
}
public void setLeftSon(BinaryTreeNode leftSon)
{
this.leftSon = leftSon;
leftSon.setParent(this);
}
public BinaryTreeNode getParent()
{
return parent;
}
public void setParent(BinaryTreeNode parent)
{
this.parent = parent;
}
public BinaryTreeNode getRightSon()
{
return rightSon;
}
public void setRightSon(BinaryTreeNode rightSon)
{
this.rightSon = rightSon;
rightSon.setParent(this);
}
public boolean isLeaf()
{
return (this.leftSon==nullthis.rightSon==null);
}
public boolean isRoot()
{
return this.parent==null;
}
public double getData()
{
return data;
}
public void setData(double data)
{
this.data = data;
}
}
package test.cardgame;
import java.util.ArrayList;
public class CardGame
{
private ArrayListString expressions=new ArrayListString();
public void solute(ArrayListBinaryTreeNode nodes,double target)
{
//whether the root data equals target
if (nodes.size()==1)
{
if (nodes.get(0).getData()==target)
{
String expression=printBinaryTree(nodes.get(0));
addExpression(expression);
return;
}
}
for (int i=0;inodes.size();i++)
{
for (int j=0;jnodes.size();j++)
{
if (i==j)
{
continue;
}
for (int k=0;k4;k++)
{
BinaryTreeNode node=new BinaryTreeNode();
BinaryTreeNode leftSon=nodes.get(i);
BinaryTreeNode rightSon=nodes.get(j);
if (k==0)
{
node.setData(leftSon.getData()+rightSon.getData());
}
else if (k==1)
{
node.setData(leftSon.getData()-rightSon.getData());
}
else if (k==2)
{
node.setData(leftSon.getData()*rightSon.getData());
}
else if (k==3)
{
if (rightSon.getData()==0)
{
continue;
}
node.setData(leftSon.getData()/rightSon.getData());
}
node.setLeftSon(leftSon);
node.setRightSon(rightSon);
node.setSign(k);
ArrayListBinaryTreeNode clonedArrayList=cloneArrayList(nodes);
//remove nodes from the tree
clonedArrayList.remove(leftSon);
clonedArrayList.remove(rightSon);
clonedArrayList.add(node);
solute(clonedArrayList,target);
}
}
}
}
public void printResult()
{
for (int i=0;iexpressions.size();i++)
{
System.out.println("Solution "+i+": "+expressions.get(i));
}
}
private void addExpression(String expression)
{
if (expressions.contains(expression))
{
return;
}
expressions.add(expression);
}
private ArrayListBinaryTreeNode cloneArrayList(ArrayListBinaryTreeNode source)
{
ArrayListBinaryTreeNode result=new ArrayListBinaryTreeNode();
for (int i=0;isource.size();i++)
{
result.add(source.get(i));
}
return result;
}
private String printBinaryTree(BinaryTreeNode resultRoot)
{
if (resultRoot.isLeaf())
{
return doubleToString(resultRoot.getData());
}
else
{
String expression="(";
expression+=printBinaryTree(resultRoot.getLeftSon());
int sign=resultRoot.getSign();
if (sign==0)
{
expression+="+";
}
else if (sign==1)
{
expression+="-";
}
else if (sign==2)
{
expression+="*";
}
else if (sign==3)
{
expression+="/";
}
expression+=printBinaryTree(resultRoot.getRightSon());
expression+=")";
return expression;
}
}
private String doubleToString(double value)
{
int intValue=(int)value;
if (value==intValue)
{
return String.valueOf(intValue);
}
else
{
return String.valueOf(value);
}
}
public BinaryTreeNode buildBinaryTreeNode(double value)
{
BinaryTreeNode node=new BinaryTreeNode();
node.setData(value);
return node;
}
public static void main(String[] args)
{
CardGame cardGame=new CardGame();
ArrayListBinaryTreeNode nodes=new ArrayListBinaryTreeNode();
nodes.add(cardGame.buildBinaryTreeNode(4));
nodes.add(cardGame.buildBinaryTreeNode(6));
nodes.add(cardGame.buildBinaryTreeNode(1));
nodes.add(cardGame.buildBinaryTreeNode(1));
cardGame.solute(nodes, 24);
cardGame.printResult();
}
}
用JAVA如何算出24点?
24点的源代码,因该可以计算出4则运算24 public class Test24Point{ public static void main(String[] args){ int index = 0 ; int temp = 0 ; int totalSUC = 0 ; int numb[] = new int[4];//the first four numbers double num[][] = new double[36][3];//three numbers after calculating double total[] = new double[6];//the number after three steps of calculating double p[][] = new double[6][8]; double q[][] = new double[3][7]; //System.out.println(2465%108); //System.out.println(2465/108); System.out.println("\"a--b\"means\"b-a\""); System.out.println("\"a//b\"means\"b/a\"\n"); /* for(int h = 0; h = 9; h ++)//Get the first four numbers for calculating and store into the array numb[4]; for(int i = 0; i = 9; i ++) for(int j = 0; j = 9; j ++) for(int k = 0; k = 9; k ++){ numb[0] = h ; numb[1] = i ; numb[2] = j ; numb[3] = k ; }*/ for(int i = 0 ; i 4 ; i ++){ numb = Integer.parseInt(args); } for(int i = 0; i 3; i ++)//Get two of the four to calculate and then store the new number into the array p; for(int j = i + 1; j 4 ; j ++,temp ++){ p[temp][0] = numb + numb[j]; p[temp][1] = numb - numb[j]; p[temp][2] = numb[j] - numb; p[temp][3] = numb * numb[j]; if(numb[j] != 0) p[temp][4] = numb / (double)numb[j]; else p[temp][4] = 10000; if(numb != 0) p[temp][5] = numb[j] / (double)numb; else p[temp][5] = 10000;
Java24点
粗略看了下，至少发现三个BUG:
1.没有考虑int类型相除时是否整除的问题，如3/4在你的算法中直接以零作为计算结果；
2.如果前两个或前三个数计算结果已经为24，则直接输出，没有等到四个全部参与计算；
3.类似n == 24.0这种浮点数的相等判断在绝大多数计算机语言中都是不正确的。
关于24点问题java和的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。