C语言的一小步—————— 一些小项目及解析

——--------

　　仅以此献给东半球第二优秀的C语言老师，黑锤李某鸽,希望总有那么一天我们的知识可以像他的丰臀一样渊博！

bug跟蚊子的相似之处：

1、不知道藏在哪里。

2、不知道有多少。

3、总是在你即将睡觉休息的时候出现。

基础练习  基础练习  基础练习  基础练习  基础练习  基础练习

 //1、（课堂）编写程序，输出“XXX欢迎来到动物园！”（XXX是自己的名字）。

 #include<stdio.h>
 #define N 20
 int main(){
     char ch[N]={};
     scanf("%s",ch);
     printf("%s欢迎来到动物园",ch);

     //}

     return ;
 }

 //2、（课堂）打印用*组成的字母C
 #include<stdio.h>

 int main(){

     printf("  ***\n");
     printf(" *   *\n");
     printf("*\n");
     //printf("*\n");
     printf("*\n");
     printf(" *   *\n");
     printf("  ***\n");
     return ;
 }

 #if 0
 交换杯子里的液体。使用不同的整数代表液体，变量代表杯子。
 （课堂）方法1：中间变量法
 （课堂）方法2：三步异或法
 #endif

 #include<stdio.h>

 void fun1(int *i,int *j){
     int temp;
     temp=*i;
     *i=*j;
     *j=temp;

 }
 void fun2(int *i,int *j){
     *i^=*j;
     *j^=*i;
     *i^=*j;
 }
 int main(){

     int i=,j=;
     printf("i=%d,j=%d\n",i,j);
     fun1(&i,&j);
     printf("i=%d,j=%d\n",i,j);
     fun2(&i,&j);
     printf("i=%d,j=%d\n",i,j);

     return ;
 }

 //4、（课堂）使用宏定义PI来定义3.1415926，计算圆的面积。
 #include<stdio.h>
 #define PI 3.1415926
 int main(){
     int length,perimiter;
     printf("输入半径：");
     scanf("%d",&length);
     perimiter=length**PI;
     printf("周长：%d",perimiter);
 }

 #if 0
 、（课堂）租船问题。
 写程序计算游客需要付的租船的费用。租船每小时30元。游客输入租船时间，计算出租船费用。租船费用=时间*每小时钱数+押金。
 要求押金与每小时钱数使用宏定义。
 #endif
 #include<stdio.h>
 #define unit 30
 #define deposite 100

 int main(){
     int time,total;
     printf("请输入时间");
     scanf("%d",&time);
     total=time*unit+deposite;
     printf("总价：%d",total);
     return ;
 }

 #if 0
 7_1、输入整数代表的ASCII码字符，输出这个一个整数（~）。
 解题思路：
 以%c形式输入以%d形式输出
 以%d形式输入以%c形式输出

 错误分析：
 如果scanf()和printf()交替出现
 则第二次scanf()时会首先输出前一次最后的回车。

 getchar()的用处去除回车，

 #endif
 #include<stdio.h>

 int main(){
     char ch;
     int a;
     while(){
         printf("输入一个字符\n");
         scanf("%c",&ch);
         getchar();

         printf("输入一个数字\n");
         scanf("%d",&a);
         getchar();
         printf("ASKII=%d\n",ch);

         printf("字符=%c\n",a);
     }

     return ;
 }

 #if 0
 、输入一个字符，判断这个字符是0~9之间的数字，还是大写字母，还是小写字母。若都不是输出错误信息。
 解题思路：
 多分支条件判断：
 #endif

 #include<stdio.h>

 int main(){
     char ch;
     while(){
     printf("输入要判定的字符：\n");
     scanf("%c",&ch);
     getchar();
     if(ch>='a'&&ch<='z'){
         printf("%c是小写字母\n",ch);
     }else if(ch>='A'&&ch<='Z'){
         printf("%c是大写字母\n",ch);
     }else if(ch>=''&&ch<=''){
         printf("%c是数字\n",ch);
     }else{
         printf("%c是特殊字符\n",ch);
     }
     }
     return ;
 }

 #if 0
 、计算输入时间的下一秒。例如输入12  ，输出12::；输入21  ，输出22::。
 若输入非法时间（如输入小时是25、输入分钟/秒是61等情况）则报错。

 解题思路：
 一。多分支判断输入数据是否合法：
 二。数据转换规则：
     秒加一
     如果秒加一大于59
     则秒归零，分加一，此时如果分大于59
     则分归零，时加一，此时如果时大于23
     则时归零

 错误分析：
 一。数据转换不是多分支判断；
 #endif

 #include<stdio.h>
 void print(int time){
     printf("%d:错误数值",time);
 }

 int main(){
     int hour,minute,second;
     printf("输入时分秒 \n格式：xx xx xx\n");
     scanf("%d %d %d",&hour,&minute,&second);

     //判断数据是否合法
     if(>hour||hour>){
         print(hour);
         return ;
     }else if(>minute||minute>){
         print(minute);
         return ;
     }else if(>second||second>){
         print(second);
         return ;
     }

     if((++second)>){
         second=;
         if((++minute)>){
             minute=;
             if((++hour)>){
                 hour=;
             }
         }
     }
     printf("\n当前时间：%d：%d：%d",hour,minute,second);
     return ;
 }

 //10、（课堂）练习：从键盘输入5个学生的成绩（整数），要求输出总成绩（整数）和平均成绩（小数）
 #include<stdio.h>

 int main(){

     int stu1,stu2,stu3,stu4,stu5;
     int sum;
     float ave;
     printf("输入5个学生的成绩（整数）:\n格式： xx xx xx xx xx\n");
     scanf("%d %d %d %d %d",&stu1,&stu2,&stu3,&stu4,&stu5);
     sum=stu1+stu2+stu3+stu4+stu5;
     ave=(float)sum/;
     printf("sum=%d,ave=%f",sum,ave);
     return ;
 }

 //11、（课堂）读以下程序，猜想输出的结果，再执行程序检验自己的猜想
 #include <stdio.h>
 int main(void)
 {
 double y;
 float a = 2.0;
 int b =,c=;
 y = a*b/c-1.5+'A';
 printf("%f\n",y);
 return ;
 }

 //12、（课堂）读以下程序，猜想输出的结果，再执行程序检验自己的猜想
 #include <stdio.h>
 int main()
 {
 int i = ,j = ,k = ;
 int m,n,p;

 m = ++i;
 n = j--;
 p = (++m)*(n++)+(--k);
 printf("i=%d,j=%d,k=%d\n",i,j,k);
 printf("m=%d,n=%d,p=%d\n",m,n,p);
 return ;
 }

#if 0
、（课堂）设
int a=,b=,c=,d;
分别求出下列表达式的d的值（即判断此表达式真假）
）d = a+b>c && b==c
）d = a || b+c && b-c
）d = !(a>b) && !c ||
）d = !(x=a)&&(y=b)&&（x和y均为int型，求出x和y的值）
）d = !(a+b)+c- && b+c/
#endif

 #if 0
 、（课堂）输入3个整数，从小到大输出

 解题思路：
 将所有的项遍历，两两对比所有项。
 #endif
 #include<stdio.h>
 void jiao(int *a,int *b){
     (*a)^=(*b);
     (*b)^=(*a);
     (*a)^=(*b);
 }

 int main(){
     int a,b,c;
     printf("输入3个整数：\n");
     scanf("%d %d %d",&a,&b,&c);
     if(a>b){
         jiao(&a,&b);
     }
     if(a>c){
         jiao(&a,&c);
     }
     if(b>c){
         jiao(&b,&c);
     }
     printf("从小到大排序：%d %d %d",a,b,c);
     return ;
 }

 #if 0
 、（课堂）输入3个正整数作为3条线段的长度，判断这3条线段能否构成三角形。
 构成三角形的条件是：任意两边之和大于第三边

 解题思路：
 对三边长度进行排序
 找到三边中较短的两边，此两边之和大于第三边则可构成第三遍
 #endif
 #include<stdio.h>
 void jiao(int *a,int *b){
     (*a)^=(*b);
     (*b)^=(*a);
     (*a)^=(*b);
 }

 int main(){
     int a,b,c;
     printf("请输入三角形三边长度;\n");
     scanf("%d %d %d",&a,&b,&c);
     if(a>b){
         jiao(&a,&b);
     }
     if(a>c){
         jiao(&a,&c);
     }
     if(b>c){
         jiao(&b,&c);
     }
     //printf("%d %d %d",a,b,c);
     if((a+b)>c){
         printf("%d %d %d 可以构成三角形",a,b,c);
     }else{
         printf("%d %d %d 不可以构成三角形",a,b,c);
     }
     return ;
 }

 #if 0
 、（课堂）输入一个年份（正整数），判断这年是否是闰年。闰年判断标准：年份能被4整除；如若遇到100的倍数，
 则需判断年份能否被400整除。（逢4一闰，逢百不闰，逢400又闰）

 解题思路：
 一。各个数据的包含关系：
 能被4整除 包含 能被100整除 包含 能被400整除
 二。多分支判断，从最小集合开始判断则判断条件最为简单；

 #endif
 #include<stdio.h>

 int main(){
     int year;
     printf("输入一个年份（正整数）:\n");
     scanf("%d",&year);

     if((year%)==){
         printf("%d是闰年",year);
     }else if((year%)==){
         printf("%d不是闰年",year);
     }else if((year%)==){
         printf("%d是闰年",year);
     }else{
         printf("%d不是闰年",year);
     }
     return ;
 }

 #if 0
 、（课堂）输入一个学生的成绩，输出该成绩对应的分数段。~100为优，~89为良，~79为中，~69为及格，
 ~59为不及格，其他则输出错误信息。要求使用switch实现。

 解题思路：
 一。判断数据是否合法；
 二。提取分数的十位进行switch判断。

 #endif
 #include<stdio.h>
 int main(){
     int grade;
     printf("输入一个学生的成绩;\n");
     scanf("%d",&grade);
     if((grade>)||(grade<)){
         printf("%d数据不合法",grade);
         return ;
     }
     int aa=grade/;
     switch(aa){
         case :
         case :
             printf("%d等级为：优",grade);
         break;
         case :
             printf("%d等级为：良",grade);
         break;
         case :
             printf("%d等级为：中",grade);
         break;
         case :
             printf("%d等级为：及格",grade);
         break;
         default:
             printf("%d等级为：不及格",grade);

     }
     //printf("%lf",(grade*0.4));

     return ;
 }

 #if 0
 、（课堂）运输公司对用户按路程计算费用。路程越远，每吨*千米运费折扣越高。计算运费公式如下：
 freight = distance * distance * price * (-discount);
 路程与折扣的关系如下：
 s<：无折扣
 <=s<:%折扣
 <=s<:%折扣
 <=s<：%折扣
 <=s<：%折扣
 <=s：%折扣
 要求从键盘输入货运总重（单位吨）、货运路程（单位千米）、每吨*千米货运单价（单位元），输出总花费。

 解题思路：
 一。将重量进行分段，对每段重量的费用进行计算。
 二。从大重量向小重量遍历计算比小重量向大重量计算各直观
     例如
     大到小：向算先算一千到一百，自减九百，再算一百到零，
     小到大：先算零到一百，自减一百，再算零至900；
 三。依次从大到小判断重量的大小，计算对应重量的费用，然后重量相应自减已计算重量。

 #endif

 #include<stdio.h>
 int fun(int distance,int price,int weight){
     int freight=;
     if(distance>=){
         freight+=(distance-)*price*8.5*weight;
         printf("\n%d=(%d-3000)*%d*0.9*%d\n",freight,distance,price,weight);
         distance=;

     }
     if(distance>=){
         freight+=(distance-)*price*0.90*weight;
         printf("\n%d=(%d-2000)*%d*0.9*%d\n",freight,distance,price,weight);
         distance=;

     }
     if(distance>=){
         freight+=(distance-)*price*0.92*weight;
         printf("\n%d=(%d-3000)*%d*0.9*%d\n",freight,distance,price,weight);
         distance=;

     }
     if(distance>=){
         freight+=(distance-)*price*0.95*weight;
         printf("\n%d=(%d-3000)*%d*0.9*%d\n",freight,distance,price,weight);
         distance=;
     }
     if(distance>=){
         freight+=(distance-)*price*0.95*weight;
         printf("\n%d=(%d-250)*%d*0.9*%d\n",freight,distance,price,weight);
         distance=;

     }
     if(distance>=){
         freight+=(distance)*price*weight;
         printf("\n%d=(%d-3000)*%d*%d\n",freight,distance,price,weight);
     }
     if(distance<){
         printf("\n%d路程不能为负",distance);
     }

     return freight;
 }

 int main(){
     int distance,price, weight;
     int freight;
     printf("输入 ；重量  单价  路程: ");
     scanf("%d %d %d",&weight,&price,&distance);
     //printf("%d %d %d",distance,unit,distance);
     freight=fun(distance,price,weight);
     printf("\n总价为：%d\n",freight);

     return ;
 }

