Question

我想生成随机线性/数学方程。我有两个输入，最终结果和运算符的数量。例如：

result = 84
noOfOperators = 3

所以我希望等式为15 + (20 * 4) - 11 = 84。

Answer 1

考虑到没有未知因素，甚至不确定这是否是一个等式： - ）

无论哪种方式，都有很多变化。想到的一种算法是这样的：

从最终结果开始
选择“最后一次操作”
根据操作，生成两个合适的参数。可能是这样的：
- 用于乘法，生成素数因子并将每个素数因子随机地放在两个参数之一上。如果只有一个主要因素，则更改为“无操作”（除非您喜欢有1 * n个术语）
- 对于除法，加法和减法，你可能只是生成一个随机的“第二个参数”
- 编辑：对于“无操作”（参见下一步），只生成一个与输入相同的参数。这只是为了更容易递归，因为你也可以在那里递归
对每个参数执行相同操作，也允许“无操作”

还需要决定停止的合适条件。编辑：你的'运营商数量'可以提供。不要算“没有操作”，你会没事的。

这将为您提供一个带有结果的表达式树，并且还可以坚持整数领域（如果这样可以创建小学数学问题，那么这通常是您想要的）

Answer 2

输入结果和n（运算符）
生成n + 1个随机数据和n个随机运算符。
根据随机数据计算答案。
对于每个数据d，如果d之前的运算符不是＆＃39; *＆＃39;要么＆＃39; /＆＃39;，让d = d *结果/回答。
打印数据和操作员。

测试代码如下：

#include <iostream>
#include <stdlib.h>
#include <stack>
#include <time.h>

using namespace std;

#define MAX_RAN 100

char OpDisplay(int i)
{
    switch(i)
    {
        case 0: return '+';
        case 1: return '-';
        case 2: return '*';
        case 3: return '/';
        default: break;
    }
    return '+';
}

double CalOp(double a, double b, int Op)
{
    switch(Op)
    {
        case 0: return (a+b);
        case 1: return (a-b);
        case 2: return (a*b);
        case 3: return (a/b);
    }
    return 0;
}

int main(int argc, char* argv[])
{
    srand( (unsigned)time( NULL ) );

    int result;
    int numOp = 1;
    cout<<"Enter the Result:";
    cin>>result;
    cout<<"Enter the number of operators:";
    cin>>numOp;

    double* pData = new double[numOp+1];
    int* pOp = new int[numOp];

    for(int i = 0; i < numOp; i++)
    {
        //Generate Num
        pData[i] = rand()% MAX_RAN;
        //Generate Op
        pOp[i] = rand()%4;  
    }
    pData[numOp] = rand()% MAX_RAN;

    stack<double> sD;
    stack<int> sOp;
    sD.push(pData[0]);

    //caluculate * and / first
    for(int i = 0; i < numOp; i++)
    {
        if(pOp[i]>1)    // * or /
        {
            double re = sD.top();
            re = CalOp(re, pData[i+1],pOp[i] );
            sD.pop();
            sD.push(re);
        }
        else
        {
            sOp.push(pOp[i]);
            sD.push(pData[i+1]);
        }
    }

    stack<double> sD_R;
    stack<int> sOp_R;
    //reverse the stack
    while(!sD.empty())
    {
        sD_R.push(sD.top());
        sD.pop();
    }
    while(!sOp.empty())
    {
        sOp_R.push(sOp.top());
        sOp.pop();
    }

    //calculate + and -
    double answer = sD_R.top();
    sD_R.pop();
    while(!sOp_R.empty())
    {
        answer = CalOp(answer, sD_R.top(), sOp_R.top());
        sD_R.pop();
        sOp_R.pop();
    }

    //resign the data according to the answer and the result we entered before.
        for(int i = 0; i < numOp; i++)
    {
        cout<<"("<<pData[i]<<")"<<OpDisplay(pOp[i]);
    }
    cout<<"("<<pData[numOp]<<")"<<" = "<<answer<<endl;

    pData[0] = pData[0]*result/answer;
    for(int i = 1; i < numOp+1; i++)
    {
        if(3 != pOp[i-1] && 2 != pOp[i-1] )
        {
            pData[i] = pData[i]*result/answer;
        }

    }

    for(int i = 0; i < numOp; i++)
    {
        cout<<"("<<pData[i]<<")"<<OpDisplay(pOp[i]);
    }
    cout<<"("<<pData[numOp]<<")"<<" = "<<result<<endl;

    delete[] pData;
    delete[] pOp;   
}

如何生成随机线性方程

2 个答案: