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

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

二、效能分析

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

　　

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

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

　　也提升了开发效率！

三、设计实现过程（思路）

　　　　1-9需求均已实现

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

　　　　

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

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

四、关键部分代码

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

 function two_oper(op1, op2 , sel_oper1)

 {

     var result

     var formula = [op1 , sel_oper1 , op2]

     switch(sel_oper1)

     {

         case 0:

             result = op1 + op2

             break

         case 1:

             var high_op = op1>op2 ? op1 : op2

             var low_op = op1<op2 ? op1 : op2

             result = high_op - low_op

             break

         case 2:

             result = op1 * op2

             break

         case 3:

             if(op1%op2 != 0)

             {

                 if(op1/op2 >= 1)

                 result = parseInt(op1/op2) + "'" + op1%op2 + '/' + op2

                 else result = op1 + '/' + op2

             }else{

                 result = op1 / op2

             }

             break

         default:break

     }

     for (var j=0; j<3; j++) {

         Formula[j] = formula[j]

     }

     return result

 }

　　2.三元算式结果计算

 function thr_oper(op1 , op2 , op3 , sel_oper1 , sel_oper2)

 {

     var formula = [op1 , sel_oper1 , op2 , sel_oper2 , op3]

     var result

     switch(sel_oper1)

     {

         case 0:

             switch(sel_oper2)

             {

                 case 0:

                      result = formula[0] + formula[2] + formula[4]

                     break

                 case 1:

                     var high_op = (formula[0]+formula[2])>formula[4] ? (formula[0]+formula[2]) : formula[4]

                     var low_op = (formula[0]+formula[2])<formula[4] ? (formula[0]+formula[2]) : formula[4]

                     result = two_oper(high_op , low_op , sel_oper2)

                     if(high_op == formula[4])

                     {

                         formula[0] = op3

                         formula[4] = op1

                         formula[1] = sel_oper2

                     }

                     break

                 case 2:

                     result = formula[0] + (formula[2] * formula[4])

                     break

                 case 3:

                     result = two_oper((formula[0]*formula[4]+formula[2]) , formula[4] , sel_oper2)

                     break

                 default:break

             }

             break

         case 1:

             switch(sel_oper2)

             {

                 case 0:

                     var high_op = (formula[0]+formula[4])>formula[2] ? (formula[0]+formula[4]) : formula[2]

                     var low_op = (formula[0]+formula[4])<formula[2] ? (formula[0]+formula[4]) : formula[2]

                     result = two_oper(high_op , low_op , sel_oper1)

                     if(high_op == formula[2])

                     {

                         formula[0] = op2

                         formula[2] = op1

                         formula[3] = sel_oper1

                     }

                     break

                 case 1:

                     var high_op = (formula[2]+formula[4])>formula[0] ? (formula[2]+formula[4]) : formula[0]

                     var low_op = (formula[2]+formula[4])<formula[0] ? (formula[2]+formula[4]) : formula[0]

                     result = two_oper(high_op , low_op , sel_oper2)

                     if(high_op == (formula[2]+formula[4]))

                     {

                         formula[0] = op3

                         formula[4] = op1

                         formula[1] = sel_oper2-1

                     }

                     break

                 case 2:

                     var high_op = (formula[2]*formula[4])>formula[0] ? formula[2]*formula[4] : formula[0]

                     var low_op = (formula[2]*formula[4])<formula[0] ? formula[2]*formula[4] : formula[0]

                     result = two_oper(high_op , low_op , sel_oper1)

                     if(high_op == (formula[2]*formula[4]))

                     {

                         formula[0] = op3

                         formula[4] = op1

                         formula[1] = 2

                         formula[3] = 1

                     }

                     break

                 case 3:

                     var high_op = (formula[0]*formula[4])>formula[2] ? formula[0]*formula[4] : formula[2]

                     var low_op = (formula[0]*formula[4])<formula[2] ? formula[0]*formula[4] : formula[2]

                     //

                     result = two_oper((high_op-low_op) ,formula[4] , sel_oper2)

                     if(formula[2]> (formula[0]*formula[4]))

                     {

                         formula[0] = op2

                         formula[2] = op3

                         formula[4] = op1

                         formula[1] = sel_oper2

                         formula[3] = sel_oper1

                     }

                     break

                 default:break

             }

             break

         case 2:

             switch(sel_oper2)

             {

                 case 0:

                      result = formula[0] * formula[2] + formula[4]

                     break

                 case 1:

                     result = two_oper((formula[0]*formula[2]) , formula[4] , sel_oper2)

                     if(formula[4]> (formula[0]*formula[2]))

                     {

                         formula[0] = op3

                         formula[4] = op1

                         formula[1] = sel_oper2

                         formula[3] = sel_oper1

                     }

                     break

                 case 2:

                     result = formula[0] * formula[2] * formula[4]

                     break

                 case 3:

                     result = two_oper((formula[0]*formula[2]) , formula[4] , sel_oper2)

                     break

                 default:break

             }

             break

         case 3:

             switch(sel_oper2)

             {

                 case 0:

                     result = two_oper((formula[0]+formula[4]*formula[2]) , formula[2] , sel_oper1)

                     break

                 case 1:

                     var high_op = formula[0]>(formula[2]*formula[4]) ? formula[0] : (formula[2]*formula[4])

                     var low_op = formula[0]<(formula[2]*formula[4]) ? formula[0] : (formula[2]*formula[4])

                     result = two_oper((high_op-low_op) ,formula[2] , sel_oper1)

                     if((formula[2]*formula[4]) > formula[0])

                     {

                         formula[0] = op3

                         formula[2] = op1

                         formula[4] = op2

                         formula[1] = sel_oper2

                         formula[3] = sel_oper1

                     }

                     break

                 case 2:

                     result = two_oper((formula[0]*formula[4]) , formula[2] , sel_oper1)

                     break

                 case 3:

                     result = two_oper(formula[0] , (formula[2]*formula[4]) , sel_oper1)

                     break

                 default:break

             }

             break

         default: break

 }

     for (var j=0; j<5; j++) {

             Formula[j] = formula[j]

         }

     return result

 }

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

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

 function ffo(max){

 var op_gath = Math.floor(Math.random()*(3)+2)

 var sel_oper1 = Math.floor(Math.random()*4)

 var sel_oper2 = Math.floor(Math.random()*4)

 var sel_oper3 = Math.floor(Math.random()*4)

 var result

 switch(op_gath)

 {

     case 2:

         var op1 = Math.floor(Math.random()*(max)+1)

         var op2 = Math.floor(Math.random()*(max)+1)

         result = two_oper(op1 , op2 , sel_oper1)

         if((sel_oper1 == 1)&&(op1 < op2))

         {

             Formula[0] = op2

             Formula[2] = op1

         }

         canswer[cindex] = result

         cindex++

         myanswer[index] = '答案' + (index+1)+': '+result

         index++

         Formula[0] = String(Formula[0])

         Formula[2] = String(Formula[2])

         Formula[1] = operator[Formula[1]]

         for(var i=0; i<3; i++)

         document.write(Formula[i])

         document.write('=' + '<input type="text" />' + '<br />')

         break

     case 3:

         var op1 = Math.floor(Math.random()*(max)+1)

         var op2 = Math.floor(Math.random()*(max)+1)

         var op3 = Math.floor(Math.random()*(max)+1)

         result = thr_oper(op1 , op2 , op3 , sel_oper1 , sel_oper2)

         canswer[cindex] = result

         cindex++

         myanswer[index] = '答案' + (index+1)+': '+result

         index++

         Formula[0] = String(Formula[0])

         Formula[2] = String(Formula[2])

         Formula[4] = String(Formula[4])

         Formula[1] = operator[Formula[1]]

         Formula[3] = operator[Formula[3]]

         for(var i=0; i<5; i++)

         document.write(Formula[i])

         document.write('=' + '<input type="text" />' + '<br />')

         break

     case 4:

         var op1 = Math.floor(Math.random()*(max)+1)

         var op2 = Math.floor(Math.random()*(max)+1)

         var op3 = Math.floor(Math.random()*(max)+1)

         var op4 = Math.floor(Math.random()*(max)+1)

         result = four_oper(op1 , op2 , op3 , op4 , sel_oper1 , sel_oper2 , sel_oper3)

         canswer[cindex] = result

         cindex++

         myanswer[index] = '答案' + (index+1)+': '+result

         index++

         Formula[0] = String(Formula[0])

         Formula[2] = String(Formula[2])

         Formula[4] = String(Formula[4])

         Formula[6] = String(Formula[6])

         Formula[1] = operator[Formula[1]]

         Formula[3] = operator[Formula[3]]

         Formula[5] = operator[Formula[5]]

         for(var i=0; i<7; i++)

         document.write(Formula[i])

         document.write('=' + '<input type="text" />' + '<br />')

         break

     default: break

 }

 }

