设计一个Android关于24点的小游戏之一（24点算法设计）

今天一位同事问24点怎么搞。所以考虑写个小Demo。

首先，得考虑算法。

以下，是我写的两个类。

一个是基础的两个数四则运算，一个是对指定值N的四个数运算判断。

由于我这个是遍历。故有许多待优化的地方。

 

package com.nq.point;

public class CalcBase {
	private double a, b;//定义做基本运算的两个值a,b

	public CalcBase(double n1, double n2) {
		this.a = n1;
		this.b = n2;
	}
	public double getAdd(){
		return a+b;
	}
	public double getSub(){
		return a-b;
	}
	public double getMul(){
		return a*b;
	}
	public double getDiv(){
		return a/b;
	}
	public double getSubO(){
		return b-a;
	}
	public double getDivO(){
		return b/a;
	}
}

 

 

package com.nq.point;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

public class ChargeN {
	private double N;// 定义目标数值
	List<String> str = new ArrayList<String>();// 定义接收所有结果的list

	public ChargeN(double n) {
		this.N = n;
	}

	// 无序的结果
	public int Charge(double a, double b, double c, double d) {
		double arr[] = { a, b, c, d };
		int TAG[] = { -1, -1, -1, -1 };
		int num = 0;
		for (int i = 0; i < 4; i++) {
			TAG[0] = i;
			for (int j = 0; j < 4; j++) {
				TAG[1] = j;
				if (TAG[0] == TAG[1])
					continue;
				for (int k = 0; k < 4; k++) {
					TAG[2] = k;
					if (TAG[2] == TAG[0] || TAG[2] == TAG[1])
						continue;
					for (int l = 0; l < 4; l++) {
						TAG[3] = l;
						if (TAG[3] == TAG[2] || TAG[3] == TAG[1]
								|| TAG[3] == TAG[0])
							continue;
						else {
							num += myCharge22(arr[i], arr[j], arr[k], arr[l])
									+ myCharge31(arr[i], arr[j], arr[k], arr[l]);
						}
					}
				}
			}
		}
		return num;
	}

	// 判断有序的四个数的两两运算结果
	public int myCharge22(double a, double b, double c, double d) {
		CalcBase calc1 = new CalcBase(a, b);
		CalcBase calc2 = new CalcBase(c, d);
		int n = 0;
		double arr1[] = { calc1.getAdd(), calc1.getSub(), calc1.getMul(),
				calc1.getDiv(), calc1.getSubO(), calc1.getDivO() }, arr2[] = {
				calc2.getAdd(), calc2.getSub(), calc2.getMul(), calc2.getDiv(),
				calc2.getSubO(), calc2.getDivO() };
		for (int i = 0; i < 6; i++) {
			for (int j = 0; j < 6; j++) {
				if ((new CalcBase(arr1[i], arr2[j]).getAdd()) == N) {
					str.add("(" + a + getStr(i) + b + ")" + "+" + "(" + c
							+ getStr(j) + d + ")");
					n++;
				}
				if ((new CalcBase(arr1[i], arr2[j]).getSub()) == N) {
					str.add("(" + a + getStr(i) + b + ")" + "-" + "(" + c
							+ getStr(j) + d + ")");
					n++;
				}
				if ((new CalcBase(arr1[i], arr2[j]).getMul()) == N) {
					str.add("(" + a + getStr(i) + b + ")" + "*" + "(" + c
							+ getStr(j) + d + ")");
					n++;
				}
				if ((new CalcBase(arr1[i], arr2[j]).getDiv()) == N) {
					str.add("(" + a + getStr(i) + b + ")" + "/" + "(" + c
							+ getStr(j) + d + ")");
					n++;
				}
				if ((new CalcBase(arr1[i], arr2[j]).getSubO()) == N) {
					str.add("("+a + getStr(i) + b +")" + "--" + c + getStr(j)
							+ d);
					n++;
				}
				if ((new CalcBase(arr1[i], arr2[j]).getDivO()) == N) {
					str.add("(" + a + getStr(i) + b + ")" + "//" + "(" + c
							+ getStr(j) + d + ")");
					n++;
				}
			}
		}
		return n;
	}

	// 判断有序的四个数的连续运算的结果
	public int myCharge31(double a, double b, double c, double d) {
		int num = 0;
		CalcBase c1 = new CalcBase(a, b);
		CalcBase arr[] = { new CalcBase(c1.getAdd(), c),
				new CalcBase(c1.getSub(), c), new CalcBase(c1.getMul(), c),
				new CalcBase(c1.getDiv(), c), new CalcBase(c1.getSubO(), c),
				new CalcBase(c1.getDivO(), c), };
		CalcBase arrAdd[] = { new CalcBase(arr[0].getAdd(), d),
				new CalcBase(arr[1].getAdd(), d),
				new CalcBase(arr[2].getAdd(), d),
				new CalcBase(arr[3].getAdd(), d),
				new CalcBase(arr[4].getAdd(),d ),
				new CalcBase(arr[5].getAdd(), c)};
		CalcBase arrSub[] = { new CalcBase(arr[0].getSub(), d),
				new CalcBase(arr[1].getSub(), d),
				new CalcBase(arr[2].getSub(), d),
				new CalcBase(arr[3].getSub(), d), 
				new CalcBase(arr[4].getSub(), d),
				new CalcBase(arr[5].getSub(), d)};
		CalcBase arrMul[] = { new CalcBase(arr[0].getMul(), d),
				new CalcBase(arr[1].getMul(), d),
				new CalcBase(arr[2].getMul(), d),
				new CalcBase(arr[3].getMul(), d),
				new CalcBase(arr[4].getMul(), d),
				new CalcBase(arr[5].getMul(), d)};
		CalcBase arrDiv[] = { new CalcBase(arr[0].getDiv(), d),
				new CalcBase(arr[1].getDiv(), d),
				new CalcBase(arr[2].getDiv(), d),
				new CalcBase(arr[3].getDiv(), d),
				new CalcBase(arr[4].getDiv(), d),
				new CalcBase(arr[5].getDiv(), d)};
		CalcBase arrSubO[]={
				new CalcBase(arr[0].getSubO(), d),
				new CalcBase(arr[1].getSubO(), d),
				new CalcBase(arr[2].getSubO(), d),
				new CalcBase(arr[3].getSubO(), d),
				new CalcBase(arr[4].getSubO(), d),
				new CalcBase(arr[5].getSubO(), d)
		};
		CalcBase arrDivO[]={
				new CalcBase(arr[0].getDivO(), d),
				new CalcBase(arr[1].getDivO(), d),
				new CalcBase(arr[2].getDivO(), d),
				new CalcBase(arr[3].getDivO(), d),
				new CalcBase(arr[4].getDivO(), d),
				new CalcBase(arr[5].getDivO(), d)
		};
		CalcBase[] arrToal[] = { arrAdd, arrSub, arrMul, arrDiv,arrSubO,arrDivO };
		for (int i = 0; i < 6; i++) {
			for (int j = 0; j < 6; j++) {
				if (arrToal[i][j].getAdd() == N) {
					str.add(a + getStr(j) + b + getStr(i) + c + "+" + d);
					num++;
				}

				if (arrToal[i][j].getSub() == N) {
					str.add(a + getStr(j) + b + getStr(i) + c + "-" + d);
					num++;
				}

				if (arrToal[i][j].getMul() == N) {
					str.add("(" + a + getStr(j) + b + getStr(i) + c + ")*" + d);
					num++;
				}

				if (arrToal[i][j].getDiv() == N) {
					str.add("(" + a + getStr(j) + b + getStr(i) + c + ")/" + d);
					num++;
				}
				if (arrToal[i][j].getSubO() == N) {
					str.add(a + getStr(j) + b + getStr(i) + c + "--" + d);
					num++;
				}
				if (arrToal[i][j].getDivO() == N) {
					str.add("(" + a + getStr(j) + b + getStr(i) + c + ")//" + d);
					num++;
				}
			}
		}
		return num;
	}

	// 当中两个数结合
	public int myCharge121() {
		int num = 0;
		return num;
	}

	// 判断运算符号
	public String getStr(int i) {
		String s = "";
		switch (i) {
		case 0:
			s = "+";
			break;
		case 1:
			s = "-";
			break;
		case 2:
			s = "*";
			break;
		case 3:
			s = "/";
			break;
		case 4:
			s = "--";
			break;
		case 5:
			s = "//";
			break;
		default:
			break;
		}
		return s;
	}

	// 剔除重复结果
	public List<String> getStr() {
		HashSet h = new HashSet(str);
		str.clear();
		str.addAll(h);
		return str;
	}
}

然后，在main函数里面测试一下，

package com.nq.point;
import java.util.List;
import java.util.Scanner;
public class Main {
 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  double a,b,c,d;
  do{
  System.out.println("请输入四个数字,\n注:a--b代表b-a,a//b代表b/a");
         Scanner scan=new Scanner(System.in);
         a=scan.nextDouble();
         b=scan.nextDouble();
         c=scan.nextDouble();
         d=scan.nextDouble();
         ChargeN chargeN=new ChargeN(24);
         chargeN.Charge(a, b, c, d);
         List<String> s=chargeN.getStr();
         int num=s.size();
         if(s.isEmpty()){
          System.out.println("这四个数无法经过四则运算得到24");
         }
         else{
          System.out.println("以下是所有能经过四则运算得到的"+num+"个结果：");
           for(String e:s){
          System.out.println(e);
         } 
         }
  }
  while(true);
 }
}