24點速算游戲 Java 代碼

import?java.util.ArrayList;?

創(chuàng)新互聯(lián)建站主營涇川網(wǎng)站建設(shè)的網(wǎng)絡(luò)公司,主營網(wǎng)站建設(shè)方案,重慶APP軟件開發(fā),涇川h5成都小程序開發(fā)搭建,涇川網(wǎng)站營銷推廣歡迎涇川等地區(qū)企業(yè)咨詢

import?java.util.Arrays;?

import?java.util.Collection;?

import?java.util.HashSet;?

import?java.util.List;?

import?java.util.Set;?

/**?

*?用給定的4個整數(shù)通過加減乘除運算得到24點，如果有多種情況，則全部輸出，如果不能得到24點，輸出提示br?

*?

*?@思路:將指定的4個數(shù)字進行全排列，將運算符‘+’、‘-’、‘*’、‘/’取3個進行所有情況排列，?

*?然后將所有的數(shù)字排列與所有的運算符排列按順序計算，?

*?如果最后計算結(jié)果等于想要的結(jié)果值比如24，則為符合條件的運算，?

*?將所有符合條件的數(shù)字排列和運算符排列存儲起來，并在最后打印輸出所有可能的情況?

*?

*?@author?chenjie?

*?

*/?

public?class?TwentyFourPoint?{?

public?static?void?main(String[]?args)?{?

try?{?

SetString?set?=?caculate(new?int[]?{?18,?18,?6,?12?},?24);?

printlnResultSet(set);?

}?catch?(Exception?e)?{?

//?e.printStackTrace();開發(fā)期間方便查找錯誤，測試通過后就無需打印錯誤信息了?

System.err.println(e.getMessage());?

}?

}?

/**?

*?打印結(jié)果集?

*?

*?@param?resultSet?

*?結(jié)果集?

*/?

private?static?void?printlnResultSet(CollectionString?resultSet)?{?

for?(String?str?:?resultSet)?{?

System.out.println(str);?

}?

}?

/**?

*?得到給定整形數(shù)組的全排列情況?

*?

*?@param?numbers?

*?給定的整形數(shù)組?

*?@return?全排列數(shù)組?

*/?

private?static?int[][]?arrangeAllNumbers(int[]?numbers)?{?

Listint[]?list?=?new?ArrayListint[]();?

allSort(numbers,?0,?numbers.length?-?1,?list);?

int[][]?resultSet?=?new?int[list.size()][list.get(0).length];?

resultSet?=?list.toArray(resultSet);?

return?resultSet;?

}?

/**?

*?得到給定的操作中出現(xiàn)的所有操作符排列情況?

*?

*?@param?operators?

*?出現(xiàn)的操作符數(shù)組?

*?@param?number?

*?每組操作符的數(shù)量?

*?@return?所有操作符排列數(shù)組?

*/?

private?static?char[][]?arrangeAllOperators(char[]?operators,?int?number)?{?

int?setSize?=?(int)?Math.pow(operators.length,?number);?

int?index?=?0;?

char[][]?resultSet?=?new?char[setSize][number];?

for?(int?i?=?0;?i??operators.length;?i++)?{?

for?(int?j?=?0;?j??operators.length;?j++)?{?

for?(int?k?=?0;?k??operators.length;?k++)?{?

resultSet[index][0]?=?operators[i];?

resultSet[index][1]?=?operators[j];?

resultSet[index][2]?=?operators[k];?

index++;?

}?

}?

}?

return?resultSet;?

}?

/**?

*?根據(jù)給定的一組整數(shù)，通過加減乘除運算，得到想要的結(jié)果，如果可以得到結(jié)果，則返回所有可能的結(jié)果的運算形式。?

*?返回的運算形式，均按從左到右的順序計算，并不是遵循四則運算法則，比如：br?

*?輸出的結(jié)果形式為：br?

*?1?*?8?-?6?*?12?=?24?br?

*?表示的運算順序是：br?

*?1:1?*?8?=?8,br?

*?2:8?-?6?=?2,br?

*?3:2?*?12?=?24br?

*?而不是按照四則運算法則計算：br?

*?1:1?*?8?=?8,br?

*?2:6?*?12?=?72,br?

*?3:8?*?72?=?576br?

*?

*?

*?@param?numbers?

*?給定進行運算的一組整數(shù)，4個數(shù)為一組?

*?@param?targetNumber?

*?想要得到的結(jié)果?

*?@return?所有可能得到想要的結(jié)果的所有運算形式的字符串形式集合?

*?@throws?Exception?

*?如果不能得到想要的結(jié)果，則拋出該異常，表明根據(jù)指定的一組數(shù)字通過一系列的加減乘除不能得到想要的結(jié)果?

*/?

public?static?SetString?caculate(int[]?numbers,?int?targetNumber)?

throws?Exception?{?

SetString?resultSet?=?new?HashSetString();//?這里用Set而不是用List，主要是因為當(dāng)給定的一組數(shù)字中如果有重復(fù)數(shù)字的話，同一結(jié)果會被出現(xiàn)多次，如果用List存放的話，會將重復(fù)的結(jié)果都存放起來，而Set會自動消除重復(fù)值?

char[][]?operatorsArrangement?=?arrangeAllOperators(new?char[]?{?'+',?

'-',?'*',?'/'?},?3);?

int[][]?numbersArrangement?=?arrangeAllNumbers(numbers);?

for?(int[]?nums?:?numbersArrangement)?

for?(char[]?operators?:?operatorsArrangement)?{?

int?result?=?0;?

try?{?

result?=?caculate(nums,?operators);?

}?catch?(Exception?e)?{//?出現(xiàn)非精確計算?

continue;?

}?

if?(result?==?targetNumber)?

resultSet.add(buildString(nums,?operators,?targetNumber));//?如果計算后的結(jié)果等于想要的結(jié)果，就存放到集合中?

}?

if?(resultSet.isEmpty())?

throw?new?Exception("給定的數(shù)字："?+?Arrays.toString(numbers)?

+?"不能通過加減乘除運算得到結(jié)果："?+?targetNumber);?

return?resultSet;?

}?

/**?

*?將一組整型數(shù)字以給定的操作符按順序拼接為一個完整的表達式字符串?

*?

*?@param?nums?

*?一組整型數(shù)字?

*?@param?operators?

*?一組操作符?

*?@param?target?

*?目標(biāo)值?

*?@return?拼接好的表達式字符串?

*/?

private?static?String?buildString(int[]?nums,?char[]?operators,?int?target)?{?

String?str?=?String.valueOf(nums[0]);?

for?(int?i?=?0;?i??operators.length;?i++)?{?

str?=?str?+?'?'?+?operators[i]?+?'?'?+?nums[i?+?1];?

}?

str?=?str?+?"?=?"?+?target;?

return?str;?

}?

/**?

*?將給定的一組數(shù)字以給定的操作符按順序進行運算，如：int?result?=?caculate(new?int[]{3,4,5,8},?new?

*?char[]{'+','-','*'});?

*?

*?@param?nums?

*?一組數(shù)字?

*?@param?operators?

*?一組運算符，數(shù)量為數(shù)字的個數(shù)減1?

*?@return?最后的計算結(jié)果?

*?@throws?Exception?

*?當(dāng)計算結(jié)果不精確時，拋出該異常，主要是針對除法運算，例如18?/?8?=?2，諸如這樣不精確計算將拋出該異常?

*/?

private?static?int?caculate(int[]?nums,?char[]?operators)?throws?Exception?{?

int?result?=?0;?

for?(int?i?=?0;?i??operators.length;?i++)?{?

if?(i?==?0)?{?

result?=?caculate(nums[i],?nums[i?+?1],?operators[i]);?

}?else?{?

result?=?caculate(result,?nums[i?+?1],?operators[i]);?

}?

}?

return?result;?

}?

/**?

*?根據(jù)指定操作符將兩個給定的數(shù)字進行計算?

*?

*?@param?num1?

*?數(shù)字1?

*?@param?num2?

*?數(shù)字2?

*?@param?operator?

*?操作符，只能從“+、-、*、/”4個操作符中取值?

*?@return?計算結(jié)果?

*?@throws?Exception?

*?當(dāng)計算結(jié)果不精確時，拋出該異常，主要是針對除法運算，例如18?/?8?=?2，諸如這樣不精確計算將拋出該異常?

*/?

private?static?int?caculate(int?num1,?int?num2,?char?operator)?

throws?Exception?{?

double?result?=?0;?

switch?(operator)?{//?根據(jù)操作符做相應(yīng)的計算操作?

case?'+':?

result?=?num1?+?num2;?

break;?

case?'-':?

result?=?num1?-?num2;?

break;?

case?'*':?

result?=?num1?*?num2;?

break;?

case?'/':?

result?=?(double)?num1?/?(double)?num2;?

break;?

}?

if?(!check(result))?

throw?new?Exception("不精確的計算數(shù)字");?

return?(int)?result;?

}?

/**?

*?檢查指定的浮點數(shù)是否可以直接轉(zhuǎn)換為整型數(shù)字而不損失精度?

*?

*?@param?result?

*?要檢查的浮點數(shù)?

*?@return?如果可以進行無損轉(zhuǎn)換，返回true，否則返回false?

*/?

private?static?boolean?check(double?result)?{?

String?str?=?String.valueOf(result);?

int?pointIndex?=?str.indexOf(".");//?小數(shù)點的下標(biāo)值?

String?fraction?=?str.substring(pointIndex?+?1);?

return?fraction.equals("0")???true?:?false;//?通過判斷小數(shù)點后是否只有一個0來確定是否可以無損轉(zhuǎn)換為整型數(shù)值?

}?

/**?

*?對傳入的整型數(shù)組buf進行全排列?

*?

*?@param?buf?

*?要進行全排列的整型數(shù)組?

*?@param?start?

*?開始的下標(biāo)值?

*?@param?end?

*?結(jié)束下標(biāo)值?

*?@param?list?

*?保存最后全排列結(jié)果的集合?

*/?

private?static?void?allSort(int[]?buf,?int?start,?int?end,?Listint[]?list)?{?

if?(start?==?end)?{//?當(dāng)只要求對數(shù)組中一個字母進行全排列時，只要就按該數(shù)組輸出即可?

int[]?a?=?new?int[buf.length];?

System.arraycopy(buf,?0,?a,?0,?a.length);?

list.add(a);?

}?else?{//?多個字母全排列?

for?(int?i?=?start;?i?=?end;?i++)?{?

int?temp?=?buf;//?交換數(shù)組第一個元素與后續(xù)的元素?

buf?=?buf[i];?

buf[i]?=?temp;?

allSort(buf,?start?+?1,?end,?list);//?后續(xù)元素遞歸全排列?

temp?=?buf;//?將交換后的數(shù)組還原?

buf?=?buf[i];?

buf[i]?=?temp;?

}?

}?

}?

}?

用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;

算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();

}

}