　　5.检查对错功能函数

 function checkanswer(){

         var right = new Array()

         var wrong = new Array()

         var r_index=0

         var w_index=0

         var num=0

         var inputtag = document.getElementsByTagName('input')

         for (var j=0;j<inputtag.length;j++) {

             if(inputtag[j].value == "") continue

             else break

         }

         if(j==inputtag.length) alert("请输入答案再检查")

         else {

             for (var i=0 ; i<inputtag.length ;i++) {

             if(inputtag[i].value == canswer[i])

                 {

                     right[r_index] = i+1

                     r_index++

                 }

             else {

                 wrong[w_index] = i+1

                 w_index++

             }

         }

         var show = ['correct:' + (right.length) + '(' , 'wrong:' + (wrong.length) + '(' , ')']

         exportRaw('check.txt' , show[0]+right+show[2]+show[1]+wrong+show[2])

         }

 }

　　6.导出文件函数

 function fakeClick(obj) {

        　　var ev = document.createEvent("MouseEvents");

 　　　　ev.initMouseEvent("click", true, false, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);

 　　　　obj.dispatchEvent(ev);

 　　}

 　　function exportRaw(name, data) {

 　　　　var urlObject = window.URL || window.webkitURL || window;

         　var export_blob = new Blob([data]);

 　　　　var save_link = document.createElementNS("http://www.w3.org/1999/xhtml", "a")

 　　　　save_link.href = urlObject.createObjectURL(export_blob);

         save_link.download = name;

 　　　　fakeClick(save_link);

 　　}

