精华内容
下载资源
问答
  • 在比赛或者工作时,有时候会经常要求我们编程求素数,但是我们自己写出来的时间复杂度太高,...C语言// 对 n 进行素数判断inline static int is_prime(int n){int i;if (n == 2){return 1;}if (n < 2 || n % 2 =...

    在比赛或者工作时,有时候会经常要求我们编程求素数,但是我们自己写出来的时间复杂度太高,所以我在这里做个总结。

    先贴上最终函数,该段代码在开启最大代码优化时,可以直接内嵌进调用程序中,使得速度更加极致。

    C语言

    // 对 n 进行素数判断

    inline static int is_prime(int n)

    {

    int i;

    if (n == 2)

    {

    return 1;

    }

    if (n < 2 || n % 2 == 0)

    {

    return 0;

    }

    for (i = 3; i * i <= n; i += 2)

    {

    if (n % i == 0)

    {

    return 0;

    }

    }

    return 1;

    }

    Python

    Python 的话,由于本身是脚本语言,所以很难做到很快,一般都是用C语言进行计算的。

    # 对 n 进行素数判断

    # 注意:请不要传入浮点数

    def is_prime(n):

    if (n == 2):

    return True

    if (n < 2 or n % 2 == 0):

    return False

    i = 3

    while( i * i <= n):

    if( n % i == 0):

    return False

    i += 2

    return True

    原理

    根据定义

    根据概念判断:如果一个正整数只有两个因子, 1 和 p,则称 p 为素数。所以根据定义我们写出如下函数:

    int is_prime(int n)

    {

    int i;

    if (n < 2)

    {

    return 0;

    }

    for (i = 2; i < n; i++)

    {

    if (n % i == 0)

    {

    return 0;

    }

    }

    return 1;

    }

    时间复杂度为O(n),可以说是很差的算法。

    上面的函数做了很多不必要的动作,比如偶数的判断,因为除了2本身以外,其他的大于0的偶数都有因子2。

    偶数优化

    这面这段代码,去掉了偶数的判断。

    int is_prime(int n)

    {

    int i;

    if (n < 2)

    {

    return 0;

    }

    if (n == 2)

    {

    return 1;

    }

    for (i = 3; i < n; i += 2)

    {

    if (n % i == 0)

    {

    return 0;

    }

    }

    return 1;

    }

    时间复杂度O(n/2), 速度提高一倍,比之前的性能更优化了一点。

    根据定理进行优化

    定理: 如果 n 不是素数, 则 n 有满足 1

    int is_prime(int n)

    {

    int i;

    if (n == 2)

    {

    return 1;

    }

    if (n < 2 || n % 2 == 0)

    {

    return 0;

    }

    for (i = 3; i * i <= n; i += 2)

    {

    if (n % i == 0)

    {

    return 0;

    }

    }

    return 1;

    }

    时间复杂度O(sqrt(n)/2), 速度极大的提高了。

    后言

    其实还可以将已经计算出来的素数数组带到算法中去的,这样的算法速度会更快,但是其由于其不符合高内聚、低耦合的编程思想,这里就不提了。这样的算法可以用于特定程序来做优化,但是不适合普遍程序。

    总结

    算法的优化是数量级别的。

    展开全文
  • for i in range(2,int(n**0.5)):#对2到根号n取余 if n % i == 0: return False else: return True N = 1000#求素数的范围 strPrime = "" for j in range(2,N): if isPrime1(j):#使用isPrime1() isPrime2 isPrime3...

    def isPrime1(n):

    for i in range(2,n):#对2到n取余

    if n % i == 0:

    return False

    else:#注意缩进

    return True

    def isPrime2(n):

    for i in range(2,n//2+1):#对2到n/2取余

    if n % i == 0:

    return False

    else:

    return True

    def isPrime3(n):

    for i in range(2,int(n**0.5)):#对2到根号n取余

    if n % i == 0:

    return False

    else:

    return True

    N = 1000#求素数的范围

    strPrime = ""

    for j in range(2,N):

    if isPrime1(j):#使用isPrime1()  isPrime2 isPrime3() isPrime4()函数功能相同效率不同,可以引入time判断使用的时间

    #涉及简单计时http://www.cnblogs.com/didiaoxiaoguai/p/6684094.html

    strPrime = strPrime + str(j) + " "

    print(strPrime)

    #以下为另一写法

    def isPrime4(n):

    for i in range(3,int(n**0.5),2):#将步长设为2

    if n % i == 0:

    return False

    else:

    return True

    N = 1000 #

    strPrime = "2 "

    for j in range(3,N,2):

    if isPrime4(j):

    strPrime = strPrime + str(j) + " "

    print(strPrime)

    展开全文
  • java 判断素数优化

    2019-10-21 20:21:32
    素数:只能被1或者 自身整除 例 16: n = ab 44 28 116 <=n/2 8: n = ab 24 1*8 <= 根号n 2.8 public static void main (String[] args) { boolean ret = func(99); System.out.println(ret); } public ...

    素数:只能被1或者 自身整除
    例 16: n = ab 44 28 116 <=n/2
    8: n = ab 24 1*8 <= 根号n 2.8

    public static void main (String[] args) {
         boolean ret = func(99);
         System.out.println(ret);
    }
    public static boolean func (int n){
        for (int i = 2; i <=Math.sqrt(n); i++) {
            if (n % i == 0){
                return false;
            }
        }
              return true;
    }
    展开全文
  • 判断素数及其算法优化

    千次阅读 2018-04-25 22:25:46
    首先,我们要清楚什么是素数素数:又称质数,一个大于1的...根据素数的定义,我们可以写成出判断一个数是不是素数的算法。 /** * 判断是否是素数 * * @param n 目标数 * @return true:是素数; fals...

    首先,我们要清楚什么是素数?

    素数又称质数,一个大于1的自然数,除了1和它本身外,不能被其他自然数整除,换句话说就是该数除了1和它本身以外不再有其他的因数;否则称为合数

    根据素数的定义,我们可以写成出判断一个数是不是素数的算法。

        /**
         * 判断是否是素数
         *
         * @param n 目标数
         * @return true:是素数; false:不是素数
         */
        public static boolean isPrime(int n) {
            // 1 不是素数
            if (n <= 1) {
                return false;
            }
            // 由于在找 n 的因数时,只需要除到 n 开根号,所以只需 i*i<n 即可
            for (int i = 2; i * i < n; i++) {
                // 只要能被 i 整除,则返回 0
                if (n % i == 0) {
                    return false;
                }
            }
            return true;
        }

    我们知道如何判断一个数是不是素数后,就容易在给定的范围里寻找素数了。

    不过,上面的判断素数的算法,在大范围内筛选素数的效率不是最高的。下面介绍一种Eratosthenes(埃拉托斯特尼)算法来进行素数的筛选,它的效率要高的多。

     

    (1)先把1删除(1既不是质数也不是合数)

    (2)读取队列中当前最小的数2,然后把2的倍数删去

    (3)读取队列中当前最小的数3,然后把3的倍数删去

    (4)读取队列中当前最小的数5,然后把5的倍数删去

    .......

    (n)读取队列中当前最小的状态为true的数n,然后把n的倍数删去

     

        /**
         * Eratosthenes算法(用于筛选素数)
         *
         * @param primes 标记素数的数组
         */
        private static void Eratosthenes(boolean[] primes) {
            // 数组的长度
            int length = primes.length;
    
            // 初始化数组,标志 true 代表是素数
            for (int i = 2; i < length; i++) {
                primes[i] = true;
            }
    
            for (int i = 2; i * i < length; i++) {
                // 筛选素数
                if (primes[i]) {
                    for (int j = 2 * i; j < length; j++) {
                        // 不是素数,则继续筛选
                        if (!primes[j]) {
                            continue;
                        }
                        // 如果数 j 能被整除,则不是素数
                        if (j % i == 0) {
                            primes[j] = false;
                        }
                    }
                }
            }
        }

    下面我们使用分别上面的算法,传入一个测试用例来比较两个算法筛选素数的效率。

    (1)使用Eratosthenes算法

        /**
         * 使用 Eratosthenes 算法寻找num以内的素数
         *
         * @param num 目标数
         */
        public static void selectPrimesByEratosthenes(int num) {
            // 定义保存素数的数组
            boolean[] primes = new boolean[num + 1];
            //统计素数个数
            int count = 0;
            // 调用 Eratosthenes 算法,筛选素数
            Eratosthenes(primes);
            // 遍历出num内的所有素数
            for (int i = 2; i <= num; i++) {
                if (primes[i]) {
                    count++;
                    System.out.println(i);
                }
            }
        }

     

    测试代码:

    
        public static void main(String[] args) {
            // 寻找100000以内的素数
            int n = 100000;
            long start_time = System.currentTimeMillis();
            selectPrimesByEratosthenes(n);
            long end_time = System.currentTimeMillis();
            System.out.println("selectPrimesByEratosthenes:" + (double) (end_time - start_time) + " ms");
    
        }

    (2)使用一般算法

        /**
         * 使用一般算法寻找素数
         *
         * @param num
         */
        public static void selectPrimeByGenerate(int num) {
            for (int i = 2; i <= num; i++) {
                if (isPrime(i)) {
                    System.out.println(i);
                }
            }
        }

    测试代码:

        public static void main(String[] args) {
            // 寻找100000以内的素数
            int n = 100000;
            long start_time = System.currentTimeMillis();
            selectPrimesByGenerate(n);
            long end_time = System.currentTimeMillis();
            System.out.println("selectPrimesByGenerate:" + (double) (end_time - start_time) + " ms");
    
        }

    比较时间:(这里的时间还加上了打印素数的时间)

    所以,当在大范围内筛选素数时,Eratosthenes算法效率要高的多。

     

    展开全文
  • 对开根号判断素数优化

    千次阅读 2017-09-16 22:35:53
    恼人的素数连羽疲倦的推开公主阁的门,“啊啊啊,怎么会留这么麻烦的作业。”“既然布置了,那就没有办法了啊...“素数啊,我到是知道些比较快的判断方法。”“真的?”连羽如同见了救星一般。作为立志要成为计算机...
  • C语言对素数判断优化 #include <stdio.h> #include <stdlib.h> #include<math.h> int isPrime(int x) { int i,j,flag=0; if(x==1) printf("%d既不是素数又不是合数",x); else { if(x==2) ...
  • for i in range(2,int(n**0.5)):#对2到根号n取余 if n % i == 0: return False else: return True N = 1000#求素数的范围 strPrime = "" for j in range(2,N): if isPrime1(j):#使用isPrime1() isPrime2 isPrime3()...
  • 素数判断优化

    2018-12-01 20:29:54
    可以看到,不在6的倍数两侧,即6x两侧的数为6x+2,6x+3,6x+4,由于2(3x+1),3(2x+1),2(3x+2),所以它们一定不是素数,再除去6x本身,显然,素数要出现只可能出现在6x的相邻两侧。在6的倍数相邻两...
  • 38-优化判断素数

    2020-11-22 22:23:26
    //优化判断素数 从2遍历到n^1/2(n开平方) int main() { int n; scanf("%d",&n);// //for(int i=2;i<=sqrt((double)n);i++) for(int i=2;i<=sqrt(n*1.0);i++)//经常考试 { if(n%i == 0) { ...
  •  if isPrime1(j):#使用isPrime1() isPrime2 isPrime3() isPrime4()函数功能相同效率不同,可以引入time判断使用的时间  #涉及简单计时 http://www.cnblogs.com/didiaoxiaoguai/p/6684094.html    strPrime = ...
  • 我们认为计算机判断一个数是否是素数过程 :例如11i=22*3 2*3 2*5i=33*2 3*3i=44*2i=55*2i=6( 超过11的大小了)6*2这里我们可以很简单的写出一个穷举法的程序int i=2;while((n%i!=0)&&ii++;很明显上面这个...
  • 素数判断优化算法

    2020-06-26 21:54:49
    任何一个大于3的素数都可以被写为6k±1的形式,因为6k+2=2(3k+1),6k+3=3(2k+1),6k+4=2(3k+2)。 注意充分与必要关系,能被写为6k±1形式的数不一定为素数。 代码: bool isprime(int n){ if(n<=1) return false...
  • 11.素数判断及打印素数表-优化

    千次阅读 2020-01-18 15:22:36
    11.素数判断及打印素数表-优化版 1. 素数判断 素数定义:除了1和本身以外,不能被任何其他整数整除的一类数; 如果这个数X,isprime(x)返回1则是素数 返回0则非素数 int isprime(int x) { if(x<=1) return 0; ...
  • 判断素数: 普通的就不说了 一种更高效的做法: 结论是:大于等于5的质数一定和6的倍数相邻 令x≥1x≥1,将大于等于55的自然数表示如下:......6x-1,6x,6x+1,6x+2,6x+3,6x+4,6x+5,6(x+1),6(x+1)+1............6x...
  • 判断素数的方法.html

    2019-12-08 17:38:21
    判断素数的方法汇总:1.常见方法的讲述及代码,常见方法的优化的讲解及代码。2.筛选法的方法及代码。3.6素数法的方法及代码。
  • 素数判断及初步优化
  • 我们认为计算机判断一个数是否是素数过程 :例如11i=22*3 2*3 2*5i=33*2 3*3i=44*2i=55*2i=6( 超过11的大小了)6*2这里我们可以很简单的写出一个穷举法的程序int i=2;while((n%i!=0)&&ii++;很明显上面这个...
  • 以搜索1000以内的素数为例,判断出来的素数存放于一维数组中。1、一般遍历(双重循环) 采用双重循环,表层循环游标 J 负责遍历2-1000,内层游标K的范围是[2,根号J],在内层游标遍历的过程中,如果 表层循环游标J...
  • 我们认为计算机判断一个数是否是素数过程 :例如11i=22*3 2*3 2*5i=33*2 3*3i=44*2i=55*2i=6( 超过11的大小了)6*2这里我们可以很简单的写出一个穷举法的程序int i=2;while((n%i!=0)&&ii++;很明显上面这个...
  • 3.3 Go语言算法:判断素数

    千次阅读 2019-01-04 11:53:03
    判断是否素数 func IsPrime(n int) bool { if n == 1 { return false } //从2遍历到n-1,看看是否有因子 for i := 2; i &lt; n; i++ { if n%i == 0 { ...判断是否素数优化算法 func Is...
  • 判断素数的几种求法

    2020-02-13 20:55:18
    总结一下判断素数的几种求法 素数的概念 素数及除了1和本身之外,不能被其他数整除的一类数,1既不是素数也不是合数 素数的判断 判断n是否能被2,3,…n-1中的一个整除,只有全部都不能被整除才能判断为,而只要其中...
  • //素数判断 #include int main() { int n=0, i=0,count=0; for(n=101 ;n { for(i=2 ;i { if( n%i==0 ) { break; } } if(i==n) { printf("%5d",n); count++; } } printf("\ncount=%d\n",count); ...
  • #include#include#include#include#include#define M 100000.0using namespace std;int len,num=0;int list[10000],p=0;char str[10];bool v[10];int
  • 就是判断一个数是不是素数判断一个数是不是素数方法很简单,根据素数的定义(素数是只能被1和它自身整除的大于1的自然数)可以很容易写出程序出来,但是用一些小技巧的话可以将程序更加优化,提高算法的时间效率。...
  • 我们首先看这样一个很简单的问题:判定正整数\(n\)是否为素数 最简单的做法就是枚举\(2\)到\(n\)的所有数,看是否有数是\(n\)的因数,时间复杂度\(O(n)\) 稍微优化一下发现只要枚举\(2\)到\(\sqrt{n}\)中的数就可以...
  • 经常有初学者询问求解N内所有素数(质数)的问题,对此,网上的解答也很多,但很多要么不够专业,要么只有程序没有算法解析,所以三藏大厦对此问题做个小结,探讨一下求解...试除判断法算法描述:从上述定义可知,素数...
  • //判断a到b范围内的素数(包含上下界) //从小到大扣掉素数的倍数 //Input a,b (正整数) //Output q,w,e,...(范围内素数,逗号分格,每5个一行) #include #include using namespace std; int pow2(int x){//2
  • 判断一个数字是素数还是合数的算法——aks算法,具有较强的优化性和较低的计算复杂度。方便、快捷、准确。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 386
精华内容 154
关键字:

判断素数优化