//19、（课堂）求1+2+3+……+99+100=?。使用while()、do-while()和for()三种循环分别实现。
//解题思路：for()和while互为语法糖，当循环超过一次是while()、do-while()等价；
#include<stdio.h>

int fun_while(int num){
    int sum=;
    int i=;
    while(i<=num){
        sum+=i;
        i++;
    }

    return sum;
}
int fun_dowhile(int num){
    int sum=;
    int i=;
    do{
        sum+=i;
        i++;
    }while(i<=num);
    return sum;
}

int fun_for(int num){
    int sum=;
    int i=;
    for(i=;i<=num;i++){
        sum+=i;

    }
    return sum;
}

int main(){
    int sum1,sum2,sum3;
    sum1=fun_while();
    sum2=fun_dowhile();
    sum3=fun_for();
    printf("while=%d ,dowhile=%d ,for=%d",sum1,sum2,sum3);
    return ;
}

 #if 0
 、打印所有水仙花数。水仙花数是这样的三位数：各位数字的立方和等于其本身。如153就是一个水仙花数。
 解题思路：
 一。遍历100至999；每次分别提取个十百位上的数；
 二。判断对每次提取的数进行立方和，对比和本身是否相等从而确定水仙花数。

 #endif

 #include<stdio.h>
 void shuixian(){
     int i=;
     while(i<=){

         int ge=i%;
         int bai=i/;
         int shi=(i/)%;
         //printf("%d  %d %d ",bai,shi,ge);
         int sum=(ge*ge*ge)+(shi*shi*shi)+(bai*bai*bai);
             //printf("\n水仙花数：%d\n",sum);
         if(sum==i){
             printf("\n%d\n",sum);
         }
         i++;
     }

 }

 int main(){
     shuixian();
     return ;
 }

 #if 0
 、（课堂）打印斐波那契数列的前n项，其中n由键盘输入。斐波那契数列的特点如下：
 F1=            (n=)
 F2=            (n=)
 Fn=Fn- + Fn-  (n>=)

 解题思路：
 一。应该建立一个数组来存储产生的斐波那契数列，但没有对数列的操作，所以不存储直接输出
 二。使用两个标志位存储n- 和n- 的值，由此产生n的值。
 #endif

 #include<stdio.h>

 void fei(int len){
     int one=;
     int two=;
     int i;
     printf("%d\n%d \n",one,two);
     for(i=;i<=len;i++){
         int temp=two;
         two+=one;
         one=temp;
         printf("%d\n",two);
     }
 }
 int main(){
     int n;
     printf("打印多少项");
     scanf("%d",&n);

     fei(n);

     return ;
 }

 #if 0
 、（课堂）输出如下图形：
      *
     ***
    *****
   *******
  *********
 ……
 其中需要输出几行由键盘输入。

 解题思路：
 一。确定输出多少行；
 二。第i行的空格数：总行数-i
     第i行的*数：i*-
 #endif
 #include<stdio.h>

 void sanjiao(int len){
     //第I次输出几个*   i*2-1
     //第i次空几个      i-1

     int kong,xiang,i;
     for(i=;i<=len;i++){
         //printf("%d",i);
         //printf("%d",i);

         for(kong=len-i;kong>=;kong--){
             printf(" ");
         }
         for(xiang=(i*-);xiang>=;xiang--){
             printf("*");

         }
         printf("\n");
     }

 }

 int main(){
     int hang;
     printf("输出几行三角");
     scanf("%d",&hang);
     sanjiao(hang);

     return ;
 }

 #if 0
 、（课堂）现有100元钱要买以下3种文具。其中一个笔记本20元，一套尺6元，一个笔4元，每样文具至少买1个。
 列举出所有的购买方案，以及列举出所有花光100元的购买方案

 解题思路：
 一。排除各买一件则剩余70元。
 二。建立一个三重循环，分别代表笔记本，尺子，笔。可以遍历所有情况。总价恰好为70则为结果。

 错误分析：
 大O算法为n^ ，算法效率太低。有待改进。
 #endif
 #include<stdio.h>

 void wenju(int money){
     money-=(++);//30 70
     int notebook,rule,pen;
     for(notebook=;notebook<=;notebook++){
         for(rule=;rule<=;rule++){
             for(pen=;pen<=;pen++){
                 if(notebook*+rule*+pen*==){
                     if(notebook!=){
                         printf(" notebook=%d*20",notebook);
                     }
                     if(rule!=){
                         printf(" rule=%d*6",rule);
                     }
                     if(pen!=){
                         printf(" pen=%d*6",pen);
                     }
                     printf(" sum=70\n");
                 }
             }
         }
     }
 }

 int main(){
     //组合正好一百元；
     wenju();
 }

 #if 0
 、（课堂）输出100~200间的所有素数
 解题思路：
 一。遍历100~，每个数取余 2至n/，判断如果所有余数都不为零则该数为素数。
 #endif
 #include<stdio.h>

 void su(int low,int high){
     int i;
     for(i=low;i<=high;i++){
         int j;
         int st=;
         for(j=;j<low;j++){
             if(i%j==){
                 st++;
             }

         }
         if(st==){
             printf("%d 是素数\n",i);
         }

     }

 }
 int main(){

     su(,);
     return ;
 }

 #if 0
 、计算1+++……++=?，在执行加法之前由用户输入3个数，这3个数不参与运算。例如输入3、57和89，则最终结果等于4901。

 解题思路：
 一。建立一个五个元素数组，中间三个用于用户输入，首尾元素分别为0 。
 二。依次遍历数组两两之间，元素值之间不包括本身进行累加，
 三。将最后累加值总和进行输出为结果。
 #endif

 #include<stdio.h>

 int Accumulate(int low,int high){
     int sum=;
     if((low+)>=(high)){
         return ;
     }
     for(++low;low<high;low++){
         sum+=low;
     }
     return sum;
 }

 int main(){
     int a[]={,,,,};
     int i;
     int sum=;
     printf("请输入三个数");
     scanf("%d %d %d",&a[],&a[],&a[]);
     for(i=;i<;i++){
         sum+=Accumulate(a[i-],a[i]);
         //sum+=Accumulate(0,101);
     }
     //sum=Accumulate(0,101);
     printf("\n结果是：%d\n",sum);

     return ;
 }

 #if 0
 、编写一个程序，由键盘输入若干正整数，输入0代表输入完成。计算输入的数中的奇数的个数、总和、平均值；
 计算输入的数中的偶数的个数、总和、平均值。

 解题思路：
 。通过命令行传参获取数据，但数据是字符串形式
 。将字符串形式数据转换为int形式数据，放在一个数组中，便于操作
 。按要求对数据进行操作

 #endif

 #include<stdio.h>
 #include<stdlib.h>

 int my_even(int num[],int len){
     int even=;
     int i=;
     for(i=;i<len;i++){
         if(num[i]%==){
             ++even;
         }

     }

     return even;
 }
 int my_sum(int num[],int len){
     int sum=;
     int i=;
     for(i=;i<len;i++){
         sum+=num[i];
     }
     return sum;
 }

 int my_ave(int num[],int len){
     int ave=my_sum(num,len);
     ave/=len;
     return ave;

 }

 int main(int argc,char *argv[]){
     int i=;
     for(i=;i<argc;i++){
         //printf("%s\n",argv[i]);
         if(*argv[i]==''){
             //i;
             break;
         }
     }
     //printf("%s",argv[i]);
     int *num;
     int len=i-;
     if(NULL==(num=(int *)malloc(sizeof(int)*len))){
         perror("cannot malloc");
         return ;
     }
     //num[0]=NULL;

     for(i=;i<len;i++){
         int sum=;
         char *s=argv[i+];
         while(*s !='\0'){
             sum=sum*+((*s++)-'');
             //printf("%c",*s);
             //++s;
         }
         num[i]=sum;
     }
     /*
     for(i=0;i<len;i++){
         printf("%d \n",num[i]);
     }
     */
     int even=my_even(num,len);
     int sum=my_sum(num,len);
     int ave=my_ave(num,len);
     printf("偶数个数：%d，总和：%d，平均值：%d。",even,sum,ave);

     return ;
 }

 #if 0
 、卡拉兹(Callatz)猜想：
 对任何一个自然数n，如果它是偶数，那么把它砍掉一半；如果它是奇数，那么把(3n+)砍掉一半。这样一直反复砍下去，
 最后一定在某一步得到n= 。卡拉兹在1950年的世界数学家大会上公布了这个猜想，传说当时耶鲁大学师生齐动员，
 拼命想证明这个貌似很傻很天真的命题，结果闹得学生们无心学业，一心只证(3n+)，以至于有人说这是一个阴谋，
 卡拉兹是在蓄意延缓美国数学界教学与科研的进展……
 我们今天的题目不是证明卡拉兹猜想，而是对给定的任一不超过1000的正整数n，简单地数一下，需要多少步才能得到n=？
 解题思路：
 .  获取一个数
 .  判断是偶数则除二，是奇数乘三加一
 。 循环判断直至得到1；

 #endif

 #include<stdio.h>

 int main(){
     int num=;
     printf("输入一个1000以内的自然数：");
     scanf("%d",&num);

     while(num!=){
         if(num%==){
             num/=;
         }else if(num%==){
             num=num*+;
         }
         printf("%d\t",num);
     }
     return ;
 }

 //28、读懂以下程序，分析程序逻辑，画出流程图，说明程序的功能
 #include<stdio.h>
 int main()
 {
     int x,y;
     printf("enter x:");
     scanf("%d",&x);
     y=;
     if(x!=)
     {
         if(x>)
         y=;
         else
         y=-;
     }
     printf("x=%d\ny=%d\n",x,y);
     return ;
 }

 #if 0
 、给定一个不多于5位的正整数，要求：
 ①求出它是几位数
 ②分别输出每一位数字（这里的位指十进制的位而非二进制的bit）
 ③将数字逆序。例如输入123，则输出321

 解题思路：
 一。对输入数值合法性进行判定
 二。判断数据的位数。
 三。提取按从高位到低位进行，但将提取的数据按从低位到高位累加可得置逆结果。

 错误分析：
 本例中应该用一个数组存储提取的每一位的值。
 #endif

 #include<stdio.h>
 #include<math.h>

 int main(){
     int num;
     int Q=;
     int wei=;
     int ni=;
     printf("输入不大于十万(100000)的数");
     scanf("%d",&num);
     if(num>){
         printf("数据过大");
         return ;
     }
     while(num/Q==){
         Q=Q/;

     }
     while(Q>){
         int a=num/Q;
         Q=Q/;
         a=a%;

         printf("第%d位是：%d\n",wei+,a);
         ni=ni+pow(,wei)*a;
         wei++;
     }
     printf("\n置逆%d\n",ni);

     return ;
 }

 #if 0
 、使用公式求π的近似值
 π/ =  - / + / - / + ……
 直到某一项的绝对值小于10^-6为止。
 （提示：判断该数字是否小于10^-，可以使用系统库函数fabs
 fabs(f)>=1e-//1e-6是10^-6的科学计数法表示方式
 若要使用fabs()函数，则应包含头文件math.h
 #include<math.h>
 而且要在编译时添加-lm，即手动添加数学库libm.o
 gcc qiupai.c -o qiupai -lm）

 解题思路：
 一。使用累加结束条件为某一项的绝对值小于10^-6为止。
 二。每一项中加减交替，分子为1，分母为奇数递增。
 三。累加结果乘四为π的值

 错误经历：
 将double型的数据以%d形式输出；

 #endif

 #include<stdio.h>
 #include<math.h>

 int main(){
     double PI;
     double sum=;
     double item=;
     int i=;
     double jue=;
     //int fp=1;
     while(fabs(jue)>=1e-){
         if(i>){
             i+=;
         }else{
             i-=;
         }
         i=-i;
         item=(double)/i;

         sum+=item;
         //printf("item=%lf\n",sum);

         jue=item;
         if(jue<){
             jue=-jue;
         }

         //fp++;
         /*
         if(fp>1000){
             break;
         }
         */

     }
     PI=sum*;
     printf("π=%lf ",PI);

     return ;
 }

 //31、读懂以下程序，说明程序的功能
 #include<stdio.h>
 int main()
 {
     int m,n,r,m1,m2;
     printf("请输入2个正整数：");
     scanf("%d%d",&m1,&m2);
     m=m1;
     n=m2;
     do{
         r=m%n;
         m=n;
         n=r;
     }while(r!=);
     printf("%d\n",m);
     return ;
 }

 #if 0
 、一个数如果恰好等于它的所有的因子之和，则这个数就称为“完数”。例如6的因子有1、、，而1++=，因此6是一个完数。
 编程找出1000内所有的完数。

 思路分级：
 一。遍历2-1000内的所有数。
 二。寻找每个数所有的公约数累加等于本身则为完数。
 #endif

 #include<stdio.h>
 int main(){

     int num=;
     for(num=;num<;num++){
         int sum=;
         int i=;
         for(i=;i<=num/;i++){
             if(num%i==){

                 sum+=i;
             }
         }
         if(num==sum){
             printf("%d:是一个完数\n",sum);
         }
     }

     return ;
 }

 、（课堂）思考这个宏定义错在哪里
 #define S (r) PI*r*r//注意S与(r)之间有空格

 、我们在头文件（.h文件）中，经常看到这样的内容
 #ifndef __H_INCLUDE__
 #define __H_INCLUDE__
 //头文件的实际内容
 #endif
 思考头文件的开头和结尾需要这样书写的原因。

 、（课堂）运行以下程序
 int main()
 {
     char a,b;
     a = getchar();
     b = getchar();
     putchar(a);
     putchar(b);
     return ;
 }
 运行程序，输入x回车y回车，会发现输出的并不是xy，而是
 x

 #if 0
 、（课堂）使用数组存储斐波那契数列前40项，并输出

 解题思路：
 一。创建一个长度为40的数组。
 二。将第一第二个元素置为1；
 三。遍历数组 第N个元素的值为 元素（N-）+元素（N-）；
 #endif

 #include<stdio.h>
 #include<stdlib.h>
 int *fibonacci(int len){
     int *p;
     int i;

     if(NULL==(p=(int *)malloc(sizeof(int)*len))){
         perror("cannot malloc");
         return NULL;
     }
     p[]=;
     p[]=;
     for(i=;i<len;i++){
         p[i]=p[i-]+p[i-];

     }
     return p;
 }
 void print(int p[],int len){
     int i;
     for(i=;i<len;i++){
         printf("p[%d]=%d\t",i+,p[i]);

     }

 }

 int main(){
     int *fib;
     fib=fibonacci();

     print(fib,);

     return ;
 }

 #if 0
 、（课堂）从键盘输入10个学生的成绩，如果遇到大于100或者小于0的成绩需要提示输入错误重新输入。
 之后计算10个学生的总成绩和平均成绩

 解题思路：
 一。创建长度为十的数组表示学生成绩
 二。在输入时判断数值是否合法。
 三。遍历数组累加 求总成绩和平均成绩
 #endif

 #include<stdio.h>
 #include<stdlib.h>

 int *getmemory(int len){
     int *p;
     if(NULL==(p=(int *)malloc(sizeof(int)*len))){
         perror("cannot malloc");
         return NULL;

     }
     return p;
 }

 void my_scanf(int p[],int len){
     int i;

     for(i=;i<len;i++){
         printf("请输入第%d个学生成绩:\n",i+);
         //scanf("%d",&p[i]);
         int grade=;
         scanf("%d",&grade);
         if(grade<||grade>){
             printf("成绩区间为1至100");
             i--;
         }else{
             p[i]=grade;
         }
     }

 }

 void my_printf(int p[],int len){
     int i;

     for(i=;i<len;i++){

         printf("第 %d个学生的成绩；%d",i+,p[i]);
     }

 }

 int my_sum(int p[],int len){
     int i=;
     int sum=;

     for(i=;i<len;i++){
         sum+=p[i];

     }
     return sum;

 }

 double my_ave(int p[],int len){
     double ave;

     ave=my_sum(p,len)/len;

     return ave;

 }

 int main(){
     int num;
     int *stu;

     printf("需要输入几个学生的成绩");
     scanf("%d",&num);
     stu=getmemory(num);//创建容器

     my_scanf(stu,num);//输入数据

     //my_printf(stu,num);//输出数据

     int sum=my_sum(stu,num);//求和
     printf("学生的总成绩:%d",sum);

     double ave=my_ave(stu,num);//求平均
     printf("学生的平均成绩：%lf",ave);

     return ;
 }

 #if 0
 、（课堂）冒泡排序
 从键盘输入10个各不相同的整数，存储在数组中，使用冒泡排序法将数组排序并输出
 冒泡排序：是一种简单的排序算法
 ）比较相邻的元素和其身后的元素。如果第一个比第二个大，就交换他们两个。
 ）对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。一次循环过后，最后的元素应该会是最大的数。
 ）针对所有的元素重复以上的步骤，除了最后一个。
 ）持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

 #endif
 #include<stdio.h>

 void my_scanf(int a[],int len){
     int i=;
     for(i=;i<len;i++){

         printf("请输入第 %d个元素: ",i+);
         scanf("%d",&a[i]);

     }

 }
 void bubblesort(int a[],int len){
     int i,j;
     for(i=;i<len-;i++){

         for(j=;j<len--i;j++){
             if(a[j]<a[j+]){
                 a[j]^=a[j+];
                 a[j+]^=a[j];
                 a[j]^=a[j+];

             }

         }
     }

 }

 void my_printf(int a[],int len){
     int i=;
     for(i=;i<len;i++){
         printf("a[%d]=%d\t",i+,a[i]);
         if(i%==)printf("\n");

     }

 }
 int main(){
     int a[]={};
     my_scanf(a,);

     bubblesort(a,);

     my_printf(a,);

     return ;
 }

 #if 0
 、（课堂）自定义一个3*4的矩阵，输出矩阵中值最大的元素，并输入其数组下标
 解题思路：
 一。构建一个3*4的矩阵，然后给矩阵内的每个元素赋值。
 二。创建三个变量分别存放最大值及其坐标
 三。遍历矩阵得到最大值及其坐标

 错误分析：
 应该定义一个结构体来存放最大值及其坐标
 #endif
 #include<stdio.h>
 #include<stdlib.h>

 void my_scanf(int (*a),int x,int y){
     int i=,j=;
     for(i=;i<x;i++){
         for(j=;j<y;j++){
             printf("请输入第 %d行%d 列的值:\n",i+,j+);
             scanf("%d",&a[(i*(x+)+j)]);

         }

     }

     for(i=;i<x;i++){
         for(j=;j<y;j++){
             printf("a[%d][%d]=%d\t",i+,j+,a[(i*(x+)+j)]);
             //printf("%d\n",(i*(x+1)+j));

         }

     }

 }

 void max(int (*a),int x,int y){
     int num,i=,j=,sub_i=,sub_j=;
     num=a[];
     for(i=;i<x;i++){
         for(j=;j<y;j++){
             if(num<a[(i*(x+)+j)]){
                 num=a[(i*(x+)+j)];
                 sub_i=i+;
                 sub_j=j+;

             }

         }

     }

     printf("\nmax:a[%d][%d]=%d",sub_i,sub_j,num);

 }

 int main(){
     //printf("哈哈哈999\n");
     int a[][]={};
     //int (*a)=(int *)malloc(sizeof(int)*3*4);

     //int i=3,j=4;
     my_scanf(a,,);

     max(a,,);

     //free(a);
     //a=NULL;

     return ;
 }

 #if 0
 、（课堂）打印杨辉三角型前10行

 思路分析：
 一。打印十行杨辉三角得第十行长度为十，所以建立一个长度为十的数组，作为每行的数据存储
 二。按 -9循环，代表行号，每次循环按行号递减遍历操作数组，
 三。行号位元素置一，递减遍历 元素（n）=元素（n）+元素（n-），首位不运算。
 四。对一行操作完成可得到对应的杨慧三角值。输出。

 错误分析：
 没有将完整的杨慧三角记录。
 #endif

 #include<stdio.h>
 #include<stdlib.h>
 int main(){
     int row;
     int *yang=NULL;
     int i=;

     printf("打印几行杨辉三角：\n");
     scanf("%d",&row);
     yang=(int *)malloc(sizeof(int)*row);
     if(NULL==yang){
         perror("cannot malloc");
         return ;
     }
     for(i=;i<row;i++){
         yang[i]=;
         int j;
         for(j=i-;j>;j--){
             yang[j]+=yang[j-];
             //printf("4444444444");
         }
         int k=;
         for(k=;k<=i;k++){
             printf("%d\t",yang[k]);
         }
         printf("\n");

     }

     return ;
 }

 #if 0
 、给定任一个各位数字不完全相同的4位正整数，如果我们先把4个数字按非递增排序，再按非递减排序，然后用第1个数字减第2个数字，
 将得到一个新的数字。一直重复这样做，我们很快会停在有“数字黑洞”之称的6174，这个神奇的数字也叫Kaprekar常数。
 例如，我们从6767开始，将得到
  -  =
  -  =
  -  =
  -  =
  -  =
 ... ...
 现给定任意4位正整数，请编写程序演示到达黑洞的过程。

 思路分析：
 一。利用循环结束条件为结果等于6174
 二。接收数据，
 三。对数据排序，得到递增递减两数的差值，判断是否为6174，否则继续循环。
 #endif
 #include<stdio.h>
 void bubblesort(int a[],int len){
     int i,j;
     for(i=;i<len-;i++){
         for(j=;j<len--i;j++){
             if(a[j]>a[j+]){
                 a[j]^=a[j+];
                 a[j+]^=a[j];
                 a[j]^=a[j+];
             }
         }
     }

 }

 int dijian(int danwei[],int len){
     int sum=;
     bubblesort(danwei,len);
     int i=;
     for(i=len-;i>=;i--){
         sum=sum*;
         sum+=danwei[i];
     }
     return sum;
 }
 int dizeng(int danwei[],int len){
     int sum=;
     bubblesort(danwei,len);
     int i=;
     for(i=;i<len;i++){
         sum=sum*;
         sum+=danwei[i];
     }
     return sum;
 }

 int main(){

     //获得一个数
     int num=;
     printf("请输入一个四位数：");
     scanf("%d",&num);
     while(num!=){
     //分解数值

     int danwei[];
     danwei[]=num/;
     danwei[]=(num%)/;
     danwei[]=(num%)/;
     danwei[]=num%;
     //排序成两个新数据
     int jian=dijian(danwei,);
     int zeng=dizeng(danwei,);
     //相减得到新数据
     num=jian-zeng;
     printf("%d-%d=%d\n",jian,zeng,num);

     }
     return ;
 }

 、（课堂）自定义2个字符数组，不使用系统提供的strcat()函数，实现strcat()函数功能。
 、（课堂）自定义2个字符数组，不使用系统提供的strcpy()函数，实现strcpy()函数功能。
 、（课堂）自定义2个字符数组，不使用系统提供的strcmp()函数，实现strcmp()函数功能。
 、（课堂）自定义1个字符数组，不使用系统提供的strlen()函数，实现strlen()函数功能。

 #if 0
 、输出以下图案。要求每行的字符数与每次偏移几个字符由用户输入。结束条件为最后一行开头与第一行末尾对齐或在其之后
 **********
   **********
     **********
       **********
         **********
           **********

 思路分析：
 一。空格数=++kong  * 偏移量
 二。循环执行条件 空格数小于字符数

 #endif

 #include<stdio.h>

 int main(){
     int zifu,pianyi;
     printf("每行的字符数");
     scanf("%d",&zifu);
     printf("每次偏移几个字符");
     scanf("%d",&pianyi);
     int kongge=;
     int kong=;
     while(kongge<zifu){
         int k=;
         kongge=kong*pianyi;
         for(k=;k<kongge;k++){
             printf(" ");
         }
         kong++;

         int j=;
         for(j=;j<zifu;j++){
             printf("*");
         }
         printf("\n");

     }
     return ;
 }

 #if 0
 、按以下规律加密一段文字。
 A->Z    a->z
 B->Y    b->y
 C->X    c->x
 ……
 Z->A    z->a
 其中不是字母的部分不加密。

 解题思路：
 一。利用字母对应的ASCII码表的数值进行运算，达到加密的目的。
 二。B-A=Z-Y;  C-A=Z-X ==》X=Z-(C-A)=Z-C+A

 #endif

 #include<stdio.h>

 int main(){
     int i=;
     char encryption[]={'','A','a','','B','b','','Z','z','','','Q','q',''};
     for(i=;i<;i++){
         printf("%c",encryption[i]);
     }
     printf("\n加密结果：\n");
     for(i=;i<;i++){
         if((encryption[i]>='A')&&(encryption[i]<='Z')){
             encryption[i]='Z'-encryption[i]+'A';
         }
         if((encryption[i]>='a')&&(encryption[i]<='z')){
             encryption[i]='z'-encryption[i]+'a';
         }

     }
     for(i=;i<;i++){
         printf("%c",encryption[i]);
     }
     return ;
 }

 #if 0
 、规定一句话中以空格作为分词符。输入一句话，求一句话中最长单词的长度。例如：
 I love China!
 则最长单词是China!，最长单词长度是6

 解题思路：
 一。因为不需要对数组本身进行修改，所以直接操作字符串常量
 二。四个变量，
       最高值             最高值单词首地址
       每个单词的长度     单词首地址
 三。输出最高值的结果。

 错误分析：
 如果以空格为判断标志则最后一个单词无法判断
 解决在循环结束后再判断一次；

 如果要用scanf（）输入需要知道语句长度
 scanf("%s",p);这样写并不是在代码区p的值使stdin的地址；

 #endif

 #include<stdio.h>

 void my_printf(char p[]){
     while((*p!='\0'&&(*p!=' '))){
         printf("%c",*p++);
     }
 }

 int main(){
     char *p="I love China!";
     int max=;
     int len=;

     char *plen=p;

     //scanf("%s",p);||(*p!=' ')

     printf("%s\n",p);

     char *pmax=p;
     while(*p!='\0'){
         if(*p!=' '){
             ++len;

         }else{

             if(len>max){
                 max=len;
                 pmax=plen;

             }
             plen=p+;
             len=;
         }

         p++;
     }
     if(len>max){
                 max=len;
                 pmax=plen;
             }
     printf("最大长度：%d,单词：",max);
     my_printf(pmax);

     //printf("最大长度：%s\n",pmax);

     //printf("最大长度：%p\n",plen);
     //printf("最大长度：%p\n",p);

     return ;
 }

 //49、读以下程序，猜想程序的运行结果，然后上机验证
 #include<stdio.h>
 int main()
 {
     int i;
     int lh,rh,le,re,m;
     char *lefthand[] = {"╮","o","<","~\\"};
     char *righthand[]= {"╭","o",">","/~"};
     char *lefteye[] = {"╯","^","-","=",">","@","⊙"};
     char *righteye[]= {"╰","^","-","=","<","@","⊙"};
     char *mouth[] = {"Д","▽","_","ε","^"};
     printf("请选择左手：\n");
     for(i=;i<=;i++)
     {
         printf("%d.[%s]  ",i+,lefthand[i]);
     }
     printf("\n");
     scanf("%d",&lh);
     lh--;
     printf("请选择右手：\n");
     printf("推荐：%d.[%s]\n其他：",lh+,righthand[lh]);
     for(i=;i<=;i++)
     {
         if(i==lh)
             continue;
         printf("%d.[%s]  ",i+,righthand[i]);
     }
     printf("\n");
     scanf("%d",&rh);
     rh--;
     printf("请选择左眼：\n");
     for(i=;i<=;i++)
     {
         printf("%d.[%s]  ",i+,lefteye[i]);
     }
     printf("\n");
     scanf("%d",&le);
     le--;
     printf("请选择右眼：\n");
     printf("推荐：%d.[%s]\n其他：",le+,righteye[le]);
     for(i=;i<=;i++)
     {
         if(i==le)
             continue;
         printf("%d.[%s]  ",i+,righteye[i]);
     }
     printf("\n");
     scanf("%d",&re);
     re--;
     printf("请选择嘴：\n");
     for(i=;i<=;i++)
     {
         printf("%d.[%s]  ",i+,mouth[i]);
     }
     printf("\n");
     scanf("%d",&m);
     m--;
     printf("%s(%s%s%s)%s\n",lefthand[lh],lefteye[le],mouth[m],righteye[re],righthand[rh]);
     return ;
 }

