anill

随机30道小学计算题03

设计思路：

本次实验在实验二的基础上完成，新增功能：判断结果是否正确。

使用结构体存储算式：

struct equation{ //定义结构体“算式”equation

double value; //值value，用于存算式的值

int num; //当前算式为num元运算

bool isFraction; //标记是否为分数

string shape; //形式shape，用于存算式形式

}Equation[9999];

主要函数：

void getRequirement()：记录用户需求，即可定制（数量/打印方式）、是否有乘除法、是否有括号（最多可以支持十个数参与计算）、数值范围、加减有无负数、除法有无余数。

void CreateEquation()：生成初始算式。这里生成二元运算，并随机决定算式是整数算式还是分数算式以及是否继续加长算式。

void MakeBrackets(equation*)：加括号。随机增加运算符和运算数，随机决定是否继续加长算式。递归函数。

void Print()：输出并评判结果。包括屏幕输出和文件输出。分数输出分行。对结果评判精度为10^-2。

void absoluteValue(int &numfirst, int &numsecond)：绝对值。用来调整真分数。

代码：

//2016/03/06
//打印100以内四则运算式，包含真分数。
//2016/03/11
//新增：题目避免重复；可定制（数量/打印方式）；可以控制以下参数：
//是否有乘除法；是否有括号（最多可以支持十个数参与计算）；数值范围；
//加减有无负数；除法有无余数；
#include<iostream>
#include<fstream>
#include <stdio.h>
#include <stdlib.h>
#include<string>
#include<random>
#include<cmath>
#include<ctime>
#include<conio.h>
#include<windows.h>
using namespace std;

int NUM_equation = 0;               //打印数量
bool PrintToFile;               //是否输出到文件
bool HasMultAndDivi;            //是否有乘除法
bool HasBrackets;               //是否有括号
bool HasNegative;               //加减是否有负数
bool HasRemainder;              //除法是否有余数
int MaxOfRange = 100;                 //数值范围上限
int MinOfRange = -100;                 //数值范围下限

//int NUM_equation = 20;               //打印数量
//bool PrintToFile = false;               //是否输出到文件
//bool HasMultAndDivi = true;            //是否有乘除法
//bool HasBrackets = true;               //是否有括号
//bool HasNegative = true;               //加减是否有负数
//bool HasRemainder = true;              //除法是否有余数
//int MaxOfRange = 100;                 //数值范围上限
//int MinOfRange = -100;                 //数值范围下限
default_random_engine generator;
uniform_int_distribution<int> distribution(MinOfRange, MaxOfRange);
struct equation{                //定义结构体“算式”equation

    double value;               //值value，用于存算式的值
    int num;                    //当前算式为num元运算
    bool isFraction;            //标记是否为分数
    string shape;               //形式shape，用于存算式形式
}Equation[9999];

void MakeBrackets(equation*);

void absoluteValue(int &numfirst, int &numsecond)
{
    int tonumf;          //第一个数的绝对值
    int tonums;
    int flag_1;
    int flag_2;
    int temp;
    if (numfirst < 0)
    {
        tonumf = 0 - numfirst;
        flag_1 = -1;
    }
    else
    {
        tonumf = numfirst;
        flag_1 = 1;
    }
    if (numsecond < 0)
    {
        tonums = 0 - numsecond;
        flag_2 = -1;
    }
    else
    {
        tonums = numsecond;
        flag_2 = 1;
    }
    if (tonums < tonumf)
    {
        temp = tonumf;
        tonumf = tonums;
        tonums = temp;
    }
    int i;
    for (i = tonumf; i > 0; i--)
    {
        if (tonumf%i == 0 && tonums%i == 0)
        {
            break;
        }
    }
    if (i)
    {
        numfirst = tonumf / i;
        numsecond = tonums / i;
    }
    else
    {
        numfirst = tonumf;
        numsecond = tonums;
    }
    if (flag_1*flag_2 < 0)
    {
        numfirst = 0 - numfirst;
    }
}

void getRequirement()                    //输入要求
{
    string buffer;
    bool flag_NUM_right = false;
    do{
        cout << "请选择打印数量（1-9999整数）：";
        cin >> buffer;
        int i;
        if (buffer.length() < 5)
        {
            for (i = 0; i < buffer.length(); i++)                 //判断是否为数字
            {
                if (buffer[i] < 48 || buffer[i]>57)
                {
                    break;                                      //不是数字则跳出
                }
            }
            if (i == buffer.length())                             //如果没有跳出（都是数字）
            {
                if (buffer[0] != '0')
                {
                    for (i = 0; i < buffer.length(); i++)         //字符转为整形
                    {
                        NUM_equation += (buffer[i] - 48)*pow(10, buffer.length() - 1 - i);
                    }
                    flag_NUM_right = true;
                }
            }
        }
    } while (!flag_NUM_right);

    bool flag_Print_right = false;
    do{
        cout << "请选择输出方式（1.屏幕/2.文件）：";
        switch (getche())
        {
        case 49:                                        //'1'
            PrintToFile = false;
            flag_Print_right = true;
            cout << endl;
            break;
        case 50:                                        //'2'
            PrintToFile = true;
            flag_Print_right = true;
            cout << endl;
            break;
        default:
            cout << endl;
        }
    } while (!flag_Print_right);

    bool flag_MultAndDivi_right = false;
    do{
        cout << "请选择是否有乘除法（Y.有/N.无）：";
        switch (getche())
        {
        case 78:                                                   //'N'
            HasMultAndDivi = false;
            flag_MultAndDivi_right = true;
            cout << endl;
            break;
        case 89:                                                   //'Y'
            HasMultAndDivi = true;
            flag_MultAndDivi_right = true;
            cout << endl;
            break;
        default:
            cout << endl;
        }
    } while (!flag_MultAndDivi_right);


    bool flag_Brackets_right = false;
    do{
        cout << "请选择是否有括号（Y.有/N.无）：";
        switch (getche())
        {
        case 78:                                                   //'N'
            HasBrackets = false;
            flag_Brackets_right = true;
            cout << endl;
            break;
        case 89:                                                   //'Y'
            HasBrackets = true;
            flag_Brackets_right = true;
            cout << endl;
            break;
        default:
            cout << endl;
        }
    } while (!flag_Brackets_right);
    /////////////////////////////////
    string bufferforRage;
    bool flag_Rage_right = false;
    bool isNegative;
    do{
        cout << "请规定数值范围（整数-99999~99999）：上限为：";
        cin >> bufferforRage;
        int i;
        if (bufferforRage[0] == '-')                                         //若可能为负数
        {
            if (bufferforRage.length() < 7)
            {
                for (i = 1; i < bufferforRage.length(); i++)                 //判断是否为数字
                {
                    if (bufferforRage[i] < 48 || bufferforRage[i]>57)
                    {
                        break;                                      //不是数字则跳出
                    }
                }
                if (i == bufferforRage.length())                             //如果没有跳出（都是数字）
                {
                    if (bufferforRage[0] != '0')
                    {
                        for (i = 1; i < bufferforRage.length(); i++)         //字符转为整形
                        {
                            MaxOfRange -= (bufferforRage[i] - 48)*pow(10, bufferforRage.length() - i - 1);
                        }
                        flag_Rage_right = true;
                    }
                }
            }
        }
        if (bufferforRage[0] != '-')                                         //若可能为正数
        {
            if (bufferforRage.length() < 6)
            {
                for (i = 0; i < bufferforRage.length(); i++)                 //判断是否为数字
                {
                    if (bufferforRage[i] < 48 || bufferforRage[i]>57)
                    {
                        break;                                      //不是数字则跳出
                    }
                }
                if (i == bufferforRage.length())                             //如果没有跳出（都是数字）
                {
                    if (bufferforRage[0] != '0')
                    {
                        for (i = 0; i < bufferforRage.length(); i++)         //字符转为整形
                        {
                            MaxOfRange += (bufferforRage[i] - 48)*pow(10, bufferforRage.length() - 1 - i);
                        }
                        flag_Rage_right = true;
                    }
                    else
                    {
                        MaxOfRange = 0;
                        flag_Rage_right = true;
                    }
                }
            }
        }

    } while (!flag_Rage_right);

    flag_Rage_right = false;
    do{
        cout << "下限为：";
        cin >> bufferforRage;
        int i;
        if (bufferforRage[0] == '-')                                         //若可能为负数
        {
            if (bufferforRage.length() < 7)
            {
                for (i = 1; i < bufferforRage.length(); i++)                 //判断是否为数字
                {
                    if (bufferforRage[i] < 48 || bufferforRage[i]>57)
                    {
                        break;                                      //不是数字则跳出
                    }
                }
                if (i == bufferforRage.length())                             //如果没有跳出（都是数字）
                {
                    if (bufferforRage[0] != '0')
                    {
                        for (i = 1; i < bufferforRage.length(); i++)         //字符转为整形
                        {
                            MinOfRange -= (bufferforRage[i] - 48)*pow(10, bufferforRage.length() - i - 1);
                        }
                        if (MinOfRange < MaxOfRange)
                        {
                            flag_Rage_right = true;
                        }
                        else
                        {
                            MinOfRange = 0;
                        }
                    }
                }
            }
        }
        if (bufferforRage[0] != '-')                                         //若可能为正数
        {
            if (bufferforRage.length() < 6)
            {
                for (i = 0; i < bufferforRage.length(); i++)                 //判断是否为数字
                {
                    if (bufferforRage[i] < 48 || bufferforRage[i]>57)
                    {
                        break;                                      //不是数字则跳出
                    }
                }
                if (i == bufferforRage.length())                             //如果没有跳出（都是数字）
                {
                    if (bufferforRage[0] != '0')
                    {
                        for (i = 0; i < bufferforRage.length(); i++)         //字符转为整形
                        {
                            MinOfRange += (bufferforRage[i] - 48)*pow(10, bufferforRage.length() - 1 - i);
                        }
                    }
                    else
                    {
                        MinOfRange = 0;
                    }
                    if (MinOfRange < MaxOfRange)
                    {
                        flag_Rage_right = true;
                    }
                    else
                    {
                        MinOfRange = 0;
                    }
                }
            }
        }

    } while (!flag_Rage_right);

    ///////////////////////////////////


    bool flag_Negative_right = false;
    do{
        cout << "请选择加减是否有负数（Y.有/N.无）：";
        switch (getche())
        {
        case 78:                                                   //'N'
            HasNegative = false;
            flag_Negative_right = true;
            cout << endl;
            break;
        case 89:                                                   //'Y'
            HasNegative = true;
            flag_Negative_right = true;
            cout << endl;
            break;
        default:
            cout << endl;
        }
    } while (!flag_Negative_right);

    if (HasMultAndDivi)
    {
        bool flag_Remainder_right = false;
        do{
            cout << "请选择除法是否有余数（Y.有/N.无）：";
            switch (getche())
            {
            case 78:                                                   //'N'
                HasRemainder = false;
                flag_Remainder_right = true;
                cout << endl;
                break;
            case 89:                                                   //'Y'
                HasRemainder = true;
                flag_Remainder_right = true;
                cout << endl;
                break;
            default:
                cout << endl;
            }
        } while (!flag_Remainder_right);
    }
}

