calculator.cpp

24点游戏源代码,用vc编写,个人作品,可能还有点错误,只是一个大概的算法

// Calculator.cpp: implementation of the CCalculator class.
//
//////////////////////////////////////////////////////////////////////

#include <iostream.h>
#include <stdlib.h>
#include <math.h>
#include "Calculator.h"
#include "Stack.h"
#include "Operator.h"
#include "Digital.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CCalculator::CCalculator()
{

}

CCalculator::~CCalculator()
{

}

void CCalculator::Calculate(int A, int B, int C, int D)
{
	Cal(A, B, C, D);
	Cal(A, B, D, C);
	Cal(A, C, B, D);
	Cal(A, C, D, B);
	Cal(A, D, B, C);
	Cal(A, D, C, B);

	Cal(B, A, C, D);
	Cal(B, A, D, C);
	Cal(B, C, A, D);
	Cal(B, C, D, A);
	Cal(B, D, A, C);
	Cal(B, D, C, A);

	Cal(C, B, A, D);
	Cal(C, B, D, A);
	Cal(C, A, B, D);
	Cal(C, A, D, B);
	Cal(C, D, B, A);
	Cal(C, D, A, B);

	Cal(D, A, C, B);
	Cal(D, A, B, C);
	Cal(D, C, A, B);
	Cal(D, C, B, A);
	Cal(D, B, A, C);
	Cal(D, B, C, A);

}

void CCalculator::Cal(int D1, int D2, int D3, int D4)
{
	for (int O1 = 0; O1 <= 3; O1++)
		for (int O2 = 0; O2 <= 3; O2++)
			for (int O3 = 0; O3 <= 3; O3++)
				Cal(D1, D2, D3, D4, O1, O2, O3);
}


void CCalculator::Cal(int D1, int D2, int D3, int D4, int O1, int O2, int O3)
{
	CStack S1, S2, S3, S4, S5;

	S1.Push(new COperator(O3));
	S1.Push(new COperator(O2));
	S1.Push(new COperator(O1));
	S1.Push(new CDigital(D4));
	S1.Push(new CDigital(D3));
	S1.Push(new CDigital(D2));
	S1.Push(new CDigital(D1));

	Cal(S1);

	S2.Push(new COperator(O3));
	S2.Push(new COperator(O2));
	S2.Push(new CDigital(D4));
	S2.Push(new COperator(O1));
	S2.Push(new CDigital(D3));
	S2.Push(new CDigital(D2));
	S2.Push(new CDigital(D1));

	Cal(S2);

	S3.Push(new COperator(O3));
	S3.Push(new CDigital(D4));
	S3.Push(new COperator(O2));
	S3.Push(new COperator(O1));
	S3.Push(new CDigital(D3));
	S3.Push(new CDigital(D2));
	S3.Push(new CDigital(D1));

	Cal(S3);

	S4.Push(new COperator(O3));
	S4.Push(new CDigital(D4));
	S4.Push(new COperator(O2));
	S4.Push(new CDigital(D3));
	S4.Push(new COperator(O1));
	S4.Push(new CDigital(D2));
	S4.Push(new CDigital(D1));

	Cal(S4);

	S5.Push(new COperator(O3));
	S5.Push(new COperator(O2));
	S5.Push(new CDigital(D4));
	S5.Push(new CDigital(D3));
	S5.Push(new COperator(O1));
	S5.Push(new CDigital(D2));
	S5.Push(new CDigital(D1));

	Cal(S5);
}

void CCalculator::Cal(CStack &Stack)
{
	CStack StackA;
	for(int I = 0; I < Stack.GetCount(); I++)
		StackA.Push(Stack.GetObject(I));

	CStack StackB;
	
	for(I = 0; I < 3; I++)
	{
		CObject * pObj = StackA.Pop();
		StackB.Push(pObj);
	}

	for(;;)
	{
		int Count = StackB.GetCount();

		if (Count == 1 && StackA.GetCount() == 0)
		{
			float R = ((CDigital *)StackB.Pop())->Value;
			if (fabs(R - 24) < 0.001) Out(Stack, R);
			break;
		}

		if (Count >= 3)
		{
			if (
				StackB.GetObject(Count - 1)->IsOperator()
				&&
				StackB.GetObject(Count - 2)->IsDigital()
				&&
				StackB.GetObject(Count - 3)->IsDigital()
				)
			{
				COperator * pO = (COperator *)StackB.Pop();
				CDigital * pD2 = (CDigital *)StackB.Pop();
				CDigital * pD1 = (CDigital *)StackB.Pop();

				try
				{
					CDigital * pResult = new CDigital(
						Cal(*pD1, *pD2, *pO));
					StackB.Push(pResult);
				}
				catch(...)
				{
					break;
				}


				continue;
			}
		}

		CObject * pObj = StackA.Pop();
		StackB.Push(pObj);
	}

//	cout << endl;
	
}

float CCalculator::Cal(CDigital &D1, CDigital &D2, COperator &O)
{
	//cout << D1.Value << " ";
	
	float Result = 0;
	switch (O.Value)
	{
	case 0:
	//	cout << "+ " << D2.Value;
		Result = D1.Value + D2.Value;
		break;

	case 1:
	//	cout << "- " << D2.Value;
		Result = D1.Value - D2.Value;
		break;

	case 2:
	//	cout << "* " << D2.Value;
		Result = D1.Value * D2.Value;
		break;

	case 3:
	//	cout << "/ " << D2.Value;
		Result = D1.Value / D2.Value;
		break;
	}

	//cout << " = " << Result << ", ";

	return Result;
}

void CCalculator::Out(CStack &Stack, float R)
{
	for(int I = Stack.GetCount() - 1; I >= 0; I--)
	{
		CObject * pObj = Stack.GetObject(I);
		if (pObj->IsDigital())
		{
			cout << ((CDigital *)pObj)->Value;
		}
		else
		{
			COperator * pO = (COperator *)pObj;
			switch (pO->Value)
			{
			case 0:
				cout << "+";
				break;
			case 1:
				cout << "-";
				break;
			case 2:
				cout << "*";
				break;
			case 3:
				cout << "/";
				break;
			}
		}

		cout << " ";
	}

	cout << "= " << R;

	cout << endl;
}