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

 

posted @ 2020-04-14 15:43  有风丶不铭  阅读(201)  评论(0编辑  收藏  举报