#if 0
、围绕着山顶有10个圆形排列的洞，狐狸要吃兔子，兔子说：“可以，但必须先找到我，我就藏身于这十个洞中的某个洞。
你从1号洞找，下次隔1个洞（即3号洞）找，第三次隔2个洞（即6号洞）找，再隔3个…以后在这个圆圈中如此类推，次数不限。
”但狐狸从早到晚进进出出了1000次，仍没有找到兔子。
问：兔子可能藏身于哪（几）个洞中？

思路分析：
一。创建一个十一个元素数组，元素角标对应山洞。
二。
第几次寻找      对应的洞号      相应洞号的差值

三。根据洞号差来确定每次的洞号,山洞对应的元素自增；
四。输出每个元素的值为零即使没有找过的。

#endif

#include<stdio.h>

int main(){
    int i=;
    int sum=;
    int fp[]={};
    int j;
    for(i=;i<=;i++){
        sum+=i;
        j=sum%;
        //if(j==0)j=10;
        fp[j]++;
    }
    fp[]=fp[];
    int k=;
    for(k=;k<;k++){

        printf("%d号洞被找%d次\n",k,fp[k]);
    }

    return ;
}

提高题       提高题       提高题       提高题       提高题

 #if 0
 、编写程序，随机生成一个1~10内的数，让对方猜3次。如果3次内能猜中则输出“恭喜你”；若3次内猜不中则输出正确答案。
 C语言中提供生成随机数的函数rand()
 用法：
 ①所需头文件：

 ②生成随机数种子：
 #include<math.h>
 #include<time.h>
 //sleep(1);
 srand(time());

 ③生成某范围内的随机数。例如生成1~100内的随机数
 #include<stdlib.h>
 int a = rand()%+;//将这个数取余100，会得到一个0~99之间的数，将这个数+1即可得到1~100之间的数

 解题思路：
 一。生成随机数
 二。三次循环判断，每次循环进行判等，

 错误分析：
 第一个方法问题：

 第二个方法问题：

 #include<stdlib.h>
 #include<time.h>
 #include<math.h>
 头文件互相冲突不能共存；

 #endif

 #include<stdio.h>
 #include<stdlib.h>
 #include<time.h>

 int main(){
     /*
         int a ;
     while(a!=3){
         a = rand()%10+1;
         printf("%d\t",a);
     }

     int a ;
     int i=0;
     while(i!=3){
         a = srand(time(0))%10+1;
         printf("!!!!!!!!!!%d\t",a);
         i++;
     }

     */

     int i;
     srand((unsigned)(time(NULL)));
     int a=rand()%+;
     for(i=;i<;i++){
         int b;
         printf("\n输入猜测值[1-10]: ");
         scanf("%d",&b);
         if(a==b){
             printf("888恭喜你！");
             return ;
         }
     }

     printf("%d是正确答案： ",a);

     return ;
 }

 #if 0
 、在上一题基础上，编写一个彩票程序。
 彩票程序在后台随机生成1~35内的7个各不相同的数字。用户会输入一组7个数字，中奖规则：
 猜中
 7个500万
 6个100万
 5个1万
 4个5000
 3个500
 ，，2个没中奖
 输出是否中奖及奖金。

 解题思路：
 如何高效的生成随机数；
 #endif

 #include<stdio.h>
 #include<stdlib.h>
 #include<time.h>
 int main(){
     int caipiao[];
     srand((unsigned)(time(NULL)));
     int i;
     for(i=;i<;i++){
         int j=;
         int temp=rand()%+;
         for(j=;j<i;j++){
             if(caipiao[i]==temp){
                 i--;
                 continue;
             }
         }
         caipiao[i]=temp;
     }
     int my_cai[];
     printf("请输入竞猜彩票七位1-35的数：例 1 2 3 4 5 6 7 \n");
     scanf("%d %d %d %d %d %d %d",&my_cai[],&my_cai[],&my_cai[],&my_cai[],&my_cai[],&my_cai[],&my_cai[]);
     int k=;
     for(i=;i<;i++){
         int j;
         for(j=;j<;j++){
             if(my_cai[i]==caipiao[j])
             k++;
         }
     }
     printf("您的竞猜结果：");
     if(k==){
         printf("500万");
     }else if(k==){
         printf("100万");
     }else if(k==){
         printf("1万");
     }else if(k==){
         printf("");
     }else if(k==){
         printf("");
     }else{
         printf("抱歉");
     }
     printf("猜对%d个\n",k);
     for(i=;i<;i++){
         printf("第%d位号码：%d 。我的竞猜%d \n",i+,caipiao[i],my_cai[i]);
     }
     return ;
 }

 #if 0
 、判断一个矩阵中是否存在鞍点，若存在输出鞍点。鞍点是这样一个数字：在该行最大，在该列最小。例如：

 则数字6（a[][]）是鞍点。一个矩阵可能没有鞍点，可能拥有不止一个鞍点。

 解题思路：
 一。 寻找每行的最大值
 二。判断最大值是否为所在列的最小值

 #endif

 #include<stdio.h>

 int main(){
     typedef struct an{
         int max;
         int i;
         int j;
     }an;

     int a[][]={
         { ,  , , },
         { ,  ,  ,},
         { , , ,}
     };

     int hang=,lie=;
     int i=;
     an andian;

     //遍历所有行
     for(i=;i<hang;i++){
         andian.max=a[i][];
         andian.i=i;
         andian.j=;

         int j;
         //寻找这行里最大值
         for(j=;j<lie;j++){
             if(andian.max==a[i][j]){
                 break;
             }
             if(andian.max<a[i][j]){
                 andian.max=a[i][j];
                 //andian.i=i;
                 andian.j=j;

             }
             //遍历完行最后一位且行中没有相等 取得行最大值；
             if(j==(lie-)){
                 //遍历行最大值所在列，判断是否为最小值
                     int ii,jj=(andian.j);
                     for(ii=;ii<hang;ii++){
                         if(ii==i)continue;
                         if(a[ii][jj]<andian.max){
                             break;
                         }
                         if(ii==hang-){
                             printf("鞍点=%d  ，行=%d   列=%d\n",andian.max,andian.i+,andian.j+);
                         }
                     }

                 }

         }

     }

     return ;
 }

 #if 0
 、使用1、、、4四个数字能组成多少个无重复数字的三位数？输出这些三位数。

 思路分析：
 达成遍历的效果。

 错误分析：
 大o算法=n^ ，比较高；

 #endif
 #include<stdio.h>

 int main(){
     int a[]={,,,};
     int i,j,k,len=;
     for(i=;i<len;i++){

         for(j=;j<len;j++){
             if(i==j)continue;
             for(k=;k<len;k++){
                 if((i==k)||(j==k))continue;
                 printf("%d \t",(a[i]*+a[j])*+a[k]);
             }
         }
     }

     return ;
 }

 #if 0
 、输入一个日期（年、月、日），计算该日期是这一年的第几天。注意判断闰年
 解题思路：
 一。建立一个数组存贮每个月的天数
 二。判断是否为闰年，若月份大于2则天数加一。

 错误分析：
 没有输入数据合法性分析。
 认为最好的方法是创建两个月的数组，一个存储闰年。
 #endif

 #include<stdio.h>
 int runnian(int year){

     if((year%)==){
         printf("%d是闰年\n",year);return ;
     }else if((year%)==){
         printf("%d不是闰年\n",year);return ;
     }else if((year%)==){
         printf("%d是闰年\n",year);return ;
     }else{
         printf("%d不是闰年\n",year);return ;
     }
     return ;
 }

 int main(){
     int yueping[]={,,,,,,,,,,,,};
     int nian,yue,ri;
     printf("输入年 月 日：");
     scanf("%d %d %d",&nian,&yue,&ri);
     if(runnian(nian)&&(yue>)){
         ri++;
     }
     int sum=;
     int i;
     for(i=;i<yue;i++){
         sum+=yueping[i];
     }
     sum+=ri;
     printf("%d:%d:%d一共有：%d 天。",nian,yue,ri,sum);

     return ;
 }

 #if 0
 、输出9*9乘法口诀表
 *=
 *=    *=
 *=    *=    *=
 ……

 思路分析：
      *
      *
      *
      *
      *    

  利用一个双重循环产生上图数据
 #endif

 #include<stdio.h>

 int main(){
     int len=;
     int i=;
     for(i=;i<=len;i++){
         int j=;
         for(j=;j<=i;j++){
             printf("%d*%d=%d\t",i,j,(i*j));
         }
         printf("\n");

     }

     return ;
 }

 #if 0
 、输入2个正整数，求它们的最大公约数和最小公倍数
 解题思路：
 最大公约数：
 n--, 第一个取余为零的数
 n++，第一个取余为零的数
 #endif

 #include<stdio.h>

 int main(){

     int a,b,mix,max,yueshu,beishu;
     printf("输入两个数：\n");
     scanf("%d %d",&a,&b);
     mix=a<b?a:b;
     max=a>b?a:b;

     int i=;
     //求最大公约数
     for(i=mix;i>;i--){
         if((mix%i==)&&(max%i==)){
             yueshu=i;
             break;
         }
     }
     //求公倍数
     for(i=max;i<=max*mix;i++){
         if((i%mix==)&&(i%max==)){
             beishu=i;
             break;
         }
     }
     printf("%d,%d的公约数%d；公倍数%d",mix,max,yueshu,beishu);

 }