void CreateEquation()
{
    default_random_engine generator;
    uniform_int_distribution<int> distribution(MinOfRange, MaxOfRange);
    for (int i = 0; i < NUM_equation; i++)
    {
        if (rand() % 2 == 0)
        {
            Equation[i].isFraction = false;
        }
        else
        {
             Equation[i].isFraction = true;
        }
        string middle;
        char sign;                                           //生成初始运算符
        do
        {
            switch (rand() % 4)
            {
            case 0:
                sign = '+';
                break;
            case 1:
                sign = '-';
                break;
            case 2:
                sign = '*';
                break;
            case 3:
                sign = '/';
                break;
            }
        } while ((sign == '/' || sign == '*') && !HasMultAndDivi);
        bool wrong = false;
        double value = 0;
        do
        {
            wrong = false;
            if (!Equation[i].isFraction)                        //生成运算数-整数
            {
                int numFormer;
                int numLatter;
                numFormer = distribution(generator);
                do
                {
                    numLatter = distribution(generator);
                } while (numLatter == 0 && sign == '/');
                char strnumFormer[7] = { '0' };
                itoa(numFormer, strnumFormer, 10);
                char strnumLatter[7] = { '0' };
                itoa(numLatter, strnumLatter, 10);
                if (sign == '+' || sign == '-')                            //加减
                {
                    if (HasNegative)
                    {
                        if (sign == '+')
                        {
                            value = numFormer + numLatter;
                        }
                        else
                        {
                            value = numFormer - numLatter;
                        }
                        if (value<MinOfRange || value>MaxOfRange)
                        {
                            wrong = true;
                        }
                        else
                        {
                            middle = strnumFormer;
                            middle = middle + sign;
                            if (numLatter < 0)
                            {
                                middle = middle + '(' + strnumLatter + ')';
                            }
                            else
                            {
                                middle = middle + strnumLatter;
                            }

                            //Equation[i].shape = strnumFormer + sign;
                            //Equation[i].shape = Equation[i].shape + strnumLatter;
                        }
                    }
                    else
                    {
                        if (numFormer < 0 || numLatter < 0)
                        {
                            wrong = true;
                        }
                        else
                        {
                            if (sign == '+')
                            {
                                value = numFormer + numLatter;
                            }
                            else
                            {
                                value = numFormer - numLatter;
                            }
                            if (value<MinOfRange || value>MaxOfRange || value < 0)
                            {
                                wrong = true;
                            }
                            else
                            {
                                middle = strnumFormer;
                                middle = middle + sign;
                                middle = middle + strnumLatter;
                                //Equation[i].shape = strnumFormer + sign;
                                //Equation[i].shape = Equation[i].shape + strnumLatter;
                            }
                        }
                    }
                }
                else if (sign == '*')                                                     //乘
                {
                    value = numFormer*numLatter;
                    if (value<MinOfRange || value>MaxOfRange)
                    {
                        wrong = true;
                    }
                    else
                    {
                        middle = strnumFormer;
                        middle = middle + sign;
                        if (numLatter < 0)
                        {
                            middle = middle + '(' + strnumLatter + ')';
                        }
                        else
                        {
                            middle = middle + strnumLatter;
                        }
                        //Equation[i].shape = strnumFormer + sign;
                        //Equation[i].shape = Equation[i].shape + strnumLatter;
                    }
                }
                else                                                                  //除
                {
                    if (HasRemainder)
                    {
                        value = (double)numFormer / (double)numLatter;
                        if (value<MinOfRange || value>MaxOfRange)
                        {
                            wrong = true;
                        }
                        else
                        {
                            middle = strnumFormer;
                            middle = middle + sign;
                            if (numLatter < 0)
                            {
                                middle = middle + '(' + strnumLatter + ')';
                            }
                            else
                            {
                                middle = middle + strnumLatter;
                            }
                            //Equation[i].shape = strnumFormer + sign;
                            //Equation[i].shape = Equation[i].shape + strnumLatter;
                        }
                    }
                    else
                    {
                        if (numFormer%numLatter != 0)
                        {
                            wrong = true;
                        }
                        else
                        {
                            value = (double)numFormer / (double)numLatter;
                            if (value<MinOfRange || value>MaxOfRange)
                            {
                                wrong = true;
                            }
                            else
                            {
                                middle = strnumFormer;
                                middle = middle + sign;
                                if (numLatter < 0)
                                {
                                    middle = middle + '(' + strnumLatter + ')';
                                }
                                else
                                {
                                    middle = middle + strnumLatter;
                                }
                                //Equation[i].shape = strnumFormer + sign;
                                //Equation[i].shape = Equation[i].shape + strnumLatter;
                            }
                        }
                    }
                }
            }
            else                                               //生成运算数-分数
            {
                int NumeratorFormer;
                int NumeratorLatter;
                int DenominatorFormer;
                int DenominatorLatter;
                do
                {
                    NumeratorFormer = distribution(generator);
                } while (NumeratorFormer == 0);
                do
                {
                    DenominatorFormer = distribution(generator);
                } while (DenominatorFormer == 0 || DenominatorFormer == NumeratorFormer);
                absoluteValue(NumeratorFormer, DenominatorFormer);
                do
                {
                    NumeratorLatter = distribution(generator);
                } while (NumeratorLatter == 0);
                do
                {
                    DenominatorLatter = distribution(generator);
                } while (DenominatorLatter == 0 || DenominatorLatter == NumeratorLatter);
                absoluteValue(NumeratorLatter, DenominatorLatter);
                char strNF[7];
                itoa(NumeratorFormer, strNF, 10);
                char strDF[7];
                itoa(DenominatorFormer, strDF, 10);
                char strNL[7];
                itoa(NumeratorLatter, strNL, 10);
                char strDL[7];
                itoa(DenominatorLatter, strDL, 10);
                if (sign == '+' || sign == '-')                                          //加减
                {
                    if (HasNegative)
                    {
                        if (sign == '+')
                        {
                            value = (double)NumeratorFormer / (double)DenominatorFormer + (double)NumeratorLatter / (double)DenominatorLatter;
                        }
                        else
                        {
                            value = (double)NumeratorFormer / (double)DenominatorFormer - (double)NumeratorLatter / (double)DenominatorLatter;
                        }
                        if (value<MinOfRange || value>MaxOfRange)
                        {
                            wrong = true;
                        }
                        else
                        {
                            middle = strNF;
                            middle = middle + 'd';
                            middle = middle + strDF;
                            middle = middle + sign;
                            middle = middle + strNL;
                            middle = middle + 'd';
                            middle = middle + strDL;
                            //Equation[i].shape = strNF + 'd';
                            //Equation[i].shape = Equation[i].shape + strDF + sign + strNL + 'd' + strDL;
                        }
                    }
                    else
                    {
                        if (NumeratorFormer < 0 || NumeratorLatter < 0)
                        {
                            wrong = true;
                        }
                        else
                        {
                            if (sign == '+')
                            {
                                value = (double)NumeratorFormer / (double)DenominatorFormer + (double)NumeratorLatter / (double)DenominatorLatter;
                            }
                            else
                            {
                                value = (double)NumeratorFormer / (double)DenominatorFormer - (double)NumeratorLatter / (double)DenominatorLatter;
                            }
                            if (value<MinOfRange || value>MaxOfRange || value<0)
                            {
                                wrong = true;
                            }
                            else
                            {
                                middle = strNF;
                                middle = middle + 'd';
                                middle = middle + strDF;
                                middle = middle + sign;
                                middle = middle + strNL;
                                middle = middle + 'd';
                                middle = middle + strDL;
                                //Equation[i].shape = strNF + 'd';
                                //Equation[i].shape = Equation[i].shape + strDF + sign + strNL + 'd' + strDL;
                            }
                        }
                    }
                }
                else                                                         //乘除
                {
                    if (sign == '*')
                    {
                        value = ((double)NumeratorFormer / (double)DenominatorFormer) * ((double)NumeratorLatter / (double)DenominatorLatter);
                    }
                    else
                    {
                        value = ((double)NumeratorFormer / (double)DenominatorFormer) / ((double)NumeratorLatter / (double)DenominatorLatter);
                    }
                    if (value<MinOfRange || value>MaxOfRange)
                    {
                        wrong = true;
                    }
                    else
                    {
                        middle = strNF;
                        middle = middle + 'd';
                        middle = middle + strDF;
                        middle = middle + sign;
                        middle = middle + strNL;
                        middle = middle + 'd';
                        middle = middle + strDL;
                        //Equation[i].shape = strNF + 'd';
                        //Equation[i].shape = Equation[i].shape + strDF + sign + strNL + 'd' + strDL;
                    }
                }
            }
        } while (wrong);
        Equation[i].shape = middle;
        Equation[i].value = value;
        Equation[i].num = 2;
        if (HasBrackets)
        {
            if (rand() % 5 != 0)
            {
                Equation[i].shape = '(' + Equation[i].shape + ')';
                equation *E = &Equation[i];
                MakeBrackets(E);
            }
        }
        //cout << Equation[i].shape << endl;///////////////////////////////////////////////////////
    }
}

