100programe.txt

100个经典C语言程序

                                       /*判断i是否为阿姆斯特朗数*/
            printf("%5d",i);            /*若满足条件，则输出*/
        
    }
    printf("\\n");
}
*运行结果
    There are following Armstrong number smaller than 1000:
      153        370        371        407
24.完全数
    如果一个数恰好等于它的因子之和，则称该数为“完全数”。
*题目分析与算法设计
    根据完全数的定义，先计算所选取的整数a(a的取值1~1000)的因子，将各因子累加于m，若m等于a，则可确认a为完全数。
*程序说明与注释
#include<stdio.h>
void main()
{
    int a,i,m;
    printf("There are following perfect numbers smaller than 1000:\\n");
    for(a=1;a<1000;a++)      /*循环控制选取1~1000中的各数进行判断*/
    {
        for(m=0,i=1;i<=a/2;i++)   /*计算a的因子，并将各因子之和m=a，则a是完全数输出*/
            if(!(a%i))m+=i;
        if(m==a)
            printf("%4d    ",a);
    }
    printf("\\n");
}
*运行结果
    TThere are following perfect numbers smaller than 1000:
    6        28        496
26.亲密数
    如果整数A的全部因子(包括1，不包括A本身)之和等于B；且整数B的全部因子(包括1，不包括B本身)之和等于A，则将整数A和B称为亲密数。求3000以内的全部亲密数。
*题目分析与算法设计
    按照亲密数定义，要判断数a是否有亲密数，只要计算出a的全部因子的累加和为b，再计算b的全部因子的累加和为n，若n等于a则可判定a和b是亲密数。计算数a的各因子的算法：
    用a依次对i(i=1~a/2)进行模运算，若模运算结果等于0，则i为a的一个因子；否则i就不是a的因子。
*程序说明与注释
#include<stdio.h>
void main()
{
    int a,i,b,n;
    printf("There are following friendly--numbers pair smaller than 3000:\\n");
    for(a=1;a<3000;a++)        /*穷举1000以内的全部整数*/
    {       
        for(b=0,i=1;i<=a/2;i++)    /*计算数a的各因子，各因子之和存放于b*/
            if(!(a%i))b+=i;        /*计算b的各因子，各因子之和存于n*/
        for(n=0,i=1;i<=b/2;i++)
            if(!(b%i))n+=i;
        if(n==a&&a<b)
            printf("%4d..%4d    ",a,b);     /*若n=a，则a和b是一对亲密数，输出*/
    }
}
*运行结果
    There are following friendly--numbers pair smaller than 3000:
        220..  284        1184.. 1210        2620.. 2924
27.自守数
    自守数是指一个数的平方的尾数等于该数自身的自然数。例如：
            252=625      762=5776       93762=87909376
    请求出200000以内的自守数
*题目分析与算法设计
    若采用“求出一个数的平方后再截取最后相应位数”的方法显然是不可取的，因为计算机无法表示过大的整数。
    分析手工方式下整数平方(乘法)的计算过程，以376为例：
        376                  被乘数
     X  376                    乘数
   ----------
       2256              第一个部分积=被乘数*乘数的倒数第一位
      2632               第二个部分积=被乘数*乘数的倒数第二位
     1128                第三个部分积=被乘数*乘数的倒数第三位
   ----------
     141376              积
    本问题所关心的是积的最后三位。分析产生积的后三位的过程，可以看出，在每一次的部分积中，并不是它的每一位都会对积的后三位产生影响。总结规律可以得到：在三位数乘法中，对积的后三位产生影响的部分积分别为：
        第一个部分积中：被乘数最后三位*乘数的倒数第一位
        第二个部分积中：被乘数最后二位*乘数的倒数第二位
        第三个部分积中：被乘数最后一位*乘数的倒数第三位
    将以上的部分积的后三位求和后截取后三位就是三位数乘积的后三位。这样的规律可以推广到同样问题的不同位数乘积。
    按照手工计算的过程可以设计算法编写程序。
