精华内容
下载资源
问答
  • 随机生成算式

    2019-03-21 17:53:47
    <!doctype html> <head> <meta charset="UTF-8"> ...算式</title> <style> div.font{ font-size:10px; } </style> </head> <body> ...
    <!doctype html>
    
     <head>
      <meta charset="UTF-8">
      <title>算式</title>
      <style>
      div.font{
          font-size:10px;
      }
      </style>
     </head>
     <body>
     <button onclick='myFunction()'>click</button>
     <script>   
     function myFunction(){  
    	 
        var c,i,a,b;
    	
    	for(var j=1;j<=100;j++){
    	a=Math.floor(Math.random()*100);
    	b=Math.floor(Math.random()*100);
    	c=Math.floor(Math.random()*4+1);
    	
    	if(c==1)
    	    i=' + ';
    	else if(c==2)
    	    i=' - ';
    	else if(c==3)
    	    i=' * ';
    	else 
    	    i=' ÷ ';
    	
    	if(a<b && i==' - ')
    	    document.write( b + i + a + '='+"<div class='font'> </div>");
    	else if(b==0 && i==' ÷ ')
    	    continue;
    	else
    	    document.write( a+ i + b + '='+"<div class='font'> </div>");
    
    	if(j%5==0)
    	    document.write('<br>');
        }
    
    }   
     </script>
     </body>
    </html>
    
    
    展开全文
  • 分析:实现随机生成算式,支持括号和四则运算。 思路:先生成随机字符数组,然后生成随机数组,两者拼接。支持指定范围生成,和指定算式的长度。 代码 package com.instance; import java.util.ArrayList; import ...

    分析:实现随机生成算式,支持括号和四则运算。

    思路:先生成随机字符数组,然后生成随机数组,两者拼接。支持指定范围生成,和指定算式的长度。

    代码
    package com.instance;

    import java.util.ArrayList;
    import java.util.List;
    import java.util.Random;

    public class Create_title

    public String create_title( int range, int num2) //num:提目数 range:范围 num2:题目组成数量

    Random random = new Random(range);

    String char_arrays = null;
    int num3 = (int) (Math.random() * num2);//分数的个数
    int num4 = num2 - num3;//正数个数
    int charNum = num2 - 1;//符号个数

    int bracketL = 0;//(位置

    int int_arrays = new intnum4 + num3 * 2;
    boolean flag = isBracket();
    if(flag)
    char_arrays = returnChar(num3,charNum+2,flag);

    }else
    char_arrays = returnChar(num3,charNum,false);
    }

    for(int w=0;w<num2;wint_arraysw = random.nextInt(range);
    }
    String title = “”;
    if(char_arrays0.equals("("))
    for(int i = 0;i<num2;ititle +=char_arraysi+((int)(Math.random()*range)+"");
    }
    if(char_arraysnum2.equals(")"))
    title += “)”;
    }

    }else
    for (int i = 0; i <= num2; ititle += ((int) (Math.random() * range) + “”) + char_arraysi;
    }
    }
    if(title.charAt(title.length()-1)’+'title.charAt(title.length()-1)’/'title = title.substring(0,title.length()-1);
    }

    return title;
    }

    boolean isBracket()
    return true;
    }

    String returnChar(int mark,int charNum,boolean flag)
    Random random = new Random();
    String char_array = new StringcharNum;

    if(flag)
    int bracketL = random.nextInt(charNum-2);//(位置,最后一位和倒数第二位不能是(

    int j = charNum - bracketL - 2;

    int bracketR = bracketL+random.nextInt(j) + 2;//)位置这个随机数可以生成0

    if(bracketL!=0)
    char_arraybracketL = “+(”;
    }else
    char_arraybracketL = “(”;

    }

    if(bracketRcharNum-1)
    char_arraybracketR = “)”;
    }else
    char_arraybracketR = “)-”;
    }
    }
    int mark1 = 0;
    while(true)
    if(mark1
    mark)
    break;
    }
    int i = (int)(Math.random()*charNum);
    if(char_arrayi==null)
    char_arrayi="/";
    mark1}

    }
    int num = 0;
    while(true)

    if(num == charNum)break;
    if(char_arraynum == null)
    int i= (int)(Math.random()2);
    switch (i)
    case 0:char_arraynum="
    ";
    break;
    case 1:char_arraynum="+";
    break;
    case 2:char_arraynum="-";
    break;
    }
    }

    num
    }
    return char_array;
    }

    }
    调用
    在这里插入图片描述
    [结果展示
    在这里插入图片描述

    展开全文
  • 随机生成一年级加减法算式 支持指定算式数量,被减数、和的最大值,是否只生成退位减法算式,每页几个算式,生成几页等;
  • 随机生成30个四则运算算式,这并没有什么难度。关键是要注意除数不能为0这个细节。 int firNum = (int)(1 + Math.random()*98);这是另一个需要注意的细节,这条语句如果写成了int firNum = 1 + (int)Math.random()...

    package classWork;
    import java.lang.Math;
    public class MathTest1 {

    /**
    * @param args
    */
    public static void main(String[] args) {
    // TODO Auto-generated method stub
    for(int i = 0;i < 30;i++)
    {
    int firNum = (int)(1 + Math.random()*99);//生成1到99的随机数
    int secNum = 1 + (int)(Math.random()*99);
    int operaNum = 1 + (int)(Math.random()*4);//用1到4分别代表加减乘除
    if(operaNum == 1)
    {
    System.out.println(firNum + "+" + secNum + "=?");
    }
    if(operaNum == 2)
    {
    System.out.println(firNum + "-" + secNum + "=?");
    }
    if(operaNum == 3)
    {
    System.out.println(firNum + "*" + secNum + "=?");
    }
    if(operaNum == 4)
    {
    if(secNum != 0)
    {
    System.out.println(firNum + "/" + secNum + "=?");
    }
    else if(firNum != 0)
    {
    System.out.println(secNum + "/" + firNum + "=?");
    }
    else
    {
    System.out.println(30 + "/" + 15 + "=?");
    }

    }
    }

    }

    }

    程序运行结果如下:

    随机生成30个四则运算算式,这并没有什么难度。关键是要注意除数不能为0这个细节。

    int firNum = (int)(1 + Math.random()*98);这是另一个需要注意的细节,这条语句如果写成了int firNum = 1 + (int)Math.random()*98,那么就会有一种很奇怪的现象,那就是firNum一直是1.这是因为取整的优先级要高于乘法的优先级,因此即使是在简单的程序,我们也要亲手去把它们实现了,避免出现眼高手低的情况。还有一个问题就是修改了代码之后,必须要保存更改。要不然程序运行的还是没修改以前的代码的结果,这样即使是程序完全正确也不能够显示出我们想要的结果来。

    转载于:https://www.cnblogs.com/1102whw/p/5250738.html

    展开全文
  • c++实现计算器(自动生成算式并计算) 要满足的需求有以下几个: 自动生成随机的四则运算算式,包含括号和小数。 对生成的算式计算出结果。 算式、结果分别存储到不同的文件。 一 生成算式 由上述需求可知,算式中...

    c++实现计算器(自动生成算式并计算)

    要满足的需求有以下几个:

    1. 自动生成随机的四则运算算式,包含括号和小数。
    2. 对生成的算式计算出结果。
    3. 算式、结果分别存储到不同的文件。

    一 生成算式

    由上述需求可知,算式中有运算符('+','-','*','/','(',')'),整数,小数(重点是有小数点),同时满足程序模块化设计的要求,所以使用STL中的string类存储生成的算式。
    生成算式时有几点需要注意:

    • 首先生成一个数字,然后运算符('+','-','*','/')和数字交替出现,可以限定长度为奇数,在偶数位置(位置从0开始)生成数字,奇数位置生成运算符。
    • 生成数字有整数有小数。使用一个随机变量控制生成的小数和整数的比例。
    • 生成小数时控制好位数、大小。
    • 生成括号时注意一个左括号一定要有一个右括号对应,因此设置一个变量存储剩余要生成的右括号的数量,即每生成一个左括号该变量加一,没生成一个右括号该变量减一。同时控制除非到了算式最后,不会出现一对括号只括住一个数字的情况。
      在程序中,以上这些由string GenerateExpression()实现,同时它还会调用int GenerateRightBracket()int GenerateLeftBracket()char GenerateOperator()double GeneratNumber()int GenerateInt()

    二 中缀表达式转为逆波兰式

    逆波兰式即后缀表达式,栈可以方便的在计算机中计算后缀表达式的值。

    将一个普通的中序表达式转换为逆波兰表达式的一般算法是:
    首先需要分配2个栈,一个作为临时存储运算符的栈S1(含一个结束符号),一个作为输入逆波兰式的栈S2(空栈),S1栈可先放入优先级最低的运算符#,注意,中缀式应以此最低优先级的运算符结束。可指定其他字符,不一定非#不可。从中缀式的左端开始取字符,逐序进行如下步骤:

    • 若取出的字符是操作数,则分析出完整的运算数,该操作数直接送入S2栈
    • 若取出的字符是运算符,则将该运算符与S1栈栈顶元素比较,如果该运算符优先级(不包括括号运算符)大于S1栈栈顶运算符优先级,则将该运算符进S1栈,否则,将S1栈的栈顶运算符弹出,送入S2栈中,直至S1栈栈顶运算符低于(不包括等于)该运算符优先级,最后将该运算符送入S1栈。
    • 若取出的字符是“(”,则直接送入S1栈顶。
    • 若取出的字符是“)”,则将距离S1栈栈顶最近的“(”之间的运算符,逐个出栈,依次送入S2栈,此时抛弃“(”。
    • 重复上面的1~4步,直至处理完所有的输入字符
    • 若取出的字符是“#”,则将S1栈内所有运算符(不包括“#”),逐个出栈,依次送入S2栈。

    以上来自逆波兰式-百度百科,完成以上步骤,S2栈便为逆波兰式输出结果。不过S2应做一下逆序处理。

    在本程序中,使用队列(queue)取代栈S2,省去逆序处理的步骤,这些步骤由函数queue<string> ConvertToRpn(string s,map<string,int>p,map<char,int>p_char)实现。

    三 计算逆波兰式

    新建一个表达式,如果当前字符为变量或者为数字,则压栈,如果是运算符,则将栈顶两个元素弹出作相应运算,结果再入栈,最后当表达式扫描完后,栈里的就是结果。

    计算功能由double Operation(queue<string> q)实现,同时它还会调用double Calculate(double n1, double n2, char c)

    三 存储到文件

    程序运行结果包括单纯的中缀表达式和含结果的中缀表达式,分别存储到不同的文件。两文件分别如下:

    1506386-20181021204348753-1541386487.png
    1506386-20181021204351802-621822562.png

    完整代码

    /*
        构建之法第一章习题一,实现自动生成四则运算的算式并判断用户计算的正误。
        计划分三步走:
        1.自动生成算式
        2.输入算式转换为逆波兰式
        3.计算算式结果
    */
    #include<iostream>
    #include<string>
    #include<sstream>
    #include<stack>
    #include<queue>
    #include<map>
    #include<fstream>
    using namespace std;
    
    //将中缀表达式转换为逆波兰式
    queue<string> ConvertToRpn(string s,map<string,int>p,map<char,int>p_char)
    {
        int length = s.length();
        string temp_s="";
        string temp_for_push;
        stack<string>sk1;
        queue<string>sk2;
        sk1.push("#");
        for (int i = 0; i < length;)
        {
            if (isdigit(s[i]))
            {//判断字符是否是0~9的数字
                while (isdigit(s[i]) || s[i] == '.')
                {
                    temp_s = temp_s + s[i];
                    i++;
                }
                sk2.push(temp_s);
                temp_s.clear();
            }
            else
            {
                if (s[i] == '+' || s[i] == '-' || s[i] == '*' || s[i] == '/'||s[i]=='^')
                {
                    if (p_char[s[i]] >p[sk1.top()])
                    {
                        temp_for_push.clear();
                        temp_for_push = temp_for_push + s[i];
                        sk1.push(temp_for_push);
                        i++;
                    }
                    else
                    {
                        while (p_char[s[i]] <= p[sk1.top()])
                        {
                            sk2.push(sk1.top());
                            sk1.pop();
                        }
                        temp_for_push.clear();
                        temp_for_push = temp_for_push + s[i];
                        sk1.push(temp_for_push);
                        i++;
                    }
                }
                else if (s[i] == '(')
                {
                    temp_for_push.clear();
                    temp_for_push = temp_for_push + s[i];
                    sk1.push(temp_for_push);
                    i++;
                }
                else if(s[i]==')')
                {
                    while (sk1.top() != "(")
                    {
                        sk2.push(sk1.top());
                        sk1.pop();
                    }
                    sk1.pop();
                    i++;
                }
            }
            if (i == length)
            {
                while (sk1.size() != 1)
                {
                    sk2.push(sk1.top());
                    sk1.pop();
                }
            }
        }
        return sk2;
    }
    
    //生成随机小数
    double GeneratNumber()
    {
        double number;
        int temp;
        number = ((double)rand()) / ((double)(rand()/50));
        temp = number * 10;
        number = ((double)temp) / 10;
        number = number - (int)number + (int)number % 49;
        return number;
    }
    
    //生成随机整数
    int GenerateInt()
    {
        double int_number;
        int_number = rand() % 49;
        return int_number;
    }
    
    //计算逆波兰式中简单表达式
    double Calculate(double n1, double n2, char c){
        double result = 0;
        if (c == '+'){
            result = n1 + n2;
        }
        else if (c == '-'){
            result = n2 - n1;
        }
        else if (c == '*'){
            result = n1*n2;
        }
        else if (c == '/'){
            result = n2 / n1;
        }
        return result;
    }
    
    //计算逆波兰式
    double Operation(queue<string> q)
    {
        stack<double> temp_for_digit;
        char temp_for_char;
        double temp_for_push = 0;
        double num1, num2;
        double temp_result = 0;
        int length = q.size();
        stringstream ss;
        while (q.size() != 0)
        {
            if (isdigit(q.front()[0]))
            {
                ss << q.front();
                ss >> temp_for_push;
                temp_for_digit.push(temp_for_push);
                q.pop();
                ss.clear();
            }
            else
            {
                temp_for_char = q.front()[0];
                q.pop();
                num1 = temp_for_digit.top();
                temp_for_digit.pop();
                num2 = temp_for_digit.top();
                temp_for_digit.pop();
                temp_result = Calculate(num1, num2, temp_for_char);
                temp_for_digit.push(temp_result);
            }
        }
        return temp_result;
    }
    
    //生成随机运算符
    char GenerateOperator()
    {
        char result;
        int which = rand() % 6;
        if (which == 0 || which == 4)
        {
            result = '+';
        }
        else if (which == 1 || which == 5)
        {
            result = '-';
        }
        else if (which == 2)
        {
            result = '*';
        }
        else if (which == 3)
        {
            result = '/';
        }
        return result;
    }
    
    //生成左括号
    int GenerateLeftBracket()
    {
        int result = 0;
        int whether_bracket = rand() % 7;
        if (whether_bracket ==1)
        {
            result = 1;
        }
        return result;
    }
    
    //生成右括号
    int GenerateRightBracket()
    {
        int result = 0;
        int whether_bracket = rand() % 7;
        if (whether_bracket <= 5)
        {
            result = 1;
        }
        return result;
    }
    
    //生成表达式
    string GenerateExpression()
    {
        string expression = "";
        string temp_string;
        int count_right_bracket = 0;
        int length = 3;
        int location_for_last_bracket = 0;
        length += 2*(rand() % 15);
        stringstream ss;
        double temp_num;
        int whether_int = 0;
        int whether_bracket = 0;
        for (int i = 0; i < length; i++)
        {
            whether_int = rand() % 5;
            if (i % 2 == 0)
            {
                if (whether_int <= 3)
                {//80%生成整数
                    temp_num = GenerateInt();
                }
                else
                {
                    temp_num = GeneratNumber();
                }
                ss << temp_num;
                ss >> temp_string;
                expression += temp_string;
                ss.clear();
                if (count_right_bracket&&i>=location_for_last_bracket+3)
                {
                    if (GenerateRightBracket())
                    {
                        count_right_bracket -= 1;
                        expression += ')';
                    }
                }
            }
            else
            {
                expression += GenerateOperator();
                whether_bracket= GenerateLeftBracket();
                if (whether_bracket == 1)
                {
                    expression += '(';
                    count_right_bracket += whether_bracket;
                    location_for_last_bracket = i;
                }
            }
        }
        while ((count_right_bracket--) != 0)
        {
            expression += ')';
        }
        return expression;
    }
    
    int main()
    {
        map<string, int> priorites;
        priorites["+"] = 1;
        priorites["-"] = 1;
        priorites["*"] = 2;
        priorites["/"] = 2;
        priorites["^"] = 3;
        map<char, int> priorites_char;
        priorites_char['+'] = 1;
        priorites_char['-'] = 1;
        priorites_char['*'] = 2;
        priorites_char['/'] = 2;
        priorites_char['^'] = 3;
        string expression;
        queue<string> RPN;
        double result;
        int count_expression;
        ofstream just_expression, answer;
        just_expression.open("expression.txt");
        answer.open("answer.txt");
        cout << "how many expressions do you want: " << endl;
        cin >> count_expression;
        for (int i = 0; i<count_expression; i++)
        {
            expression = GenerateExpression();
            RPN = ConvertToRpn(expression,priorites,priorites_char);//得到后缀表达式
            result = Operation(RPN);
            just_expression << i+1 << ".  " << expression << endl;
            answer << i+1 << ".  " << expression << " = " << result << endl;
            expression.clear();
            RPN = queue<string>();//清空当前队列
        }
        just_expression.close();
        answer.close();
        cout << "finished" << endl;
        system("pause");
        return 0;
    }

    转载于:https://www.cnblogs.com/thechosenone95/p/9826744.html

    展开全文
  • 此次程序使用了“ctime”头文件,用来获取时间,用rand()函数生成随机数...代码如下://主要功能:随机生成四个1~13之间的数字,进行24点运算,输出所有成立的算式。 #include "stdafx.h" #include "iostream" #incl
  • 随机产生算式(vector和random)

    千次阅读 2016-11-03 14:25:12
    随机产生4个整数(0~99),生成一道混合运算题,让用户给出答案。共生成10到混合运算题,每题10分,完成后对用户的答题给出分值,并且显示出用户哪些题错误,哪些题正确。错误的给出正确答案。其中“+”、“-”运算符...
  • 1 #include<iostream> 2 #include<cstdlib> 3 #include<ctime> 4 using namespace std; 5 #define random(x) (rand()%x) 6 int gcd(int a,int b){ 7 if(b==0)return a;... 8 ...
  • 随机生成50道加减算术题

    千次阅读 2021-01-20 13:50:38
    随机生成50道100以内的加减法及混合运算习题数字。 可以实现批改操作。 可以统计正确及错误数量。 二、内容 (一)模块化软件构造 在模块化软件构造中,有如下几个重要问题: 采用什么数据结构类,这里采用的是...
  • 1.程序可接收一个输入参数n,然后随机产生n道加减乘除练习题,每个数字在 0 和 100 之间,运算符在3个到5个之间。 2.每个练习题至少要包含2种运算符。 3.练习题在运算过程中不得出现负数与非整数,比如不能出 3/5+...
  • 用c++随机生成10小学生算术题的课设

    千次阅读 2019-12-28 14:36:50
    面向小学1~2年级学生,随机选择两个整数和加减法形成算式要求学生解答。 功能要求: (1)电脑随机出10道题,每题10分,程序结束时显示学生得分; (2)确保算式没有超出12年级的水平,只允许进行50以内的加减法,不...
  • * 生成次数为正整数,根据生成次数,随机生成随机册数次的加减运算 */ Random r = new Random(); int i = 0; while (true) { i = r.nextInt(); if (i >= 0) break; } System.out.println(“开始>>>>>...
  • 随机生成算式和式子的答案 3.生成算式和答案的txt文件来保存算式和答案 思路: 生成里的运算数分为三个部分,整数,如果是分数就再分为分子和分母,然后为这三个部分创建数组,然后将运算符插入到四个运算数...
  • 随机函数生成的随机数是有周期、有规律的(源于同样的算式)。用随机函数辅助生成没有周期、没有规律的(或者很难找到规律)序列值是很有意义的,密码学需要这样的序列(数组)。 
  • 本软件基于C#,SQL Server,功能,用户注册,登录,输入希望生成试题的总数n点击“生成试题”按钮便可随机生成n道加减乘除的算式。答题过程总可点击“当前得分”查看已答题目是否正确。中途可退出。下次登录后点击...
  • 1.程序可接收一个输入参数n,然后随机产生n道加减乘除(分别使用符号±*÷来表示)练习题,每个数字在 0 和 100 之间,运算符在3个到5个之间。 2.每个练习题至少要包含2种运算符。同时,由于小学生没有分数与负数的...
  •  为节省父母出题的时间,加强孩子的计算能力,需要设计出可以随机生成算式的程序 二、功能设计 基本功能  (1)自动生成10道100以内的2个操作数的四则运算算式(+ - * /),要求运算结果也在100以内  (2)...
  • 1.需求分析: (1)自动生成四则运算算式(+ - * /),或两则运算(+ -)。...基本功能:随机生成算式,可控制题目数量及相关参数。筛选重复的算式并剔除。 拓展功能:当操作数生成负数是会产生小括号。 ...
  • 随机生成算式在那篇代码里只是小儿科,用来显示函数功能的附属品。 大整数运算审查地址 大整数运算代码地址 一、题目要求: 我们在刚开始上课的时候介绍过一个小学四则运算自动生成程序的例子,请实现它,要求: 1....
  • 结对项目总结

    2016-06-20 17:35:00
    本质上来说,是将上回的计算功能模块化,再加入随机生成算式的功能模块,最后把他们附在界面上调用。 在这次结对编程过程中,我们主要完成了以下几点: 1、随机生成算式 2、能选择生成算式的长度 3、能够选择...
  • 经过前面的分析,随机对象生成只是需要三个方法: 方法1. 通过索引元素(由子类实现),可以理解为将一个数字转换为一个具体的对象; 方法2. 获取一个随机对象的方法(模板提供)。 方法3. 获取多个随机对象的...
  • 采取面向对象的方法,四则运算自动出题软件,根据需求可以划分为几个类?...1.生成算式类,它用来随机生成数字与四则运算符号,从而随机生成算式 class ramdom { private: int number[4]; int ari[3]; public: ...
  • 四则运算2

    2017-12-06 19:08:00
    ⑶ 实现随机生成算式的功能,并按照用户输入的题目数量生成相应数量的题目。 ⑷ 将生成的算式写入数据库中,并将用户做对的题目与做错的题目分开存放。 ⑸ 实现计时的功能。 2.程序源代码 登录界面 <%@ ...
  • 实现功能: 1.整数和真分数的四则运算, 运算数和运算结果都可以是整数或分数; 2.能生成任意个运算数的算式; 3.算式的个数、数的范围、运算数的个数... 方法成员包括两个构造函数,其中一个随机生成算式并计算结...
  • 实现功能: 1.整数和真分数的四则运算, 运算数和运算结果都可以是整数或分数; 2.能生成任意个运算数的算式(不超过... 方法成员包括一个初始化函数,随机生成算式并计算结果;一个输出函数,用来打印算式;以及...
  • 随机生成分数四则运算到指定word文档,可以定义分母最大值,需要生成的算式个数,每个算式下留空给学生计算,答案自动生成在文档最后页。
  • 2015个人项目——四则运算题目生成程序 性能测试 生成表达式 首先我们来看一组图: 生成500算式 ...生成运算表达式是完全随机的方式,而且是用标准文法的方式生成,所以运算式很容易产生,因而占用...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 165
精华内容 66
关键字:

随机生成算式