24点问题（java）

一、 题目内容
从扑克中每次取出4张牌。使用加减乘除，第一个能得出24者为赢。（其中，J代表11，Q代表12，K代表13，A代表1），按照要求编程解决24点游戏。
二、 题目分析

1. 求解用4张牌算出24的思路：
   在4张牌中用排列组合的方式抽出两张牌进行四则运算，将所得的结果看成一张新的牌，再和剩下两张牌放在一起组成3张牌的组合，再从三张牌中抽取两张进行四则运算又得到一张新牌，再与剩下的一张牌合在一起做四则运算判断结果是否为24。
2. 用随机函数生成4个1到13的随机整数放入数组。
3. 定义一个四则运算的方法，用两个整形和一个字符作为参数。返回值为两数进行四则运算后的结果。
4. 定义一个计算24点的方法。
5. 有解则输出表达式，无解则输出无解。
   三、 算法设计
   1.用随机数生成4个1到13的数放入数组。

int [] array= new int [4];    //定义长度为4的数组存放随机生成的初始牌面值
		Random r = new Random();
		for(i =0;i<4;i++) {
			array[i]=r.nextInt(12)+1;
		}
		for(i =0;i<4;i++) {
			System.out.print(array[i]+" ");
		}
		System.out.println("");

2.定义进行四则运算的方法，由于运算涉及到除法，可能会得到小数，因此将返回值类型和参数类型都设置成double型。在此之前先定义一个字符数组mark[]，分别存放+，-,*,/，在运算时用mark[]来确定运算符。

	static char [] mark= new char[]{'+','-','*','/'};
	
	public static double calculate(double a,double b,char mark) {
		if(mark=='+')
			return a+b;
		else if(mark=='-')
			return a-b;
		else if(mark=='*')
			return a*b;
		if(b!=0)
			return a/b;
		else
			return 0;
	}

3 求解24点的方法
定义一个长度为3和长度为2的double型数组。分别存放第一次运算和第二次运算后的结果。长度为4的数组在主方法中定义且已赋值，故不在此定义。同时定义一个布尔型变量judge，初值为false，用于判断是否有解。
4个数中选取两个数用排列方式共有6种组合，但不包括括号。如果把能凑成24点的表达式用带括号的形式表示，再去掉括号，就可以看成先把某两个相邻的数做运算。所以只对两个相邻的数做运算可以相当于括号的作用。而且只对相邻的数做运算只有三种情况。
在每一种情况下，把相邻数运算得到的结果放入长度为3的数组中的相应位置。如果第一次运算的是1,2个数，就把结果放入下一个数组的第一个位置。如果第一次计算的是第2,3个数，就把结果放入下一个数组的第2个位置，如果第一次计算的是第3,4个数，就把结果放入下个数组的第3个位置。再把剩下两个没参与运算的值放到剩下对应的位置。再进行第二次运算。放入结果的规则不变。如果运算的是1,2个数，就把结果放入下一个数组的第一个位置，如果运算的第2,3个数，就把结果放入下一个数组的第二个位置。m和n分别作为4选3和3选2的循环变量。

public static void solve(int array[]) {
		double  temp[]= new double [3];
		double tem[] = new double [2];   //第一个符号放置后，经过计算后相当于剩下三个数，这个数组用于存储这三个数  
		double  sum;  //求得的和  
		boolean judge = false;   //判断是否找到一个合理的解   
		for (int i = 0; i < 4; i++)  //第一次从4个数中抽取两个数运算的符号  
		{
			for (int j = 0; j < 4; j++)   //第二次从三个数中抽取两个数运算的符号   
			{
				for (int k = 0; k < 4; k++)    //第三次将剩下的数进行运算的符号    
				{
					for (int m = 0; m < 3; m++)      //首先计算的两个相邻数字，共有3种情况，相当于括号的作用     
					{
						if (array[m + 1] == 0 && mark[i] == '/') break;
						temp[m] = calculate(array[m], array[m + 1], mark[i]);
						temp[(m + 1) %3] = array[(m + 2) %4];
						temp[(m + 2) %3 ] = array[(m + 3) %4];      //先确定首先计算的两个数字，计算完成相当于剩下三个数，按顺序储存在temp数组中       
						for (int n = 0; n < 2; n++)       //三个数字选出先计算的两个相邻数字，两种情况，相当于第二个括号       
						{
							if (temp[n + 1] == 0 && mark[j] == '/') break;
							tem[n] = calculate(temp[n], temp[n + 1], mark[j]);
							tem[(n + 1) % 2] = temp[(n + 2) % 3];        //先确定首先计算的两个数字，计算完成相当于剩下两个数，按顺序储存在temp数组中        
							if (tem[1] == 0 && mark[k] == '/') break;
							sum = calculate(tem[0], tem[1], mark[k]);                     
							if (sum == 24)        //若和为24       
							{
								judge = true;         //判断符为true，表示已求得解          
								if (m == 0 && n == 0)
									System.out.println( "((" + array[0] +mark[i] +array[1] + ")" + mark[j]+ array[2] +")" +mark[k] + array[3] + "=24" );
								else if (m == 0 && n == 1)
									System.out.println( "(" + array[0] + mark[i] + array[1] + ")" + mark[k] + "(" + array[2] + mark[j] +array[3] + ")=24");
								else if (m == 1 && n == 0)
									System.out.println( "(" + array[0] + mark[j] + "(" + array[1] + mark[i] + array[2] + ")" + mark[k] +array[3] + ")=24" );
								else if (m == 1 && n == 1)
									System.out.println(array[0]+" " + mark[k] + "((" + array[1] + mark[i] + array[2] + ")" + mark[j] + array[3] + ")=24" );
								else if (m == 2 && n == 0)
									System.out.println("("+ array[0] + mark[j] + array[1] + ")" + mark[k] + "(" + array[2] + mark[i] + array[3] +")=24");
								else if (m == 2 && n == 0)
									System.out.println( array[0] + mark[k] + "(" +array[1] + mark[j] + "(" +array[2]+ mark[i] + array[3] + "))=24");          //m=0,1,2 n=0,1表示六种括号放置可能，并按照这六种可能输出相应的格式的计算式               
							}
						}
					}
				}
			}
		}
		if (judge == false)
			 System.out.print("无解");  //如果没有找到结果，符号位为false 
	
	}

四、 运行结果

五、 问题

1. 开始没想到如何把运算符作为函数的参数，然后让两个数进行运算，后来查到可以用字符数组的形式判断运算符并进行运算，然后就设计了一个calculate函数对两个数进行运算。
2. 最后求得的表达式有重复的，因为第一次运算1,2个数，第二次运算2,3个数的表达式和第一次运算3,4个数，第二次运算1,2个数的表达式是一样的。那么可以在输出表达式的时候去掉其中一种，只保留一种。
3. 对于运算优先级而言。应该是括号大于*/大于±。但是由于循环层数有点多，在输出表达式的时候用的是mark[i]的格式。所以无法准确该符号是加减还是乘除。所以统一用括号来表示运算优先级。换言之譬如一些不需要加括号的步骤也用了括号。