//李妍 2015.3.12

//四则运算新

#include<iostream>

#include<fstream>

#include<iomanip>

#include<cmath>

#include<vector>

#include<string>

#include<stdio.h>

#include<stdlib.h>

#include<time.h>

using namespace std;

#define random() (rand()%1000)

const int MAX=;

  /*输入模块*/

  class Input

  {

  public:

      Input()

      {

          for( int i = ;i < MAX;i++ )

              Str_input[i] = '\0';

      }

      char Str_input[MAX];

      void inStr()

      {

          cin>>Str_input;

      }

  };

  /*输出模块*/

  class Output

  {

  public:

      Output()

      {

          result = ;

      }

      double getRes( double res )

      {

          result = res;

          return result;

      }

  private:

      double result;

  };

  /*计算用的存储结构*/

  template <class Type>

  class STACK{

     private:

         Type base[MAX];

         int Size;

     public:

         STACK()

         {

             Size=;

         };

         void push(Type a)

         {

             base[Size]=a;

            Size++;

         }

         Type pop()

         {

             return base[--Size];

         }

         int size()

        {return Size;}

  };

  /*计算的模块*/

  class jisuan

  {

  public:

      bool shuhanshu(char);

      bool fuhanshu(char);

      int jckh(char);

      bool jcxsd(char *);

      int pdyxj(char);

      double ToData(char*);

      double Call(double,double,char);

      int ppkh(char* buffer,int pos);

      void Opr( STACK<char>&, STACK<double>&, int& );

      double Calculate(char*, double& );   

  };

  bool jisuan::shuhanshu(char ch)

  {

      return ((ch>=''&&ch<='')||ch=='.')?true:false;

  }

  bool jisuan::fuhanshu(char ch)

 {

     return (ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch=='#')?true:false;

 }

 int jisuan::jckh(char ch)

 {

     if(ch=='(')

        return ;

     if(ch==')')

        return -;

     return ;

 }

 bool jisuan::jcxsd(char *ch)

 {

     int a=;

     for(int i=;i<strlen(ch);i++)

         if(ch[i]=='.')

             a++;

        if(a>)

             return false;

         return true;

 }

 int jisuan::pdyxj(char ch)          //符号的优先极别

 {

     switch(ch)

     {

     case '+':

         return ;

     case '-':

         return ;

     case '*':

         return ;

     case '/':

         return ;

     case '#':

         return ;

     default:

         return -;

     }

 }

 double jisuan::ToData(char* ch)   //将数字转化为数值

 {

     int i,j,sumn=;

     double sum=0.0;

     if(!jcxsd(ch)) return 0.0;

     for(i=;i<strlen(ch);i++)

     {

         if(ch[i]!='.')

             sumn=sumn*+(ch[i]-'');

         else break;

     }

     if(i<strlen(ch))

         for(j=i+;j<strlen(ch);j++)

             sum=sum*+(ch[j]-'');

     sum /= pow(10.0,(double)(strlen(ch)--i));

     return (sum+sumn);

 }

 double jisuan::Call(double sum,double data,char ch)

 {

     double ans=0.0;

     switch(ch)

     {

     case '+':

         ans=sum+data;

         break;

     case '-':

         ans=sum-data;

         break;

     case '*':

         ans=sum*data;

         break;

     case '/':

         if( data != 0.0 )

             ans=sum/data;

         else

         {

             cout<<"程序出现除0错误，终止！\n";

             system("pause");

             exit();

         }

         break;

     case '#':

         return ;

     default:ans=0.0;

         break;

     }

     return ans;

 }

 int jisuan::ppkh(char* buffer,int pos)     //利用栈找到匹配的括号

 {

     STACK<char> Temp;

     int i;

     for(i=pos;i<strlen(buffer);i++)

     {

         if(jckh(buffer[i])==)

             Temp.push('');

         if(jckh(buffer[i])==-)

         {

             Temp.pop();

             if(Temp.size()==) return i;

         }

     }

     return -;

 }

 void jisuan::Opr(STACK<char>& symbol,STACK<double>& data,int& mark)

 {

     double sum;

     while(symbol.size()!=)

     {

         char tem=symbol.pop();

         int temp=pdyxj(tem);

         symbol.push(tem);

         if(temp<mark)

             break;

         else{

             sum=Call(data.pop(),data.pop(),symbol.pop());

             data.push(sum);

         }

     }

 }

 double jisuan::Calculate(char* buffer,double& sum)   //字符串读入和各个函数调配

 {

     STACK<double> data;

     STACK<char> symbol;

     double ans;

     char temp[MAX];

     int ct=,mark=,tp=;

     data.push(sum);

     while(ct<=strlen(buffer))

     {

         if(shuhanshu(buffer[ct]))            //如果是数字或小数点

         {

             while( ct < strlen(buffer) && shuhanshu(buffer[ct]) )

                 temp[tp++]=buffer[ct++];

             temp[tp]='\0';

             tp=;                         //读到非数字也非小数为止

             ans=ToData(temp);             //把读到的字符串转化为数

             data.push(ans);

             if(ct==strlen(buffer))        //已经独到字符串末尾

             {

                 mark=;

                 Opr(symbol,data,mark);

                 sum=data.pop();

                 return sum;

             }

             else{

                 int mark=pdyxj(buffer[ct]);

                 Opr(symbol,data,mark);     //计算

             }

         }

         else if(fuhanshu(buffer[ct]))         //如果是运算符

             symbol.push(buffer[ct++]);     //运算符入symbol栈

         else

         {

             char BF[];int k=;          //如果都不是，则只能是括号

             while( jckh( buffer[ct] ) !=  && ct <= strlen(buffer) )

                 BF[k++] = buffer[ct++];

             BF[k]='\0';

             if(jckh(buffer[ct])==)       //一旦读到左括号，寻找它匹配的右括号

             {

                 int i,j;

                 char Temp[];

                 for(i=ct+,j=;i<ppkh(buffer,ct);i++,j++)

                     Temp[j]=buffer[i];     //把这对括号中的字符串存入Temp

                 Temp[j]='\0';

                 data.push(Calculate(Temp,sum)); 

                 ct+=(strlen(Temp)+);

                 if(ct+==strlen(buffer))

                 {

                     mark=;

                     Opr(symbol,data,mark);

                     sum=data.pop();

                     return sum;

                 }

                 else

                 {

                     mark=pdyxj(buffer[ct+]); //不是的话继续计算

                     Opr(symbol,data,mark);

                 }

                 ct++;                           //读入下一个字符

             }

         }

     }

     return .;

 }