*程序说明与注释
#include<stdio.h>
void main()
{
    long mul,number,k,ll,kk;
    printf("It exists following automorphic nmbers small than 200000:\\n");
    for(number=0;number<200000;number++)
    {
        for(mul=number,k=1;(mul/=10)>0;k*=10);
                   /*由number的位数确定截取数字进行乘法时的系数k*/
        kk=k*10;      /*kk为截取部分积时的系数*/
        mul=0;        /*积的最后n位*/
        ll=10;        /*ll为截取乘数相应位时的系数*/
        while(k>0)
        {
            mul=(mul+(number%(k*10))*(number%ll-number%(ll/10)))%kk;
                 /*(部分积+截取被乘数的后N位*截取乘数的第M位)，%kk再截取部分积*/
            k/=10;               /*k为截取被乘数时的系数*/
            ll*=10;
        }
        if(number==mul)         /*判断若为自守数则输出*/
            printf("%ld   ",number);
    }
}
*运行结果
    It exsts following automorphic numbners smaller than 200000:
     0    1    5    6    25    76    376    625    9376    90625    109376
28.回文数
    打印所有不超过n(取n<256) 的其平方具有对称性质的数(也称回文数)。
*题目分析与算法设计
    对于要判断的数n，计算出其平方后(存于a)，将a的每一位进行分解，再按a的从低到高的顺序将其恢复成一个数k(如n=13，则a=169且k=961)，若a等于k则可判定n为回亠数。
*程序说明与注释
#include<stdio.h>
void main()
{
    int m[16],n,i,t,count=0;
    long unsigned a,k;
    printf("No.    number     it\'s square(palindrome)\\n");
    for(n=1;n<256;n++)            /*穷举n的取值范围*/
    {
        k=0;t=1;a=n*n;            /*计算n的平方*/
        for(i=1;a!=0;i++)     /*从低到高分解数a的每一位存于数组m[1]~m[16]*/
        {
            m=a%10;
            a/=10;
        }
    
    for(;i>1;i--)
    {
        k+=m[i-1]*t;
        t*=10;
    }
    if(k==n*n)
        printf("%2d%10d%10d\\n",++count,n,n*n);
   } 
}
*运行结果
        No.            number            it\'s square(palindrome)
        1                1                    1
        2                2                    4
        3                3                    9
        4                11                   121
        5                22                   484
        6                26                   676
        7                101                  10201
        8                111                  12321
        9                121                  14641
 
29.求具有abcd=(ab+cd)2性质的四位数
    3025这个数具有一种独特的性质：将它平分为二段，即30和25，使之相加后求平方，即(30+25)2，恰好等于3025本身。请求出具有这样性质的全部四位数。
*题目分析与算法设计
    具有这种性质的四位数没有分布规律，可以采用穷举法，对所有四位数进行判断，从而筛选出符合这种性质的四位数。具体算法实现，可任取一个四位数，将其截为两部分，前两位为a，后两位为b，然后套用公式计算并判断。
*程序说明与注释
#include<stdio.h>
void main()
{
    int n,a,b;
    printf("There are following number with 4 digits satisfied condition\\n");
    for(n=1000;n<10000;n++)             /*四位数N的取值范围1000~9999*/
    {
        a=n/100;                        /*截取N的前两位数存于a*/
        b=n%100;                        /*截取N的后两位存于b*/
        if((a+b)*(a+b)==n)      /*判断N是否为符合题目所规定的性质的四位数*/
            printf("%d  ",n);
    }
}
*运行结果
    There are following numbers with 4 digits satisfied condition:
        2025        3025        9801
30.求素数
    求素数表中1~1000之间的所有素数
*问题分析与算法设计
    素数就是仅能衩1和它自身整除的整数。判定一个整数n是否为素数就是要判定整数n能否被除1和它自身之外的任意整数整除，若都不能整除，则n为素数。
    程序设计时i可以从2开始，到该整数n的1/2为止，用i依次去除需要判定的整数，只要存在可以整除该数的情况，即可确定要判断的整数不是素数，否则是素数。