#if 0
、楼梯有n阶台阶，上楼可以一步上1阶，也可以一步上2阶，编程序计算n阶台阶共有多少种不同的走法
解题思路：
一。全部是一阶
二。有一个二阶
三。有两个二阶
四。以此类推到二阶最多的情况。
五。对每种情况进行全排序

.....
..
将2插入1看有多少情况
2插到2旁边是一样的。

#endif
#include<stdio.h>

int main(){
    int taijie;
    printf("输入台阶数：\n");
    scanf("%d",&taijie);
    int liangjie=,sum=;

    while((taijie-*liangjie)>=){
        int yijie=taijie-*liangjie;
        int zoufa=;
        //i等于2阶的个数，代表插入几次；
        int i=liangjie;
        while(i){
            zoufa*=(yijie+);

            i--;
        }

        printf("有%d步为两阶,走法%d种\n",liangjie,zoufa);

        sum+=zoufa;
        ++liangjie;
    }

    printf("\n总共有%d种\n",sum);
    return ;
}

 #if 0
 、协助破案。假设已经查清，有a、b、c、d、e五个犯罪嫌疑人可能参与作案，但是不知道哪（几）个是真正的案犯。不过有证据表明：

 ⒈如果a参与了作案，则b一定也参与
 ⒉b和c两人中只有一人参与了作案
 ⒊c和d要么都参与作案，要么都没有参与
 ⒋d和e两个人中至少有一人参与了作案
 ⒌如果e作案，则a和d必定协助作案。
 编程找出谁是真正的案犯（可能不止一人）

 解题思路：
 设计五个变量abcde；
 如果abcde全部被判定，赋值则跳出循环。

 如果D=；可以实现对a到e的判断；则值出现一次循环未改变 跳出循环
 否则e=；再次循环

 错误分析：
 应该是我输入一个猜测，然后输出此猜测的结果。
 根据题意有两种可能。
 #endif

 #include<stdio.h>

 int main(){
     int a=,b=,c=,d=,e=;
     //判断有没有语句执行
     int aa,bb,cc,dd,ee;
     //假设d=1；看是不是能判断所有人，若果i=0时还不能判断所有人。在循环中改成c=1
     d=;
     while(a==||b==||c==||d==||e==){
         aa=a;bb=b;cc=c;dd=d;ee=e;
         //⒈如果a参与了作案，则b一定也参与
         if(a==){
             b=;

         }
         //⒉b和c两人中只有一人参与了作案
         if(b==){
             c=;

         }else {
             c=;
         }
         if(c==){
             b=;
         }else{
             b=;
         }

         //⒊c和d要么都参与作案，要么都没有参与
         if(c==){
             d=;

         }else if(d==){
             c=;

         }
         //⒌如果e作案，则a和d必定协助作案。
         if(e==){
             a=;
             d=;

         }
         printf("a=%d,b=%d,c=%d,d=%d,e=%d\n",a,b,c,d,e);

         //⒋d和e两个人中至少有一人参与了作案
         if(a==aa && b==bb && c==cc && d==dd&& e==ee){
             a=;b=;c=;d=;e=;
         }

     }
     printf("最终结果a=%d,b=%d,c=%d,d=%d,e=%d\n\n\n",a,b,c,d,e);
     if(a==){
         printf("a是罪犯\n");
     }else{
         printf("a不是罪犯\n");
     }
     if(b==){
         printf("b是罪犯\n");
     }else{
         printf("b不是罪犯\n");
     }
     if(c==){
         printf("c是罪犯\n");
     }else{
         printf("c不是罪犯\n");
     }
     if(d==){
         printf("d是罪犯\n");
     }else{
         printf("d不是罪犯\n");
     }
     if(e==){
         printf("e是罪犯\n");
     }else{
         printf("e不是罪犯\n");
     }

     return ;
 }

 #if 0
 、给定一个5位数，判断这个数字是否是回文数。例如12321是回文数，而12345就不是回文数。
 解题思路：
 因为是给定的五位数
 可以将第一位和第五位比，第二位和第四位比。
 #endif

 #include<stdio.h>

 int huiwen(int num){
     if((num/)!=(num%)){
         return ;
     }
     if((num/%)!=(num%/)){
         return ;
     }
     return ;
 }

 int main(){
     printf("请输入一个五位数");
     int num;
     scanf("%d",&num);
     int i=huiwen(num);
     if(i){
         printf("%d是回文数",num);
     }else{
         printf("%d不是回文数",num);
     }

     return ;
 }

 #if 0
 、自定义一个5*5矩阵，将这个矩阵转置。
 一。定义一个5* 的矩阵A；
 二。新建一个5* 的矩阵B；
     B[i][j]=a[j][i];

 #endif

 #include<stdio.h>

 void my_scanf(int *a,int x,int y){
     int i=,j=;
     for(i=;i<x;i++){
         //j不应该从零开始
         for(j=;j<y;j++){
             printf("请输入第 %d行%d 列的值:\n",i+,j+);
             scanf("%d",&a[(i*(x+)+j)]);

         }

     }

     for(i=;i<x;i++){
         for(j=;j<y;j++){
             printf("a[%d][%d]=%d\t",i+,j+,a[(i*(x+)+j)]);
             //printf("%d\n",(i*(x+1)+j));

         }

     }
     //printf(""\n\n\n);

 }
 void zhuanzhi(int *b,int x,int y,int *a ){
     int i=,j=;
     for(i=;i<x;i++){
         //j不应该从零开始
         for(j=;j<y;j++){
             //printf("请输入第 %d行%d 列的值:\n",i+1,j+1);
             //scanf("%d",&a[(i*(x+1)+j)]);
             b[(i*(x+)+j)]=a[(j*(x+)+i)];
         }

     }
     for(i=;i<x;i++){
         for(j=;j<y;j++){
             printf("b[%d][%d]=%d\t",i+,j+,b[(i*(x+)+j)]);
             //printf("%d\n",(i*(x+1)+j));

         }

     }
 }

 int main(){
     printf("创建矩阵A；\n");
     int a[][]={};
     my_scanf(a,,);
     printf("创建转置矩阵B: \n");
     int b[][]={};
     zhuanzhi(b,,,a);

     return ;
 }

 #if 0
 、假设你收到了一行使用凯撒密码加密过的单词但不知道秘钥（偏移字母数），请破译这段密文。
 密文：PELCGBTENCUL
 提示：凯撒密码加密是一种字母替换加密算法，其加密原则是：将26个字母连接成环，明文的所有字母被后n位的字母替换得到密文。例如当n=3的时候替换规则是：
 A--->D
 B--->E
 C--->F
 ……
 X--->A
 Y--->B
 Z--->C
 明文HELLO----->密文KHOOR

 解题思路：
 一。输入一段密码和原文判断秘钥
 二。根据秘钥解码密文

 #endif

 #include<stdio.h>
 #define len 20

 void jiemi(char *kaisa,char *kaisayuanwen,int miyao){

     while(*kaisa!='\0'){
         *kaisayuanwen=*kaisa+miyao;

         *kaisa++;
         *kaisayuanwen++;
     }
     *kaisayuanwen='\0';

 }
 int main(){
     char mingwen[len],miwen[len],kaisa[len],kaisayuanwen[len];
     printf("输入明文:\n");
     scanf("%s",mingwen);

     printf("输入密文:\n");
     scanf("%s",miwen);

     int miyao=mingwen[]-miwen[];

     printf("输入凯撒密文\n");
     scanf("%s",kaisa);

     jiemi(kaisa,kaisayuanwen,miyao);
     printf("输入凯撒原文\n");

     printf("%s\n",kaisayuanwen);

     return ;
 }

 #if 0
 、棋子移动问题
 有2n（n>=）个棋子排成一行，其中黑棋B有n个，白棋W有n个，并留有两个空格。
 例如，当n=4时排列如下所示：（W为白棋，B为黑棋，0为空格）
 W W W W B B B B
 当n=5时排列如下所示：（W为白棋，B为黑棋，0为空格）
 W W W W W B B B B B
 现在需要移动棋子，移动规则如下：
 ⒈每次必须同时移动相邻的两个棋子
 ⒉每次移动必须跳过若干棋子
 ⒊不能随意调换任意两个棋子的位置
 目标：将所有的棋子移动为黑白棋相间的形式，中间不能有空格。
 例如：当n=4时移动步骤如下：
 起始：  W W W W B B B B
 第一步：W W W   B B B W B
 第二步：W W W B W B B   B
 第三步：W   B W B B W W B
 第四步：W B W B W B   W B
 第五步：  W B W B W B W B（完成）
 编程实现：从键盘输入n（n>=），求每一步的棋子移动

 思路分析：
 一。创建一个数组， n-1赋值W  n-1赋值B  最后两个赋值'';
 二。调换原则：

 起始：  W W W W B B B B  

 第一步：W W W   B B B W B          //2n <==>n-1   /2-1    -2/1 

 第二步：W W W B W B B   B          n- <==>2n-  *+     

 第三步：W   B W B B W W B          2n- <==>n-  /

 第四步：W B W B W B   W B          n- <==> 2n-

 第五步：  W B W B W B W B（完成）  2n-<==>n-  

 结束条件：
           n-=

 三。采用递归的方法
 递归逻辑：N>,
 递归出口：N<,

 #endif

 #include<stdio.h>
 #include<stdlib.h>

 char *getmemory(int n){

     //不能q++的原因是：返回的q不是首地址。
     char *qi;
     int len=n*+;
     if(NULL==(qi=(char *)malloc(sizeof(int)*len))){
         perror("cannot malloc");
         return NULL;
     }
     int i=;
     while(i<n){
         qi[i]='W';

          i++;
     }
     while(i<*n){
         qi[i]='B';

          i++;
     }
     while(i<(*n+)){
         qi[i]='';

          i++;
     }
     return qi;
 }

 void jiaohuan(char *qi,int i,int j){
     char temp;
     temp=qi[i];
     qi[i]=qi[j];
     qi[j]=temp;
     i++;j++;
     temp=qi[i];
     qi[i]=qi[j];
     qi[j]=temp;
 }
 void si(char *qi){
     jiaohuan(qi,,);
     jiaohuan(qi,,);
     jiaohuan(qi,,);
     jiaohuan(qi,,);
     jiaohuan(qi,,);
 }
 void my_printf(char *qi,int m){
     int i=;
     for(i=;i<m*+;i++){
         printf(" %c ",qi[i]);
     }
     printf("\n");
 }

 void qijiaohuan(char *qi,int n,int m){

     if(n>){
         jiaohuan(qi,n,*n+);
         jiaohuan(qi,n,*n);
         n--;
         my_printf(qi,m);
         qijiaohuan(qi,n,m);

     }else{
         si(qi);
         my_printf(qi,m);
     }

 }

 int main(){
     int n;
     printf("请输入N的个数：\n");
     scanf("%d",&n);
     char *qi;

     qi=getmemory(n);
     //int i=0;
     my_printf(qi,n+);

     qijiaohuan(qi,n-,n);
     //si(qi);

     return ;
 }

