精华内容
下载资源
问答
  • 在判断一个数是否为素数的题上,花费了我大量的时间,所以我不得不拿来说一说 一、素数是什么? 素数就是所有比1大的整数,除了1和它本身以外,不再有别的因数,这种整数叫做素数(质数) 二、思考步骤 1.满足...


    在判断一个数是否为素数的题上,花费了我大量的时间,所以我不得不拿来说一说


    一、素数是什么?

    素数就是在所有比1大的整数中,除了1和它本身以外,不再有别的因数,这种整数叫做素数(质数)

    二、思考步骤

    1.满足定义:拿一个数看能不能被1和它本身整除,对吗??

    在这里插入图片描述

                             那肯定是不对的,那不是随便一个数都是素数了
    

    应该考虑从2开始到输入的数减一为止,都不能被你输入的数整除,才定义为素数**

    2.先说说1-100以内的素数如何输出:

    首先我们需要一个循环,遍历一下1-100的全部整数,可以用for()循环
    要明白的是最小的质数是:2 肯定有很多人不知道吧在这里插入图片描述
    那么这个for从i=2开始
    在考虑内层循环,必须让外层循环的每一个数进入内层循环去除2到它自身-1的所有数看结果为不为零来判断,话不多说上码

    public class HomeWork {
     public static void main(String[] args) {
            int j;
            for (int i = 2; i <= 100; i++) { //遍历1-100的整数
                for (j = 2; j <= i - 1; j++) {  //j:被i去除
                    if (i % j == 0) {     //如果能被2-到i-1中的任何一个数整除就说明不是素数
                        break;      //不用break 每一个都会输出是素数
                    }
                }
                if (i == j) {
                    System.out.println(i + "是素数");
                }
            }
        }
    }
    

    那么怎么变成判断输入的一个数是不是素数呢??

    在这里插入图片描述
    那既然是输入的肯定要new 一个Scanner,然后我们不需要外面那个遍历1-100的循环了,把它去掉,里面的只需要让i小于你输入的数-1,在循环就可以啦

    public static void main(String[] args) {
    
            Scanner scan = new Scanner(System.in);
            int n = scan.nextInt();
            int i;
            for (i = 2; i < n; i++) {
                if (n % i == 0) {
                    System.out.println(n + "不是素数");
                    break;
                }
            }
                if (n==i){
                    System.out.println(n+"是素数");
    
                }
        }
    }
    
    

    总结

    对于写每一个编程题来说,最重要的是先要自己理解题目,逻辑清楚,就像这个素数,自己要知道素数是怎么定义的,根据定义来写代码,层层递进,当然这个方法不是最优方案,最优方案下次再说给你们吧!
    在这里插入图片描述

    展开全文
  •  素数:又称质数,指大于1的自然数,除了1和该本身外,无法被其他自然数整除的(也可定义只有1与该本身两因数的)。  举例子:5---除了能被1或5整除外,再也找不到第三可以整除它的自然数了...

    首先,需要明确什么是素数?

      素数:又称质数,指在大于1的自然数中,除了1和该数本身外,无法被其他自然数整除的数(也可定义为只有1与该数本身两个因数的数)。

      举个例子:5---除了能被1或5整除外,再也找不到第三个可以整除它的自然数了。那么5就是素数。

    那么,如果用程序如何来判断它是不是素数?

    实现思路:

    1 需要先输入一个被判断的数字并赋值给 Number
    2 判断这个数符不符合“Number > 1”的规则,如果不符合就结束循环,如果符合就去检验是不是素数
    3 如果能被1到Number之间的任意一个正整数整除就可以判断为不是素数,即可结束循环
    4 如果1至Number之间所有的正整数都不能整除,那么就是素数,即可结束循环

    有了思路,咱们来看具体要怎么实现:

    Number = int(input("请输入一个数字:"))          # 输入一个正整数,并赋值给Number
    if Number > 1:                                 # 判断输入的正整数是否大于1
        for i in range(2,Number):                  # 循环取出2至Number-1的正整数 i
            if Number % i == 0:                    # 将Number与i取余,如果余数为0 ,则就可以被整除
                print ("数字%s不是素数" % Number)
                break                              # 不是素数,结束循环
        else:
            print("数字%s是素数" % Number)           # 否则就是素数,打印结果
    else:
        print("输入的数字小于1,不合法")

    对于这段代码,有个地方要注意:

      else没有和if是一对,而是和for并排的,else与for搞到了一起,凑成了一对,我们常见的是if…else…或者if…elif…else诸如此类,但其实for也可以和else搭配出现,在这段代码里,当某一次遍历结果余数为0后,break生效,那循环就结束了。就这样完了,就是上边思路中的第三点。

    最后来看看不同情况的结果:

    请输入一个数字:17
    数字17是素数
    
    请输入一个数字:-10
    输入的数字小于1,不合法
    
    请输入一个数字:9
    数字9不是素数

     

     

    转载于:https://www.cnblogs.com/Zhan-W/p/11519708.html

    展开全文
  • 如何判断质数?

    2018-08-27 11:30:00
    1.一般,大家在程序中判断质数都是写一个函数,函数中循环从2到这个数的算数平方根枚举,看看这个数是否能整除枚举的数,如果能,则是质数,反之合数。 C Code: intpd(intn) { inti; for(i=2; i<=floor...

    质数,又称“素数”,质数定义为在大于1的自然数中,除了1和它本身以外不再有其他因数。

    现在,ljn教大家如何用程序判断质数。

     

    1.一般,大家在程序中判断质数都是写一个函数,函数中循环从2到这个数的算数平方根枚举,看看这个数是否能整除枚举的数,如果能,则是质数,反之合数。

    C Code:

    int pd(int n) {
        int i;
        for(i=2; i<=floor(sqrt(n)); i++)
            if(n%i==0) return 0;
        return 1;
    }

    C++ Code:

    bool pd(int n) {
        for(int i=2; i<=floor(sqrt(n)); i++)
            if(n%i==0) return 0;
        return 1;
    }

    Pascal Code:

    Function pd(n:longint):boolean;
    var i:longint;
    begin
        for i:=2 to trunc(sqrt(n)) do
            if n mod i=0 then exit(false);
        exit(true);
    end;

    注:C/C++ Code中,调用了floor函数,Pascal Code中,调用了trunc函数,它们都是把浮点数的小数部分去掉(不是四舍五入)。

        C/C++和Pascal的sqrt函数是求一个数的算术平方根。

        C/C++的floor函数和sqrt函数均在头文件<math.h>中。

     

    2.接下来介绍一种Monte-Carlo算法:

      如果n是一个正整数,如果a^(n-1)≡1(mod n),我们说n是基于a的伪素数。如果一个数是伪素数,它几乎肯定是素数。另一方面,如果一个数不是伪素数,它一定不是素数。由于我们可以自由地选取基,所以如果在选取了s个基后发现n都是伪素数,就几乎可以肯定n是素数了。

      它最简单的实现方法是一个循环,时间复杂度为O(s),s越大,准确率越高。

    Pascal Code:

    Function MR(n:longint):boolean;
    var i,a:longint;
    begin
        for i:=1 to s do
        begin
            a:=random(n-2)+2;
            if modular_exp(a,n-1,n)<>1 then  exit(false);
        end;
        exit(true);
    end;

    注:此处调用了modular_exp函数,即计算a^b mod c的值。

      这种思路也可以采用二进制扫描法快速地计算出a^b mod c的值。根据模算术的基本知识,(a*b)mod c=((a mod c)*b)mod c,那么可以把a^b mod c变成一系列较小数的乘积。把b写成二进制(a[t],a[t-1]…,a[1],a[0])。

      这样,有:a^b mod c=a^(a[t]*2^t+a[t-1]*2^(t-1)+…+a[1]*2^1+a[0]*2^0)mod c=((a^(a[0]*2^0)mod c)*(a^(a[1]*2^1)mod c)*…*(a^(a[t]*2^t)mod c))mod c。

      总时间复杂度为O(log3(b))。

     

    3.有一些题目会让你输出一个区间的质数,那么大家会想到筛法。

      现在大家常用的筛法是Eraosthenes氏筛法:每次求出一个新的素数,就把n以内的它的所有倍数都筛去。在实现的时候,对于每一个素数p,只需要筛去p×p,p×(p+1),…就可以了,因为p×q(q<p)已经在q的第一个素因子被找到的时候筛去了。

    C Code:

    #include <stdio.h>

    int i,j,a,b;
    int f[10000];

    void pd(int b) {
        for(i=2; i<=b; i++) if(!f[i])
            for(j=i*i; j<=b; j+=i) f[j]=1;
    }

    int main() {
        scanf("%d%d",&a,&b);
        pd(b);
        for(i=a; i<=b; i++) if(!f[i])
            printf("%d\n",i);
        return 0;
    }
    C++ Code:

    #include <iostream>
    #include <cstdio>

    using namespace std;

    int a,b;
    int f[10000];

    void pd(int b) {
        for(int i=2; i<=b; i++) if(!f[i])
            for(int j=i*i; j<=b; j+=i) f[j]=1;
    }

    int main() {
        cin >> a >> b;
        pd(b);
        for(int i=a; i<=b; i++) if(!f[i])
            cout << i << endl;
        return 0;
    }
    Pascal Code:

    Program ex;
    var a,b,i:longint;
        f:array[0..10000] of boolean;

    Procedure pd(b:longint);
    var i,j:longint;
    begin
        for i:=2 to b do if not f[i] then begin
            for j:=i to (b div i) do f[i*j]:=true;
        end;
    end;

    Begin
        read(a,b);
        pd(b);
        for i:=a to b do if not f[i] then
            writeln(i);
    End.

    有问题请联系QQ3046036317或加入QQ群555088375。

    如果你觉得有用,就点“好文要顶”“关注我”“收藏该文”。

     

     

    转载于:https://www.cnblogs.com/ljnoit/p/9536585.html

    展开全文
  • 素数问题最核心的就是如何判断一个数是否素数。对于判断一个数m是否是素数,最原始的方法就是按照素数的定义,试除2开始到m-1的整数,如果无一例外地都不能整除,则该数一定是素数。实现程序如下: //=======...

      素数定义:质数定义为在大于1的自然数中,除了1和它本身以外不再有其他因数。

      素数问题变化莫测,但万变不离其宗。素数问题最核心的就是如何判断一个数是否是素数。对于判断一个数m是否是素数,最原始的方法就是按照素数的定义,试除2开始到m-1的整数,如果无一例外地都不能整除,则该数一定是素数。实现程序如下:

    //============================
    //判断是否是素数1
    //============================
    #include <iostream>
    using namespace std;
    
    int main() {
        cout << "please inpout a number.";
        int m;
        cin >> m;
        for (int i = 2; i < m; ++i)
            if (m%i == 0) {
                cout << m << " isn't a prime\n";
                return 1;
            }
        cout << m << " is a prime\n";
        return 0;
    }

      改进:我们知道如果一个数有因子的话,那么在它的平方根数以内就应该有,否则就没有因子。例如66的平方根在8与9之间,因为66不是素数,,则它一定有比8还小的因子,我们知道66的因子是2、3、6等。

      现在我们就可以将m试除2到√m的整数,如果无一例外地都不能整除,则该数一定是素数。实现程序如下:
    //============================
    //判断是否是素数法2
    //============================
    #include <iostream>
    using namespace std;
    int main() {
        cout << "please inpout a number.";
        int m;
        cin >> m;
        double sqrtm = sqrt(m*1.0);
        for (int i = 2; i < sqrtm; ++i)
            if (m%i == 0) {
                cout << m << " isn't a prime\n";
                return 1;
            }
        cout << m << " is a prime\n";
        return 0;
    }

      改进:现在举个例子,判断102是否是素数,本来要从2试除到10。但事实上,中间的4、6、8、10也都无须试,只需要试除2、3、5、7。直接来说,就是只需要试除2到√m之间的所有素数即可。而所有素数(除了2和3)都满足6*i-1或6*i+1(i=1、2、3...)。那么代码又可以改进,如下:

    //============================
    //判断是否是素数法3
    //============================
    #include <iostream>
    using namespace std;
    int main() {
        cout << "please inpout a number.";
        int m;
        cin >> m;
        //两个较小数另外处理
        if (m == 2 || m == 3)
            return 1;
        double sqrtm = sqrt(m*1.0);
        for (int i = 5; i <= sqrtm; i += 6)
            if (m %i == 0 || m % (i + 2) == 0)
                cout << m << " isn't a prime\n";
        cout << m << " is a prime\n";
        return 0;
    }

      下面这种方法也是本人借鉴别人的,如有侵权请联系我删除。

      改进:素数有2、3、5、7、11、13、17、19、23、29...,观察可知:素数一定在6的倍数的左右,但6的倍数的左右不一定是素数,如23是素数,但25不是素数。则我们可以先通过这个条件将可能是素数的数筛选出来,然后采用方法三,代码如下:
    //============================
    //判断是否是素数法4
    //============================
    #include <iostream>
    using namespace std;
    int main() {
        cout << "please inpout a number.";
        int m;
        cin >> m;
        //两个较小数另外处理
        if (m == 2 || m == 3)
            return 1;
        //不在6的倍数两侧的一定不是质数
        if (m % 6 != 1 && m % 6 != 5) {
            cout << m << " isn't a prime\n";
            return 0;
        }
    
        double sqrtm = sqrt(m*1.0);
        //在6的倍数两侧的也可能不是质数
        for (int i = 5; i <= sqrtm; i += 6)
            if (m %i == 0 || m % (i + 2) == 0)
                cout << m << " isn't a prime\n";
        //排除所有,剩余的是质数
        cout << m << " is a prime\n";
        return 0;
    }

    现在对这四种方法的效率进行测试,测试代码如下:

    #include <iostream>
    #include <ctime>
    using namespace std;
    
    int isPrime_1(int num);
    int isPrime_2(int num);
    int isPrime_3(int num);
    int isPrime_4(int num);
    int main() {
        int num = 30000;
        int tstart, tstop; //分别记录起始和结束时间
    
                           //测试第一个判断质数函数
        tstart = clock();
        for (int i = 1; i <= num; i++)
            isPrime_1(i);
        tstop = clock();
        cout << "isPrime_1方法的时间(ms):" << tstop - tstart << endl;
    
        //测试第二个判断质数函数
        tstart = clock();
        for (int i = 1; i <= num; i++)
            isPrime_2(i);
        tstop = clock();
        cout << "isPrime_2方法的时间(ms):" << tstop - tstart << endl;
    
        //测试第三个判断质数函数
        tstart = clock();
        for (int i = 1; i <= num; i++)
            isPrime_3(i);
        tstop = clock();
        cout << "isPrime_3方法的时间(ms):" << tstop - tstart << endl;
    
        //测试第四个判断质数函数
        tstart = clock();
        for (int i = 1; i <= num; i++)
            isPrime_4(i);
        tstop = clock();
        cout << "isPrime_4方法的时间(ms):" << tstop - tstart << endl;
        cout << endl;
        return 0;
    }
    
    int isPrime_1(int num) {
        for (int i = 2; i <= num - 1; i++)
            if (num %i == 0)
                return 0;
        return 1;
    }
    
    int isPrime_2(int num) {
        double sqrtnum = sqrt(num*1.0);
        for (int i = 2; i <= sqrtnum; i++)
            if (num %i == 0)
                return 0;
        return 1;
    }
    
    int isPrime_3(int num) {
        //两个较小数另外处理
        if (num == 2 || num == 3)
            return 1;
        double sqrtnum = sqrt(num*1.0);
        for (int i = 5; i <= sqrtnum; i += 6)
            if (num %i == 0 || num % (i + 2) == 0)
                return 0;
        return 1;
    }
    
    int isPrime_4(int num) {
        //两个较小数另外处理
        if (num == 2 || num == 3)
            return 1;
        //不在6的倍数两侧的一定不是质数
        if (num % 6 != 1 && num % 6 != 5)
            return 0;
        double sqrtnum = sqrt(num*1.0);
        //在6的倍数两侧的也可能不是质数
        for (int i = 5; i <= sqrtnum; i += 6)
            if (num %i == 0 || num % (i + 2) == 0)
                return 0;
        //排除所有,剩余的是质数
        return 1;
    }

    判断1-30000之间素数的耗时:

    现在测试判断1-300000之间素数的耗时:
    方法二和方法三的效率之间相差其实不大,什么原因大家可以思考思考。
      本人又学到一种以时间换空间的素数判断方法,现在先将点预备知识,C++的 bitset 在 bitset 头文件中,位集bitset是一种关联容器,因为位集编程简单,效率也不错。bitset中只有0、1,且每个元素占一位。用法:
      构造函数
      bitset常用构造函数有四种,如下:
    bitset<4> bitset1;  //无参构造,长度为4,默认每一位为0
    
    bitset<8> bitset2(12);  //长度为8,二进制保存,前面用0补充
    
    string s = "100101";
    bitset<10> bitset3(s);  //长度为10,前面用0补充
        
    char s2[] = "10101";
    bitset<13> bitset4(s2);  //长度为13,前面用0补充
    
    cout << bitset1 << endl;  //0000
    cout << bitset2 << endl;  //00001100
    cout << bitset3 << endl;  //0000100101
    cout << bitset4 << endl;  //0000000010101

      可用函数

    bitset<8> foo ("10011011");
    
    cout << foo.count() << endl;  //5  (count函数用来求bitset中1的位数,foo中共有5个1
    cout << foo.size() << endl;   //8  (size函数用来求bitset的大小,一共有8位
    cout << foo.test(0) << endl;  //true  (test函数用来查下标处的元素是0还是1,并返回false或true,此处foo[0]为1,返回true
    cout << foo.test(2) << endl;  //false  (同理,foo[2]为0,返回false
    
    cout << foo.any() << endl;  //true  (any函数检查bitset中是否有1
    cout << foo.none() << endl;  //false  (none函数检查bitset中是否没有1
    cout << foo.all() << endl;  //false  (all函数检查bitset中是全部为1

      现在言归正传来讲如何判断素数,加入要我们判断2到1亿之间有多少素数,首先我们可以调用上面的方法1亿次,到当你这样干的时候,估计你电脑要运行几十分钟才能有结果。现在我们就采用空间换时间的方法。设置一个空间为1亿的bitset来标记哪些是素数,因为我们知道如果一个数不是素数,那么它的倍数也肯定不是素数。借助这个思想,我们有如下程序:

    //=====================================
    //利用bitset判断2到1亿之间的素数个数
    //=====================================
    #include<iostream>
    #include<bitset>
    using namespace std;
    
    int main() {
        bitset<100000000> *p=new bitset<100000000>;
        p->set();    //每个元素置1
        for (int i = 2; i <= 10000; ++i)
            if (p->test(i))    //第i位为0返回false,为1返回true;
                for (int j = i*i; j < p->size(); j += i)
                    p->reset(j);    //每个元素置0
        int num = 0;
        for (int i = 2; i < 100000000; ++i)
            if (p->test(i))
                num++;
        cout << num << endl;
        delete[] p;
        return 0;
    }

     

    转载于:https://www.cnblogs.com/SupremeBoy/p/10241294.html

    展开全文
  • 实例220 在程序中改变当前路径 307 6.5 复制文件 307 实例221 使用FileStream复制大文件 308 实例222 复制文件时显示复制进度 310 实例223 批量复制文件 312 6.6 指定类型的文件操作 313 实例224 文本...
  • 说明:本题重在考查如何一个整数取出每一个数字。 (6)教材第5章编程题第5题:编写程序计算用户输入所得额的税金。 说明:本题考查简单的选择结构。 (7)教材第5章编程题第11题:编写程序实现将用户输入的...
  • 系统如何判断一个量的“真”和“假”? 10 5.3写出下面各逻辑表达式的值。设a=3,b=4,c=5。 10 5.4有3个整数a,b,c,由键盘输入,输出其中最大的。 10 5.5有一函数: 11 5.6给出一百分制成绩,要求输出成绩等级’...
  • 1. 编写一个函数,判断一个数是不是素数。主函数输入一个整数,输出是否是素数的信息。 实验步骤与要求: (1) 编写一个函数prime(n),返回给定整数n是否为素数。 (2) 编写一个主函数,输入一个整数,调用(1)的...
  • 程序开发范例宝典>>

    2012-10-24 10:41:28
    实例220 在程序中改变当前路径 307 6.5 复制文件 307 实例221 使用FileStream复制大文件 308 实例222 复制文件时显示复制进度 310 实例223 批量复制文件 312 6.6 指定类型的文件操作 313 实例224...
  • Java范例开发大全 (源程序

    热门讨论 2011-04-27 07:47:22
     实例129 统计指定文件的字符个数 183  实例130 对象的序列化与反序列化 185  实例131 同时显示多个文件 187  实例132 生成zip压缩文件 189  实例133 解压缩zip文件 192  实例134 生成Excel文件 194 ...
  • C#程序开发范例宝典(第2版).part02

    热门讨论 2012-11-12 07:55:11
    实例228 在程序中调用.HLP文件 317 实例229 C#中实现文件拖放 317 实例230 文件比较 318 实例231 获取文件夹中的图标资源 319 实例232 获取文件夹下的所有文件夹及文件的名称 321 第7章 操作系统与Windows...
  • C#程序开发范例宝典(第2版).part13

    热门讨论 2012-11-12 20:17:14
    实例228 在程序中调用.HLP文件 317 实例229 C#中实现文件拖放 317 实例230 文件比较 318 实例231 获取文件夹中的图标资源 319 实例232 获取文件夹下的所有文件夹及文件的名称 321 第7章 操作系统与Windows...
  • 实例228 在程序中调用.HLP文件 317 实例229 C#中实现文件拖放 317 实例230 文件比较 318 实例231 获取文件夹中的图标资源 319 实例232 获取文件夹下的所有文件夹及文件的名称 321 第7章 操作系统与Windows...
  • 实例228 在程序中调用.HLP文件 317 实例229 C#中实现文件拖放 317 实例230 文件比较 318 实例231 获取文件夹中的图标资源 319 实例232 获取文件夹下的所有文件夹及文件的名称 321 第7章 操作系统与Windows...
  • 实例228 在程序中调用.HLP文件 317 实例229 C#中实现文件拖放 317 实例230 文件比较 318 实例231 获取文件夹中的图标资源 319 实例232 获取文件夹下的所有文件夹及文件的名称 321 第7章 操作系统与Windows...
  • 实例228 在程序中调用.HLP文件 317 实例229 C#中实现文件拖放 317 实例230 文件比较 318 实例231 获取文件夹中的图标资源 319 实例232 获取文件夹下的所有文件夹及文件的名称 321 第7章 操作系统与Windows...
  • 实例228 在程序中调用.HLP文件 317 实例229 C#中实现文件拖放 317 实例230 文件比较 318 实例231 获取文件夹中的图标资源 319 实例232 获取文件夹下的所有文件夹及文件的名称 321 第7章 操作系统与Windows...
  • 实例228 在程序中调用.HLP文件 317 实例229 C#中实现文件拖放 317 实例230 文件比较 318 实例231 获取文件夹中的图标资源 319 实例232 获取文件夹下的所有文件夹及文件的名称 321 第7章 操作系统与Windows...
  • 实例228 在程序中调用.HLP文件 317 实例229 C#中实现文件拖放 317 实例230 文件比较 318 实例231 获取文件夹中的图标资源 319 实例232 获取文件夹下的所有文件夹及文件的名称 321 第7章 操作系统与Windows...
  • 实例228 在程序中调用.HLP文件 317 实例229 C#中实现文件拖放 317 实例230 文件比较 318 实例231 获取文件夹中的图标资源 319 实例232 获取文件夹下的所有文件夹及文件的名称 321 第7章 操作系统与Windows...
  • 实例228 在程序中调用.HLP文件 317 实例229 C#中实现文件拖放 317 实例230 文件比较 318 实例231 获取文件夹中的图标资源 319 实例232 获取文件夹下的所有文件夹及文件的名称 321 第7章 操作系统与Windows...
  • Java范例开发大全(全书源程序

    热门讨论 2013-04-05 11:50:26
    实例129 统计指定文件的字符个数 183 实例130 对象的序列化与反序列化 185 实例131 同时显示多个文件 187 实例132 生成zip压缩文件 189 实例133 解压缩zip文件 192 实例134 生成Excel文件 194 实例135 读取...
  • 实例228 在程序中调用.HLP文件 317 实例229 C#中实现文件拖放 317 实例230 文件比较 318 实例231 获取文件夹中的图标资源 319 实例232 获取文件夹下的所有文件夹及文件的名称 321 第7章 操作系统与Windows相关...
  • 实例228 在程序中调用.HLP文件 317 实例229 C#中实现文件拖放 317 实例230 文件比较 318 实例231 获取文件夹中的图标资源 319 实例232 获取文件夹下的所有文件夹及文件的名称 321 第7章 操作系统与Windows...
  • 3.1.2 假定一个解并判断是否可行 3.1.3 最大化最小值 3.1.4 最大化平均值 3.2 常用技巧精选(一) 3.2.1 尺取法 3.2.2 反转(开关问题) 3.2.3 弹性碰撞 3.2.4 折半枚举(双向搜索) 3.2.5 坐标离散化 3.3 活用各种...
  • 实例220 在程序中改变当前路径 307 6.5 复制文件 307 实例221 使用FileStream复制大文件 308 实例222 复制文件时显示复制进度 310 实例223 批量复制文件 312 6.6 指定类型的文件操作 313 实例224 文本...
  • 实例220 在程序中改变当前路径 307 6.5 复制文件 307 实例221 使用FileStream复制大文件 308 实例222 复制文件时显示复制进度 310 实例223 批量复制文件 312 6.6 指定类型的文件操作 313 实例224 文本...
  •  实例185 在程序中改变当前路径 267  6.5 复制文件 268  实例186 移动正在使用的文件 268  实例187 批量复制文件 269  6.6 指定类型的文件操作 270  实例188 文本文件的操作 270  实例189 简单...

空空如也

空空如也

1 2 3 4
收藏数 70
精华内容 28
关键字:

在程序中如何判断一个数是否为素数