Right-BICEP要求设计四则运算2

最新推荐文章于 2024-10-30 18:07:32 发布
最新推荐文章于 2024-10-30 18:07:32 发布
阅读量102 收藏
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/mengqimoli/p/5323754.html
版权 
import java.util.*;
public class Operation2 {
    public static int SIZE(int size)//定制数量
    {
        int q;
        q=size;
        return q;
    }
    
    public static int SecondOperation(String p1)//是否有乘除法
    {
        int q = 4;
        if(p1.equals("Y"))
        {
            q=4;
        } 
        if(p1.equals("N"))
        {
            q=2;
        }
        return q;
    }
    
    public static String Negative(String p2)//加减有无负数
    {
        String q;
        q=p2;
        return q;
    }
    
    public static String Remainder(String p3)//除法有无余数
    {
        String q;
        q=p3;
        return q;
    }
    
    public static int Max(int max)//最大数
    {
        int m;
        m=max;
        return m;
    }
    public static int Min(int min)//最小数
    {
        int m;
        m=min;
        return m;
    }
    
    public static void Display(int SIZE,int SecondOperation,String Negative,String Remainder,int Max,int Min)//算式计算
    {
        String Again[][]=new String[SIZE][1];//用数组装算式，用以判断是否重复
        for(int i=0;i<SIZE;i++)//重复次数，用以确定算式多少
        {        
            int cha=Max-Min;
            int c,q1,w1,q2,w2;
            String s1=new String();
            String s2=new String();
            String equation=new String();       
            String symbol=new String();//符号判定
            c=(int)(Math.random()*SecondOperation);
            if(c==0) symbol="+";
            if(c==1) symbol="-";
            if(c==2) symbol="*";
            if(c==3) symbol="/";     
            for(int j=0;j<2;j++)//两次循环，第一次为第一个数字，第二次为第二个数字
            {
                int n1 =-99999,n2=-99999;//用于后面是否为分数的判定
                int s=(int)(Math.random()*2);//随机数判定整数或分数，0整数，1分数
                if(s==0)//整数
                {
                    if(Negative.equals("N"))
                    {
                        if(c==0||c==1)
                        {
                            while(n1<0)
                            {
                                n1=(int)(Min+Math.random()*(cha+1));//随机产生从min到max之间的数
                            }
                        }
                        else
                        {
                            n1=(int)(Min+Math.random()*(cha+1));
                        }
                    }
                    if(Negative.equals("Y"))
                    {
                        n1=(int)(Min+Math.random()*(cha+1));
                    }
                }
                if(s==1)//分数
                {
                    n1=(int)(Min+Math.random()*(cha+1));//随机产生从min到max之间的数
                    n2=(int)(Min+Math.random()*(cha+1));
                        if(Negative.equals("N"))
                        {
                            if(c==0||c==1)
                            {
                                while(n1<=0||n2<=0)
                                {
                                    n1=(int)(Min+Math.random()*(cha+1));
                                    n2=(int)(Min+Math.random()*(cha+1));
                                }
                            }
                            else
                            {
                                while(n1==0||n2==0)//分母不能为零
                                {
                                    n1=(int)(Min+Math.random()*(cha+1));
                                    n2=(int)(Min+Math.random()*(cha+1));
                                }
                            }
                        }
                        if(Negative.equals("Y"))
                        {
                            while(n1==0||n2==0)//分母不能为零
                            {
                                n1=(int)(Min+Math.random()*(cha+1));
                                n2=(int)(Min+Math.random()*(cha+1));
                            }
                        }
                    int z1=Math.abs(n1),z2=Math.abs(n2);//取n1和n2的绝对值，以便化简输出
                    int chushu=2;
                    if(z1>z2)//化简
                    {
                        while(z2>=chushu)
                        {
                            if(z1%chushu==0&&z2%chushu==0)
                            {
                                z1=z1/chushu;z2=z2/chushu;
                            }
                            else
                            {
                                chushu++;
                            }
                        }                    
                    }
                    else if(z1<z2)
                    {
                        while(z1>=chushu)
                        {
                            if(z1%chushu==0&&z2%chushu==0)
                            {
                                z1=z1/chushu;z2=z2/chushu;
                            }
                            else
                            {
                                chushu++;
                            }
                        }
                    }
                    else
                    {
                        z1=1;z2=1;
                    };
                    if(n1<0)//去掉绝对值，返回原来的数          
                    {
                        n1=0-z1;
                    }
                    else 
                    {
                        n1=z1;
                    }
                    if(n2<0)
                    {
                        n2=0-z2;
                    }
                    else 
                    {
                        n2=z2;
                    }
                }
                if(j==0)//第一个数字
                {
                    q1=n1;w1=n2;
                    if(w1==-1&&q1<0)
                    {
                        q1=Math.abs(q1);
                    }
                    if(w1==-1&&q1>0)
                    {
                        q1=0-q1;
                    }
                    if(w1>-99999)//如果存在分母，则为分数
                    {
                        if(Math.abs(w1)!=1)
                        {
                            if(q1<0&&w1<0)
                            {
                                q1=Math.abs(q1);w1=Math.abs(w1);
                            }
                            if(w1<0)
                            {
                                s1="("+q1+"/("+w1+"))"+"";
                            }
                            else
                            {
                                s1="("+q1+"/"+w1+")"+"";
                            }
                        }
                        if(Math.abs(w1)==1)//为整数
                        {
                            if(q1>=0)
                            {
                                s1=q1+"";
                            }
                            if(q1<0)
                            {
                                s1="("+q1+")"+"";
                            }
                        }
                    }
                    
                    else//否则为整数
                    {
                        if(q1>=0)
                        {
                            s1=q1+"";
                        }
                        if(q1<0)
                        {
                            s1="("+q1+")"+"";
                        }
                    }
                }
                if(j==1)//第二个数字
                {
                    q2=n1;w2=n2;
                    if(c==3)//当为除法时，除数不能为0，
                    {
                        while(q2==0)
                        {
                            q2=(int)(Min+Math.random()*(cha+1));
                        }//分子或整数不能为0
                    }
                    if(w2==-1&&q2<0)
                    {
                        q2=Math.abs(q2);
                    }
                    if(w2==-1&&q2>0)
                    {
                        q2=0-q2;
                    }
                    if(w2>-99999)//如果存在分母，则为分数
                    {
                        if(Math.abs(w2)!=1)
                        {
                            if(q2<0&&w2<0)
                            {
                                q2=Math.abs(q2);w2=Math.abs(w2);
                            }
                            if(w2<0)
                            {
                                s2="("+q2+"/("+w2+"))"+"";
                            }
                            else
                            {
                                s2="("+q2+"/"+w2+")"+"";
                            }
                        }
                        else
                        {
                            if(q2<0)
                            {
                                s2="("+q2+")"+"";
                            }
                            if(q2>0)
                            {
                                s2=q2+"";
                            }
                        }
                    }
                    else//否则为整数
                    {
                        if(q2<0)
                        {
                            s2="("+q2+")"+"";
                        }
                        if(q2>0)
                        {
                            s2=q2+"";
                        }
                    }
                    if(c==3&&Remainder.equals("N"))//除法无余数
                    {
                        q1=q2*n1;w1=w2;
                        if(w1%n1==0)
                        {
                            w1=w1/n1;q1=q1/n1;
                        }
                        if(w1>-99999)//如果存在分母，则为分数
                        {
                            if(Math.abs(w1)!=1)
                            {s1="("+q1+"/"+w1+")"+"";}
                            else//否则为整数
                            {
                                s1=q1+"";
                            }
                        }
                        else//否则为整数
                        {
                            s1=q1+"";
                        }
                        
                    }
                }
            }
            equation=equation+s1+symbol+s2+"=";//表达式
            Again[i][0]=equation;
            for(int k=0;k<(i+1);k++)//避免重复
            {
                if(Again[i][0].equals(Again[k][0]))
                {
                    k--;break;
                }
            }
            System.out.println(equation);
            }
        }  
    public static void main(String args[])
    {
        String p3="Y";
        @SuppressWarnings("resource")
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入定制数量：");
        int size=sc.nextInt();
        System.out.println("是否有乘除法，有（Y），没有（N）");
        String p1=sc.next();
        System.out.println("加减有无负数，有（Y），没有（N）");
        String p2=sc.next();
        if(p1.equals("Y"))
        {
            System.out.println("除法有无余数，有（Y），没有（N）");
            p3=sc.next();
        }
        System.out.println("请输入数值范围最大值：");
        int max=sc.nextInt();
        System.out.println("请输入数值范围最小值：");
        int min=sc.nextInt();        
        int a=SIZE(size);
        int b=SecondOperation(p1) ;
        String c=Negative(p2);
        String d=Remainder(p3);
        int e=Max(max);
        int f=Min(min);
        
        Display(a,b,c,d,e,f);//函数的调用，实现
    }
}

 