练习题：
注：标有（课堂）字样的为课上练习，其他为课下练习
基础题（50题）
1、（课堂）编写程序，输出“XXX欢迎来到动物园！”（XXX是自己的名字）。
2、（课堂）打印用*组成的字母C
3、交换杯子里的液体。使用不同的整数代表液体，变量代表杯子。
（课堂）方法1：中间变量法
（课堂）方法2：三步异或法
方法3：加和分减法
4、（课堂）使用宏定义PI来定义3.1415926，计算圆的面积。
5、（课堂）租船问题。
写程序计算游客需要付的租船的费用。租船每小时30元。游客输入租船时间，计算出租船费用。租船费用=时间*每小时钱数+押金。
要求押金与每小时钱数使用宏定义。
6、（课堂）求以下数字的原码、反码、补码。（可以使用计算器）
15（10进制）
0xE3A4（16进制）
7、输入一个整数（0~255），输出这个整数代表的ASCII码字符。

8、输入一个字符，判断这个字符是0~9之间的数字，还是大写字母，还是小写字母。若都不是输出错误信息。

9、计算输入时间的下一秒。例如输入12 15 32，输出12:15:33；输入21 59 59，输出22:00:00。
若输入非法时间（如输入小时是25、输入分钟/秒是61等情况）则报错。

