素数判断程序测试范例
判断素数的python语言程序
判断素数的python语言程序素数（Prime number）是指大于1且只能被1和自身整除的自然数。
判断一个数是否为素数是一道经典的数学题，也是编程中常见的问题。
在Python语言中，我们可以使用以下程序来判断一个数是否为素数：```pythondef is_prime(n):if n <= 1:return Falsefor i in range(2, int(n ** 0.5) + 1):if n % i == 0:return Falsereturn True# 测试代码num = int(input("请输入一个正整数: "))if is_prime(num):print(num, "是素数")else:print(num, "不是素数")```上述程序通过定义一个名为`is_prime`的函数，该函数接收一个参数`n`，判断`n`是否为素数并返回布尔值。
接下来，我们通过输入一个正整数并调用`is_prime`函数来判断该整数是否为素数。
函数内部的逻辑如下：1. 如果`n`小于等于1，则它不是素数，直接返回`False`。
2. 使用一个循环从2到$\sqrt{n}$（取整）的范围内遍历所有可能的因子。
如果找到一个能整除`n`的因子，则`n`不是素数，返回`False`。
3. 如果循环结束后都没有找到能整除`n`的因子，则`n`是素数，返回`True`。
通过以上的Python程序，我们可以方便地判断一个数是否为素数，有效地应用于互联网技术、商业以及其他技术应用中。
编写这样的程序不仅能够提高算法设计与实现的能力，还能实际应用于解决问题。
素数测试
素数测试问题（Monte Carlo算法）求a m(mod n)的算法(m≢n)设m的二进制表示为b k b k-1…b1b0（b k=1）。
例：m=41=101001(2)，b k b k-1…b1b0=101001，（k=5）。
求a m可以用下述方法：初始C←1。
b5=1：C←C2(=1)，∵b k=1，做C←a*C(=a)；b5b4=10：C←C2(=a2)，∵b k-1=0，不做动作；b5b4b3=101：C←C2(=a4)，∵b k-2=1，做C←a*C(=a5)；b5b4b3b2=1010：C←C2(=a10)，∵b k-3= b2=0，不做动作；b5b4b3b2b1=10100：C←C2(=a20)，∵b k-4= b1=0，不做动作；b5b4b3b2b1b0=101001：C←C2(=a40)，∵b k-5= b0=1，做C←a*C(=a41)。
最终要对a m求模，而求模可以引入到计算中的每一步：即在求得C2及a*C之后紧接着就对这两个值求模，然后再存入C。
这样做的好处是存储在C中的最大值不超过n-1，于是计算的最大值不超过max{(n-1)2,a(n-1)}。
因此，即便a m很大，求a m(mod n)时也不会占用很多空间。
注意，当n极大时，即使是O(n)时间的算法也不能容许。
e.g. 大整数的素因子分解。
如n=1060，若算法时间复杂度为O(n)，设高速计算机每秒1亿亿次(1016)基本运算，则需1044秒，大于1042分钟，大于1040小时，大于1038天，大于1035年！∴O(n)时间的算法绝对不能接受！求a m(mod n)的算法EXPMOD(a,m,n)C←1;For j=k to 0 do{C←C2(mod n)/*本例中：C=1,a2,a4,a10,a20,a40(mod n)*/ if b j=1 then C←a*C (mod n)/*本例中：C=a,a5,a41(mod n)*/ }return C算法分析：如果把乘、除法（包括取模）看成常数时间，则算法的时间复杂度为Θ(k)= Θ(log m)=O(log n)。
算法实训-素数测试问题—费马小定律
素数测试问题一、问题定义【问题描述】输入2个正整数m、n（m<n），输出[m,n]间的素数。
【输入输出及示例】输入：测试范围的起止值m、n。
输出：输出[m,n]间的所有素数。
示例：请输入测试范围的起始值：100 200100到200间的素数有：101 103 107 109 113 127 131 137 139 149151 157 163 167 173 179 181 191 193 197199二、问题分析1、判断素数什么是素数？一个大于1的正整数，如果除了1和它本身以外，不能被其他正整数整除，就叫素数。
因此判断一个整数m是否是素数最简单的方法只需把 m 被 2 ~ m-1 之间的每一个整数去除，如果都不能被整除，那么 m 就是一个素数。
这种方法可以判断出一个数是否为素数，但这是一种暴力的方法，当一个数非常大的时候，用这种办法会花掉许多的时间。
所以在此题中使用蒙特卡罗法算法结合费尔马小定理结合二次探测定理来判断素数。
2、蒙特卡罗法算法蒙特卡罗方法，又称随机抽样或统计试验方法。
传统的经验方法由于不能逼近真实的物理过程，很难得到满意的结果，而蒙特卡罗方法由于能够真实地模拟实际物理过程，故解决问题与实际非常符合，可以得到很圆满的结果。
随机产生问题的解，但在产生的解中，有一部分可以判断真假，一部分不能判断真假。
对于不能判断的，则可能是错误的解。
随着多次调用此算法，由于每次调用都是独立的，因此产生错误解的概率越来越小。
在实验中，通过srand(0);，设计随机数种子，保证每次产生的随机数的随机性，令int a = rand() % (n - 2) + 2;通过rand函数每次产生2-n的随机数，为了保证产生错误解的概率越小，在实验中，对每一个范围内的数，产生100随机数，保证结果的正确性。
3、费马小定律的使用费马小定理：如果p是一个质数，而整数a不是p的倍数，则有a^（p-1）≡1（mod p）。
Java查询判断素数实验报告
Java查询判断素数实验报告实验源代码：package sushu;import java.util.Scanner;public class First {int size=2;int data[]=new int[100];int data1[]=new int[1000];Scanner input=new Scanner(System.in);//界⾯public void menu() {System.out.println();System.out.println("1.输出3-100所有素数");System.out.println("2.输出任意两个数之间的所有素数");System.out.println("3.两个整数之间的最⼤的10个和最⼩的10个素数");System.out.println(" 请输⼊:");String choice1=input.next();switch(choice1) {case "1":sushu1();break;case "2":sushu2();break;case "3":sushu3();break;}}public void sushu1() {int massage1=0;size=2;data[1]=3;for(int whole=4;whole<=100;whole++){for(int i=2;i<=Math.sqrt(whole);i++){if(whole%i==0){massage1=1;break;}}if(massage1==0){data[size]=whole;size++;massage1=0;}if(massage1==1){massage1=0;}}System.out.println("素数如下：");for(int i=1;i<size;i++){System.out.print(data[i]+"\t");if(i%5==0){System.out.println();}}}public void sushu2() {System.out.println("请输⼊下限：");int min=input.nextInt();System.out.println("请输⼊上限：");int max=input.nextInt();int massage1=0;if(max<=3) {System.out.println("素数如下：");System.out.println("2"+"\t"+"3");}if(max>3) {data1[1]=3;size=2;for(int j=min;j<=max;j++){for(int i=2;i<=Math.sqrt(j);i++){if(j%i==0){massage1=1;break;}}if(massage1==0){data1[size]=j;size++;massage1=0;}if(massage1==1){massage1=0;}}System.out.println("素数如下：");for(int i=1;i<size;i++){System.out.print(data1[i]+"\t");if(i%5==0){System.out.println();}}}}public void sushu3() {System.out.println("请输⼊下限：");int min=input.nextInt();System.out.println("请输⼊上限：");int max=input.nextInt();int massage1=0;if(max<=3) {System.out.println("素数如下：");System.out.println("2"+"\t"+"3");}if(max>3) {data1[1]=3;size=2;for(int j=min;j<=max;j++){for(int i=2;i<=Math.sqrt(j);i++){if(j%i==0){massage1=1;break;}}if(massage1==0){data1[size]=j;size++;massage1=0;}if(massage1==1){massage1=0;}}System.out.println("最⼩的⼗个素数：");for(int i=1;i<=10;i++){System.out.println(data1[i]);}System.out.println("最⼤的⼗个素数：");for(int i=size-1;i>=(size-10);i--){System.out.println(data1[i]);}}}}实验结果：。
判断一个数是否为素数(Python)
判断一个数是否为素数（Python）素数（prime number）是指只能被1和自身整除的正整数，即除了1和本身之外没有其他因子的数。
素数是数学中非常重要且有趣的概念，其具有许多特殊性质和应用，因此判断一个数是否为素数也是一项常见的数学问题。
在Python中，判断一个数是否为素数可以采用多种方法，下面我们将介绍一种基本的判断素数的方法，并对其进行详细的解释。
**方法一：朴素算法**朴素算法是一种最基本的判断素数的方法，其思想是遍历该数的所有可能因子并判断是否存在能整除该数的因子。
具体步骤如下：1.将待判断的数记为n，初始令i=2；2.从i=2开始，逐一判断i是否能整除n，若能整除，则n不为素数，退出循环；3.若i不能整除n，则i加1，继续进行判断，直到i大于等于n 的平方根；4.若在步骤3中没有找到能整除n的因子，则n为素数。
下面是Python代码实现该朴素算法：```pythondef is_prime(n):if n <= 1:return Falsefor i in range(2, int(n**0.5)+1):if n % i == 0:return Falsereturn True#测试素数判断函数num = int(input("请输入一个正整数："))if is_prime(num):print(num, "是素数")else:print(num, "不是素数")```**代码解释**：-定义了一个函数is_prime(n)，用于判断一个数n是否为素数；-如果输入的数n小于等于1，则直接返回False（因为1不是素数）；-循环变量i从2开始到n的平方根，并判断是否存在能整除n的因子，若找到，则返回False；-若在循环中未找到能整除n的因子，则返回True。
以上是一个基本的朴素算法的判断素数方法，其时间复杂度为O(√n)。
判定树例题经典案例
判定树例题经典案例
一个经典的判定树例题是判断一个数字是否为素数。
素数是只能被1和自身整除的正整数，例如2、3、5、7、11等都是素数。
判定树可以按照以下步骤进行构建：
1. 根据素数的定义，首先判断该数字是否小于2，如果小于2，则不是素数。
2. 如果该数字大于等于2，再判断是否可以被2整除，如果可以被2整除，且不是2本身，则不是素数。
3. 如果不能被2整除，再判断是否可以被3整除，如果可以被3整除，且不是3本身，则不是素数。
4. 如果不能被3整除，再判断是否可以被5整除，如果可以被5整除，且不是5本身，则不是素数。
5. 依次类推，判断是否可以被7、11、13、17等素数整除，直到判断到根号n。
6. 如果在上述判断过程中都没有除尽，则该数字是素数。
通过对应的判断树，可以很快判断一个数字是否为素数。
例如，对于数字7，判断树的路径为：
数字7是否小于2？否
数字7是否可以被2整除？否
数字7是否可以被3整除？否
数字7是否可以被5整除？否
判断到根号7，没有除尽，所以数字7是素数。
这是一个经典的判定树例题，通过构建判定树可以快速判断一个数字是否为素数，是判定树在数学和计算机应用中的重要应用之一。
素数的判断方法java语言代码
素数的判断方法java语言代码素数是指只能被1和自身整除的正整数，如2、3、5、7、11等。
在计算机编程中，判断一个数是否为素数是一个常见的问题。
本文将介绍几种判断素数的方法，并给出Java语言代码实现。
方法一：暴力枚举法暴力枚举法是最简单的判断素数的方法，即对于一个数n，从2到n-1枚举每个数，判断是否能整除n。
如果存在一个数能整除n，则n不是素数，否则n是素数。
Java代码实现：```public static boolean isPrime(int n) {if (n <= 1) {return false;}for (int i = 2; i < n; i++) {if (n % i == 0) {return false;}}return true;}```方法二：优化枚举法在暴力枚举法的基础上，可以进行一些优化。
例如，只需要枚举到n的平方根即可，因为如果存在一个大于n的平方根的因子，那么一定存在一个小于n的因子。
另外，可以判断n是否为偶数，如果是偶数则一定不是素数。
Java代码实现：```public static boolean isPrime(int n) {if (n <= 1) {return false;}if (n == 2 || n == 3) {return true;}if (n % 2 == 0) {return false;}for (int i = 3; i <= Math.sqrt(n); i += 2) {return false;}}return true;}```方法三：埃氏筛法埃氏筛法是一种筛选法，可以快速地找出一定范围内的所有素数。
具体做法是，先将2到n的所有数标记为素数，然后从2开始，将每个素数的倍数标记为合数，直到n为止。
最后，未被标记的数即为素数。
Java代码实现：```public static boolean[] sieve(int n) {boolean[] isPrime = new boolean[n + 1];Arrays.fill(isPrime, true);isPrime[0] = false;isPrime[1] = false;for (int i = 2; i <= Math.sqrt(n); i++) {for (int j = i * i; j <= n; j += i) {isPrime[j] = false;}}}return isPrime;}```以上三种方法都可以判断一个数是否为素数，但是它们的时间复杂度不同。
判断一个数是否为素数(Python)
判断一个数是否为素数（Python）判断一个数是否为素数是一个常见的编程问题。
在这篇文章中，我们将使用Python编写一个函数来判断一个数是否为素数，并对算法进行解释。
在数论中，素数（也称为质数）是只能被1和它自己整除的自然数。
也就是说，如果一个数不能被其他自然数整除，那么它就是素数。
首先，我们需要编写一个函数来判断一个数是否为素数。
以下是使用简单的方法实现的函数：```pythondef is_prime(n):if n <= 1:return Falsefor i in range(2, n):if n % i == 0:return Falsereturn True```这个函数的基本思想是，对于给定的整数n，我们从2开始到n-1，逐个检查n是否可以被这些数整除。
如果n能被其中任何一个数整除，那么它不是素数。
这个方法的时间复杂度是O(n)，其中n是给定数n的大小。
虽然这个方法可以解决问题，但效率较低，特别是对于大型数。
下面我们将介绍一种更高效的方法，称为“试除法”或“质因数分解法”。
这种方法基于如下事实：如果一个数可以被一个大于1且小于它自身的数整除，那么它一定可以被一个质数整除。
因此，我们只需要检查2到sqrt(n)之间的数即可。
```pythonimport mathdef is_prime(n):if n <= 1:return Falsefor i in range(2, math.isqrt(n) + 1):if n % i == 0:return Falsereturn True```在这个改进的方法中，我们只需要检查2到sqrt(n)之间的数是否能整除n，这大大减少了计算量。
因为如果n不是素数，那么它肯定有一个在2到sqrt(n)之间的因数。
这个方法的时间复杂度是O(sqrt(n))。
接下来，我们将对这两种方法进行测试，看看它们对于不同大小的数的性能表现如何。
```pythonimport timedef test_func(func):numbers = [10000019, 100003, 100019, 100043, 100049, 100057, 100069, 100103, 100109, 100129]start_time = time.time()for number in numbers:result = func(number)print(f"{number} is {'prime' if result else 'not prime'}") end_time = time.time()execution_time = end_time - start_timeprint(f"Execution time: {execution_time} seconds")test_func(is_prime)```在这个测试函数中，我们选择了一些不同大小的数进行测试，并计算函数执行的时间。
Python素数检测的方法
Python素数检测的⽅法本⽂实例讲述了Python素数检测的⽅法。
分享给⼤家供⼤家参考。
具体如下：因⼦检测：检测因⼦，时间复杂度O(n^(1/2))def is_prime(n):if n < 2:return Falsefor i in xrange(2, int(n**0.5+1)):if n%i == 0:return Falsereturn True费马⼩定理：如果n是⼀个素数，a是⼩于n的任意正整数，那么a的n次⽅与a模n同余实现⽅法：选择⼀个底数（例如2），对于⼤整数p，如果2^(p-1)与1不是模p同余数，则p⼀定不是素数；否则，则p很可能是⼀个素数2**(n-1)%n 不是⼀个容易计算的数字模运算规则：(a^b) % p = ((a % p)^b) % p(a * b) % p = (a % p * b % p) % p计算X^N(% P)可以如果N是偶数，那么X^N =（X*X）^[N/2]；如果N是奇数，那么X^N = X*X^(N-1) = X *（X*X）^[N/2]；def xn_mod_p(x, n, p):if n == 0:return 1res = xn_mod_p((x*x)%p, n>>1, p)if n&1 != 0:res = (res*x)%preturn res也可以归纳为下⾯的算法两个函数是⼀样的def xn_mod_p2(x, n, p):res = 1n_bin = bin(n)[2:]for i in range(0, len(n_bin)):res = res**2 % pif n_bin[i] == '1':res = res * x % preturn res有了模幂运算快速处理就可以实现费马检测费马测试当给出否定结论时，是准确的，但是肯定结论有可能是错误的，对于⼤整数的效率很⾼，并且误判率随着整数的增⼤⽽降低def fermat_test_prime(n):if n == 1:return Falseif n == 2:return Trueres = xn_mod_p(2, n-1, n)return res == 1MILLER-RABIN检测Miller-Rabin检测是⽬前应⽤⽐较⼴泛的⼀种⼆次探测定理:如果p是⼀个素数,且0<x<p,则⽅程x^2%p=1的解为:x=1或x=p-1费马⼩定理：a^(p-1) ≡ 1(mod p)这就是Miller-Rabin素性测试的⽅法。
求100以内所有素数的和、平均值c语言
求100以内所有素数的和、平均值c语言一、问题概述在数学中，素数是指只有两个正因数（1和它自身）的自然数。
通常，我们只考虑小于等于100的素数。
在这个问题中，我们需要编写一个C语言程序，找出所有小于等于100的素数，并求出它们的和以及平均值。
二、解决方案以下是一个C语言程序的示例，可以用于求和和平均值：```c#include<stdio.h>//判断一个数是否为素数intis_prime(intnum){if(num<=1)return0;for(inti=2;i*i<=num;i++){if(num%i==0)return0;}return1;}intmain(){intsum=0;//求和变量intcount=0;//素数计数器for(inti=2;i<=100;i++){if(is_prime(i)){//判断是否为素数sum+=i;//将素数加入求和变量count++;//增加素数计数器}}printf("总和：%d\n",sum);//输出总和printf("平均值：%.2f\n",(float)sum/count);//输出平均值return0;}```这段代码首先定义了一个函数`is_prime`，用于判断一个数是否为素数。
然后在主函数中，我们使用一个循环从2到100遍历所有数字，对每个数字调用`is_prime`函数进行判断，如果是素数则加入求和变量，并增加素数计数器。
最后输出总和和平均值。
三、代码解释这段代码使用了基本的C语言语法和数据结构，包括循环、条件判断、数组等。
具体来说：*`#include<stdio.h>`：包含标准输入输出库的头文件，用于输出结果。
*`is_prime`函数：使用一个for循环从2开始遍历到数的平方根，如果存在能整除该数的因数，则该数不是素数，否则为素数。
这是一种常用的判断素数的算法。
Python编程实例：判断素数
在主函数中调 用is_prime函 数，输入要判 断的数字，并 打印结果
定义函数is_prime(n)，输入一个数字n
在函数内部，定义一个变量i，从2开始，遍历到n的开 方
在循环内部，判断i是否能被n整除，如果能，则返回 False，表示n不是素数
如果循环结束，没有找到能整除n的数，则返回True， 表示n是素数
添加标 题
`if n % i == 0:` 判断n是否能被i整除 ，如果是，返回False
添加标 题
`return True` 如果n不能被2到n的平 方根之间的任何数整除，返回True，int(is_prime(5))` 调用函数 is_prime，输入5，输出True，表示5 是素数
作者：
素数在数论中具有 重要的地位，许多 数学问题都与素数 有关
素数的分布规律是 数论中的一个重要 问题，至今尚未完 全解决
素数在密码学、信 息科学等领域有着 广泛的应用
密码学：素数在密 码学中有广泛应用 ，如RSA加密算法
素数筛法：用于寻 找大量素数的高效 算法
素数定理：研究素 数的分布规律
哥德巴赫猜想：与 素数相关的著名数 学问题，尚未得到 证明
作者：
素数是自然数中的 基本元素，大于1 且只能被1和自身 整除的数
素数的性质：素数 只能被1和自身整 除，没有其他因数
素数的分布：素数 在自然数中的分布 是无规律的，没有 明显的规律可循
素数的重要性：素 数在数学中具有重 要的地位，广泛应 用于密码学、数论 等领域
素数是自然数中的 基本元素，除了1 和它本身以外不再 有其他因数
if n % i == 0: return True ``` ● ```python ● def is_prime(n): ● if n <= 1: ● return False ● for i in range(2, int(n**0.5) + 1): ● if n % i == 0: ● return True ● ``` ● 优化效果：提高了代码效率，减少了时间复杂度
素数判断程序测试范例
问题描述：键盘输入m和n（10<m<n<=2000）,求出m--n之间的所有素数，且按每行2个数的形式输出。
相应代码：#include <iostream>#include <math.h>using namespace std;int main(){int m,n,i;static int k=0;cout<<"输入m,m(其中10<m<n<=2000)"<<endl;cin>>m>>n;while(m<=10||m>=n||n>2000){cout<<"输入数据有误，请再次输入："<<endl;cout<<"输入m,m(其中10<m<n<=2000)"<<endl;cin>>m>>n;}for(i=m;i<=n;i++){int x=(int)sqrt((double)i);for(int j=2;j<=x;j++){if(i%j==0){break;}else if(j==x){cout<<i<<"";k++;if(k%2==0)cout<<endl;}elsecontinue;}}cout<<endl;return 0;}一．控制流测试1、控制流图如下:2、根据以上控制流图：因为控制流的1-2-3-2部分为用户输入的m,n的重复赋值过程，与输入数据密切相关且每次取值不同，关系到控制流测试，所以将此独立出来：以为节点“2”的复合谓词为或的关系，全为false时只有一种情况，而为true 时有7种情况，对“2”的复合谓词（m<=10||m>=n||n>2000）为真假时其表1如下：设A:m<=10; B:m>=n; C:n>2000但是对于节点“2”的情况，并非所有可能都会取到，因为当A为真时，就不会执行B，依此，生成下表2：根据表2，得出此部分的取值及路径为：3、当节点“2”取F时，对整体取路径达到谓词覆盖标准有：以上路径可以看出，对于单一谓词---节点5,8,9,10,14均取到T,F,加之节点2之前的取值，所有谓词均达到覆盖标准，所以此控制流测试达到谓词覆盖标准。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
问题描述：键盘输入m和n（10<m<n<=2000）,求出m--n之间的所有素数，且按每行2个数的形式输出。
相应代码：
#include <iostream>
#include <math.h>
using namespace std;
int main()
{
int m,n,i;
static int k=0;
cout<<"输入m,m(其中10<m<n<=2000)"<<endl;
cin>>m>>n;
while(m<=10||m>=n||n>2000)
{
cout<<"输入数据有误，请再次输入："<<endl;
cout<<"输入m,m(其中10<m<n<=2000)"<<endl;
cin>>m>>n;
}
for(i=m;i<=n;i++)
{
int x=(int)sqrt((double)i);
for(int j=2;j<=x;j++)
{
if(i%j==0)
{
break;
}
else if(j==x)
{
cout<<i<<"";
k++;
if(k%2==0)
cout<<endl;
}
else
continue;
}
}
cout<<endl;
return 0;
}
一．控制流测试1、控制流图如下:
2、根据以上控制流图：
因为控制流的1-2-3-2部分为用户输入的m,n的重复赋值过程，与输入数据密切相关且每次取值不同，关系到控制流测试，所以将此独立出来：以为节点“2”的复合谓词为或的关系，全为false时只有一种情况，而为true 时有7种情况，对“2”的复合谓词（m<=10||m>=n||n>2000）为真假时其表1如下：
设A:m<=10; B:m>=n; C:n>2000
但是对于节点“2”的情况，并非所有可能都会取到，因为当A为真时，就不会执行B，依此，生成下表2：
根据表2，得出此部分的取值及路径为：
3、当节点“2”取F时，对整体取路径达到谓词覆盖标准有：
以上路径可以看出，对于单一谓词---节点5,8,9,10,14均取到T,F,加之节点2之前的取值，所有谓词均达到覆盖标准，所以此控制流测试达到谓词覆盖标准。
对于其他区间内的m,n，路径内循环次数增加，但内部循环路径相同。
二．数据流测试
2、根据数据流图，得出节点的def()和c-use()集合：
3、找出边的谓词和p-use集合
4.根据代码，可知共有变量i,j,k，不列举其all-c-use和all-p-use.直接写出其all-uses,其循环次数不一定只有一次，因为循环时内部路径相同，都写出来路径太长太繁琐，所以以一次为基准，循环不定，可以是任意次。
对于变量i：
节点1,4,12有其定义，节点6,12有其c-use，边(5,6),(5,7),(11,13),(11,14)有其p-use,所以包含其all-p-use和其all-c-use的即为其all-uses:
1-2-4-5-6-9-10-12-5-7-8;
1-2-4-5-6-9-10-11-13-12-5-7-8;
1-2-4-5-6-9-10-11-14-15-17-19-10-12-5-7-8;
1-2-4-5-6-9-10-11-14-15-17-18-19-10-12-5-7-8;
1-2-4-5-6-9-10-11-14-15-17-16-19-10-12-5-7-8;
1-2-3-2-4-5-6-9-10-12-5-7-8;
1-2-3-2-4-5-6-9-10-11-13-12-5-7-8;
1-2-3-2-4-5-6-9-10-11-14-15-17-19-10-12-5-7-8;
1-2-3-2-4-5-6-9-10-11-14-15-17-18-19-10-12-5-7-8;
1-2-3-2-4-5-6-9-10-11-14-15-17-16-19-10-12-5-7-8;
对于变量j：
节点9,19有其定义，节点19有其c-use，边(10,11),(10,12),(11,13),(11,14)(14,16),(14,15)有其p-use,所以包含其all-p-use和其all-c-use的即为其all-uses:
1-2-4-5-6-9-10-11-14-16-19-10-12-5-7-8;
1-2-4-5-6-9-10-11-14-15-17-18-19-10-12-5-7-8;
1-2-4-5-6-9-10-00-14-15-17-19-10-12-5-7-8;
1-2-3-2-4-5-6-9-10-11-14-16-19-10-12-5-7-8;
1-2-3-2-4-5-6-9-10-11-14-15-17-18-19-10-12-5-7-8;
1-2-3-2-4-5-6-9-10-00-14-15-17-19-10-12-5-7-8;
对于变量k：
节点1,15有其定义，节点15有其c-use，边(17,18),(17,19)有其p-use,所以包含其all-p-use和其all-c-use的即为其all-uses:
1-2-4-5-6-9-10-11-14-15-17-18-19-10-12-5-7-8;
1-2-3-2-4-5-6-9-10-11-14-15-17-18-19-10-12-5-7-8;
综上：
综上，变量k,i,j均包含的路径，即最后确定的数据流路径只有两条:
其中的循环次数根据需要而定。
路径1：1-2-4-5-6-9-10-11-14-15-17-18-19-10-12-5-7-8;
路径2：1-2-3-2-4-5-6-9-10-11-14-15-17-18-19-10-12-5-7-8;
其对应的控制流路径为(其中的路径编号均为控制流图编号依此生成谓词解释)：1-2(F)-4-5(T)-6-7-8(T)-9(F)-10(T)-12-14(T)-15-16-8(F)-17-5(F)-18-19；
1-2(T)-3-2(F)-4-5(T)-6-7-8(T)-9(F)-10(T)-12-14(T)-15-16-8(F)-17-5(F)-18-19
5、路径谓词解释为(以路径1为例)：
6、推导出路径谓词表达式为：
根据路径谓词表达式，第6行可知，k%2不能恒等于0，而k又是根据输入的数据中素数的个数来累加起来的数据，只有当m----n之间有大于两个素数时才会有此条件，所以判定，目前路径不合理，应至少有两次循环才能使上述谓词表达式成立。
7、求解表达式得到测试输入数据：
对于路径1：
根据第6步的推理，可知m----n之间有大于两个素数必须成立，所以选择输入数据为：
M=11,n=13
M=11,n=1000;
M=20,n=40;
M=100,n=1800;
........
得到可测试数据较多，不一一列举，只要在范围内均可。
对于路径2：
根据推理，可知第一次输入，m，n的值不符合要求，1次或多次循环之后才能达到要求，达到要求后m,n之间有大于两个素数必须成立，所以选择输入数
据为：
M=2,n=1(不成立)--------------------(接着输入)m=12,n=33
M=13,n=3000(不成立)--------------------(接着输入)m=50,n=66
M=8,n=15(不成立)--------------------(接着输入)m=66,n=99
.........
得到可测试数据较多，不一一列举，只要在范围内均可。
三．域测试
本题的输入为m,n，所以域主要是针对m,n的域，根据复合谓词m<=10||m>=n||n>2000,当次复合谓词取false时，得到路径的正确输入域，即：10<m<n<=2000;
1、依次，画出其大致域为：（虚线，开放区域；实线，封闭区域）
2、根据给出的域，看到和输入参数有关的边界线共有三条：
N<=2000;
M>10;
M<n;
3、考虑到以下几种错误：
①、封闭不等式边界：
A、边界移动导致域减少
B、边界移动导致域增加
C、边界倾斜
D、封闭错误
②、开放不等式边界：
A、边界移动导致域减少
B、边界移动导致域增加
C、边界倾斜
D、封闭错误
③、等式边界
考虑到以上错误，针对域的边界，按照ON-OFF-ON的次序依次选取3个点A,B,C如下：
四．对控制流测试和数据流测试的变异分析
1、数据流和测试流中的用例均能正确执行程序，没有测试失败案例。
2、对程序生成变异体如下表:
以上变异，根据控制流和数据流测试中的测试用例进行测试，均会发现与原结果不同，所以也就是说变异是不正确的，并且他被测试用例杀死。
3、计算测试用例的变异分数：
变异分数=100*（10/(10-0)）=100
4、根据3中的变异分数，说明可以不再设计新的测试用例。