void MakeBrackets(equation *thisEquation)                        //加括号
{

    bool wrong = false;
    double value=0;
    string interForShape="";
    do{
        interForShape = (*thisEquation).shape;
        wrong = false;
        if ((*thisEquation).isFraction)                          //若为分数运算
        {
            int numerator;
            int denominator;
            do{
                numerator = distribution(generator);
            } while (numerator == 0);
            do{
                denominator = distribution(generator);
            } while (denominator == 0 || denominator == numerator);
            absoluteValue(numerator, denominator);
            /*if (numerator > denominator)
            {
                int tem;
                tem = numerator;
                numerator = denominator;
                denominator = tem;
            }*/
            char strNumerator[7];
            char strDenominator[7];
            itoa(numerator, strNumerator, 10);
            itoa(denominator, strDenominator, 10);
            switch (rand() % 8)
            {
            case 0:
                if (HasNegative)
                {
                    value = (*thisEquation).value + (double)numerator / (double)denominator;
                    if (value > MaxOfRange || value < MinOfRange)
                    {
                        wrong = true;
                        break;
                    }
                    interForShape = '+' + interForShape;
                    interForShape = strDenominator + interForShape;
                    interForShape = 'd' + interForShape;
                    interForShape = strNumerator + interForShape;
                }
                else
                {
                    if (numerator > 0 && denominator > 0)
                    {
                        value = (*thisEquation).value + (double)numerator / (double)denominator;
                        if (value > MaxOfRange || value < MinOfRange || value < 0)
                        {
                            wrong = true;
                            break;
                        }
                        interForShape = '+' + interForShape;
                        interForShape = strDenominator + interForShape;
                        interForShape = 'd' + interForShape;
                        interForShape = strNumerator + interForShape;
                    }
                    else
                    {
                        wrong = true;
                        break;
                    }
                }
                break;
            case 1:
                if (HasNegative)
                {
                    value = (*thisEquation).value + (double)numerator / (double)denominator;
                    if (value > MaxOfRange || value < MinOfRange)
                    {
                        wrong = true;
                        break;
                    }
                    interForShape = interForShape + '+';
                    interForShape = interForShape + strNumerator;
                    interForShape = interForShape + 'd';
                    interForShape = interForShape + strDenominator;
                }
                else
                {
                    if (numerator > 0 && denominator > 0)
                    {
                        value = (*thisEquation).value + (double)numerator / (double)denominator;
                        if (value > MaxOfRange || value < MinOfRange || value < 0)
                        {
                            wrong = true;
                            break;
                        }
                        interForShape = interForShape + '+';
                        interForShape = interForShape + strNumerator;
                        interForShape = interForShape + 'd';
                        interForShape = interForShape + strDenominator;
                    }
                    else
                    {
                        wrong = true;
                        break;
                    }
                }
                break;
            case 2:
                if (HasNegative)
                {
                    value = (double)numerator / (double)denominator - (*thisEquation).value;
                    if (value > MaxOfRange || value < MinOfRange)
                    {
                        wrong = true;
                        break;
                    }
                    interForShape = '-' + interForShape;
                    interForShape = strDenominator + interForShape;
                    interForShape = 'd' + interForShape;
                    interForShape = strNumerator + interForShape;
                }
                else
                {
                    if (numerator > 0 && denominator > 0)
                    {
                        value = (double)numerator / (double)denominator - (*thisEquation).value;
                        if (value > MaxOfRange || value < MinOfRange || value < 0)
                        {
                            wrong = true;
                            break;
                        }
                        interForShape = '-' + interForShape;
                        interForShape = strDenominator + interForShape;
                        interForShape = 'd' + interForShape;
                        interForShape = strNumerator + interForShape;
                    }
                    else
                    {
                        wrong = true;
                        break;
                    }
                }
                break;
            case 3:
                if (HasNegative)
                {
                    value = (*thisEquation).value - (double)numerator / (double)denominator;
                    if (value > MaxOfRange || value < MinOfRange)
                    {
                        wrong = true;
                        break;
                    }
                    interForShape = interForShape + '-';
                    interForShape = interForShape + strNumerator;
                    interForShape = interForShape + 'd';
                    interForShape = interForShape + strDenominator;
                }
                else
                {
                    if (numerator > 0 && denominator > 0)
                    {
                        value = (double)numerator / (double)denominator - (*thisEquation).value;
                        if (value > MaxOfRange || value < MinOfRange || value < 0)
                        {
                            wrong = true;
                            break;
                        }
                        interForShape = interForShape + '-';
                        interForShape = interForShape + strNumerator;
                        interForShape = interForShape + 'd';
                        interForShape = interForShape + strDenominator;
                    }
                    else
                    {
                        wrong = true;
                        break;
                    }
                }
                break;
            case 4:
                if (HasMultAndDivi)
                {
                    value = (double)numerator / (double)denominator * (*thisEquation).value;
                    if (value > MaxOfRange || value < MinOfRange)
                    {
                        wrong = true;
                        break;
                    }
                    interForShape = '*' + interForShape;
                    interForShape = strDenominator + interForShape;
                    interForShape = 'd' + interForShape;
                    interForShape = strNumerator + interForShape;
                }
                else
                {
                    wrong = true;
                }
                break;
            case 5:
                if (HasMultAndDivi)
                {
                    value = (*thisEquation).value * (double)numerator / (double)denominator;
                    if (value > MaxOfRange || value < MinOfRange)
                    {
                        wrong = true;
                        break;
                    }
                    interForShape = interForShape + '*';
                    interForShape = interForShape + strNumerator;
                    interForShape = interForShape + 'd';
                    interForShape = interForShape + strDenominator;
                }
                else
                {
                    wrong = true;
                }
                break;
            case 6:
                if (HasMultAndDivi)
                {
                    value = (double)numerator / (double)denominator / (*thisEquation).value;
                    if (value > MaxOfRange || value < MinOfRange)
                    {
                        wrong = true;
                        break;
                    }
                    interForShape = '/' + interForShape;
                    interForShape = strDenominator + interForShape;
                    interForShape = 'd' + interForShape;
                    interForShape = strNumerator + interForShape;
                }
                else
                {
                    wrong = true;
                }
                break;
            case 7:
                if (HasMultAndDivi)
                {
                    value = (*thisEquation).value / ((double)numerator / (double)denominator);
                    if (value > MaxOfRange || value < MinOfRange)
                    {
                        wrong = true;
                        break;
                    }
                    interForShape = interForShape + '/';
                    interForShape = interForShape + strNumerator;
                    interForShape = interForShape + 'd';
                    interForShape = interForShape + strDenominator;
                }
                else
                {
                    wrong = true;
                }
                break;
            }
        }
        else                                                       //若为整数运算
        {
            int integer;
            integer = distribution(generator);
            char strInteger[7];
            itoa(integer, strInteger, 10);
            switch (rand() % 8)
            {
            case 0:
                if (HasNegative)
                {
                    value = (*thisEquation).value + (double)integer;
                    if (value > MaxOfRange || value < MinOfRange)
                    {
                        wrong = true;
                        break;
                    }
                    interForShape = '+' + interForShape;
                    if (integer < 0)
                    {
                        //interForShape = '(' + strInteger + ')' + interForShape;
                        interForShape = ')' + interForShape;
                        interForShape = strInteger + interForShape;
                        interForShape = '(' + interForShape;
                    }
                    else
                    {
                        interForShape = strInteger + interForShape;
                    }
                }
                else
                {
                    if (integer > 0)
                    {
                        value = (*thisEquation).value + (double)integer;
                        if (value > MaxOfRange || value < MinOfRange || value < 0)
                        {
                            wrong = true;
                            break;
                        }
                        interForShape = '+' + interForShape;
                        interForShape = strInteger + interForShape;
                    }
                    else
                    {
                        wrong = true;
                        break;
                    }
                }
                break;
            case 1:
                if (HasNegative)
                {
                    value = (*thisEquation).value + (double)integer;
                    if (value > MaxOfRange || value < MinOfRange)
                    {
                        wrong = true;
                        break;
                    }
                    interForShape = interForShape + '+';
                    if (integer < 0)
                    {
                        //interForShape = interForShape + '(' + strInteger + ')';
                        interForShape = interForShape + '(';
                        interForShape = interForShape + strInteger;
                        interForShape = interForShape + ')';
                    }
                    else
                    {
                        interForShape = interForShape + strInteger;
                    }
                }
                else
                {
                    if (integer > 0)
                    {
                        value = (*thisEquation).value + (double)integer;
                        if (value > MaxOfRange || value < MinOfRange || value < 0)
                        {
                            wrong = true;
                            break;
                        }
                        interForShape = interForShape + '+';
                        interForShape = interForShape + strInteger;
                    }
                    else
                    {
                        wrong = true;
                        break;
                    }
                }
                break;
            case 2:
                if (HasNegative)
                {
                    value = (double)integer - (*thisEquation).value;
                    if (value > MaxOfRange || value < MinOfRange)
                    {
                        wrong = true;
                        break;
                    }
                    interForShape = '-' + interForShape;
                    if (integer < 0)
                    {
                        //interForShape = '(' + strInteger + ')' + interForShape;
                        interForShape = ')' + interForShape;
                        interForShape = strInteger + interForShape;
                        interForShape = '(' + interForShape;
                    }
                    else
                    {
                        interForShape = strInteger + interForShape;
                    }
                }
                else
                {
                    if (integer > 0)
                    {
                        value = (double)integer - (*thisEquation).value;
                        if (value > MaxOfRange || value < MinOfRange || value < 0)
                        {
                            wrong = true;
                            break;
                        }
                        interForShape = '-' + interForShape;
                        interForShape = strInteger + interForShape;
                    }
                    else
                    {
                        wrong = true;
                        break;
                    }
                }
                break;
            case 3:
                if (HasNegative)
                {
                    value = (*thisEquation).value - (double)integer;
                    if (value > MaxOfRange || value < MinOfRange)
                    {
                        wrong = true;
                        break;
                    }
                    interForShape = interForShape + '-';
                    if (integer < 0)
                    {
                        //interForShape = interForShape + '(' + strInteger + ')';
                        interForShape = interForShape + '(';
                        interForShape = interForShape + strInteger;
                        interForShape = interForShape + ')';
                    }
                    else
                    {
                        interForShape = interForShape + strInteger;
                    }
                }
                else
                {
                    if (integer > 0)
                    {
                        value = (*thisEquation).value - (double)integer;
                        if (value > MaxOfRange || value < MinOfRange || value < 0)
                        {
                            wrong = true;
                            break;
                        }
                        interForShape = interForShape + '-';
                        interForShape = interForShape + strInteger;
                    }
                    else
                    {
                        wrong = true;
                        break;
                    }
                }
                break;
            case 4:
                if (HasMultAndDivi)
                {
                    value = (double)integer * (*thisEquation).value;
                    if (value > MaxOfRange || value < MinOfRange)
                    {
                        wrong = true;
                        break;
                    }
                    interForShape = '*' + interForShape;
                    if (integer < 0)
                    {
                        //interForShape = '(' + strInteger + ')' + interForShape;
                        interForShape = ')' + interForShape;
                        interForShape = strInteger + interForShape;
                        interForShape = '(' + interForShape;
                    }
                    else
                    {
                        interForShape = strInteger + interForShape;
                    }
                }
                else
                {
                    wrong = true;
                }
                break;
            case 5:
                if (HasMultAndDivi)
                {
                    value = (*thisEquation).value * (double)integer;
                    if (value > MaxOfRange || value < MinOfRange)
                    {
                        wrong = true;
                        break;
                    }
                    interForShape = interForShape + '*';
                    if (integer < 0)
                    {
                        //interForShape = interForShape + '(' + strInteger + ')';
                        interForShape = interForShape + '(';
                        interForShape = interForShape + strInteger;
                        interForShape = interForShape + ')';
                    }
                    else
                    {
                        interForShape = interForShape + strInteger;
                    }
                }
                else
                {
                    wrong = true;
                }
                break;
            case 6:
                if (HasMultAndDivi)
                {
                    if ((*thisEquation).value<1E-7&&(*thisEquation).value>-(1E-7))          //若除数为0
                    {
                        wrong = true;
                        break;
                    }
                    if (HasRemainder)
                    {
                        value = (double)integer / (*thisEquation).value;
                        if (value > MaxOfRange || value < MinOfRange)
                        {
                            wrong = true;
                            break;
                        }
                        interForShape = '/' + interForShape;
                        if (integer < 0)
                        {
                            //interForShape = '(' + strInteger + ')' + interForShape;
                            interForShape = ')' + interForShape;
                            interForShape = strInteger + interForShape;
                            interForShape = '(' + interForShape;
                        }
                        else
                        {
                            interForShape = strInteger + interForShape;
                        }
                    }
                    else
                    {
                        if ((*thisEquation).value - int((*thisEquation).value) > 1E-7 || (*thisEquation).value - int((*thisEquation).value) < -(1E-7))
                        {
                            wrong = true;
                            break;
                        }
                        if (integer%int((*thisEquation).value) > 1E-7 || integer%int((*thisEquation).value) < -(1E-7))
                        {
                            wrong = true;
                            break;
                        }
                        else
                        {////
                            value = (double)integer / (*thisEquation).value;
                            if (value > MaxOfRange || value < MinOfRange)
                            {
                                wrong = true;
                                break;
                            }
                            interForShape = '/' + interForShape;
                            if (integer < 0)
                            {
                                //interForShape = '(' + strInteger + ')' + interForShape;
                                interForShape = ')' + interForShape;
                                interForShape = strInteger + interForShape;
                                interForShape = '(' + interForShape;
                            }
                            else
                            {
                                interForShape = strInteger + interForShape;
                            }
                        }
                    }
                }
                else
                {
                    wrong = true;
                }
                break;
            case 7:
                if (HasMultAndDivi)
                {
                    if (0 == integer)          //若除数为0
                    {
                        wrong = true;
                        break;
                    }
                    if (HasRemainder)
                    {
                        value = (*thisEquation).value / (double)integer;
                        if (value > MaxOfRange || value < MinOfRange)
                        {
                            wrong = true;
                            break;
                        }
                        interForShape = interForShape + '/';
                        if (integer < 0)
                        {
                            //interForShape = interForShape + '(' + strInteger + ')';
                            interForShape = interForShape + '(';
                            interForShape = interForShape + strInteger;
                            interForShape = interForShape + ')';
                        }
                        else
                        {
                            interForShape = interForShape + strInteger;
                        }
                    }
                    else
                    {
                        if ((*thisEquation).value - int((*thisEquation).value) > 1E-7 || (*thisEquation).value - int((*thisEquation).value) < -(1E-7))
                        {
                            wrong = true;
                            break;
                        }
                        if ((int((*thisEquation).value)) % integer > 1E-7 || (int((*thisEquation).value)) % integer < -(1E-7))
                        {
                            wrong = true;
                            break;
                        }
                        else
                        {////
                            value = (*thisEquation).value / (double)integer;
                            if (value > MaxOfRange || value < MinOfRange)
                            {
                                wrong = true;
                                break;
                            }
                            interForShape = interForShape + '/';
                            if (integer < 0)
                            {
                                //interForShape = interForShape + '(' + strInteger + ')';
                                interForShape = interForShape + '(';
                                interForShape = interForShape + strInteger;
                                interForShape = interForShape + ')';
                            }
                            else
                            {
                                interForShape = interForShape + strInteger;
                            }

                        }
                    }
                }
                else
                {
                    wrong = true;
                }
                break;
            }
        }
    } while (wrong);
    (*thisEquation).shape = interForShape;
    (*thisEquation).value = value;
    (*thisEquation).num += 1;
    if (rand() % 2 > 0 && (*thisEquation).num < 10)
    {
        (*thisEquation).shape = '(' + (*thisEquation).shape + ')';
        MakeBrackets(thisEquation);
    }
}