10、（课堂）练习：从键盘输入5个学生的成绩（整数），要求输出总成绩（整数）和平均成绩（小数）

11、（课堂）读以下程序，猜想输出的结果，再执行程序检验自己的猜想
#include <stdio.h>
int main(void)
{
double y;
float a = 2.0;
int b =6,c=3;
y = a*b/c-1.5+'A';
printf("%f\n",y);
return 0;
}
12、（课堂）读以下程序，猜想输出的结果，再执行程序检验自己的猜想
#include <stdio.h>
int main()
{
int i = 8,j = 10,k = 12;
int m,n,p;

m = ++i;
n = j--;
p = (++m)*(n++)+(--k);
printf("i=%d,j=%d,k=%d\n",i,j,k);
printf("m=%d,n=%d,p=%d\n",m,n,p);
return 0;
}
13、（课堂）设
int a=3,b=4,c=5,d;
分别求出下列表达式的d的值（即判断此表达式真假）
1）d = a+b>c && b==c
2）d = a || b+c && b-c
3）d = !(a>b) && !c || 1
4）d = !(x=a)&&(y=b)&&0（x和y均为int型，求出x和y的值）
5）d = !(a+b)+c-1 && b+c/2
14、（课堂）输入3个整数，从小到大输出
15、（课堂）输入3个正整数作为3条线段的长度，判断这3条线段能否构成三角形。构成三角形的条件是：任意两边之和大于第三边