*程序与程序注释
#include<stdio.h>
void main()
{
    int n1,nm,i,j,flag,count=0;
    do{
        printf("Input START and END=?");
        scanf("%d%d",&n1,&nm);           /*输入求素数的范围*/
    }while(!(n1>0&&n1<nm));               /*输入正确的范围*/
    printf("...........PRIME TABLE(%d--%d)............\\n",n1,nm);
    if(n1==1||n1==2)                  /*处理素数2*/
    {
        printf("%4d",2);
        n1=3;count++;
    }
    for(i=n1;i<=nm;i++)              /*判定指定范围内的整数是否为素数*/
    {
        if(!(i%2))continue;
        for(flag=1,j=3;flag&&j<i/2;j+=2)
                                    /*判定能否被从3到整数的一半中的某一数所整除*/
            if(!(i%j))flag=0;       /*若能整除则不是素数*/
        if(flag) printf(++count%15?"%4d":"%4d\\n",i);
    }
}
31.歌德巴赫猜想
    验证：2000以内的正偶数都能够分解为两个素数之和(即验证歌德巴赫猜想对2000以内的正偶数成立)。
*问题分析与算法设计
    为了验证歌德巴赫猜想对2000以内的正偶数都是成立的，要将整数分解为两部分，然后判断出分解出的两个整数是否均为素数。若是，则满足题意；否则重新进行分解和判断。
    程序中对判断是否为素数的算法进行了改进，对整数判断“用从2开始到该整数的一半”改为“2开始到该整数的平方根”。原因何在请自行分析。
*程序与程序注释
#include<stdio.h>
#include<math.h>
int fflag(int n);
void main()
{
    int i,n;
    for(i=4;i<=2000;i+=2)
    {
        for(n=2;n<i;n++)         /*将偶数i分解为两个整数*/
            if(fflag(n))         /*分别判断两个整数是否均为素数*/
                if(fflag(i-n))
                {
                    printf("%14d=%d+%d\\n",i,n,i-n);        /*若均是素数则输出*/
                    break;
                }
            if(n==i)  printf("error %d\\n",i);
    }
}  

int fflag(int i)           /*判断是否为素数*/
{
    int j;
    if(i<=1)return 0;
    if(i==2)return 1;
    if(!(i%2))return 0;     /*if no,return 0*/
    for(j=3;j<=(int)(sqrt((double)i)+1);j+=2)
        if(!(i%j))return 0;
    return 1;              /*if yes,return 1*/
}
32.要发就发
    “1898--要发就发”。请将不超过1993的所有素数从小到大排成第一行，第二行上的每个素数都等于它右肩上的素数之差。编程求出：第二行数中是否存在这样的若干个连续的整数，它们的和恰好是1898？假好存在的话，又有几种这样的情况？
    第一行：2  3  5  7  11  13  17......1979  1987  1993
    第二行：1  2  2  4  2  4......         8     6
*问题分析与算法设计：
    首先从数学上分析该问题：
    假设第一行中的素数为n[1]、n[2]、n[3]....n、...第二行中的差值为m[1]、m[2]、m[3]...m[j]...。其中m[j]为：
    m[j]=n[j+1]-n[j]。
则第二行连续N个数的和为：
    SUM=m[1]+m[2]+m[3]+...+m[j]
       =(n[2]-n[1])+(n[3]-n[2])+(n[4]-n[3])+...+(n[j+1]-n[j])
       =n[j+1]-n[1]
由此题目就变成了：在不超过1993的所有素数中是否存在这样两个素数，它们的差恰好是1898。若存在，则第二行中必有所需整数序列，其和恰为1898，。
    对等价问题的求解是比较简单的。
    由分析可知，在素数序列中不必包含2，因为任意素数与2的差一定为奇数，所以不必考虑。
*程序与程序注释：
#include<stdio.h>
#include<math.h>
#define NUM 320
int number[NUM];      /*存放不超过1993的全部奇数*/
int fflag(int i);
void main()
{
    int i,j,count=0;
    printf("there are follwing primes sequences in first row:\\n");