void Print()
{
    for (int i = 0; i < NUM_equation; i++)
    {
        if (Equation[i].isFraction)
        {
            string line1 = "";
            string line2 = "";
            string line3 = "";
            bool Fin_Negative = false;
            bool Fin_Numerator = false;
            bool Fin_Denominator = false;
            int NumNumerator = 0;
            int NumDenominator = 0;
            for (int j = 0;j<Equation[i].shape.length(); j++)
            {
                if ((Equation[i].shape[j]<48 || Equation[i].shape[j]>57) && Equation[i].shape[j] != 'd'&& Equation[i].shape[j] != '-')
                {
                    Fin_Denominator = true;
                    Fin_Numerator = false;
                    line1 = line1 + "  ";
                    line2 = line2 + Equation[i].shape[j] + ' ';
                    line3 = line3 + "  ";
                }
                else if (Equation[i].shape[j] == '-')
                {
                    if (j != 0 && (Equation[i].shape[j - 1] == '-' || Equation[i].shape[j - 1] == '+' || Equation[i].shape[j - 1] == '*' || Equation[i].shape[j - 1] == '/'))
                    {
                        line1 = line1 + '-';
                        line2 = line2 + '-';
                        line3 = line3 + ' ';
                    }
                    else
                    {

                        Fin_Denominator = true;
                        Fin_Numerator = false;

                        line1 = line1 + "  ";
                        line2 = line2 + "- ";
line3 = line3 + "  ";
                    }
                }
                else if (Equation[i].shape[j] == 'd')
                {
                    Fin_Numerator = true;
                    Fin_Denominator = false;
                    for (int k = 1;; k++)
                    {
                        //if ((Equation[i].shape[j + k]==NULL)||(Equation[i].shape[j + k] < 48 || Equation[i].shape[j + k] > 57))
                        if ((j + k) > Equation[i].shape.length() || (Equation[i].shape[j + k] < 48 || Equation[i].shape[j + k] > 57))
                        {
                            NumDenominator = k - 1;
                            break;
                        }
                    }
                    for (int h = 1;; h++)
                    {
                        if ((j - h < 0) || (Equation[i].shape[j - h] < 48 || Equation[i].shape[j - h] > 57))
                        {
                            NumNumerator = h - 1;
                            break;
                        }
                    }
                    if (NumNumerator > NumDenominator)
                    {
                        for (int n = 0; n < NumNumerator - NumDenominator; n++)
                        {
                            line3 = line3 + ' ';
                        }
                        for (int n = 0; n < NumNumerator; n++)
                        {
                            line2 = line2 + '-';
                        }
                    }
                    if (NumDenominator > NumNumerator)
                    {
                        for (int n = 0; n < NumDenominator - NumNumerator; n++)
                        {
                            line1 = line1 + ' ';
                        }
                        for (int n = 0; n < NumDenominator; n++)
                        {
                            line2 = line2 + '-';
                        }
                    }
                    else
                    {
                        for (int n = 0; n < NumDenominator; n++)
                        {
                            line2 = line2 + '-';
                        }
                    }
                }
                else
                {
                    if (!Fin_Numerator)
                    {
                        line1 = line1 + Equation[i].shape[j];
                    }
                    else if (!Fin_Denominator)
                    {
                        line3 = line3 + Equation[i].shape[j];
                    }
                }
            }
            if (PrintToFile)
            {
                ofstream ofile;
                ofile.open("print.txt");
                ofile << line1 << endl << line2 << endl << line3 << endl << endl;
                ofile.close();
            }
            else
            {
                cout << line1 << endl << line2 << endl << line3 << endl << endl;
            }

        }
        else
        {
            if (PrintToFile)
            {
                ofstream ofile;
                ofile.open("print.txt");
                ofile << Equation[i].shape << endl << endl;
                ofile.close();
            }
            else
            {
                cout << Equation[i].shape << endl << endl;
            }
        }
        string buffer;
        bool Result_Right = true;
        int NumofDiv=0;
        int Numofdot = 0;
        int SpaceofDiv;
        cout << "结果:";
        cin >> buffer;
        if (!buffer.empty())
        {
            for (int m = 0; m < buffer.length(); m++)
            {
                if ((buffer[m] < 48 || buffer[m]>57) && buffer[m] != '/'&& buffer[m] != '.')
                {
                    Result_Right = false;
                    break;
                }
                if (buffer[m] == '/')
                {
                    NumofDiv += 1;
                    if (NumofDiv > 1)
                    {
                        Result_Right = false;
                        break;
                    }
                    SpaceofDiv = m;
                }
                if (buffer[m] == '.')
                {
                    Numofdot += 1;
                    if (Numofdot > 1)
                    {
                        Result_Right = false;
                        break;
                    }
                }
            }
            if (Result_Right)
            {
                double result;
                if (NumofDiv == 1)
                {
                    string strfor=buffer.substr(0,SpaceofDiv);
                    string strlat = buffer.substr(SpaceofDiv+1,buffer.length()-SpaceofDiv-1);
                    double former = atof(strfor.c_str());
                    double latter = atof(strlat.c_str());
                    if ((latter - 0) < 1E-7 && (latter - 0) > (-1E-7))
                    {
                        Result_Right = false;
                        break;
                    }
                    result = former / latter;
                }
                else
                {
                    result = atof(buffer.c_str());
                }
                if ((result - Equation[i].value) < 1E-2 && (result - Equation[i].value) > (-1E-2))
                {
                    Result_Right = true;
                }
                else
                {
                    Result_Right = false;
                }
            }
            if (Result_Right)
            {
                cout << "正确!" << endl;
            }
            else
            {
                cout << "错误！" << endl;
            }
        }
        else
        {
            cout << "错误！" << endl;
        }
    }
}

