精华内容
下载资源
问答
  • C语言求质数的算法

    万次阅读 2014-06-13 12:38:44
    上次被出了一题质数的C语言求解题目,当时用了最粗暴的算法,回来仔细参考资料,其实答案有很多种: 1,小学生版本:判断 x 是否为质数,就从 2 一直算到 x-1。 static rt_uint32_t array1[ARRAY_LEN]; void func1...

    前言

    上次被出了一题质数的C语言求解题目(面试),当时用了最粗暴的算法,回来仔细参考资料,其实答案有很多种:

    1,小学生版本:

    判断 x 是否为质数,就从 2 一直算到 x-1。
    static rt_uint32_t array1[ARRAY_LEN];
    void func1(void)
    {
        for (rt_uint32_t i = 1; i <= ARRAY_LEN; i++)
        {
            array1[i - 1] = 0;
        }
    
        rt_uint32_t x, y = 0, z = 0;
        rt_uint32_t i = 0;
        for (x = 2; x <= ARRAY_LEN; x++)
        {
            y = 0;
            for (i = 1; i <= x; i++)
            {
                if (x % i == 0)
                {
                    y++;
                }
            }
            if (y == 2)
            {
                z++;
                array1[x - 1] = x;
            }
        }
        array1[0] = 1;
    }

    2,小学生毕业版:

    x 如果有质因数,肯定会小于等于 x/2,所以捏,就从 2 一直到 x/2 即可。
    static rt_uint32_t array2[ARRAY_LEN];
    void func2(void)
    {
        for (rt_uint32_t i = 1; i <= ARRAY_LEN; i++)
        {
            array2[i - 1] = 0;
        }
    
        rt_uint32_t x, y = 0, z = 0;
        rt_uint32_t i = 0;
        for (x = 3; x <= ARRAY_LEN; x++)
        {
            y = 0;
            for (i = 2; i <= x / 2; i++)
            {
                if (x % i == 0)
                {
                    y++;
                    break;
                }
            }
            if (y == 0)
            {
                z++;
                array2[x - 1] = x;
            }
        }
        array2[0] = 1;
        array2[1] = 2;
    }

    3,初中生版:

    除了2以外的质因数都是奇数。所以算从3开始一直到 x/2 的所有奇数。
    static rt_uint32_t array3[ARRAY_LEN];
    void func3(void)
    {
        for (rt_uint32_t i = 1; i <= ARRAY_LEN; i++)
        {
            array3[i - 1] = 0;
        }
    
        rt_uint32_t x, y = 0, z = 0;
        rt_uint32_t i = 0;
        for (x = 3; x <= ARRAY_LEN; x += 2)
        {
            y = 0;
            for (i = 2; i <= x / 2; i++)
            {
                if (x % i == 0)
                {
                    y++;
                    break;
                }
            }
            if (y == 0)
            {
                z++;
                array3[x - 1] = x;
            }
        }
        array3[0] = 1;
        array3[1] = 2;
    }

    4,高中生版:

    其实只要从 2 一直尝试到根号x,就可以了。因为x只要有因数必定有一个因数小于等于根号x。
    static rt_uint32_t array4[ARRAY_LEN];
    void func4(void)
    {
        for (rt_uint32_t i = 1; i <= ARRAY_LEN; i++)
        {
            array4[i - 1] = 0;
        }
    
        rt_uint32_t x, y = 0, z = 0;
        rt_uint32_t i = 0;
        for (x = 3; x <= ARRAY_LEN; x++)
        {
            y = 0;
            for (i = 2; i <= sqrt(x); i++)
            {
                if (x % i == 0)
                {
                    y++;
                    break;
                }
            }
            if (y == 0)
            {
                z++;
                array4[x - 1] = x;
            }
        }
        array4[0] = 1;
        array4[1] = 2;
    }

    5,本科生版:

    把上面的版本都综合起来
    static rt_uint32_t array5[ARRAY_LEN];
    void func5(void)
    {
        for (rt_uint32_t i = 1; i <= ARRAY_LEN; i++)
        {
            array5[i - 1] = 0;
        }
    
        rt_uint32_t x, y = 0, z = 0;
        rt_uint32_t i = 0;
        for (x = 3; x <= ARRAY_LEN; x += 2)
        {
            y = 0;
            for (i = 2; i <= sqrt(x); i++)
            {
                if (x % i == 0)
                {
                    y++;
                    break;
                }
            }
            if (y == 0)
            {
                z++;
                array5[x - 1] = x;
            }
        }
        array5[0] = 1;
        array5[1] = 2;
    }

    6,本科生毕业版本:

    就是当i是质(素)数的时候,i的所有的倍数必然是合数。如果i已经被判断不是质数了,那么再找到i后面的质数来把这个质
    数的倍数筛掉。
    static rt_uint32_t array6[ARRAY_LEN];
    void func6(void)
    {
        for (rt_uint32_t i = 1; i <= ARRAY_LEN; i += 2)
        {
            array6[i - 1] = i;
        }
    
        for (rt_uint32_t i = 3; i < sqrt(ARRAY_LEN); i+=2)
        {
            if (array6[i-1])
            {
                for(rt_uint32_t j=i<<2;j<=ARRAY_LEN;j+=i)
                {
                    array6[j] = 0;
                }
            }
        }
        array6[1] = 2;
    }

    总结

    分析了6个算法在我的嵌入式平台运行结果:
    定义ARRAY_LEN = 1000;    
    func1 2513922
    func2 221563
    func3 213926
    func4 762945
    func5 674993
    func6 14663
    我们可以看到func4、func5并没有我们想象的那么节省时间,我想问题主要出在sqrt上面;sqrt本身是比较耗时的计算,然后func4与func5调用sqrt的次数又比较多;所以导致结果不太乐观。当然如果把ARRAY_LEN调大,可能结果又会不一样

    至此,也就只是我本科毕业的水准了,后面还有更好的纯C算法可以告诉我。

    展开全文
  • 上次被出了一题质数的C语言求解题目(面试),当时用了最粗暴的算法,回来仔细参考资料,其实答案有很多种:1,小学生版本:判断 x 是否为质数,就从 2 一直算到 x-1。static rt_uint32_t array1[ARRAY_LEN];void func...

    上次被出了一题质数的C语言求解题目(面试),当时用了最粗暴的算法,回来仔细参考资料,其实答案有很多种:

    1,小学生版本:

    判断 x 是否为质数,就从 2 一直算到 x-1。

    static rt_uint32_t array1[ARRAY_LEN];

    void func1(void)

    {

    for (rt_uint32_t i = 1; i <= ARRAY_LEN; i++)

    {

    array1[i - 1] = 0;

    }

    rt_uint32_t x, y = 0, z = 0;

    rt_uint32_t i = 0;

    for (x = 2; x <= ARRAY_LEN; x++)

    {

    y = 0;

    for (i = 1; i <= x; i++)

    {

    if (x % i == 0)

    {

    y++;

    }

    }

    if (y == 2)

    {

    z++;

    array1[x - 1] = x;

    }

    }

    array1[0] = 1;

    }

    2,小学生毕业版:

    x 如果有质因数,肯定会小于等于 x/2,所以捏,就从 2 一直到 x/2 即可。

    static rt_uint32_t array2[ARRAY_LEN];

    void func2(void)

    {

    for (rt_uint32_t i = 1; i <= ARRAY_LEN; i++)

    {

    array2[i - 1] = 0;

    }

    rt_uint32_t x, y = 0, z = 0;

    rt_uint32_t i = 0;

    for (x = 3; x <= ARRAY_LEN; x++)

    {

    y = 0;

    for (i = 2; i <= x / 2; i++)

    {

    if (x % i == 0)

    {

    y++;

    break;

    }

    }

    if (y == 0)

    {

    z++;

    array2[x - 1] = x;

    }

    }

    array2[0] = 1;

    array2[1] = 2;

    }

    3,初中生版:

    除了2以外的质因数都是奇数。所以算从3开始一直到 x/2 的所有奇数。

    static rt_uint32_t array3[ARRAY_LEN];

    void func3(void)

    {

    for (rt_uint32_t i = 1; i <= ARRAY_LEN; i++)

    {

    array3[i - 1] = 0;

    }

    rt_uint32_t x, y = 0, z = 0;

    rt_uint32_t i = 0;

    for (x = 3; x <= ARRAY_LEN; x += 2)

    {

    y = 0;

    for (i = 2; i <= x / 2; i++)

    {

    if (x % i == 0)

    {

    y++;

    break;

    }

    }

    if (y == 0)

    {

    z++;

    array3[x - 1] = x;

    }

    }

    array3[0] = 1;

    array3[1] = 2;

    }

    4,高中生版:

    其实只要从 2 一直尝试到根号x,就可以了。因为x只要有因数必定有一个因数小于等于根号x。

    static rt_uint32_t array4[ARRAY_LEN];

    void func4(void)

    {

    for (rt_uint32_t i = 1; i <= ARRAY_LEN; i++)

    {

    array4[i - 1] = 0;

    }

    rt_uint32_t x, y = 0, z = 0;

    rt_uint32_t i = 0;

    for (x = 3; x <= ARRAY_LEN; x++)

    {

    y = 0;

    for (i = 2; i <= sqrt(x); i++)

    {

    if (x % i == 0)

    {

    y++;

    break;

    }

    }

    if (y == 0)

    {

    z++;

    array4[x - 1] = x;

    }

    }

    array4[0] = 1;

    array4[1] = 2;

    }

    5,本科生版:

    把上面的版本都综合起来

    static rt_uint32_t array5[ARRAY_LEN];

    void func5(void)

    {

    for (rt_uint32_t i = 1; i <= ARRAY_LEN; i++)

    {

    array5[i - 1] = 0;

    }

    rt_uint32_t x, y = 0, z = 0;

    rt_uint32_t i = 0;

    for (x = 3; x <= ARRAY_LEN; x += 2)

    {

    y = 0;

    for (i = 2; i <= sqrt(x); i++)

    {

    if (x % i == 0)

    {

    y++;

    break;

    }

    }

    if (y == 0)

    {

    z++;

    array5[x - 1] = x;

    }

    }

    array5[0] = 1;

    array5[1] = 2;

    }

    6,本科生毕业版本:

    就是当i是质(素)数的时候,i的所有的倍数必然是合数。如果i已经被判断不是质数了,那么再找到i后面的质数来把这个质

    数的倍数筛掉。

    static rt_uint32_t array6[ARRAY_LEN];

    void func6(void)

    {

    for (rt_uint32_t i = 1; i <= ARRAY_LEN; i += 2)

    {

    array6[i - 1] = i;

    }

    for (rt_uint32_t i = 3; i < sqrt(ARRAY_LEN); i+=2)

    {

    if (array6[i-1])

    {

    for(rt_uint32_t j=i<<2;j<=ARRAY_LEN;j+=i)

    {

    array6[j] = 0;

    }

    }

    }

    array6[1] = 2;

    }

    总结

    分析了6个算法在我的嵌入式平台运行结果:

    定义ARRAY_LEN = 1000;

    func1

    2513922

    func2

    221563

    func3

    213926

    func4

    762945

    func5

    674993

    func6

    14663

    我们可以看到func4、func5并没有我们想象的那么节省时间,我想问题主要出在sqrt上面;sqrt本身是比较耗时的计算,然后func4与func5调用sqrt的次数又比较多;所以导致结果不太乐观。当然如果把ARRAY_LEN调大,可能结果又会不一样

    至此,也就只是我本科毕业的水准了,后面还有更好的纯C算法可以告诉我。

    展开全文
  • C语言求质数的方法

    千次阅读 2015-10-13 20:53:51
    算法的剩余部分,遍历整个列表并剔除所有不是质数的整数。后面的步骤是这样的。找到列表中的第1个不被剔除的数(也就是2),然后将列表后面所有逢双的数都剔除,因为它们都可以被2整除,因此不是质数。接着,再...

    质数就是只能被1和本身整除的数。Eratosthenes筛选法是一种计算质数的有效方法。这个算法的第一步就是写下所有从2至某个上限之间的所有整数。在算法的剩余部分,遍历整个列表并剔除所有不是质数的整数。后面的步骤是这样的。找到列表中的第1个不被剔除的数(也就是2),然后将列表后面所有逢双的数都剔除,因为它们都可以被2整除,因此不是质数。接着,再回到列表的头部重新开始,此时列表中第一个尚未被剔除的第1个数是3,所以在3之后把每逢第3个数(3的倍数)剔除。完成这一步之后,再回到列表开头,3后面的下一个数是4,但它是2的倍数,已经剔除,所以将其跳过,轮到5,将所有5的倍数剔除,这样依次类推、反复进行,最后列表中未被剔除的数均为质数。
    编写一个程序,实现这个算法,使用数组表示列表。每个数组元素的值用于标记对应的数是否已被剔除。开始时数组所有元素的值都设置为TRUE,当算法要求“剔除”其对应的数时,就把这个元素设置为FALSE。如果你的程序运行于16位的机器上,小心考虑是不是把某个变量声明为long。一开始先使用包含1000个元素的数组。如果你使用字符数组,使用相同的空间,你将会比使用整数数组找到更多的质数。你可以使用下标来表示指向数组首元素和尾元素的指针,但你应该使用指针来访问数组元素。
    除了2之外,所有的偶数都不是质数。数组中的元素只对应奇数可以使程序的空间效率大为提高。

    #include <stdlib.h>
    #include <stdio.h>
    #define SIZE 10
    #define TRUE 1
    #define FALSE 0
    
    int main()
    {
        char sieve[ SIZE ];
        char *sp; 
        int number; 
        int j = 1;
    
        for( sp = sieve; sp < &sieve[ SIZE ]; )
            *sp++ = TRUE;
    
        for( number = 3; ; number += 2 )
        {
    
            sp = &sieve[0] + (number - 3) / 2;   
            if( sp >= &sieve[ SIZE ] )
                break;
    
            while( sp += number, sp < &sieve[ SIZE ] )    /* 关键部分,将关键位置上的
                                                            数剔除,sp += number位置
                                                            上的数据都是可以整除sp位置
                                                            上的数据,所以将其剔除*/
                *sp = FALSE;
        }
    
        printf( "%5d", 2);
        for( number = 3, sp = &sieve[ 0 ]; sp < &sieve[ SIZE ]; number += 2, sp++)
        {
            if( *sp )                          //关键部分,for循环中将奇数与数组挂钩       
            {                                  //使得相同的数组空间内可以寻找到的质数
                printf( "%5d", number );       //是原先的两倍,且在上部分的while循环 
                if (j++ % 10 == 9)             //剔除掉不是质数的奇数
                    putchar ('\n');
            }   
        }
        if (j % 10 != 0)
            putchar ('\n');
        return EXIT_SUCCESS;
    }

    为了更加的节省空间可以使用位数组,但使用位数组不具有移植性,且会降低时间效率。

    #include <stdlib.h>
    #include <stdio.h>
    #include <limits.h>
    
    #define SIZE 10
    #define TRUE 1
    #define FALSE 0
    
    unsigned character_offset (unsigned bit_number);
    unsigned bit_offset (unsigned bit_number);
    
    int main()
    {
        char str[SIZE] = {0}; 
        char *p = str;
        int i = 0;
        int j = 1; 
        int number = 3;
        int m;
        for (i = 0; i < SIZE * CHAR_BIT; i++)           //将位数组中的位全部置为TRUE 
        {
            str[character_offset(i)] |= (TRUE << bit_offset(i));    
        }
    
    
        for (i = 0, number = 3; ; number += 2, i++)
        {
            m = i;
            if (i > SIZE * CHAR_BIT)
                break;
            while (i += number, i <= SIZE * CHAR_BIT)
                str[character_offset(i)] &= ~(TRUE << bit_offset(i));           
            i = m;
        }
    
        printf ("%6d", 2);
        for (i = 0, number = 3; i < SIZE * CHAR_BIT; i++, number += 2)
        {
            if (str[character_offset(i)] & (TRUE << bit_offset(i)))
            {
                printf ("%6d", number);
                if (j++ % 10 == 9)
                    putchar ('\n');
            } 
        }
        if (j % 10 != 0)
            putchar('\n'); 
    
        return 0;
    }
    
    unsigned character_offset (unsigned bit_number)
    {
        return bit_number / 8;
    }
    
    unsigned bit_offset (unsigned bit_number)
    {
        return bit_number % 8;
    }
    展开全文
  • 今天讲点比较高级的算法,目的也很简单,求质数,但是应用一种新的算法Miller-Rabin算法,这是一种利用了概率和费马小定理的算法设计,有点玄乎吧,其实本人也是刚接触这种算法,这是一种纯数学的解法,如果各位不懂...
    今天讲点比较高级的算法,目的也很简单,求质数,但是应用一种新的算法Miller-Rabin算法,这是一种利用了概率和费马小定理的算法设计,有点玄乎吧,其实本人也是刚接触这种算法,这是一种纯数学的解法,如果各位不懂,当学习一下数学也好啊好,我们往下讲



    首先了解基本的数学知识,费马小定理:



    若n是素数,则对所有1≤a≤n-1的整数a,有a^(n-1)mod n=1;



    作者Fermat 很牛的数学家,在他在世的时候好像还没有计算机,不过今天我们要用这个定理来设计算法



    分析这个定理可以知道,如果一个数是质数,那么它必定满足任意一个整数属于(1,n-1)范围有a^(n-1)mod n=1,不懂?我们取逆否命题试试看,就是只要存在在(1,n-1)范围中的整数a 使得a^(n-1)mod n=1不成立,那么这个数就不是素数,相信明白了吧,我们要确定一个数是否是素数,只要随机生成一系列的数a,如果这些数a使N满足费马小定理的话那么就可以认定它是素数了,当然有个前提,就是这个推导只能在计算机领域内使用就跟我上次讲的用哥德巴赫猜想优化一道算法题目一样,在计算机可以运算的数的范围内可用,请不要在其他科学领域类使用





    算法如下,原本是网络上的一个C++算法,我改成C





    /*

    *费马小定理的应用,求质数

    *Miller-Rabin算法

    *2008 12 27

    */

    #include"stdio.h"

    #include"stdlib.h"

    #include"math.h"

    #include"time.h"



    int Btest(int a,int n)

    {

    int s = 0;

    int t = n-1;

    int i , j , k;

    int x = 1;

    int y;

    i = 1;

    do{

    s++;

    t = t / 2;

    }while((t%2)!=1);



    while(i < tbr>
    x = ( x * a ) % n;

    i++;

    }

    if((x == 1) || ( x == n-1))

    return 1;

    for(j = 1 ; j < s - jbr>
    y = 1;

    for(k = 1 ; k < j kbr>
    {

    y = 2 * y;

    }

    i = 1;

    x = 1;

    while(i < y tbr>
    x = ( x * a) % n;

    i++;

    }

    if(x == n - 1)

    return 1;

    }

    return 0;

    }



    int MillRab(int n)

    {

    int a;

    /*利用时间作为随机种子产生随机数*/

    a=random((unsigned)time(0))%(n-3)+2;

    return Btest(a,n);

    }



    int MillerRabin(int n,int k)

    {

    int i;

    for(i=1;i< kibr>
    {

    if(MillRab(n)==0)return 0;

    }

    return 1;

    }





    int main(){/*费马小定理的应用*/

    int i;

    int n=10000;/*定义测试范围*/

    int count=0;

    printf("2 3 ");/*先输出2跟3*/

    for(i=5;i< nbr>
    if(MillerRabin(i , (int)log10(i))){/*符合条件?*/

    printf("%d ",i);

    count++;

    }

    i=i+2;

    }

    printf("nthere %d prime(s)n",count);

    return 0;

    }


    --------------------------------------------------------------------------------------
    - 版权声明:
    - 如在本页面内无特别说明,本文内容均为[李大仁博客]原创,本文版权归[李大仁博客]所有。
    - 欢迎转载,转载请务必在文章页面明显位置提供原文链接并注明出处。欢迎您在转载本文时保留本段声明。
    - 文章标题:[算法]费马小定理求质数的算法之Miller-Rabin算法,C语言实现
    - 独立博客:李大仁博客
    - 永久链接:http://www.lidaren.com/archives/277
    --------------------------------------------------------------------------------------
    以上内容由博客自动发布工具自动发布,最终显示内容和效果会与原文内容有所偏差,敬请谅解。
    展开全文
  • c语言求范围内质数极为高效的算法 这是一个求质数极为高效的算法,基于筛数法经过数次优化,是我目前写出的最为快速的算法,1亿以内一秒完成。 C语言代码 #include <stdio.h> #include <math.h> #define...
  • C语言求素数的算法

    2015-08-22 13:45:00
    最后一次是出了素数的问题C语言解决题目(面试),当时用了最粗暴的算法。回来细致參考资料,事实上答案有非常多种: 1,小学生版本号: 推断 x 是否为质数,就从 2 一直算到 x-1。 static rt_uint32_t array1...
  • 今天考试的题目是记不得了,等题目公开了再给大家分析,...优化过的算法O(N * sqrt(N)),经典的算法我就不讲了,初学者如果不懂的话,可以留言,或者跟我联系代码如下:/*求质数的经典方法,穷举法*author CG*2008 12
  • C语言算法小技巧:找质数...根据质数的概念,一个数num,除以2到num-1所有的数。如果都不能被整除,那就是质数了。 Created with Raphaël 2.2.0数 num,除数 i = 2i ++( num % i ) == 0 ?num 不是质数yesno ...
  • 下面附上我的代码,此函数中用到了sqrt函数,其实我不会C语言质数的求解方法。我是百度的算法,然后自己写的代码,敬请见谅! #include #include int prime(int a) { int i; int flag = 1; for(i = 2; i ; i+...
  • 常见算法C语言求素数问题 素数,又称为质数,指在一个大于1自然数中,除了1和此整数自身外,无法被其他自然数整除数(只有1和本身两个因数数),维基百科:素数定义点击打开链接 算法过程:...
  • 1到100之内素数 #include<stdio.h> int main() { int i, j, k; for (i = 1; i < 100;i++) { k = 1; for (j = 2; j <i;j++) { if (i%j==0) { k = 0; break; } } if (k == 1)...
  • 在一秒内出第10000个质数的c语言实现 #include #define MAXNUM 10000 void func() { register int i, j; int cnt; int flag; int findvalue[MAXNUM] ={2}; for(cnt = 1, i = 3; cnt ; i += 2)
  • 当我们用c语言去实现素数算法的代码时,重点是去考虑其变量以及循环条件,掌握这两点就可以做素数例题啦~ 例 1 从键盘输入一个数,判断其是否为素数 ????分析:想到概念,任何素数只能被1和它本身所除,那么从1到...
  • 15.Eratosthenes筛选求质数 32 16.超长整数运算(大数运算) 34 17.长 PI 36 18.最大公因数、最小公倍数、因式分解 39 19.完美数 42 20.阿姆斯壮数 45 21.最大访客数 46 22.中序式转后序式(前序式) 48 23.后序式...
  • Eratosthenes筛选求质数 超长整数运算(大数运算) 长 PI 最大公因数、最小公倍数、因式分解 完美数 阿姆斯壮数 最大访客数 中序式转后序式(前序式) 后序式运算 关于赌博 洗扑克牌(乱数排列) ...
  • C语言素数判断算法分析

    千次阅读 2019-11-08 16:41:07
    C语言素数判断算法分析 1、素数定义 素数:也叫质数,是指大于1,且只能被1和它自身整除自然数; 1既不是素数,也不是合数; 2是最小素数; 2、三种算法分析 2.1 最简单最易懂判断方法 2,3是...
  • C语言经典算法大全

    2019-03-25 22:51:03
    C语言经典算法51节: 三色棋 ...Eratosthenes 筛选求质数 超长整数运算(大数运算) 长PI 最大公因数、最小公倍数、因式分解 完美数 阿姆斯壮数 最大访客数 中序式转后序式(前序式) 后序式运算
  • C语言常见算法实现

    千次阅读 多人点赞 2010-07-04 11:03:37
    C语言常见算法主要收集一些经常用到的算法,有些笔试面试中经常考到,自己在学习的过程中与大家分享,希望对学习算法和C语言的朋友有帮助。 1,汉诺塔算法的C语言实现  ...8,Eratosthenes筛选求质数的C语言...
  • 明除了自身之外,无法被其它整数整除数称之为质数,要求质数很简单,但如何快速求出质数则一直是程式设计人员与数学家努力课题,在这边介绍一个着名 Eratosthenes求质数方法。 首先知道这个问题可以使用...
  • 这是本人去年非典期间在vccode上发表拙作,近日看到这里人气不错,重贴给同好探讨,勿怪http://www.vccode.com/file_show.php?id=1852http://www.vccode.com/file_download.php?id=1852 源代码原创: 本文及程序...
  • C语言:证明是质数最大公约数,10000!末尾有几个0(最近没啥好更,过几天更新c算法) 1.证明是质数: #include<stdio.h> int main(){ int i,zhisu = 1; scanf("%d",&zhisu); for(i = 2;i < ...
  • c语言经典算法

    2011-12-22 17:56:06
    Eratosthenes筛选求质数 超长整数运算(大数运算) 长 PI 最大公因数、最小公倍数、因式分解 完美数 阿姆斯壮数 最大访客数 中序式转后序式(前序式) 后序式运算 关于赌博 洗扑克牌(乱数排列) Craps...
  • 15.Eratosthenes筛选求质数 32 16.超长整数运算(大数运算) 34 17.长 PI 36 18.最大公因数、最小公倍数、因式分解 39 19.完美数 42 20.阿姆斯壮数 45 21.最大访客数 46 22.中序式转后序式(前序式) 48 23.后序式...

空空如也

空空如也

1 2 3 4
收藏数 64
精华内容 25
关键字:

c语言求质数的算法

c语言 订阅