结果截图：

有乘除法，加减有负数，除法有余数

有乘除法，加减无负数，除法有余数

有乘除法，加减无负数，除法无余数

五乘除法，加减有负数

无乘除法，加减无负数

转载于:https://www.cnblogs.com/mengqimoli/p/5323754.html

weixin_30918633
关注
单元测试中 Right-BICEP 和 CORRECT
Google Oriented Programmer
05-04 3001
在单元测试中，有6个总结出的值得测试的方面，这6个方面统称为 Right-BICEP，通过这6个方面的指导，可以较完全的测试出代码中的bug。本文就是简单的介绍 Right-BICEP 到底指的哪6个方面，以及其中边界测试中的 CORRECT 助记短语。
Right-BICEP和CORRECT
klay_lei的专栏
08-06 495
 测试哪些内容，Right-BICEP    Right —— 结果是否正确？    B —— 是否所有的边界条件都是正确的？    I —— 能查一下反向关联吗？    C —— 能用其他手段交叉检查一下结果吗？    E —— 是否可以强制错误条件发生？    P —— 时候满足性能要求？边界条件，CORRECT    一致性（Conformance）——
测试中的Right-BICEP
xiaotao2010的专栏
03-14 590
测试哪些内容：Right-BICEP这几个概括了测试的六个方面。Right——结果是否正确B——是否所有的边界条件都是正确的——单元测试中最有价值的工作之一，因为bug一般就出现在边界上。I——能查一下反向关联吗——应用不同的原理来编写反向逻辑关系测试。C——能否用其它手段交叉检查一下结果——计算一个量会有一种以上的算法，可以选择其它的版本来检查我们实际应用的版本或者使用类的另一种数据检查相关的数...
Right-BICEP单元测试
weixin_30528371的博客
03-13 112
一、测试方法：Right-BICEP Right－结果是否正确？ B－是否所有的边界条件都是正确的？ I－能查一下反向关联吗？ C－能用其他手段交叉检查一下结果吗？ E－你是否可以强制错误条件发生？ P－是否满足性能要求？ 二、测试模块：定制打印的题目数 1 //可定制打印的题目数 2 printf("请输入要打印的题目数："); 3 scanf("%d...
四则运算之Right-BICEP单元测试
weixin_30699465的博客
03-13 243
一、 这篇博客要对上次实现的四则运算进行单元测试，一是检查上次的程序的实现情况，二是巩固单元测试的相关知识。本次进行单元测试用的是Riget-BICEP方法。 Riget-BICEP方法： 1、Right－结果是否正确？ 2、B－是否所有的边界条件都是正确的？ 3、I－能查一下反向关联吗？...
ri-bicep
03-31
至于压缩包中的"ri-bicep-main"文件，这可能是Bicep模板的主要文件，或者是一个包含所有相关Bicep文件的目录。在这个主文件中，可能会定义资源类型、参数、变量、输出以及资源之间的依赖关系。用户需要将这个Bicep...
private-aks-bicep:使用二头肌创建完全私有的AKS集群
04-16
带有二头肌的私人AKS 此存储库中的资源将帮助您使用二头肌系统来部署完全私有的AKS集群。 您可以在以下博客文章中找到更多详细信息。...az deployment sub create -f ./private-aks.bicep -l northeurope
azure-devops-bicep-task:简单但有用的Azure DevOps任务集，允许在Azure Pipelines中安装和运行Microsoft Bicep CLI命令
03-14
Azure DevOps Bicep任务 这是一组简单但有用的Azure DevOps任务，允许在Azure管道（跨平台）中安装和运行命令。 安装Bicep CLI任务 此任务下载并在代理中安装任何可用的Bicep CLI版本（将其添加到PATH环境变量中）...
CI-MS2-BicepMusicFanSite:Code Institute Milestone Project 2-Bicep的音乐迷网站
05-13
BICEP粉丝网站 Bicep是来自北爱尔兰贝尔法斯特的电子音乐制作和DJ二重奏，由Andrew Ferguson和Matthew McBriar组成。 这是DJ二重奏的粉丝页面。 在查看实时网站 目录 移动的 表面 调色板 版式 特征 现有功能 功能1...
azure-bicep:天蓝色的二头肌示例，在更具编程性的模型中部署资源的新方法
03-08
在“azure-bicep-main”这个文件夹中，可能包含了一系列Bicep文件，每个文件代表一个独立的资源或者资源集合。文件命名通常会反映出资源类型或功能，例如“webapp.bicep”可能用于定义Azure Web应用服务，而“vnet....
四则运算之Right－BICEP测试
weixin_30807677的博客
06-23 138
Right－结果是否正确？ 正确 B－是否所有的边界条件都是正确的？ Conformance(一致性)：值是否和预期的一致 是一致的 Ordering(顺序性)：值是否如应该的那样　　是 是有序或者无序的 Range(区间性)：值是否位于合理的最小值和最大值之间　　是 Reference(依赖性)：代码是否引用了一些不在代码本身控制范围内的外部资源　　没有 Existence(...
单元測试中 Right-BICEP 和 CORRECT
weixin_30721077的博客
03-22 129
My Blog：http://www.outflush.com/ 在单元測试中，有6个总结出的值得測试的方面，这6个方面统称为 Right-BICEP。通过这6个方面的指导。能够较全然的測试出代码中的bug。本文就是简单的介绍 Right-BICEP 究竟指的哪6个方面，以及当中边界測试中的 CORREC...
Right-BICEP 测试四则运算程序
alunm42846的专栏
03-13 101
测试方法： Right-BICEP 测试计划： 1.边界测试是否正确 2.负数表示是否实现 3.是否有乘除法 4.是否可以选择题目数量 5.是否有输出方式 6.是否有括号 7.是否有重复查询 测试结果： 1.边界正确，可以自行控制边界 2.负数可以实现，负数可以控制出现 3.可以控制乘除法的出现 4.可以选择题目数量 5.输出方式不能选择 6.括号...
按Right-BICEP的测试用例
weixin_30385925的博客
03-13 130
测试方法Right-BICEP: 测试计划： 1.Right：输出结果是否正确？ 2.B ：是否所有边界条件都是正确的？ 3.P ：是否满足性能要求？ 4. ：是否可以选择乘除法？ 5. ：是否可以选择真分数运算？ 6. ：是否可以选择数字范围？ 7. ：是否可以选择是否带括号运算？ 测试结果： 1. ...
单元测试应该测试什么？——Right-BICEP
自由是冠军
05-27 7503
 单元测试应该测试什么？——Right-BICEPRight——结果是否正确？B——是否所有的边界条件都是正确的?I——能查一下反响关联吗？C——能用其它手段交叉检查一下吗?E——你是否可以强制错误条件发生？P——是否满足性能要求？结果是否正确这个最简单不过了，就是看程序运行之后的结构和文档是否一致。当然可能很多的时候一个方法没有很完整的文档描述它，那至
服务器虚拟化
最新发布
Hellc007的博客
10-30 383
服务器虚拟化是一种将物理服务器的计算资源分割为多个独立虚拟环境的技术，通过软件层将底层硬件资源抽象化并在上层构建多个虚拟机（Virtual Machine, VM）。每个虚拟机运行独立的操作系统和应用程序，相互之间不受干扰，具备类似于物理服务器的功能。这种技术使得一台物理服务器能够承担多台虚拟服务器的角色，从而极大地提升了硬件资源的利用率。服务器虚拟化的概念最早可追溯到20世纪60年代IBM大型机时代，当时虚拟化被用来将大型机的资源分配给多个任务，使得企业在有限的资源下能够同时运行多个应用。
（1）Java 编程基础概览：数据类型、常量、变量、标识符与运算符
码界领航的Cherry Yang的博客
10-28 961
8 位，占1个字节，有符号的，范围 -128（-2^7）至 127（2^7-1）。32 位，占4个字节，范围 -2,147,483,648（-2^31）至 2,147,483,647（2^31 - 1）。Java 提供了六种数字类型，其中四个为整数类型，两个为浮点类型，还有字符类型，以及布尔型。16 位，占2个字节，范围 -32768（-2^15）至 32767（2^15 - 1）64 位，占8个字节，范围 -2^63 至 2^63 - 1。16 位 Unicode 字符，占 2 个字节。
java_方法递归调用
HHppGo的博客
10-27 452
简单的说: 递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂问题,同时可以让代码变得简洁。
Java Web开发教程：从入门到精通
孤客科技
10-25 1090
Java Web开发是一个充满挑战和机遇的领域。通过本文的学习，您应已掌握Java Web开发的基础知识和实践技巧。不断实践、深入学习，将使您在这个领域越走越远。希望您能在未来的开发旅程中创造出更多精彩的Web应用！如有任何问题或想法，欢迎在评论区留言讨论！期待您的参与与分享！
BICEP2后的Gauged M-flation：新的CMB B模式极化影响与模型预测
本文主要探讨的是在BICEP2实验公布后对M通货膨胀模型（Gauged M-flation）的再评估。BICEP2的结果指出，宇宙微波背景辐射（Cosmic Microwave Background, CMB）的B模式极化可能与张量模与标量模的比值r约为0.2到0.05...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值