zoukankan      html  css  js  c++  java
  • 四则运算2

    
    1设计思想:
    通过递归调用来完成运算式中括号的层层数
    随机的选取第一个产生的算式进行替换,用另一个二元运算替换
    如此随机抽取替换,同时判断是否加加括号。
    最后用expressoion字符串来记录运算式
     
    2源程序代码
     
    #writher gu peng
    #edit date 20160312
    
    from fractions import Fraction#分数
    from random import randint#随机数
    
    def layer(layer_accual2,operat_number2,brackets2,layer_amount2):#递归程序
    
    
        if(layer_accual2>0):#对第一层开始计算,将形成3个以上的数字,层数暂时为设定的3。
             #选择数字标号
            #print"layer_accual2",layer_accual2
            opreation_radom=randint(0,layer_accual2-1)#第一层加1,抽取号码,进行替换
            find_operat_number=operat_number[opreation_radom]
            #即两个数中选择一个数进行替换成为一个简单的四则二元运算
            #print "operater_num",operater_num
            #将选中的数字从第二层开始,用一个简单的二元运算式替换选中的数字,并插入数组
            #插入时依据数字编号判断是否加入括号,依据此数字所在的周围是否有*符号
            #判断是否有添加括号
            if((operator[opreation_radom]=="/")or(operator[opreation_radom]=="*")or(operator[opreation_radom+1]=="/")or(operator[opreation_radom+1]=="*")):#判断选中数字周围的符号
                brackets[layer_accual2]=1
            if(multiplication_and_division==2):
                brackets[layer_accual2]=0
    
    
        operater_num=randint(1,multiplication_and_division)  #将运算符入数组
        operator_one="?"
        if(operater_num==1):
            operator_one="+"
        if(operater_num==2):
            operator_one="-"
        if(operater_num==3):
            operator_one="*"
        if(operater_num==4):
            operator_one="/"
            
        if(layer_accual2==0):
            operator[1]=operator_one
        else:
            
            mov_amount=layer_accual2+2-opreation_radom
            for i in range(0,mov_amount):
                operator[layer_accual2+2-i]=operator[layer_accual2+2-i-1]
                #print"i",i 
            operator[opreation_radom+1]=operator_one
            
        zhen_zheng=randint(1,2)  #是真分数或者整数,随机
        if(fraction_exist==0):
            zhen_zheng=1
        if(zhen_zheng==1):          #产生第一个数字 
            first_num=randint(0,number_range)
            first_num=str(first_num)
        else:
            first_num1=2
            first_num2=1
            while (first_num1>=first_num2):
                first_num1=randint(1,number_range)
                first_num2=randint(1,number_range)
            first_num=Fraction(first_num1,first_num2)
            if(first_num!=0):
                first_num="("+str(first_num)+")"        
            first_num=str(first_num)
        zhen_zheng=randint(1,2)  #是真分数或者整数,随机
        if(fraction_exist==0):
            zhen_zheng=1
        if(zhen_zheng==1):          #产生第二个数字 
            second_num=randint(0,10)
            second_num=str(second_num)
        else:
            second_num1=2
            second_num2=1
            while (second_num1>=second_num2):
                second_num1=randint(1,number_range)
                second_num2=randint(1,number_range)
            second_num=Fraction(second_num1,second_num2)
            if(second_num!=0):
                second_num="("+str(second_num)+")"  
    
        if(layer_accual2==0):#第0层,将最开始的两个数字存入数组
            operat_number[0]=first_num
            operat_number[1]=second_num
            if(negative_exit==0):#(如果不存在负数)
                if(second_num>first_num and operator_one==2):
                    while(second_num>=first_num):
                        second_num=randint(1,number_range)
                        
            if(remainder==0):#(如果不存在余数)
               if(operator_one==4):
                    while(second_num%first_num!=0):
                        print"remainder"
                        second_num=randint(1,number_range)
    
    
    
    
        #从第一层开始存入两个数字
        if(layer_accual2>0):
            mov_amount=layer_accual2+2-opreation_radom
            for i in range(0,mov_amount):
                operat_number[layer_accual2+1-i]=operat_number[layer_accual2+1-i-1]
            operat_number[opreation_radom]=first_num
            operat_number[opreation_radom+1]=second_num
    
    
        #整理算式
        if(layer_accual2==1):
            tempperate1=str(operat_number[0])
            tempperate2=str(operat_number[1])
            expressions=operat_number[0]+operator[1]+operat_number[1]
          
        if(layer_accual2>1):
            #先找到替换数字,然后产生表达式2,用2替换表达式1
            global expressions
            kk=str(operat_number[opreation_radom])
            expressions2=first_num+operator_one+second_num
            #创建一个查找机制,寻找不同的数字将其替换?
            #while(same_amount>0):
                
            expressions=expressions.replace(find_operat_number,expressions2)
            
        layer_accual2=layer_accual2+1
        if(layer_accual2<layer_amount2+1):
            layer(layer_accual2,operat_number2,brackets2,layer_amount2)
    
    
    ##############程序开始
    expressions_amount=5#算式数量
    layer_amount=2  #层数,即数的个数
    number_range=10#整数数值的大小范围
    fraction_exist=1#是否有分数
    multiplication_and_division=2#是否有乘除,有则为4
    negative_exit=0#负数是否存在,1存在
    remainder=0#余数是否存在,1存在
    pritenr=1#打印机模式
    quit_num=1
    print "expressions_amount",expressions_amount
    for counter1 in range(0,expressions_amount):
        #准备部分,执行参数,运算层数,运算到的层数
        layer_accual=0
        operator=['k']*(layer_amount+3)#记录运算符的记录
        operat_number=["?"]*(layer_amount+2)#记录运算数的记录器
        brackets=[0]*(layer_amount+1)#记录括号的存在标志
        operator[0]="?"
        operator[2]="?"
        layer(layer_accual,operat_number,brackets,layer_amount)
        #expressions_mul[counter1]=expressions#查重功能
    
    while(quit_num==1):
        
        print"打印方式,1为屏幕显示,2为导出为txt文件"
        temp=input()
        while(temp!=1 and temp!=2):
            print"请重新输入"
            temp=input()
        pritenr=temp
        
        print"是否有括号,支持十个参数参与计算,1为无括号,2为有括号"
        temp=input()
        while(temp!=1 and temp!=2):
            print"请重新输入"
            temp=input()
        multiplication_and_division=2*temp
            
        print"数值范围"
        number_range=input()
        
        print"加减有无负数,1为有负数,0为无负数"
        temp=input()
        while(temp!=0 and temp!=1):
            print"请重新输入"
            temp=input()
        negative_exit=temp
            
        print"除法有无余数,1为有余数,0为无余数"
        temp=input()
        while(temp!=1 and temp!=2):
            print"请重新输入"
            temp=input()
        remainder=temp
    
        print"总数"
        expressions_amount=input()
        #expressions_mul="XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"*expressions_amount
        #print expressions_mul
        print"start"
        for counter1 in range(0,expressions_amount):
            #准备部分,执行参数,运算层数,运算到的层数
            layer_accual=0
            operator=['k']*(layer_amount+3)#记录运算符的记录
            operat_number=["?"]*(layer_amount+2)#记录运算数的记录器
            brackets=[0]*(layer_amount+1)#记录括号的存在标志
            operator[0]="?"
            operator[2]="?"
            layer(layer_accual,operat_number,brackets,layer_amount)
            #expressions_mul[counter1]=expressions#查重功能
            if(pritenr==1):
                print expressions
            else:
                f = file('output.txt', 'a')
                f.write(expressions+"
    ")
                #f.write(expressions)
    
        print"退出?0为退出,1为继续"
        temp=input()
        while(temp!=0 and temp!=1):
            print"请重新输入"
            temp=input()
        quit_num=temp


    3运行结果截图




    4
    开发过程
    独立开发,最开始设计递归,要用到的参数,是如何设计数组,
    需要几组存数据的数组,如何对数据进行保存,产生下一个产
    生式,如何回到上一层。思考好了之后开始进行试验,编写。
    遇见了很多错误,逐一修改,尽量减少出错的可能性。

    5计划日志:
    第一天设计
    第二天开始实现部分功能,首先完成递归功能的实现
    第三天开始编写各种记录信息的功能,
    第四天功能异常,检查排除问题
    第五天实现了实验的最基本要求,随机产生括号成功,
    同时存在小bug,无法在短时间内解决,开始进行程序
    的输入输出,以及其他小功能的完善
    6时间记录日志:

    星期 开始时间 结束时间 行为
    * * *
    * * *
    14:00 20:00 设计,并开始编写基本递归结构
    16:00 20:00 编写记录小部件,数组的设定 
     16:00 21:00 数组紊乱,修复功能
    10:00 15:00 周五未完成,继续修复错误。完善其他功能

    7缺陷记录日志

    缺陷 日期 原因 修改时长 如何修正
    记录符号数组出错        
    记录数字符号出错        
    递归层次错误        



      

  • 相关阅读:
    Linux内核网络协议栈优化总纲
    Java实现 蓝桥杯VIP 算法训练 连续正整数的和
    Java实现 蓝桥杯VIP 算法训练 连续正整数的和
    Java实现 蓝桥杯VIP 算法训练 寂寞的数
    Java实现 蓝桥杯VIP 算法训练 寂寞的数
    Java实现 蓝桥杯VIP 算法训练 学做菜
    Java实现 蓝桥杯VIP 算法训练 学做菜
    Java实现 蓝桥杯VIP 算法训练 判断字符位置
    Java实现 蓝桥杯VIP 算法训练 判断字符位置
    Java实现 蓝桥杯VIP 算法训练 链表数据求和操作
  • 原文地址:https://www.cnblogs.com/Megau/p/5269506.html
Copyright © 2011-2022 走看看