code for 使用n个1,2,3进行加减运算，最后结果还是1,2,3

code for 使用n个1,2,3进行加减运算，最后结果还是1,2,3

#include <iostream>
#include <math.h>
#include <time.h>
#include <string>
#include <stack>
#include <stdio.h>
#include <strstream>
#include <sys/timeb.h>
#include <windows.h>

using namespace std;

enum DATA_TYPE
{
DATA_TYPE_NUM = 0,  //数字类型
DATA_TYPE_ADD = 1,  //加号
DATA_TYPE_SUB = 2,  //减号
DATA_TYPE_END
};
 
#define MAX_NUM 3   
#define ERROR_COUNT 3  //纠错次数
#define DATA_RANDOM(x) ( rand() % x )

#if !defined(_WINSOCK2API_) && !defined(_WINSOCKAPI_)
struct timeval
{
long tv_sec;
long tv_usec;
};
#endif

time_t GetSeed()  //随机种子
{
timeval tv;
union {
long long ns100;
FILETIME ft;
} now;

GetSystemTimeAsFileTime(&now.ft);

tv.tv_usec = (long)((now.ns100 / 10LL) % 1000000LL);
tv.tv_sec = (long)((now.ns100 - 116444736000000000LL) / 10000000LL);
return ( (time_t)tv.tv_sec*(time_t)1000000 + tv.tv_usec );
}
//获得随机数字1,2,3
int GetRandomNum() 
{
int val = DATA_RANDOM(3);
return ++val;
}
//获得随机符号+，-
int GetRandomOperator()
{
int val = DATA_RANDOM(2);
return ++val;
}
//最大极限值
int GetLimitMax(int sum, int amount)
{
return sum + MAX_NUM * amount;
}
//最小极限值
int GetLimitMin(int sum, int amount)
{
return sum - MAX_NUM * amount;
}
//值是否合法
bool IsValid(int sum, int amount)
{
int max = GetLimitMax(sum, amount);
int min = GetLimitMin(sum, amount);
return (min <= 1 && max >= 1) || (min <= 2 && max >= 2) || (min <= 3 && max >= 3);
}
//数据结构体
struct Data{

int num;
int type;
int sum;

Data() :num(0), type(0), sum(0)
{

};

Data(int aNum, int aType, int aSum) :num(aNum), type(aType), sum(aSum)
{

};

string Desc()
{
if (DATA_TYPE_NUM == type)
{
strstream ss;
string str;
ss << num;
ss >> str;
return str;
}
return DATA_TYPE_ADD == type ? "+" : DATA_TYPE_SUB == type ? "-" : " ";
}
};
//获取随机的数据结构体
Data GetRandomData(bool isNum = true)
{
if (isNum)
{
int num = GetRandomNum();
return Data(num, DATA_TYPE_NUM, num);
}
else
{
int type = GetRandomOperator();
return Data(0, type, 0);
}
}
//根据数据和符号来计算
bool Calculate(const Data& src, Data& dest, Data& opera)
{
if (DATA_TYPE_NUM != src.type || DATA_TYPE_NUM != dest.type ||
(DATA_TYPE_ADD != opera.type && DATA_TYPE_SUB != opera.type) )
{
return false;
}

if (DATA_TYPE_ADD == opera.type){
dest.sum += src.sum;
}
else if (DATA_TYPE_SUB == opera.type){
dest.sum = src.sum - dest.sum;
}
return true;
}
//执行解决方案
int ExeSolution(stack<Data>& wants, int amount)
{
int index = 0;
int errorC = ERROR_COUNT; //纠错次数
int saveC = amount;
bool isError = false;

while (0 < amount)
{
if (0 == index)//第一个数据
{
wants.push( GetRandomData() ); //一.随机一个数n和结果值n
--amount;
}

++index;
--amount;

if (isError){ --errorC; } //纠错次数减一

if (0 <= amount)
{
Data sOperator = GetRandomData(false); //获取随机符号  二.随机一个运算符A与t运算(t.sum aT.type)
Data sData = GetRandomData(); //获取随机数字    三.随机一个数m与aT,t运算(sum = t.sum aT.type mT.num )
if ( !Calculate(wants.top(), sData, sOperator) ) //计算
{
std::cout << "fail to Calculate : " << wants.top().sum << " , " <<
sOperator.type << " , " << sData.sum << std::endl;
return 0;
}

if ( IsValid(sData.sum, amount) )  //数据检查是否合法
{
wants.push(sOperator);
wants.push(sData); //如果sum合法就把aT和mT放入栈中(mT.sum = sum)
}
else
{
++amount;
if ( !isError ) //第一次出现Error
{
errorC = ERROR_COUNT;
isError = true;
}
else
{
if (0 == errorC)
{
isError = false;
}
if ( 1 == wants.size() )
{  //如果是第一个数，就t出栈,回到第一步
index = 0;
amount = saveC;
wants.pop();
}
else
{
//如果不是就出栈两个(一个数字和一个运算符)，回到第二步
wants.pop();
wants.pop();
--index;
++amount;
}
}

}
}
}
if (wants.empty())
{
std::cout << "empty data" << std::endl;
return 0;
}
return saveC;
}

void main()
{
srand( GetSeed() );

int amount = 0;
int endSum = 0;

cout << "input number of group123 :" << endl;
cin >> amount;

stack<Data> wants;
if (0 != (amount = ExeSolution(wants, amount) ) )
{
endSum = wants.top().sum;
}
else
{
return;
}

stack<Data> reals;
while (!wants.empty())
{
Data realD = wants.top();
reals.push(realD);
wants.pop();
}

while (!reals.empty())
{
Data realD = reals.top();
std::cout << realD.Desc();
reals.pop();
}
std::cout << " = " << endSum << std::endl;

getchar();
}