int main()
{
    system("mode con: cols=120 lines=40");
    srand(time(0));
    getRequirement();
    CreateEquation();
    Print();
    return 0;
}

View Code

运行截图：

此次两人合作编码合作者是杨安琪，链接：

http://www.cnblogs.com/ning-JML/p/5296763.html

项目计划总结：

日期&&任务	听课	编写程序	阅读相关书籍	网上查资料	日总计
周一	2	3			5
周二			1		1
周三		4		1	5
周四	2	1			3
周五		4		2	6
周六		2		1	3
周日			2		2
周总计	4	14	3	4	25

时间纪录日志：

日期	开始时间	结束时间	中断时间	净时间	活动	备注
3/14	14:00	15:00	10	100	听课	软件工程
	16:00	20:00	60	180	重写上周的代码	二柱子02
3/15	20:00	21:00	0	60	看书	大道至简
3/16	15:00	21:00	120	240	重写上周代码、二柱子03代构思
	15:00	21:00	300	60	上网查资料
3/17	14:00	15:00	10	100	听课	软件工程
	20:00	22:00	60	60	写代码、吃东西
3/18	15:00	22:00	180	240	写代码、写作业、看书
	15:00	22:00	300	120	查资料
3/19	19:00	22:00	0	180	写博客、改程序、测试