　五、测试运行

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

Four Fundamental Operations（JS） --结对项目的更多相关文章

  1. 复利计算--结对项目<04-11-2016> 1.0.0 lastest 阶段性完工~

    结对项目:Web复利计算 搭档博客地址:25江志彬  http://www.cnblogs.com/qazwsxedcrfv/ 个人摘要: (2016-04-09-12:00)补充:之前传送门没做好, ...

  2. 结对项目：四则运算web

    1)Coding.Net项目地址 https://git.coding.net/DandelionClaw/WEB_Calculator.git 注:本项目为web端,并且需要连接SQL Server ...

  3. 201871030110-何飞 实验三 结对项目—《D{0-1}KP 实例数据集算法实验平台》项目报告

    201871030110-何飞 实验三 结对项目-<D{0-1}KP 实例数据集算法实验平台>项目报告 项目 内容 课程班级博客链接 班级博客 这个作业要求链接 作业要求 我的课程学习目标 ...

  4. 8 步搭建 Node.js + MongoDB 项目的自动化持续集成

    任何事情超过 90 秒就应该自动化,这是程序员的终极打开方式.Automating shapes smarter future. 这篇文章中,我们通过创建一个 Node.js + MongoDB 项目 ...

  5. 高级四则运算器—结对项目反思(193 & 105)

    高级四则运算器—结对项目反思(193 & 105) 本周我和一位韩国同学(71061105)一起结对编程完成了我们的结对项目——高级的小学四则运算题目生成器. PSP表格   PSP2.1 P ...

  6. 高级四则运算器—结对项目总结(193 &105)

    高级四则运算器—结对项目总结 为了将感想与项目经验体会分割一下,特在此新开一篇博文. 界面设计 啥都不说,先上图震慑一下... 上面的三个界面是我们本次结对项目的主界面,恩,我也觉得挺漂亮的!你问我界 ...

  7. js获取项目根路径

    //js获取项目根路径,如: http://localhost:8083/uimcardprj function getRootPath(){ //获取当前网址,如: http://localhost ...

  8. iKcamp团队制作｜基于Koa2搭建Node.js实战项目教学（含视频）☞ 环境准备

    安装搭建项目的开发环境 视频地址:https://www.cctalk.com/v/15114357764004 文章 Koa 起手 - 环境准备 由于 koa2 已经开始使用 async/await ...

  9. 高级软件工程2017第3次作业——结对项目：四则运算题目生成程序（基于GUI）

    Deadline:2017-10-11(周三)21:00pm (注:以下内容参考集大作业 ) 前言 想过和别人一起探索世界吗?多么希望,遇到困难时,有人能一起探讨:想要懈怠时,有人推你一把:当你专注于 ...

  10. WordCount结对项目

    合作者:201631062124,201631062423 代码地址:https://gitee.com/yryx/WordCount 作业地址:https://edu.cnblogs.com/cam ...

