zoukankan      html  css  js  c++  java
  • Four Fundamental Operations(JS) --结对项目

    一、Github地址:https://github.com/BayardM/Four-Fundamental-Operations

    (本项目由鲍鱼铭3118004995 和 许铭楷3118005023共同结对完成)

    二、效能分析

      性能提升和效率提升主要体现在下图

      

      在实现了1个运算符两个操作数的结果计算之后,原本是打算同样的思路进行2个,3个运算符的计算,但是做到一大半时感觉实在非常麻烦,开发效率及其低下!

      便想到自己可以通过对操作数进行有限的变换来达到对更低层次的1个运算符函数的调用,换成这种嵌套调用之后减少了做运算的操作,也减少了底层对临时栈的调用,既提升了运行效率

      也提升了开发效率!

    三、设计实现过程(思路)

        1-9需求均已实现

        此处以流程图展示关键的实现各种算式结果生成的具体思路

        

    (前两个流程图最后忘记加得出结果一栏。。)

    至于随机生成算式则是分为随机操作数和随机操作符两部分,操作数调用随机数库函数,操作符通过随机数字0123对应+-*/随机生成。

    四、关键部分代码

      1.二元算式结果计算函数

     1 function two_oper(op1, op2 , sel_oper1)
     2 {
     3     var result
     4     var formula = [op1 , sel_oper1 , op2]
     5     switch(sel_oper1)
     6     {
     7         case 0:
     8             result = op1 + op2
     9             break
    10         case 1:
    11             var high_op = op1>op2 ? op1 : op2
    12             var low_op = op1<op2 ? op1 : op2
    13             result = high_op - low_op
    14             break
    15         case 2:
    16             result = op1 * op2
    17             break
    18         case 3:
    19             if(op1%op2 != 0)
    20             {
    21                 if(op1/op2 >= 1)
    22                 result = parseInt(op1/op2) + "'" + op1%op2 + '/' + op2
    23                 else result = op1 + '/' + op2
    24             }else{
    25                 result = op1 / op2
    26             }
    27             break
    28         default:break
    29     }
    30     for (var j=0; j<3; j++) {
    31         Formula[j] = formula[j]
    32     }
    33     return result
    34 }

      2.三元算式结果计算

      1 function thr_oper(op1 , op2 , op3 , sel_oper1 , sel_oper2)
      2 {
      3     var formula = [op1 , sel_oper1 , op2 , sel_oper2 , op3]
      4     var result
      5     switch(sel_oper1)
      6     {
      7         case 0:
      8             switch(sel_oper2)
      9             {
     10                 case 0:
     11                      result = formula[0] + formula[2] + formula[4]
     12                     break
     13                 case 1:
     14                     var high_op = (formula[0]+formula[2])>formula[4] ? (formula[0]+formula[2]) : formula[4]
     15                     var low_op = (formula[0]+formula[2])<formula[4] ? (formula[0]+formula[2]) : formula[4]
     16                     result = two_oper(high_op , low_op , sel_oper2)
     17                     if(high_op == formula[4])
     18                     {
     19                         formula[0] = op3
     20                         formula[4] = op1
     21                         formula[1] = sel_oper2
     22                     }
     23                     break
     24                 case 2:
     25                     result = formula[0] + (formula[2] * formula[4])
     26                     break
     27                 case 3:
     28                     result = two_oper((formula[0]*formula[4]+formula[2]) , formula[4] , sel_oper2)
     29                     break
     30                 default:break
     31             }
     32             break
     33         case 1:
     34             switch(sel_oper2)
     35             {
     36                 case 0:
     37                     var high_op = (formula[0]+formula[4])>formula[2] ? (formula[0]+formula[4]) : formula[2]
     38                     var low_op = (formula[0]+formula[4])<formula[2] ? (formula[0]+formula[4]) : formula[2]
     39                     result = two_oper(high_op , low_op , sel_oper1)
     40                     if(high_op == formula[2])
     41                     {
     42                         formula[0] = op2
     43                         formula[2] = op1
     44                         formula[3] = sel_oper1
     45                     }
     46                     break
     47                 case 1:
     48                     var high_op = (formula[2]+formula[4])>formula[0] ? (formula[2]+formula[4]) : formula[0]
     49                     var low_op = (formula[2]+formula[4])<formula[0] ? (formula[2]+formula[4]) : formula[0]
     50                     result = two_oper(high_op , low_op , sel_oper2)
     51                     if(high_op == (formula[2]+formula[4]))
     52                     {
     53                         formula[0] = op3
     54                         formula[4] = op1
     55                         formula[1] = sel_oper2-1
     56                     }
     57                     break
     58                 case 2:
     59                     var high_op = (formula[2]*formula[4])>formula[0] ? formula[2]*formula[4] : formula[0]
     60                     var low_op = (formula[2]*formula[4])<formula[0] ? formula[2]*formula[4] : formula[0]
     61                     result = two_oper(high_op , low_op , sel_oper1)
     62                     if(high_op == (formula[2]*formula[4]))
     63                     {    
     64                         formula[0] = op3
     65                         formula[4] = op1
     66                         formula[1] = 2
     67                         formula[3] = 1
     68                     }
     69                     break
     70                 case 3:
     71                     var high_op = (formula[0]*formula[4])>formula[2] ? formula[0]*formula[4] : formula[2]
     72                     var low_op = (formula[0]*formula[4])<formula[2] ? formula[0]*formula[4] : formula[2]
     73                     //0
     74                     result = two_oper((high_op-low_op) ,formula[4] , sel_oper2)
     75                     if(formula[2]> (formula[0]*formula[4]))
     76                     {
     77                         formula[0] = op2
     78                         formula[2] = op3
     79                         formula[4] = op1
     80                         formula[1] = sel_oper2
     81                         formula[3] = sel_oper1
     82                     }
     83                     break
     84                 default:break
     85             }
     86             break
     87         case 2:
     88             switch(sel_oper2)
     89             {
     90                 case 0:
     91                      result = formula[0] * formula[2] + formula[4]
     92                     break
     93                 case 1:
     94                     result = two_oper((formula[0]*formula[2]) , formula[4] , sel_oper2)
     95                     if(formula[4]> (formula[0]*formula[2]))
     96                     {
     97                         formula[0] = op3
     98                         formula[4] = op1
     99                         formula[1] = sel_oper2
    100                         formula[3] = sel_oper1
    101                     }
    102                     break
    103                 case 2:
    104                     result = formula[0] * formula[2] * formula[4]
    105                     break
    106                 case 3:
    107                     result = two_oper((formula[0]*formula[2]) , formula[4] , sel_oper2)
    108                     break
    109                 default:break
    110             }
    111             break
    112         case 3:
    113             switch(sel_oper2)
    114             {
    115                 case 0:
    116                     result = two_oper((formula[0]+formula[4]*formula[2]) , formula[2] , sel_oper1)
    117                     break
    118                 case 1:
    119                     var high_op = formula[0]>(formula[2]*formula[4]) ? formula[0] : (formula[2]*formula[4])
    120                     var low_op = formula[0]<(formula[2]*formula[4]) ? formula[0] : (formula[2]*formula[4])
    121                     result = two_oper((high_op-low_op) ,formula[2] , sel_oper1)
    122                     if((formula[2]*formula[4]) > formula[0])
    123                     {
    124                         formula[0] = op3
    125                         formula[2] = op1
    126                         formula[4] = op2
    127                         formula[1] = sel_oper2
    128                         formula[3] = sel_oper1
    129                     }
    130                     break
    131                 case 2:
    132                     result = two_oper((formula[0]*formula[4]) , formula[2] , sel_oper1)
    133                     break
    134                 case 3:
    135                     result = two_oper(formula[0] , (formula[2]*formula[4]) , sel_oper1)
    136                     break
    137                 default:break
    138             }
    139             break
    140         default: break
    141 }
    142     for (var j=0; j<5; j++) {
    143             Formula[j] = formula[j]
    144         }
    145     return result
    146 }

      3.四元结果算式代码过长,暂不做展示

      4.ffo函数----算式生成函数

     1 function ffo(max){
     2 var op_gath = Math.floor(Math.random()*(3)+2)
     3 var sel_oper1 = Math.floor(Math.random()*4)
     4 var sel_oper2 = Math.floor(Math.random()*4)
     5 var sel_oper3 = Math.floor(Math.random()*4) 
     6 var result
     7 switch(op_gath)
     8 {
     9     case 2:
    10         var op1 = Math.floor(Math.random()*(max)+1)
    11         var op2 = Math.floor(Math.random()*(max)+1)
    12         result = two_oper(op1 , op2 , sel_oper1)
    13         if((sel_oper1 == 1)&&(op1 < op2))
    14         {
    15             Formula[0] = op2
    16             Formula[2] = op1
    17         }
    18         canswer[cindex] = result
    19         cindex++
    20         myanswer[index] = '答案' + (index+1)+': '+result
    21         index++
    22         Formula[0] = String(Formula[0])
    23         Formula[2] = String(Formula[2])
    24         Formula[1] = operator[Formula[1]]
    25         for(var i=0; i<3; i++)
    26         document.write(Formula[i])
    27         document.write('=' + '<input type="text" />' + '<br />')
    28         break
    29     case 3:
    30         var op1 = Math.floor(Math.random()*(max)+1)
    31         var op2 = Math.floor(Math.random()*(max)+1)
    32         var op3 = Math.floor(Math.random()*(max)+1)
    33         result = thr_oper(op1 , op2 , op3 , sel_oper1 , sel_oper2)
    34         canswer[cindex] = result
    35         cindex++
    36         myanswer[index] = '答案' + (index+1)+': '+result
    37         index++
    38         Formula[0] = String(Formula[0])
    39         Formula[2] = String(Formula[2])
    40         Formula[4] = String(Formula[4])
    41         Formula[1] = operator[Formula[1]]
    42         Formula[3] = operator[Formula[3]]
    43         for(var i=0; i<5; i++)
    44         document.write(Formula[i])
    45         document.write('=' + '<input type="text" />' + '<br />')
    46         break
    47     case 4:
    48         var op1 = Math.floor(Math.random()*(max)+1)
    49         var op2 = Math.floor(Math.random()*(max)+1)
    50         var op3 = Math.floor(Math.random()*(max)+1)
    51         var op4 = Math.floor(Math.random()*(max)+1)
    52         result = four_oper(op1 , op2 , op3 , op4 , sel_oper1 , sel_oper2 , sel_oper3)
    53         canswer[cindex] = result
    54         cindex++
    55         myanswer[index] = '答案' + (index+1)+': '+result
    56         index++
    57         Formula[0] = String(Formula[0])
    58         Formula[2] = String(Formula[2])
    59         Formula[4] = String(Formula[4])
    60         Formula[6] = String(Formula[6])
    61         Formula[1] = operator[Formula[1]]
    62         Formula[3] = operator[Formula[3]]
    63         Formula[5] = operator[Formula[5]]
    64         for(var i=0; i<7; i++)
    65         document.write(Formula[i])
    66         document.write('=' + '<input type="text" />' + '<br />')
    67         break
    68     default: break    
    69 }
    70 }

      5.检查对错功能函数

     1 function checkanswer(){
     2         var right = new Array()
     3         var wrong = new Array()
     4         var r_index=0
     5         var w_index=0
     6         var num=0
     7         var inputtag = document.getElementsByTagName('input')
     8         for (var j=0;j<inputtag.length;j++) {
     9             if(inputtag[j].value == "") continue
    10             else break
    11         }
    12         if(j==inputtag.length) alert("请输入答案再检查")
    13         else {
    14             for (var i=0 ; i<inputtag.length ;i++) {
    15             if(inputtag[i].value == canswer[i])
    16                 {
    17                     right[r_index] = i+1
    18                     r_index++
    19                 }
    20             else {
    21                 wrong[w_index] = i+1
    22                 w_index++
    23             }
    24         }
    25         var show = ['correct:' + (right.length) + '(' , 'wrong:' + (wrong.length) + '(' , ')']
    26         exportRaw('check.txt' , show[0]+right+show[2]+show[1]+wrong+show[2])
    27         }
    28 }

      6.导出文件函数

     1 function fakeClick(obj) { 
     2          var ev = document.createEvent("MouseEvents");
     3     ev.initMouseEvent("click", true, false, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
     4     obj.dispatchEvent(ev);
     5   }
     6 
     7   function exportRaw(name, data) {
     8     var urlObject = window.URL || window.webkitURL || window;
     9          var export_blob = new Blob([data]);
    10     var save_link = document.createElementNS("http://www.w3.org/1999/xhtml", "a")
    11     save_link.href = urlObject.createObjectURL(export_blob);
    12         save_link.download = name;        
    13     fakeClick(save_link);
    14   }

     五、测试运行

      1.定义题目数量

      

      2.定义范围

      

      3.10道题目生成,范围为10以内,答案txt


      4.输入答案检查对错功能

      

      5.10000道题目生成

      

    六、PSP表格

    PSP2.1

    Personal Software Process Stages

    预估耗时(分钟)

    实际耗时(分钟)

    Planning

    计划

         50

         50

    · Estimate

    · 估计这个任务需要多少时间

         20

        20 

    Development

    开发

         180

         220

    · Analysis

    · 需求分析 (包括学习新技术)

         125

         140

    · Design Spec

    · 生成设计文档

         40

         30

    · Design Review

    · 设计复审 (和同事审核设计文档)

         10

         10

    · Coding Standard

    · 代码规范 (为目前的开发制定合适的规范)

         5

         5

    · Design

    · 具体设计

         120

         100

    · Coding

    · 具体编码

         120

         160

    · Code Review

    · 代码复审

         60

         180

    · Test

    · 测试(自我测试,修改代码,提交修改)

         120

         350

    Reporting

    报告

         60

         60

    · Test Report

    · 测试报告

         60

         70

    · Size Measurement

    · 计算工作量

         10

         10

    · Postmortem & Process Improvement Plan

    · 事后总结, 并提出过程改进计划

         20

         45

    合计

     

         1000

         1445

    七、个人项目总结

    许铭楷:

        这次作业用js完成,因为我js掌握还不是很深,大部分功能都是同伴完成的,我主要负责代码的检测和改错。在合作的过程中同伴尽心尽力帮助我解决了很多问题,我也学习到了很多的新知识。总的来说,这次训练带给了我很多进步,让我充分感受到合作的重要性。

    鲍鱼铭:

        本次合作我承担的部分是具体编码和功能实现的部分,本以为自己做的不错可以减轻同伴负担,但是没想到交给同伴进行测试和debug的过程中竟然漏洞百出,幸好同伴细心检查,不断测试发现问题。问题主要呈现在减法不能存在负数与除法的真分数实现,在同伴的帮忙下自己很快得到改进。本次合作除了项目开发上的收获以外,更重要的是收获了与人合作的经历,深刻地明白了自己一个人做事总是会考虑不周全,也充分锻炼了以后到了真正工作时期与人沟通交流和接受意见的能力,收获颇丰!

  • 相关阅读:
    linux 日常命令
    apache2 修改默认php版本
    centos 6.5 创建守护进程
    ubuntu18.04 Yii2.0 安装yii2-queue并在Linux启动守护进程监听消息设置
    Ubuntu18.04 使用 deepinwine 安装企业微信后无法查看图片/头像/登陆二维码的解决方法
    CentOS 8安装Redis的两种方式
    如何在ubuntu 18.04中升级python 3.6到3.7
    Navicat 15 premium AppImage格式激活
    爬取彼岸图网实例
    requests库的介绍及get请求 + 小案例
  • 原文地址:https://www.cnblogs.com/bayardm/p/12698434.html
Copyright © 2011-2022 走看看