关于算24点代码java的信息
Java算24点
public class ershidian {
成都创新互联-专业网站定制、快速模板网站建设、高性价比商都网站开发、企业建站全套包干低至880元,成熟完善的模板库,直接使用。一站式商都网站制作公司更省心,省钱,快速模板网站建设找我们，业务覆盖商都地区。费用合理售后完善，十年实体公司更值得信赖。
// int h=0;
// public void aaa(int a[],int c)
// {
// int i=0;
// if(c==0){
// h+= a[i]+a[i+1];
// }else if(c==1){
// h+= a[i]-a[i+1];
// }else if(c==2){
// h+= a[i]*a[i+1];
// }else{
// h+= a[i]/a[i+1];
// }
// i++;
// System.out.println(h);
// }
public void kaka(int a[]){
int hi[]=new int[4];
int hj[]=new int[16];
int hf[]=new int[64];
// int hm[]=new int[4];
// int hm2[]=new int[4];
// int hv[]=new int [16];
int z=0;
int n=0;
// int p=0;
for(int i=0;i4;i++){
if(i==0){
hi[i]=a[0]+a[1];
}else if(i==1){
hi[i]=a[0]-a[1];
}else if(i==2){
hi[i]=a[0]*a[1];
}else if(i==3){
hi[i]=a[0]/a[1];
}
}
for(int j=0;j4;j++){
for(int g=0;g4;g++){
if(g==0){
hj[z]=hi[j]+a[2];
}else if(g==1){
hj[z]=hi[j]-a[2];
}else if(g==2){
hj[z]=hi[j]*a[2];
}else if(g==3){
hj[z]=hi[j]/a[2];
}
z++;
}
}
for(int f=0;f16;f++){
for(int r=0;r4;r++){
if(r==0){
hf[n]=hj[f]+a[3];
}else if(r==1){
hf[n]=hj[f]-a[3];
}else if(r==2){
hf[n]=hj[f]*a[3];
}else if(r==3){
hf[n]=hj[f]/a[3];
}
n++;
}
}
// for(int m=0;m4;m++){
// if(m==0){
// hm[m]=a[0]+a[1];
// hm2[m]=a[2]+a[3];
// }else if(m==1){
// hm[m]=a[0]-a[1];
// hm2[m]=a[2]-a[3];
// }else if(m==2){
// hm[m]=a[0]*a[1];
// hm2[m]=a[2]*a[3];
// }else if(m==3){
// hm[m]=a[0]/a[1];
// hm2[m]=a[2]/a[3];
// }
//
// }
// for(int v=0;v4;v++){
// for(int l=0;l4;l++){
// if(l==0){
// hv[p]=hm[v]+hm2[v];
// }else if(l==1){
// hv[p]=hm[v]-hm2[v];
// }else if(l==2){
// hv[p]=hm[v]*hm2[v];
// }else if(l==3){
// hv[p]=hm[v]/hm2[v];
// }
// System.out.println(hv[p]);
// p++;
//
// }
//
// }
for(int k=0;khf.length;k++){
if(hf[k]==24){
System.out.println(hf[k]);
}
}
}
public static void main(String args[]){
int aa[]={2,5,9,9};
ershidian y=new ershidian();
y.kaka(aa);
}
}
这只能算部分的，全部的还做不出
java算24点代码：输入4个数算24点，能够在命令提示符下就可以运行。100多
import java.util.Scanner;
/** 给定4个数字计算24 */
public class Core {
private double expressionResult = 24;
// private int maxLine=10;
private boolean error = true;
private double numbers[] = new double[4];
public Object resultReturn;
/**
* 该对象拥有3个私有变量 expressionResult,所需结果 maxLine,输出结果每页行数 error,是否出错
* numbers[4],记录用来运算的4个数
*
* 其次,该对象拥有以下方法供外部调用 setNumbers(double[] 运算的数) 输入用来运算的数,4个时才能计算,无返回
* setMaxLine(int 行数) 输入每页的行数,无返回 getMaxLine() 返回每页的行数,类型为int
* setExpressionResult(double 所需结果) 输入所需结果,无返回 getExpressionResult()
* 返回所需结果,类型为double getExpression() 返回可得出所需结果的表达式,类型为字符串数组
*
* 最后,私有方法均为计算与表达式转换部分
*/
// 测试使用
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int[] arr = new int[4];
System.out.print("输入第一个数：");
arr[0] = scanner.nextInt();
System.out.print("输入第二个数：");
arr[1] = scanner.nextInt();
System.out.print("输入第三个数：");
arr[2] = scanner.nextInt();
System.out.print("输入第四个数：");
arr[3] = scanner.nextInt();
Core s = new Core();
s.setNumbers(arr);
String[] output = s.getExpression();
for (int i = 0; i output.length; i++) {
System.out.println(output[i]);
}
}
/** 设定被计算的四个数，由于是数组，所以具有容错功能(不为4个数) */
public void setNumbers(double[] n) {
if (n.length == 4) {
error = false;
numbers = n;
} else
error = true;
}
public void setNumbers(int[] n) {
if (n.length == 4) {
error = false;
for (int i = 0; i 4; i++) {
numbers[i] = n[i];
}
} else
error = true;
}
/** 设定每页显示的行数 */
// public void setMaxLine(int n) {
// if (n0) {
// maxLine=n;
// }
// }
// /** 返回每页显示的行数 */
// public int getMaxLine() {
// return maxLine;
// }
/** 设定需要得到的结果 */
public void setExpressionResult(double n) {
expressionResult = n;
}
/** 返回所需结果 */
public double expressionResult() {
return expressionResult;
}
/** 返回符合条件的表达式 */
public String[] getExpression() {
if (!error) {
String[] expression = calculate(numbers);
return expression;
} else
return new String[] { "出错了,输入有误" };
}
/** cal24()，输出结果为24的表达式 */
private String[] calculate(double[] n) {
if (n.length != 4)
return new String[] { "Error" };
double[] n1 = new double[3];
double[] n2 = new double[2];
String[] resultString = new String[1024]; // 最多1000组解,暂时未溢出
int count = 0;
boolean isRepeat = false;
for (int t1 = 0; t1 6; t1++) {
for (int c1 = 0; c1 6; c1++) {
for (int t2 = 0; t2 3; t2++) {
for (int c2 = 0; c2 6; c2++) {
for (int c3 = 0; c3 6; c3++) {
if ((c1 / 3 == c2 / 3 (c1 % 3) * (c2 % 3) != 0)
|| (c2 / 3 == c3 / 3 (c2 % 3) * (c3 % 3) != 0)
|| (c1 / 3 == c3 / 3
(c1 % 3) * (c3 % 3) != 0 t2 == 2)) {
// 去除连减连除的解,因为x/(y/z)=x*z/y
continue;
}
n1 = cal1(n, t1, c1);
n2 = cal2(n1, t2, c2);
double result = cal(n2[0], n2[1], c3);
if ((result - expressionResult) 0.00000001
(expressionResult - result) 0.00000001) {
resultString[count] = calString(n, t1, c1, t2,
c2, c3)
+ "=" + (int) expressionResult;
for (int i = 0; i count; i++) {
isRepeat = false;
if (resultString[i]
.equals(resultString[count])) { // 去除完全重复的解
isRepeat = true;
break; // 提前退出循环
}
}
if (c1 == c2 c2 == c3 c1 % 3 == 0
t1 + t2 != 0) { // 连加连乘
isRepeat = true;
}
if (!isRepeat) {
count++;
}
}
}
}
}
}
}
if (count == 0)
return new String[] { "该组数无解" };
String[] resultReturn = new String[count];
System.arraycopy(resultString, 0, resultReturn, 0, count);
return resultReturn;
}
/** cal1()，将4个数计算一次后返回3个数 */
private double[] cal1(double[] n, int t, int c) { // t为原来的t1，c为原来的c1
double[] m = new double[3];
switch (t) {
case 0:
m[1] = n[2];
m[2] = n[3];
m[0] = cal(n[0], n[1], c);
break;
case 1:
m[1] = n[1];
m[2] = n[3];
m[0] = cal(n[0], n[2], c);
break;
case 2:
m[1] = n[1];
m[2] = n[2];
m[0] = cal(n[0], n[3], c);
break;
case 3:
m[1] = n[0];
m[2] = n[3];
m[0] = cal(n[1], n[2], c);
break;
case 4:
m[1] = n[0];
m[2] = n[2];
m[0] = cal(n[1], n[3], c);
break;
default:
m[1] = n[0];
m[2] = n[1];
m[0] = cal(n[2], n[3], c);
}
return m;
}
/** cal2()，将3个数计算一次后返回2个数 */
private double[] cal2(double[] n, int t, int c) { // t为原来的t2，c为原来的c2
double[] m = new double[2];
switch (t) {
case 0:
m[1] = n[2];
m[0] = cal(n[0], n[1], c);
break;
case 1:
m[1] = n[1];
m[0] = cal(n[0], n[2], c);
break;
default:
m[1] = n[0];
m[0] = cal(n[1], n[2], c);
}
return m;
}
/** cal()，将2个数计算后返回结果 */
private double cal(double n1, double n2, int c) { // n1,n2为运算数，c为运算类型
switch (c) {
case 0:
return n1 + n2;
case 1:
return n1 - n2;
case 2:
return n2 - n1;
case 3:
return n1 * n2;
case 4:
if (n2 == 0)
return 9999; // 使计算结果必不为24
else
return n1 / n2;
default:
if (n1 == 0)
return 9999; // 同上
else
return n2 / n1;
}
}
/** calString()，输出表达式 */
private String calString(double[] n, int t1, int c1, int t2, int c2, int c3) {
String[] nString = new String[4];
switch (t1) {
case 0:
nString[0] = calString2("" + (int) n[0], "" + (int) n[1], c1);
nString[1] = "" + (int) n[2];
nString[2] = "" + (int) n[3];
break;
case 1:
nString[0] = calString2("" + (int) n[0], "" + (int) n[2], c1);
nString[1] = "" + (int) n[1];
nString[2] = "" + (int) n[3];
break;
case 2:
nString[0] = calString2("" + (int) n[0], "" + (int) n[3], c1);
nString[1] = "" + (int) n[1];
nString[2] = "" + (int) n[2];
break;
case 3:
nString[0] = calString2("" + (int) n[1], "" + (int) n[2], c1);
nString[1] = "" + (int) n[0];
nString[2] = "" + (int) n[3];
break;
case 4:
nString[0] = calString2("" + (int) n[1], "" + (int) n[3], c1);
nString[1] = "" + (int) n[0];
nString[2] = "" + (int) n[2];
break;
default:
nString[0] = calString2("" + (int) n[2], "" + (int) n[3], c1);
nString[1] = "" + (int) n[0];
nString[2] = "" + (int) n[1];
}
if ((c2 / 3 c1 / 3 (t2 != 2 || c2 / 3 == c3 / 3))
|| ((c3 / 3 c1 / 3 + c2 / 3) t2 == 2)
|| (c3 == 1 c1 / 3 == 0)) // 特定情况下加上一个括号*****************************
nString[0] = '(' + nString[0] + ')';
switch (t2) {
case 0:
nString[0] = calString2(nString[0], "" + nString[1], c2);
nString[1] = nString[2];
break;
case 1:
nString[0] = calString2(nString[0], nString[2], c2);
break;
default:
nString[3] = nString[0];
nString[0] = calString2(nString[1], nString[2], c2);
nString[1] = nString[3];
}
if (c3 / 3 c2 / 3 || (c3 == 2 nString[0].indexOf('+') = 0)) // 特定情况下加上一个括号*****************************
nString[0] = '(' + nString[0] + ')';
return calString2(nString[0], nString[1], c3);
}
/** calString()，根据符号输出一部运算表达式 */
private String calString2(String n1, String n2, int c) {
switch (c) {
case 0:
return n1 + '+' + n2;
case 1:
return n1 + '-' + n2;
case 2:
return n2 + '-' + n1;
case 3:
return n1 + '*' + n2;
case 4:
return n1 + '/' + n2;
default:
return n2 + '/' + n1;
}
}
}
24点速算游戏 Java 代码
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/**
* 用给定的4个整数通过加减乘除运算得到24点，如果有多种情况，则全部输出，如果不能得到24点，输出提示br
*
* @思路:将指定的4个数字进行全排列，将运算符‘+’、‘-’、‘*’、‘/’取3个进行所有情况排列，
* 然后将所有的数字排列与所有的运算符排列按顺序计算，
* 如果最后计算结果等于想要的结果值比如24，则为符合条件的运算，
* 将所有符合条件的数字排列和运算符排列存储起来，并在最后打印输出所有可能的情况
*
* @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();开发期间方便查找错误，测试通过后就无需打印错误信息了
System.err.println(e.getMessage());
}
}
/**
* 打印结果集
*
* @param resultSet
* 结果集
*/
private static void printlnResultSet(CollectionString resultSet) {
for (String str : resultSet) {
System.out.println(str);
}
}
/**
* 得到给定整形数组的全排列情况
*
* @param numbers
* 给定的整形数组
* @return 全排列数组
*/
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;
}
/**
* 得到给定的操作中出现的所有操作符排列情况
*
* @param operators
* 出现的操作符数组
* @param number
* 每组操作符的数量
* @return 所有操作符排列数组
*/
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;
}
/**
* 根据给定的一组整数，通过加减乘除运算，得到想要的结果，如果可以得到结果，则返回所有可能的结果的运算形式。
* 返回的运算形式，均按从左到右的顺序计算，并不是遵循四则运算法则，比如：br
* 输出的结果形式为：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
* 给定进行运算的一组整数，4个数为一组
* @param targetNumber
* 想要得到的结果
* @return 所有可能得到想要的结果的所有运算形式的字符串形式集合
* @throws Exception
* 如果不能得到想要的结果，则抛出该异常，表明根据指定的一组数字通过一系列的加减乘除不能得到想要的结果
*/
public static SetString caculate(int[] numbers, int targetNumber)
throws Exception {
SetString resultSet = new HashSetString();// 这里用Set而不是用List，主要是因为当给定的一组数字中如果有重复数字的话，同一结果会被出现多次，如果用List存放的话，会将重复的结果都存放起来，而Set会自动消除重复值
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) {// 出现非精确计算
continue;
}
if (result == targetNumber)
resultSet.add(buildString(nums, operators, targetNumber));// 如果计算后的结果等于想要的结果，就存放到集合中
}
if (resultSet.isEmpty())
throw new Exception("给定的数字：" + Arrays.toString(numbers)
+ "不能通过加减乘除运算得到结果：" + targetNumber);
return resultSet;
}
/**
* 将一组整型数字以给定的操作符按顺序拼接为一个完整的表达式字符串
*
* @param nums
* 一组整型数字
* @param operators
* 一组操作符
* @param target
* 目标值
* @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;
}
/**
* 将给定的一组数字以给定的操作符按顺序进行运算，如：int result = caculate(new int[]{3,4,5,8}, new
* char[]{'+','-','*'});
*
* @param nums
* 一组数字
* @param operators
* 一组运算符，数量为数字的个数减1
* @return 最后的计算结果
* @throws Exception
* 当计算结果不精确时，抛出该异常，主要是针对除法运算，例如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;
}
/**
* 根据指定操作符将两个给定的数字进行计算
*
* @param num1
* 数字1
* @param num2
* 数字2
* @param operator
* 操作符，只能从“+、-、*、/”4个操作符中取值
* @return 计算结果
* @throws Exception
* 当计算结果不精确时，抛出该异常，主要是针对除法运算，例如18 / 8 = 2，诸如这样不精确计算将抛出该异常
*/
private static int caculate(int num1, int num2, char operator)
throws Exception {
double result = 0;
switch (operator) {// 根据操作符做相应的计算操作
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("不精确的计算数字");
return (int) result;
}
/**
* 检查指定的浮点数是否可以直接转换为整型数字而不损失精度
*
* @param result
* 要检查的浮点数
* @return 如果可以进行无损转换，返回true，否则返回false
*/
private static boolean check(double result) {
String str = String.valueOf(result);
int pointIndex = str.indexOf(".");// 小数点的下标值
String fraction = str.substring(pointIndex + 1);
return fraction.equals("0") ? true : false;// 通过判断小数点后是否只有一个0来确定是否可以无损转换为整型数值
}
/**
* 对传入的整型数组buf进行全排列
*
* @param buf
* 要进行全排列的整型数组
* @param start
* 开始的下标值
* @param end
* 结束下标值
* @param list
* 保存最后全排列结果的集合
*/
private static void allSort(int[] buf, int start, int end, Listint[] list) {
if (start == end) {// 当只要求对数组中一个字母进行全排列时，只要就按该数组输出即可
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;// 交换数组第一个元素与后续的元素
buf = buf[i];
buf[i] = temp;
allSort(buf, start + 1, end, list);// 后续元素递归全排列
temp = buf;// 将交换后的数组还原
buf = buf[i];
buf[i] = temp;
}
}
}
}
算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;
本文名称：关于算24点代码java的信息
新闻来源：http://ybzwz.com/article/hhhopg.html
