point24.java

24点 啊啊 啊啊 啊啊 并不比 不必

				}
				if(type[b]!=3)
				{
					if(isop(tempout[b][5]))
					{
						b1=tempout[b][0];
						if(isop(tempout[b][4]))
							b2=tempout[b][1];
						else b2=tempout[b][4];
					}
					else 
					{
						b1=tempout[b][5];
						if(isop(tempout[b][3]))
							b2=tempout[b][0];
						else b2=tempout[b][3];
					}
				}
				else
				{
					if(tempout[b][2]==tempout[b][6])
					{
						b1=tempout[b][0];
						b2=tempout[b][1];
					}
					else
					{
						b1=tempout[b][3];
						b2=tempout[b][4];
					}
				}
				if(a1==b1&&a2==b2||a1==b2&&a2==b1)
					return true;
				else return false;
			}
		}
		if(type[a]==3&&type[b]==3&&tempout[a][6]==tempout[b][6])
		{
			for(int j=0;j<3;j++)
			{
				one[j]=tempout[a][j];
				two[j]=tempout[b][j];
			}
				if(partsame(one,two))
				{
					for(int j=0;j<3;j++)
					{
						one[j]=tempout[a][j+3];
						two[j]=tempout[b][j+3];
					}
					if(partsame(one,two))
						return true;
				}
			if(tempout[a][6]=='+'||tempout[a][6]=='*')
			{
				for(int j=0;j<3;j++)
				{
					one[j]=tempout[a][j];
					two[j]=tempout[b][j+3];
				}
				if(partsame(one,two))
				{
					for(int j=0;j<3;j++)
					{
						one[j]=tempout[a][j+3];
						two[j]=tempout[b][j];
					}
					if(partsame(one,two))
						return true;
				}
			}
			return false;
		}
		else if(type[a]!=3&&type[b]!=3)
		{
			if(!isop(tempout[a][5])&&!isop(tempout[b][5]))
			{
				for(int j=0;j<5;j++)
				{
					one[j]=tempout[a][j];
					two[j]=tempout[b][j];
				}
				if(tempout[a][5]==tempout[b][5]&&partsame(one,two))
					return true;
			}
			if(isop(tempout[a][5])&&isop(tempout[b][5]))
			{
				for(int j=0;j<5;j++)
				{
					one[j]=tempout[a][j+1];
					two[j]=tempout[b][j+1];
				}
				if(tempout[a][0]==tempout[b][0]&&partsame(one,two))
					return true;
			}
			if(tempout[a][6]=='+'||tempout[a][6]=='*')
			{
				if(!isop(tempout[a][5])&&isop(tempout[b][5]))
				{
					for(int j=0;j<5;j++)
					{
						one[j]=tempout[a][j];
						two[j]=tempout[b][j+1];
					}
					if(tempout[a][5]==tempout[b][0]&&partsame(one,two))
						return true;
				}
				else if(isop(tempout[a][5])&&!isop(tempout[b][5]))
				{
					for(int j=0;j<5;j++)
					{
						one[j]=tempout[a][j+1];
						two[j]=tempout[b][j];
					}
					if(tempout[a][0]==tempout[b][5]&&partsame(one,two))
						return true;
				}
			}
			return false;
		}
		else return false;

	}	//判断两个字符串是否相同
	public void makeonly(int lenth)
	{
		int count=1;
		outmark[0]=true;
		for(;count<lenth;count++)
		{
			for(int i=0;i<count;i++)
			{
				if(outmark[i]==true)
				{
					if(issame(i,count))
						{
							outmark[count]=false;
							break;
						}
					else
						outmark[count]=true;
				}
			}
		} 
	}					//除去相同的字符串
	public void compute24()
	{
		quanpailie();
		int count=0;
		while(count<24&&!already[count])
		{
		for(int i=0;i<4;i++)
			number[i]=allnum[count][i];
			
		count++;		
		type1();
		type2();
		type3();
		type4();
		type5();		
		}
		
		howlong=show();
		count=0;
		while(count<howlong)
		{
			postfix(out[count]);
			for(int j=0;j<11;j++)
				tempout[count][j]=houzhui[j];
			count++;			
		}
		count=0;
		makesmall(howlong);
		makegood(howlong);
		makeonly(howlong);	
		
	}							//计算24点的主程序
	public double compute(double one,double two,int type)
	{
		if(type==1)
		return one+two;
		else if(type==2)
		return one-two;
		else if(type==3)
		return one*two;
		else
		{
			if(two==0)
			return 9999;
			else
			return one/two;
		}
	}//计算两个字符的四则运算
	public void savetype1(char one,char two,char three)
	{
		out[index]=new char[]{'(','(',(char)(number[0]+48),one,(char)(number[1]+48),')',two,(char)(number[2]+48),')',three,(char)(number[3]+48)};
		type[index]=1;
		//((a+b)+c)+d
	}//存储第一种形式的表达式
	public void savetype2(char one,char two,char three)
	{
		out[index]=new char[]{'(',(char)(number[0]+48),one,'(',(char)(number[1]+48),two,(char)(number[2]+48),')',')',three,(char)(number[3]+48)};
		type[index]=2;
		//(a+(b+c))+d
	}//存储第二种形式的表达式
	public void savetype3(char one,char two,char three)
	{
		out[index]=new char[]{'(',(char)(number[0]+48),one,(char)(number[1]+48),')',two,'(',(char)(number[2]+48),three,(char)(number[3]+48),')'};
		type[index]=3;
		//(a+b)+(c+d)
	}//存储第三种形式的表达式
	public void savetype4(char one,char two,char three)
	{
		out[index]=new char[]{(char)(number[0]+48),one,'(','(',(char)(number[1]+48),two,(char)(number[2]+48),')',three,(char)(number[3]+48),')'};
		type[index]=4;
		//a+((b+c)+d)
	}//存储第四种形式的表达式
	public void savetype5(char one,char two,char three)
	{
		out[index]=new char[]{(char)(number[0]+48),one,'(',(char)(number[1]+48),two,'(',(char)(number[2]+48),three,(char)(number[3]+48),')',')'};
		type[index]=5;
		//a+(b+(c+d))
	}//存储第五种形式的表达式
	public void type1()					//(a+(b+c))+d
	{
		for(int i=1;i<5;i++)
		{
			for(int j=1;j<5;j++)
			{
				for(int k=1;k<5;k++)
				{
					double temp=compute(compute(compute(number[0],number[1],k),number[2],j),number[3],i);
					if(temp>23.9&&temp<24.1)
					{
						savetype1(four[k-1],four[j-1],four[i-1]);
						index++;
					}
					
				}
			}
		}
		
	}
	public void type2()					//(a+(b+c))+d
	{
		for(int i=1;i<5;i++)
		{
			for(int j=1;j<5;j++)
			{
				for(int k=1;k<5;k++)
				{
					double temp=compute(compute(number[0],compute(number[1],number[2],k),j),number[3],i);
					if(temp>23.9&&temp<24.1)
					{
						savetype2(four[j-1],four[k-1],four[i-1]);
						index++;
					}
					
				}
			}
		}
		
	}
	public void type3()					//(a+b)+(c+d)
	{
		for(int i=1;i<5;i++)
		{
			for(int j=1;j<5;j++)
			{
				for(int k=1;k<5;k++)
				{
					double temp=compute(compute(number[0],number[1],j),compute(number[2],number[3],k),i);
					if(temp>23.9&&temp<24.1)
					{
						savetype3(four[j-1],four[i-1],four[k-1]);
						index++;
					}
					
				}
			}
		}
		
	}
	public void type4()					//a+((b+c)+d)
	{
		for(int i=1;i<5;i++)
		{
			for(int j=1;j<5;j++)
			{
				for(int k=1;k<5;k++)
				{
					double temp=compute(number[0],compute(compute(number[1],number[2],k),number[3],j),i);
					if(temp>23.9&&temp<24.1)
					{
						savetype4(four[i-1],four[k-1],four[j-1]);
						index++;
					}
					
				}
			}
		}
		
	}
	public void type5()					//a+(b+(c+d))
	{
		for(int i=1;i<5;i++)
		{
			for(int j=1;j<5;j++)
			{
				for(int k=1;k<5;k++)
				{
					double temp=compute(number[0],compute(number[1],compute(number[2],number[3],k),j),i);
					if(temp>23.9&&temp<24.1)
					{
						savetype5(four[i-1],four[j-1],four[k-1]);
						index++;
					}
					
				}
			}
		}
		
	}
	public boolean isdigit(char a)
	{
		if(a>48&&a<58)
		return true;
		else
		return false;
	}					//判断一个字符是否是数字
	public int isp(char temp)
	{
		switch(temp)
		{
			case '#':return 0;
			case '(':return 1;
			case '*':return 5;
			case '/':return 5;
			case '+':return 3;
			case '-':return 3;
			case ')':return 8;
			default:return 100;
		}
	}							//栈内优先级
	public int icp(char temp)
	{
		switch(temp)
		{
			case '#':return 0;
			case '(':return 8;
			case '*':return 4;
			case '/':return 4;
			case '+':return 2;
			case '-':return 2;
			case ')':return 1;
			default:return 100;
		}
	}							//栈外优先级
	public void postfix(char [] a)
	{
		int spoint=0;
		int hpoint=0;
		Stack s=new Stack();
		char y;
		s.clear();
		s.push('#');
		while(spoint<11)
		{
			if(isdigit(a[spoint]))
				houzhui[hpoint++]=a[spoint];
			else if(a[spoint]==')')
				for(y=s.pop();y!='(';y=s.pop())
					houzhui[hpoint++]=y;
			else
			{
				for(y=s.pop();isp(y)>icp(a[spoint]);y=s.pop())
					houzhui[hpoint++]=y;
				s.push(y);
				s.push(a[spoint]);
			}
			spoint++;
		}
		while(!s.IsEmpty())
		{
			y=s.pop();
			houzhui[hpoint++]=y;
		}
	}					//中缀表达式变后缀
	public int show()
	{
		int tempindex=0;
		while(out[tempindex][0]>'\0')
		{		
//		for(int i=0;i<11;i++)
//		System.out.print(out[tempindex][i]);
//		System.out.println();
		tempindex++;
		}
		return tempindex;
	} 
	public void showtemp(int lenth)
	{
		for(int k=0;k<lenth;k++)
		{
			if(outmark[k])
			{
			System.out.println(tempout[k]);
			System.out.println("    "+k);
			}
		}
	}								//计算字符串个数


}
class Stack
{
	char []elements=new char[20];
	int top;
	
	public Stack()
	{		
	}
	public void push(char item)
	{
		elements[++top]=item;
	}
	public char pop()
	{
		if(!IsEmpty())
			return elements[top--];
		else
			{
				System.out.println("you can't get a item from a empty stack!");
				return '\0';
			}
	}
	public void clear()
	{
		top=-1;
	}
	public boolean IsEmpty()
	{
		return top==-1;
	}
	
}											//字符堆栈
class NumStack
{
	double []elements=new double[20];
	int top;
	
	public NumStack()
	{		
	}
	public void push(double item)
	{
		if(top>11)
		System.out.println("overflow!");
		elements[++top]=item;
	}
	public double pop()
	{
		if(!IsEmpty())
			return elements[top--];
		else
			{
				System.out.println("you can't get a item from a empty stack!");
				return -1;
			}
	}
	public void clear()
	{
		for(int i=0;i<20;i++)
			elements[i]='\0';
		top=-1;
	}
	public boolean IsEmpty()
	{
		return top==-1;
	}
	
}										//数字堆栈