16、（课堂）输入一个年份（正整数），判断这年是否是闰年。闰年判断标准：年份能被4整除；如若遇到100的倍数，
则需判断年份能否被400整除。（逢4一闰，逢百不闰，逢400又闰）

17、（课堂）输入一个学生的成绩，输出该成绩对应的分数段。90~100为优，80~89为良，70~79为中，60~69为及格，
0~59为不及格，其他则输出错误信息。要求使用switch实现。

18、（课堂）运输公司对用户按路程计算费用。路程越远，每吨*千米运费折扣越高。计算运费公式如下：
freight = weight * distance * price * (1-discount);
路程与折扣的关系如下：
s<250：无折扣
250<=s<500:2%折扣
500<=s<1000:5%折扣
1000<=s<2000：8%折扣
2000<=s<3000：10%折扣
3000<=s：15%折扣
要求从键盘输入货运总重（单位吨）、货运路程（单位千米）、每吨*千米货运单价（单位元），输出总花费。

19、（课堂）求1+2+3+……+99+100=?。使用while()、do-while()和for()三种循环分别实现。
20、打印所有水仙花数。水仙花数是这样的三位数：各位数字的立方和等于其本身。如153就是一个水仙花数。

21、（课堂）打印斐波那契数列的前n项，其中n由键盘输入。斐波那契数列的特点如下：
F1=1 (n=1)
F2=1 (n=2)
Fn=Fn-1 + Fn-2 (n>=3)
22、（课堂）输出如下图形：
*
***
*****
*******
*********
……
其中需要输出几行由键盘输入。
23、（课堂）现有100元钱要买以下3种文具。其中一个笔记本20元，一套尺6元，一个笔4元，每样文具至少买1个。
列举出所有的购买方案，以及列举出所有花光100元的购买方案
24、（课堂）输出100~200间的所有素数
25、计算1+2+3+……+99+100=?，在执行加法之前由用户输入3个数，这3个数不参与运算。例如输入3、57和89，则最终结果等于4901。
26、编写一个程序，由键盘输入若干正整数，输入0代表输入完成。计算输入的数中的奇数的个数、总和、平均值；
计算输入的数中的偶数的个数、总和、平均值。
27、卡拉兹(Callatz)猜想：
对任何一个自然数n，如果它是偶数，那么把它砍掉一半；如果它是奇数，那么把(3n+1)砍掉一半。这样一直反复砍下去，最后一定在某一步得到n=1。卡拉兹在1950年的世界数学家大会上公布了这个猜想，传说当时耶鲁大学师生齐动员，拼命想证明这个貌似很傻很天真的命题，结果闹得学生们无心学业，一心只证(3n+1)，以至于有人说这是一个阴谋，卡拉兹是在蓄意延缓美国数学界教学与科研的进展……
我们今天的题目不是证明卡拉兹猜想，而是对给定的任一不超过1000的正整数n，简单地数一下，需要多少步才能得到n=1？
28、读懂以下程序，分析程序逻辑，画出流程图，说明程序的功能
#include<stdio.h>
int main()
{
int x,y;
printf("enter x:");
scanf("%d",&x);
y=0;
if(x!=0)
{
if(x>0)
y=1;
else
y=-1;
}
printf("x=%d\ny=%d\n",x,y);
return 0;
}
29、给定一个不多于5位的正整数，要求：
①求出它是几位数
②分别输出每一位数字（这里的位指十进制的位而非二进制的bit）
③将数字逆序。例如输入123，则输出321
30、使用公式求π的近似值
π/4 = 1 - 1/3 + 1/5 - 1/7 + ……
直到某一项的绝对值小于10^-6为止。
（提示：判断该数字是否小于10^-6，可以使用系统库函数fabs
fabs(f)>=1e-6//1e-6是10^-6的科学计数法表示方式
若要使用fabs()函数，则应包含头文件math.h
#include<math.h>
而且要在编译时添加-lm，即手动添加数学库libm.o
gcc qiupai.c -o qiupai -lm）

31、读懂以下程序，说明程序的功能
#include<stdio.h>
int main()
{
int m,n,r,m1,m2;
printf("请输入2个正整数：");
scanf("%d%d",&m1,&m2);
m=m1;
n=m2;
do{
r=m%n;
m=n;
n=r;
}while(r!=0);
printf("%d\n",m);
return 0;
}
32、一个数如果恰好等于它的所有的因子之和，则这个数就称为“完数”。例如6的因子有1、2、3，而1+2+3=6，因此6是一个完数。编程找出1000内所有的完数。
33、（课堂）思考这个宏定义错在哪里
#define S (r) PI*r*r//注意S与(r)之间有空格
34、我们在头文件（.h文件）中，经常看到这样的内容
#ifndef __H_INCLUDE__
#define __H_INCLUDE__
//头文件的实际内容
#endif
思考头文件的开头和结尾需要这样书写的原因。
35、（课堂）运行以下程序
int main()
{
char a,b;
a = getchar();
b = getchar();
putchar(a);
putchar(b);
return 0;
}
运行程序，输入x回车y回车，会发现输出的并不是xy，而是
x