string  i_s(int shuzi)

{

    int temp=abs(shuzi);

    char str[];

    itoa(temp,str,);

    string str1=str;

    return str1;

}

string zuhe (string str1,string str2,char x)

{

    string expression;

    expression=str1+x+str2;

    return expression;

}

 //是否有乘除法

char operator_random(int c1)

{

    char o;

    int c,c2;

    if(c1==)

    {

        c2=;

    }

    if(c1==)

    {

        c2=;

    }

    c= (rand() % )%c2;

    if (c == ) o = '+';

    else if (c == ) o = '-';

    else if (c == ) o = '*';

    else o = '/';

    return o;

}

void main()

{

    srand((unsigned)time(NULL));//设置时间种子 ，以使程序每次得到的结果都不同

    int mul_div,number,output_mode,value_range,num_1,num_2,plus_or_minus,jump,yushu,kuohao,score=;

    double answer=0.0,solution;

    string str_1,str_2,temp;

    char operator_r;

    char storage[];

    cout<<"    是否有乘除法？<0>没有   <1>有：";

    cin>>mul_div;

    cout<<"    有无括号？    <0>没有   <1>有：";

    cin>>kuohao;

    cout<<"    加减有无负数？<0>没有   <1>有：";

    cin>>plus_or_minus;

    cout<<"    除法有无余数？<0>没有   <1>有：";

    cin>>yushu;

    cout<<"    题目如何输出？<0>在文件中输出 ，<1>在此直接输出：";

    cin>>output_mode;

    cout<<"    请输入数值范围：";

    cin>>value_range;

    cout<<"    请输入题目的数量：";

    cin>>number;

    cout<<endl;

    string *expression=new string[number];//string expression[number];

    ofstream fout;

    if(output_mode==)

    {

        fout.open("yunsuan.txt");

        fout<<number<<"道随机四则运算："<<endl;

    }

    else

    {

        cout<<number<<"道随机四则运算："<<endl;

    }

    for (int i = ; i < number; i++)

    {

       num_1=random()%value_range+;

       num_2=random()%value_range+;

       int length;//运算式的长度

       int j=num_1-num_2;

       int x=num_1%num_2;

       operator_r=operator_random(mul_div);

       length=random()%+;

       str_1=i_s(num_1);

       str_2=i_s(num_2);

       expression[i]=zuhe(str_1,str_2,operator_r);

       if(length>)

       {

           for(length;length>;length --)

           {

               operator_r=operator_random(mul_div);

               str_1=expression[i];

               if(kuohao==)

               {

                   jump=random()%;

                   if(jump==)

                   {

                       str_1='('+str_1+')';

                   }

               }

               operator_r=operator_random(mul_div);

               num_2=random()%value_range+;

               str_2=i_s(num_2);

               jump=random()%;

               if (jump==)

               {

                   temp=str_1;

                   str_1=str_2;

                   str_2=temp;

               }

               expression[i]=zuhe(str_1,str_2,operator_r);

           }

       }

       if(output_mode==)

       {

           strcpy(storage,expression[i].c_str());

            cout.precision();            //设置精度为12

            Input in;

            jisuan cl;

            Output out;

            answer=out.getRes( cl.Calculate(storage,answer) ); //计算模块

            if(plus_or_minus== )

            {

                if(answer>)

                {

                    cout<<"    ("<<i+<<")"<<expression[i]<<"="<<endl;

                    cout<<"    输入结果：";

                    cin>>solution;

                    cout<<"    正确结果："<<answer<<endl;

                    if(answer==solution)

                    {

                        score++;

                        cout<<"    正确！！！"<<endl;

                        cout<<endl;

                    }

                    else

                    {

                        cout<<"    很遗憾，错误！"<<endl;

                        cout<<endl;

                    }

                }    //如果结果小于0

                else

                {

                    i=i-;

                }

            }

            else  //如果不要求加减无负数

            {

                cout<<"    ("<<i+<<")"<<expression[i]<<"="<<endl;

                    cout<<"    输入结果：";

                    cin>>solution;

                    cout<<"    正确结果："<<answer<<endl;

                    if(answer==solution)

                    {

                        score++;

                        cout<<"    正确！！！"<<endl;

                        cout<<endl;

                    }

                    else

                    {

                        cout<<"    很遗憾，错误！"<<endl;

                        cout<<endl;

                    }

            }

       }

       else

       {

           fout<<expression[i]<<"="<<endl;

       }

    }

    if(output_mode==)

    {

        cout<<"    得分："<<score<<endl;

        cout<<endl;

    }

    if(output_mode==)

    {

        fout.close();

    }

}