findexpression.java

一个基于Java技术编写的24点游戏逼真图形版

//import javax.swing.JOptionPane;	//测试使用
import java.util.StringTokenizer;
/** 给定4个数字计算24 */
public class FindExpression {

	private double expressionResult=24;
	private int maxLine=10;
	private boolean error=true;
	private double numbers[]=new double[4];

/** 该对象拥有3个私有变量
		expressionResult,所需结果
		maxLine,输出结果每页行数
		error,是否出错
		numbers[4],记录用来运算的4个数

	其次,该对象拥有以下方法供外部调用
		setNumbers(double[] <运算的数>)
			输入用来运算的数,4个时才能计算,无返回
		setMaxLine(int <行数>)
			输入每页的行数,无返回
		getMaxLine()
			返回每页的行数,类型为int
		setExpressionResult(double <所需结果>)
			输入所需结果,无返回
		getExpressionResult()
			返回所需结果,类型为double
		getExpression()
			返回可得出所需结果的表达式,类型为字符串数组

	最后,私有方法均为计算与表达式转换部分	*/


	public FindExpression() {
	}

/** 测试使用 **
	public static void main(String[] args) {
		FindExpression s=new FindExpression();
		s.setNumbers(new int[]{2,4,6,8});
		String[] output=s.getExpression();
		for (int i=0; i<output.length; i++) {
			JOptionPane.showMessageDialog(null,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 getExpressionResult() {
		return expressionResult;
	}

/** 返回符合条件的表达式 */
	public String[] getExpression() {
		if (!error) {
			String[] expression=calculate(numbers);
			int n=0,max=(expression.length-1)/maxLine+1;
			String output[]=new String[max];
			for (int i=0; i<expression.length; i++) {
				if (i%maxLine==0) {
					output[n]="";
				}
				output[n]+=(expression[i]+"\n");
				if ((i+1)%maxLine==0 || i==expression.length-1) {
					output[n]+="                       第"+(++n)+"页 / 共"+max+"页";
				}
			}
			return output;
		} 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[100]	; //最多100组解,暂时未溢出
		int count=0;
		boolean isRepeat=false;
		String output="";
		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;
		}
	}

}