随机推荐

  1. log4j2.xml配置使用

    jar包: log4j-api-2.10.0.jar log4j-core-2.10.10.jar log4j-1.2-api-2.10.0.jar log4j-slf4j-impl-2.10.10. ...

  2. 4.3 省选模拟赛 序列游戏 dp

    可以发现 某一段被删除后状态难以表示 也难以链接起来. 考虑暴力 有40分的状压dp 暴力存状态 然后枚举转移即可.最后注意和f[0]这个状态取max 不然一分都没有. const int MAXN= ...

  3. 要做重试机制，就只能选择 DelayQueue ？其实 RabbitMQ 它上它也行！

    原文链接:要做重试机制,就只能选择 DelayQueue ?其实 RabbitMQ 它上它也行! 一.场景 最近研发一个新功能,后台天气预警:后台启动一条线程,定时调用天气预警 API,查询现有城市的 ...

  4. MemoryMappedFile的初级应用

    public class SyncMemoryList<T>: SyncList<T>, IDisposable { private MemoryCache<T> ...

  5. Cesium加载倾斜摄影数据

    (1)倾斜摄影数据仅支持 smart3d 格式的 osgb 组织方式, 数据目录必须有一个 “Data” 目录的总入口, “Data” 目录同级放置一个 metadata.xml 文件用来记录模型的位 ...

  6. Ubuntu安装海思SDK（转）

    问题 海思SDK安装时,无法运行sdk.unpack 原因 BASH 和 DASH 的问题. Debian和Ubuntu中,/bin/sh默认已经指向dash,这是一个不同于bash的shell,它主 ...

  7. 001_解析go语言中的闭包

    go语言中的闭包,是大家学习go语言的一个大难点,笔者在学习时候也是痛苦不堪,在来回对比了其它语言的用法,并且查阅了很多网上的文章,终于对闭包有了一个较为清晰的认识,以下就是关于闭包的解析 首先看一个 ...

  8. 解决SpringBoot项目中Thymeleaf模板的中文乱码问题

    1.使用IDEA创建SpringBoot项目 package com.example.demo; import org.springframework.boot.SpringApplication; ...

  9. java_数组的定义与操作

    数组定义和访问 数组概念 数组概念: 数组就是存储多个数据的容器,数组的长度固定,多个数据的数据类型要一致. 数组的定义 方式一 数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度 ...

  10. 在 .NetCore 项目中使用 SkyWalkingAPM 踩坑排坑日记

    SkyWalking 概述 SkyWalking 是观察性分析平台和应用性能管理系统.提供分布式追踪.服务网格遥测分析.度量聚合和可视化一体化解决方案.支持Java, .Net Core, PHP, ...