思考这是为什么。
36、（课堂）使用数组存储斐波那契数列前40项，并输出
37、（课堂）从键盘输入10个学生的成绩，如果遇到大于100或者小于0的成绩需要提示输入错误重新输入。之后计算10个学生的总成绩和平均成绩
38、（课堂）冒泡排序
从键盘输入10个各不相同的整数，存储在数组中，使用冒泡排序法将数组排序并输出
冒泡排序：是一种简单的排序算法
1）比较相邻的元素和其身后的元素。如果第一个比第二个大，就交换他们两个。
2）对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。一次循环过后，最后的元素应该会是最大的数。
3）针对所有的元素重复以上的步骤，除了最后一个。
4）持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
39、（课堂）自定义一个3*4的矩阵，输出矩阵中值最大的元素，并输入其数组下标
40、（课堂）打印杨辉三角型前10行
41、给定任一个各位数字不完全相同的4位正整数，如果我们先把4个数字按非递增排序，再按非递减排序，然后用第1个数字减第2个数字，将得到一个新的数字。一直重复这样做，我们很快会停在有“数字黑洞”之称的6174，这个神奇的数字也叫Kaprekar常数。
例如，我们从6767开始，将得到
7766 - 6677 = 1089
9810 - 0189 = 9621
9621 - 1269 = 8352
8532 - 2358 = 6174
7641 - 1467 = 6174
... ...
现给定任意4位正整数，请编写程序演示到达黑洞的过程。
42、（课堂）自定义2个字符数组，不使用系统提供的strcat()函数，实现strcat()函数功能。
43、（课堂）自定义2个字符数组，不使用系统提供的strcpy()函数，实现strcpy()函数功能。
44、（课堂）自定义2个字符数组，不使用系统提供的strcmp()函数，实现strcmp()函数功能。
45、（课堂）自定义1个字符数组，不使用系统提供的strlen()函数，实现strlen()函数功能。
46、输出以下图案。要求每行的字符数与每次偏移几个字符由用户输入。结束条件为最后一行开头与第一行末尾对齐或在其之后
**********
**********
**********
**********
**********
**********
//结束条件：最后一行开头与第一行末尾对齐或在其之后
47、按以下规律加密一段文字。
A->Z a->z
B->Y b->y
C->X c->x
……
Z->A z->a
其中不是字母的部分不加密。
48、规定一句话中以空格作为分词符。输入一句话，求一句话中最长单词的长度。例如：
I love China!
则最长单词是China!，最长单词长度是6
49、读以下程序，猜想程序的运行结果，然后上机验证
#include<stdio.h>
int main()
{
int i;
int lh,rh,le,re,m;
char *lefthand[] = {"╮","o","<","~\\"};
char *righthand[]= {"╭","o",">","/~"};
char *lefteye[] = {"╯","^","-","=",">","@","⊙"};
char *righteye[]= {"╰","^","-","=","<","@","⊙"};
char *mouth[] = {"Д","▽","_","ε","^"};
printf("请选择左手：\n");
for(i=0;i<=3;i++)
{
printf("%d.[%s] ",i+1,lefthand[i]);
}
printf("\n");
scanf("%d",&lh);
lh--;
printf("请选择右手：\n");
printf("推荐：%d.[%s]\n其他：",lh+1,righthand[lh]);
for(i=0;i<=3;i++)
{
if(i==lh)
continue;
printf("%d.[%s] ",i+1,righthand[i]);
}
printf("\n");
scanf("%d",&rh);
rh--;
printf("请选择左眼：\n");
for(i=0;i<=6;i++)
{
printf("%d.[%s] ",i+1,lefteye[i]);
}
printf("\n");
scanf("%d",&le);
le--;
printf("请选择右眼：\n");
printf("推荐：%d.[%s]\n其他：",le+1,righteye[le]);
for(i=0;i<=6;i++)
{
if(i==le)
continue;
printf("%d.[%s] ",i+1,righteye[i]);
}
printf("\n");
scanf("%d",&re);
re--;
printf("请选择嘴：\n");
for(i=0;i<=4;i++)
{
printf("%d.[%s] ",i+1,mouth[i]);
}
printf("\n");
scanf("%d",&m);
m--;
printf("%s(%s%s%s)%s\n",lefthand[lh],lefteye[le],mouth[m],righteye[re],righthand[rh]);
return 0;
}
50、围绕着山顶有10个圆形排列的洞，狐狸要吃兔子，兔子说：“可以，但必须先找到我，我就藏身于这十个洞中的某个洞。你从1号洞找，下次隔1个洞（即3号洞）找，第三次隔2个洞（即6号洞）找，再隔3个…以后在这个圆圈中如此类推，次数不限。”但狐狸从早到晚进进出出了1000次，仍没有找到兔子。
问：兔子可能藏身于哪（几）个洞中？

提高题：
1、编写程序，随机生成一个1~10内的数，让对方猜3次。如果3次内能猜中则输出“恭喜你”；若3次内猜不中则输出正确答案。
C语言中提供生成随机数的函数rand()
用法：
①所需头文件：
#include<math.h>
#include<time.h>
②生成随机数种子：
srand(time(0));
③生成某范围内的随机数。例如生成1~100内的随机数
int a = rand()%100+1;//将这个数取余100，会得到一个0~99之间的数，将这个数+1即可得到1~100之间的数

2、在上一题基础上，编写一个彩票程序。
彩票程序在后台随机生成1~35内的7个各不相同的数字。用户会输入一组7个数字，中奖规则：
猜中
7个500万
6个100万
5个1万
4个5000
3个500
0，1，2个没中奖
输出是否中奖及奖金。

3、判断一个矩阵中是否存在鞍点，若存在输出鞍点。鞍点是这样一个数字：在该行最大，在该列最小。例如：
1 2 6 4
5 6 7 8
9 10 11 12
则数字6（a[0][2]）是鞍点。一个矩阵可能没有鞍点，可能拥有不止一个鞍点。

4、使用1、2、3、4四个数字能组成多少个无重复数字的三位数？输出这些三位数。

5、输入一个日期（年、月、日），计算该日期是这一年的第几天。注意判断闰年。

6、输出9*9乘法口诀表
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
……

7、输入2个正整数，求它们的最大公约数和最小公倍数

8、楼梯有n阶台阶，上楼可以一步上1阶，也可以一步上2阶，编程序计算n阶台阶共有多少种不同的走法

9、协助破案。假设已经查清，有A、B、C、D、E五个犯罪嫌疑人可能参与作案，但是不知道哪（几）个是真正的案犯。不过有证据表明：
⒈如果A参与了作案，则B一定也参与
⒉B和C两人中只有一人参与了作案
⒊C和D要么都参与作案，要么都没有参与
⒋D和E两个人中至少有一人参与了作案
⒌如果E作案，则A和D必定协助作案。
编程找出谁是真正的案犯（可能不止一人）

10、给定一个5位数，判断这个数字是否是回文数。例如12321是回文数，而12345就不是回文数。

11、自定义一个5*5矩阵，将这个矩阵转置。

12、约瑟夫环问题：
约瑟夫入狱，监狱内共有33个犯人。某日33名犯人围成一圈，从第一个犯人开始报数，报到数字7的犯人出列，被枪毙，下一名犯人重新从1开始报数。依次类推，直至剩下最后1名犯人可被赦免。聪明的约瑟夫在心里稍加计算，算出了最后枪毙的位置，他站在这个位置，最终避免了自己被枪毙，逃出升天。
问：约瑟夫算出的是哪个位置？

13、假设你收到了一行使用凯撒密码加密过的单词但不知道秘钥（偏移字母数），请破译这段密文。
密文：PELCGBTENCUL
提示：凯撒密码加密是一种字母替换加密算法，其加密原则是：将26个字母连接成环，明文的所有字母被后n位的字母替换得到密文。例如当n=3的时候替换规则是：
A--->D
B--->E
C--->F
……
X--->A
Y--->B
Z--->C
明文HELLO----->密文KHOOR

14、棋子移动问题
有2n（n>=4）个棋子排成一行，其中黑棋B有n个，白棋W有n个，并留有两个空格。例如，当n=4时排列如下所示：（W为白棋，B为黑棋，0为空格）
W W W W B B B B 0 0
当n=5时排列如下所示：（W为白棋，B为黑棋，0为空格）
W W W W W B B B B B 0 0
现在需要移动棋子，移动规则如下：
⒈每次必须同时移动相邻的两个棋子
⒉每次移动必须跳过若干棋子
⒊不能随意调换任意两个棋子的位置
目标：将所有的棋子移动为黑白棋相间的形式，中间不能有空格。
例如：当n=4时移动步骤如下：
起始： W W W W B B B B 0 0
第一步：W W W 0 0 B B B W B
第二步：W W W B W B B 0 0 B
第三步：W 0 0 B W B B W W B
第四步：W B W B W B 0 0 W B
第五步：0 0 W B W B W B W B（完成）
编程实现：从键盘输入n（n>=4），求每一步的棋子移动

15、以下是对“快速排序算法”的算法描述，请读懂这段文字，编写出快速排序算法函数QSort。
提示：函数的原型是：void QSort(int A[], int left, int right)
快速排序由C. A. R. Hoare在1962年提出，是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
快速排序算法的文字描述是：
1）设置两个变量i、j，排序开始的时候：i=0，j=N-1；
2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]；
3）从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于key的值A[j]，将A[j]和A[i]互换；
4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]互换；
5）重复第3、4步，直到i=j；此时令循环结束。将key值赋值到i（或j）的位置。
6）递归操作数组A[]在key值左的左半部分。
7）递归操作数组A[]在key值右的右半部分。