24点游戏的算法

/** 给定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) {   
  Core s = new Core();   
  s.setNumbers(new int[] { 3, 4, 8, 6 });   
  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 (n>0) {   
 // 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;   
  }   
 }   
  
}