缺陷记录日志：

日期	编号	类型	引入阶段	排除阶段	修复时间	修复缺陷
3/16	1		字符溢出	不能一起加，要分开加	120min
3/18	3		重复定义	修改定义	10min

你可能感兴趣的:(随机30道小学计算题03)

斤斤计较的婚姻到底有多难？白心之岂必有为
很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
30天风格练习-DAY2 黄希夷
Day2（重义）在一个周日/一周的最后一天，我来到位于市中心/市区繁华地带的一家购物中心/商场，中心内人很多/熙熙攘攘。我注意到/看见一个独行/孤身一人的年轻女孩/，留着一头引人注目/长过腰际的头发，上身穿一件暗红色/比正红色更深的衣服/穿在身体上的东西。走下扶梯的时候，她摔倒了/跌向地面，在她正要站起来/让身体离开地面的时候，过长/超过一般人长度的头发被支撑身体/躯干的手掌压/按在下面，她赶紧用
开心蒋泳频
从无比抗拒来上课到接受，感动，收获～看着波哥成长，晶晶幸福笑容满面。感觉自己做的事情很有意义，很开心！还有3个感召目标就是还有三个有缘人，哈哈。明天感召去明日计划：8：30-11：00小公益11：00-21点上班，感召图片发自App图片发自App图片发自App
今日联对0306 诗图佳得
自对联：烟销皓月临江浒，水漫金山荡塔裙。一一肖士平2020.3.6.1、试对肖老师联：烟销皓月临江浒，夜笼寒沙梦晚舟。耀哥求正2、试对萧老师联:烟销浩月临江浒，雾散乾坤解汉城。秀霞习作请各位老师校正3、自对联：烟销皓月临江浒，水漫金山荡塔裙。一一肖士平2020.3.6.4、试对肖老师垫场联：烟销皓月临江浒，雾锁寒林缈葉丛。小智求正[抱拳]5、试对肖老师联：烟销皓月临江浒；风卷乱云入峰巅。一一五品6
2019-12-22-22:30 涓涓1016
今天是冬至，写下我的日更，是因为这两天的学习真的是能量的满满，让我看到了自己，未来另外一种可能性，也让我看到了这两年这几年的过程中我所接受那些痛苦的来源。一切的根源和痛苦都来自于人生，家庭，而你的原生家庭，你的爸爸和妈妈，是因为你这个灵魂在那一刻选择他们作为你的爸爸和妈妈来的，所以你得接受他，你得接纳他，他就是因为他的存在而给你的学习和成长带来这些痛苦，那其实是你必然要经历的这个过程，当你去接纳的
linux中sdl的使用教程,sdl使用入门 Melissa Corvinus linux中sdl的使用教程
本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
谁家酒器最绝唱，藏在酒厂人未知？景阳冈酒厂先秦藏品大揭秘李虓酒评论
文/王赛时中国的酒器酒具历史久远，举世闻名。从北京的故宫博物院、中国国家博物馆，到世界各国的大型博物馆，都以能够收藏中国古代酒具而夸耀。但很少有人知道，在山东阳谷景阳冈酒厂，默默地收藏了两千件中国酒器。这些酒器，就封藏在景阳冈的酒道馆里。其中有一些青铜酒器，一睡就是三、四千年，堪称无声国宝，堪作无字史书！今天，我将引领诸位首先窥视一下景阳冈酒道馆的9件先秦藏品，你自己来说震撼不震撼。提示：这只是景
2023-04-17|篮球女孩长一木
1小学抑或初中阶段，在课外书了解到她的故事。“篮球女孩”。当时佩服她的顽强，也对生命多了一丝敬畏。今天刚好在公众号看到，长大后的“篮球女孩”。佩服之余又满是心疼。网络侵删祝那素未蒙面的女孩，未来一切顺遂。
2023-10-22 奥雷里亚诺第n
昨天在B站看到关于猫喜欢挠人的视频，视频教导说猫挠人的话就抓住它的后脖颈然后用手打打挠人的那个爪子。视频本身没什么，但评论区却炸开了锅（真是符合挑食者厌食心理）。令我印象最深刻的一个甚至上升到了关于我是谁这种终极问题。它说，猫就是畜生，它挠人就打它别惯着它，反正我六道轮回成了人就应该保持人的高贵，谁都别想来打破。我顿时汗颜，但看到下面全是类似的言论只不过后面的理由各有不同，本来想骂人的心都凉了一半
梁文道《尽头:怎样是好的阅读和书写》片段白夜书摘
1、写小说的人，有时会强烈地感到一种现实的召唤，想去面对和回应现实。这时他们会觉得自己正站在时代中心，就像黑格尔说的，要把时代精神掌握在自己的小说（不是哲学）里面。但是这也很危险，当一个作家像一个时代那样书写，可能就会出现问题了。2、文字是远比语言大块而且湿冷的木头，又距离我们内心的火花稍远，不容易瞬间点燃起来，这处隙缝，给了我们回身的余地，可以再多看一下想一下设身处地一下；人类过往这最后五千年，
阶段总结反思轻争
马上就要进入10月份了，今天做一下前段时间的总结和反思。前段时间，日更、英语、健身、护肤坚持的比较好。阅读、书法坚持的不好。1.中间被迫停更半个多月，其余时间一直在坚持日更挑战。偶尔也有不想写的时候，就做一下摘抄。因为阅读（输入）没跟上来，所以写作（输出）质量有待进一步加强。2.英语做到了一周至少学习5天，每次不少于30分钟，但是小班课没有跟上更新速度，下一步要争取利用零碎时间补听小班课。3.减肥
2020-12-16 长寿富贵
9：56不知今天哪位亲来说说话呀？成萌：尽尽皆是道。道道皆相同。不解呀？成萌：郁郁不得志，混混过日子。哦……说谁的呀？成萌：说自己呀……还能说谁呢？那如何办呢？成萌：回头……如何回头？成萌：回见心源。如何回见心源？成萌：不追不随诸相迁，如如不动在心田。啊？成萌：慢慢守心吧。
主题升华随机抽总结木棉咕噜
昨天晚上在火山灿教练那里抽了主题升华最后一关。一共抽了两个故事，现总结如下。第一个故事是《并不是你想象的那样》。主题一：有时候，面对别人一些貌似不合常情的行为，不要轻易的指责他，也许背后有我们所不知道的原因。在这一个主题里面，刚开始的时候，我没有加上貌似二字。所以就没有改动之后这么精准。主题二：有时候我们对他人善意的行为，可能会给我们带来一些意外的回报。主题三：面对同样一件事，因为不同的人看待问题
Rust基础知识 GRKF15 rust 开发语言后端
1.Rust语言简介1.1基础语法变量声明：let关键字用于声明变量，可以指定或不指定类型，如leta=10;和letmutc=30i32;。函数定义：使用fn关键字定义函数，并指定参数类型及返回类型，如fnadd(i:i32,j:i32)->i32{i+j}。控制流：包括if、else等，控制语句后需要使用;来结束语句。1.2数据类型整数类型：i8、i16、i32、i64、i128，以及无符号的
2019-3-23晨间日记红红火火小耳朵
今天是什么日子起床：7点40就寝：23点半天气：有太阳，不过一会儿出来一会儿进去特别清爽的凉意，还蛮舒服的心情：小激动要给女朋友过生日啦纪念日：田田女士过生日任务清单昨日完成的任务，最重要的三件事：1.英语一对一2.运动计划3.认真护肤习惯养成：调整状态周目标·完成进度英语七天打卡（5/7）轻课阅读（87/180）音标课（25/30）读书（福尔摩斯一章）学习·信息·阅读#英语课#Cookingte
那个严厉的启蒙老师小米星的天空
本文参加鹏哥教师节征文活动我的启蒙老师李老师，大概是唯一动手打过我，但是我仍然很感恩的老师吧。李老师当年四十多岁，擅长珠心算教学，算是我们乡镇小学的王牌老师。李老师很严厉，不仅要骂学生，还要动手打人，他的大眼睛一瞪，全班同学都瑟瑟发抖。在九十年代，家长不像现在这样宠溺孩子。许多家长都跟老师说，管得严一点，不听话就给我打。那时候棍棒教育是很正常的，教室里的木质米尺，常常因为被用来打调皮男生的屁股而折
【无标题】达瓦达瓦 JhonKI 考研
博客主页：https://blog.csdn.net/2301_779549673欢迎点赞收藏⭐留言如有错误敬请指正！本文由JohnKi原创，首发于CSDN未来很长，值得我们全力奔赴更美好的生活✨文章目录前言111️‍111❤️111111111111111总结111前言111骗骗流量券，嘿嘿111111111111111111111111111️‍111❤️111111111111111总结11
上图为是否色发 JhonKI 考研
博客主页：https://blog.csdn.net/2301_779549673欢迎点赞收藏⭐留言如有错误敬请指正！本文由JohnKi原创，首发于CSDN未来很长，值得我们全力奔赴更美好的生活✨文章目录前言111️‍111❤️111111111111111总结111前言111骗骗流量券，嘿嘿111111111111111111111111111️‍111❤️111111111111111总结11
第四天旅游线路预览——从贾登峪到喀纳斯景区入口（贾登峪游客服务中心）陟彼高冈yu 基于Google earth studio 的旅游规划和预览旅游
第四天：从贾登峪到喀纳斯风景区入口，晚上住宿贾登峪；从贾登峪到喀纳斯景区入口（贾登峪游客服务中心）：搭乘贾登峪①路车，路过三湾到达景区换乘中心，路程时长约40分钟；1）早上8：00起床，吃完早饭，8：30出发；2）从贾登峪到喀纳斯风景区，需要搭乘一站公交车，为免费公交车，路程4.3公里，车程约9分钟8：40左右到达喀纳斯景区入口（贾登峪游客服务中心）；3）乘坐贾登峪①路车，路过三湾到达景区换乘中心
143234234123432 JhonKI 考研
博客主页：https://blog.csdn.net/2301_779549673欢迎点赞收藏⭐留言如有错误敬请指正！本文由JohnKi原创，首发于CSDN未来很长，值得我们全力奔赴更美好的生活✨文章目录前言111️‍111❤️111111111111111总结111前言111骗骗流量券，嘿嘿111111111111111111111111111️‍111❤️111111111111111总结11
2019-01-19 王小康KK
姓名:王康公司:扬州市方圆建筑工程有限公司2018年3月16日～3月18日上海361期《六项精进》感谢二组学员【日精进打卡第307天】【知～学习】《六项精进》大纲3遍共862遍《大学》通篇3遍共860遍《六项精进》全书40页【经典名句】思想决定行为，行为决定习惯，习惯决定性格，性格决定命运。【行～实践】一、修身：（对自己个人）1、践行六项精进的理念。二、齐家：（对家庭和家人）1、和女朋友视频聊天。
道阻且长，行则将至 sweet橘子
本文参与书香澜梦主题征文“行”文章原创首发，文责自负。我们每一个人都应该有属于自己的愿望或者是理想，人一但有了理想也就算是有了方向，它就会像灯塔一样指引我们前进的方向，哪怕是再远大的理想，如果坚持，那么我相信它就一定有收获。屈原是我最喜欢的一个浪漫主义的诗人，他曾今说过：“路漫漫其修远兮，吾将上下而求索。”人生的道路很长，但是为了实现自己的理想抱负我愿意付出我毕生的精力，只专注这一件事，因为“道阻
k均值聚类算法考试例题_k均值算法(k均值聚类算法计算题) 寻找你83497 k均值聚类算法考试例题
?算法：第一步：选K个初始聚类中心，z1(1),z2(1)，…，zK(1)，其中括号内的序号为寻找聚类中心的迭代运算的次序号。聚类中心的向量值可任意设定，例如可选开始的K个.k均值聚类：---------一种硬聚类算法，隶属度只有两个取值0或1，提出的基本根据是“类内误差平方和最小化”准则；模糊的c均值聚类算法：--------一种模糊聚类算法，是.K均值聚类算法是先随机选取K个对象作为初始的聚类
2018-12-07 旅一06丁琪琪
旅管一班6组学号链接06丁琪琪16家国鑫26孟令慧30王思宁36温红丽46朱赵筱楠
社保应该缴15年还是25年？那种方式最划算？袋鼠观保保险规划师
社保无论是缴费15年还是25年，影响最大的就是养老保险和医疗保险，缴费时间越长越有利！1.养老保险真的交满15年就够了吗？要知道，社保缴费时长，直接影响到退休后能拿多少养老金，而且交得越久，退休领得越多。我拿深圳作为例子，想拿到养老金必须满足两个条件：只要达到一定的退休年龄，养老保险累计交满15年就可以拿到养老金了。那如果多缴了20年、25年甚至30年，是不是浪费了？实际上，缴满15年只是刚好可以
中原焦点团队网络初中级30期阴丽丽坚持分享第三百八十八次2022.10.18分享约练次数（74）咨询师（6）来访者（53）观察者（15）阴丽丽
今天是忙碌的一天，一早起来，总想着找点把事情弄完，可总也弄不完。就这样弄着吧！孩子的事，自己的事都在那里搁置着，不想做，有点欧！今天总体还不错，只是在下午起床时走神了俩小时，也算是给自己的放松吧！今日难得1.儿子乖巧、听话，努力配合，一天下来也是忙忙碌碌，这真的很难得！2.儿子今天录的视频被班主任认可，这真的很难得3.我今天早上做核酸时，自己把教案整了一下，这真的很难得
2021-07-31 比峰
七月的最后一天，过了今天，就是八月，心脏在颤抖……昨天两点半才睡，一直在以两倍的语速的听之前的课程，虽然隔得时间不长，但是很多知识点已经忘了差不多了，为了让自己能够掌握的稍微全面一点，还是磨刀不误砍柴工的比较好。正因为晚上睡得晚，今天一上午的状态都不好，也可能因为上午都是待在家里，所以多数时间自己是在补觉。既然太累，那就睡觉吧，总比浪费时间的好。下午到咖啡馆做题，一道差错更正一下子让自己的实力暴露
《太虚游》第六十二章。玄牝之威。古楼臭道士
“好好好，流云这孩子深得我心，想必长爻知道是你的话定然会惊喜不已的。”白玄牝听得风流云应了下来，脸色慈和，伸手在他头顶轻轻抚了抚，如同抚在怀中九尾小狐一样自然，极其温柔。身后的四位青丘长老同时一怔，嘴角微动，似要开口劝阻。风流云只感到一道霞光瑞气如有实质一般顺着头顶百会大穴直沉在下丹田内，随后这股气息又逐渐凝聚，似乎给自己吃了什么东西一般。啊喔不好，这祖奶奶该不会是看中我这肉身，像人魔一样，要给她
上班的路毛毛虫小姑娘
七点半起床，拉开窗帘，天公不作美今儿是个阴雨天，天灰蒙蒙的，毛毛雨细细密密洒落下来。脑海里的两个小人开始斗争了，一个说：“毛毛雨啦，穿着风衣打着伞穿行在雨中，是一道亮丽的风景，说不定能遇见帅哥呢！”一个说：“不要不要，走到公司衣服鞋子都潮呼呼的，趴在身上很不舒服，外面湿气这么重，对身体不好！”我思索片刻，慢吞吞为自己冲了杯五谷粉，悠哉悠哉喝完去坐班车了。
小说《灰色年代》第三章、书中自有黄金屋/第二节（1）/作者:邵明房作者_0970
——第三章、第二节、科举与国考（1）科举制的简介：科举制度是古代读书人，参加选拔考试的制度，它是历代通过考试选拔官吏的一种手段，由于采用分科取士的办法，所以叫做科举。科举制从隋代开始实行，到清光绪三十一年（1905年）举行最后一科进士考试为止，经历了1300年，1905年9月2日，清政府废除科举制度。科举考前三名，分别为状元、榜眼、探花。这种划分和称谓是在元朝时确定下来的，明清时期沿袭了元朝的这种
java数字签名三种方式知了ing java jdk
以下3钟数字签名都是基于jdk7的 1，RSA String password="test"; // 1.初始化密钥 KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA"); keyPairGenerator.initialize(51
Hibernate学习笔记 caoyong Hibernate
1>、Hibernate是数据访问层框架，是一个ORM(Object Relation Mapping)框架，作者为:Gavin King 2>、搭建Hibernate的开发环境 a>、添加jar包: aa>、hibernatte开发包中/lib/required/所
设计模式之装饰器模式Decorator（结构型）漂泊一剑客 Decorator
1. 概述若你从事过面向对象开发，实现给一个类或对象增加行为，使用继承机制，这是所有面向对象语言的一个基本特性。如果已经存在的一个类缺少某些方法，或者须要给方法添加更多的功能（魅力），你也许会仅仅继承这个类来产生一个新类—这建立在额外的代码上。
读取磁盘文件txt，并输入String 一炮送你回车库 String
public static void main(String[] args) throws IOException { String fileContent = readFileContent("d:/aaa.txt"); System.out.println(fileContent);
js三级联动下拉框 3213213333332132 三级联动
//三级联动省/直辖市<select id="province"></select> 市/省直辖<select id="city"></select> 县/区 <select id="area"></select>
erlang之parse_transform编译选项的应用 616050468 parse_transform 游戏服务器属性同步 abstract_code
最近使用erlang重构了游戏服务器的所有代码，之前看过C++/lua写的服务器引擎代码，引擎实现了玩家属性自动同步给前端和增量更新玩家数据到数据库的功能，这也是现在很多游戏服务器的优化方向，在引擎层面去解决数据同步和数据持久化，数据发生变化了业务层不需要关心怎么去同步给前端。由于游戏过程中玩家每个业务中玩家数据更改的量其实是很少
JAVA JSON的解析 darkranger java
// { // “Total”：“条数”， // Code: 1, // // “PaymentItems”:[ // { // “PaymentItemID”:”支款单ID”, // “PaymentCode”:”支款单编号”, // “PaymentTime”:”支款日期”, // ”ContractNo”:”合同号”， //
POJ-1273-Drainage Ditches aijuans ACM_POJ
POJ-1273-Drainage Ditches http://poj.org/problem?id=1273 基本的最大流，按LRJ的白书写的 #include<iostream> #include<cstring> #include<queue> using namespace std; #define INF 0x7fffffff int ma
工作流Activiti5表的命名及含义 atongyeye 工作流 Activiti
activiti5 - http://activiti.org/designer/update在线插件安装 activiti5一共23张表 Activiti的表都以ACT_开头。第二部分是表示表的用途的两个字母标识。用途也和服务的API对应。 ACT_RE_*: 'RE'表示repository。这个前缀的表包含了流程定义和流程静态资源（图片，规则，等等）。 A
android的广播机制和广播的简单使用百合不是茶 android 广播机制广播的注册
Android广播机制简介在Android中，有一些操作完成以后，会发送广播，比如说发出一条短信，或打出一个电话，如果某个程序接收了这个广播，就会做相应的处理。这个广播跟我们传统意义中的电台广播有些相似之处。之所以叫做广播，就是因为它只负责“说”而不管你“听不听”，也就是不管你接收方如何处理。另外，广播可以被不只一个应用程序所接收，当然也可能不被任何应
Spring事务传播行为详解 bijian1013 java spring 事务传播行为
在service类前加上@Transactional，声明这个service所有方法需要事务管理。每一个业务方法开始时都会打开一个事务。 Spring默认情况下会对运行期例外(RunTimeException)进行事务回滚。这
eidtplus operate 征客丶 eidtplus
开启列模式: Alt+C 鼠标选择 OR Alt+鼠标左键拖动列模式替换或复制内容(多行): 右键-->格式-->填充所选内容-->选择相应操作 OR Ctrl+Shift+V(复制多行数据,必须行数一致) -------------------------------------------------------
【Kafka一】Kafka入门 bit1129 kafka
这篇文章来自Spark集成Kafka(http://bit1129.iteye.com/blog/2174765)，这里把它单独取出来，作为Kafka的入门吧下载Kafka http://mirror.bit.edu.cn/apache/kafka/0.8.1.1/kafka_2.10-0.8.1.1.tgz 2.10表示Scala的版本，而0.8.1.1表示Kafka
Spring 事务实现机制 BlueSkator spring 代理事务
Spring是以代理的方式实现对事务的管理。我们在Action中所使用的Service对象，其实是代理对象的实例，并不是我们所写的Service对象实例。既然是两个不同的对象，那为什么我们在Action中可以象使用Service对象一样的使用代理对象呢？为了说明问题，假设有个Service类叫AService，它的Spring事务代理类为AProxyService，AService实现了一个接口
bootstrap源码学习与示例：bootstrap-dropdown（转帖） BreakingBad bootstrap dropdown
bootstrap-dropdown组件是个烂东西，我读后的整体感觉。一个下拉开菜单的设计： <ul class="nav pull-right"> <li id="fat-menu" class="dropdown">
读《研磨设计模式》-代码笔记-中介者模式-Mediator bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ /* * 中介者模式（Mediator）：用一个中介对象来封装一系列的对象交互。 * 中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。 * * 在我看来，Mediator模式是把多个对象（
常用代码记录 chenjunt3 UI Excel J#
1、单据设置某行或某字段不能修改 //i是行号,"cash"是字段名称 getBillCardPanelWrapper().getBillCardPanel().getBillModel().setCellEditable(i, "cash", false); //取得单据表体所有项用以上语句做循环就能设置整行了 getBillC
搜索引擎与工作流引擎 comsci 算法工作搜索引擎网络应用
最近在公司做和搜索有关的工作，(只是简单的应用开源工具集成到自己的产品中)工作流系统的进一步设计暂时放在一边了，偶然看到谷歌的研究员吴军写的数学之美系列中的搜索引擎与图论这篇文章中的介绍，我发现这样一个关系(仅仅是猜想) -----搜索引擎和流程引擎的基础--都是图论，至少像在我在JWFD中引擎算法中用到的是自定义的广度优先
oracle Health Monitor daizj oracle Health Monitor
About Health Monitor Beginning with Release 11g, Oracle Database includes a framework called Health Monitor for running diagnostic checks on the database. About Health Monitor Checks Health M
JSON字符串转换为对象 dieslrae java json
作为前言,首先是要吐槽一下公司的脑残编译部署方式,web和core分开部署本来没什么问题,但是这丫居然不把json的包作为基础包而作为web的包,导致了core端不能使用,而且我们的core是可以当web来用的(不要在意这些细节),所以在core中处理json串就是个问题.没办法,跟编译那帮人也扯不清楚,只有自己写json的解析了.
C语言学习八结构体，综合应用，学生管理系统 dcj3sjt126com C语言
实现功能的代码： # include <stdio.h> # include <malloc.h> struct Student { int age; float score; char name[100]; }; int main(void) { int len; struct Student * pArr; int i,
vagrant学习笔记 dcj3sjt126com vagrant
想了解多主机是如何定义和使用的, 所以又学习了一遍vagrant 1. vagrant virtualbox 下载安装 https://www.vagrantup.com/downloads.html https://www.virtualbox.org/wiki/Downloads 查看安装在命令行输入vagrant 2.
14.性能优化-优化-软件配置优化 frank1234 软件配置性能优化
1.Tomcat线程池修改tomcat的server.xml文件： <Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" maxThreads="1200" m
一个不错的shell 脚本教程入门级 HarborChung linux shell
一个不错的shell 脚本教程入门级建立一个脚本　　Linux中有好多中不同的shell，但是通常我们使用bash (bourne again shell) 进行shell编程，因为bash是免费的并且很容易使用。所以在本文中笔者所提供的脚本都是使用bash（但是在大多数情况下，这些脚本同样可以在 bash的大姐，bourne shell中运行）。　　如同其他语言一样
Spring4新特性——核心容器的其他改进 jinnianshilongnian spring 动态代理 spring4 依赖注入
Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API Spring4新
Linux设置tomcat开机启动 liuxingguome tomcat linux 开机自启动
执行命令sudo gedit /etc/init.d/tomcat6 然后把以下英文部分复制过去。（注意第一句#!/bin/sh如果不写，就不是一个shell文件。然后将对应的jdk和tomcat换成你自己的目录就行了。 #!/bin/bash # # /etc/rc.d/init.d/tomcat # init script for tomcat precesses
第13章 Ajax进阶（下） onestopweb Ajax
index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
Troubleshooting Crystal Reports off BW blueoxygen BO
http://wiki.sdn.sap.com/wiki/display/BOBJ/Troubleshooting+Crystal+Reports+off+BW#TroubleshootingCrystalReportsoffBW-TracingBOE Quite useful, especially this part: SAP BW connectivity For t
Java开发熟手该当心的11个错误 tomcat_oracle java jvm 多线程单元测试
#1、不在属性文件或XML文件中外化配置属性。比如，没有把批处理使用的线程数设置成可在属性文件中配置。你的批处理程序无论在DEV环境中，还是UAT（用户验收测试）环境中，都可以顺畅无阻地运行，但是一旦部署在PROD 上，把它作为多线程程序处理更大的数据集时，就会抛出IOException，原因可能是JDBC驱动版本不同，也可能是#2中讨论的问题。如果线程数目可以在属性文件中配置，那么使它成为
正则表达式大全 yang852220741 html 编程正则表达式
今天向大家分享正则表达式大全，它可以大提高你的工作效率正则表达式也可以被当作是一门语言，当你学习一门新的编程语言的时候，他们是一个小的子语言。初看时觉得它没有任何的意义，但是很多时候，你不得不阅读一些教程，或文章来理解这些简单的描述模式。一、校验数字的表达式数字：^[0-9]*$ n位的数字：^\d{n}$ 至少n位的数字：^\d{n,}$ m-n位的数字：^\d{m,n}$