蓝桥杯C语言学习练习一汇总

#include<stdio.h>
#include<math.h>
int main()
{
    int x,a,y;
    scanf("%d",&x);
    a = fabs(x);
    y = a%10*100+a/10%10*10+a/100;
    printf("%d\n",y);
}

通过求余和除号分别得到各数的数字

day2 求解最大奇数和

题目:定义函数g(n)为n最大的奇数因子。求f(n)=g(1)+g(2)+g(3)+…+g(n)。

#include<stdio.h>
int G(int n);
int main()
{
    int n,i,sum,a;
    printf("请输入数字:\n");
    scanf("%d",&n);
    a=n;
    sum=0;
    for(i=0;i<a;i++)
    {
        sum=sum+G(n);
        n--;
    }
    printf("%d",sum);
}

int G(int n)//求解最大奇数
{
    int a;
    if(n%2==1)
    {
        return n;//最大奇数
    }
    else
    {
        return G(n/2);
    } 
}

int G(int n)函数求解最大奇数，通过数学计算和递归求得。通过对数字除2取余是否为1.

day3 开关语句求成绩

题目：给出一百分制成绩，要求输出成绩等级‘A’、‘B’、‘C’、‘D’、‘E’。 90分以上为A 80-89分为B 70-79分为C 60-69分为D 60分以下为E

#include<stdio.h>
int main()
{
    int score;
    char grade;
    scanf("%d",&score);
    if(score>100 || score<0)//判断成绩是否输入正确
    {
        printf("输入错误!\n");
    }
    else
    {
        score=score/10;//通过除号取整
        switch (score)
        {
            case 0:
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
            grade='E';break;
            case 6:
            grade='D';break;
            case 7:
            grade='C';break;
            case 8:
            grade='B';break;
            case 9:
            case 10:
            grade='A';break;
        }
        printf("%c\n",grade);
    }
    return 0;
}

分析

求成绩，首先判断成绩数值是否正确在0到100间内，再通过除号取整得到十位的数值，通过开关语句来筛选成绩。

day 4

1、求不同组合的三位数

题目：有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？

#include<stdio.h>
int main()
{
    int i,a,b,c;
    for(a=1;a<5;a++)
    {
        for(b=1;b<5;b++)
        {
            for(c=1;c<5;c++)
            {
                if(a!=b && b!=c)//使每个位都不一样
                {
                    printf("%d%d%d\n",a,b,c);
                }
            }
        }
    }

}

分析

通过三层循环来输出不同的排序，在用一个if条件语句去掉重复的数字

2、题目：企业发放的奖金根据利润提成。

利润(I)低于或等于10万元时，奖金可提10%；
利润高于10万元，低于20万元时，低于10万元的部分按10%提成，高于10万元的部分，可提成7.5%；
20万到40万之间时，高于20万元的部分，可提成5%；
40万到60万之间时高于40万元的部分，可提成3%；
60万到100万之间时，高于60万元的部分，可提成1.5%；
高于100万元时，超过100万元的部分按1%提成。

从键盘输入当月利润I，求应发放奖金总数？

#include<stdio.h>
int main()
{
    double i,wage;//单位万元
    printf("输入工资：\n");
    scanf("%lf",&i);
    if(i<=10)
    {
        wage=i*0.1;
    }else if(i>10 && i<=20)
    {
        wage=0.1*10+(i-10)*0.075;
    }else if(i>20 && i<=40)
    {
        wage=0.1*10+10*0.75+(i-20)*0.05;
    }else if(i>40 && i<=60)
    {
        wage=0.1*10+10*0.75+20*0.05+(i-40)*0.03;
    }else if(i>60 && i<=100)
    {
        wage=0.1*10+10*0.75+20*0.05+20*0.03+(i-60)*0.015;
    }else{
        wage=0.1*10+10*0.75+20*0.05+20*0.03+40*0.015+(i-100)*0.01;
    }
    printf("总奖金:%lf万元\n",wage);

}

分析

这个题就是就是用if-else if -else语句来判断奖金

3、题目：输入某年某月某日，判断这一天是这一年的第几天？

#include<stdio.h>
int main()
{
    int day,year,month,days,i;
    int months[]={31,28,31,30,31,30,31,31,30,31,30,31};//非闰年每月天数
    printf("请输入年,月,日:\n");
    scanf("%d,%d,%d",&year,&month,&day);
    days=0;
    if(month<1 || month>12 || day>31)
    {
        printf("输入错误\n");
    }
    else
    {
        if(year%400==0||(year%4==0&&year%100!=0))//闰年判断
        {
            printf("该年为闰年\n");
            for(i=0;i<month-1;i++)//前月数天数相加
            {
                days=days+months[i];
            }
            days=days+day;
        }
        else
        {
            printf("该年不是闰年\n");
            for(i=0;i<month-1;i++)//前月数天数相加
            {
                days=days+months[i];
            }
            days=days+day;
        }
        printf("这是一年的第%d天\n",days);
    }
}

分析

先判断月份和天数是否正确输入，然后判断是否是闰年，在for循环中计算的是前几个月的天数，最后加上当月天数。菜鸟教程思维是：通过开关语句判断是几月，直接得到天数，在加上当月天数。

day5

1、输入三个整数x,y,z，请把这三个数由小到大输出。

#include <stdio.h>
int main()
{
    int x,y,z,t;
    printf("请输入三个数字:\n");
    scanf("%d%d%d",&x,&y,&z);
    if(x>y)//交换x,y
    {
        t=y;//t为较小值
        y=x;
        x=t;
    }
    if(x>z)
    {
        t=z;
        z=x;
        x=t;
    }
    if(y>z)
    {
        t=z;
        z=y;
        y=t;
    }
    printf("%d,%d,%d\n",x,y,z);//输出按x,y,z依次增大
}

分析

3个数分别相互对比，通过一个参数t来交换顺序

2、输出9*9乘法表

#include<stdio.h>
int main()
{
    int i,j;
    for(i=1;i<=9;i++)//控制行
    {
        for(j=1;j<=i;j++)
        {
            printf("%d*%d=%d  ",i,j,i*j);
        }
        printf("\n");
    }
}

分析：通过两个循环来输出，一个循环控制行，一个循环控制每行的数值增加.

3、古典问题（兔子生崽）

有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？（输出前40个月即可）

#include<stdio.h>
long Fib(int n);
int main()
{
    int month;
    printf("请输入月份:\n");
    scanf("%d",&month);
    printf("第%d月的兔子数为:%ld\n",month,Fib(month));
}

long Fib(int n)
{
    long f;
    if(n==0)
    {
        f=0;
    }
    else if(n==1)
    {
        f=1;
    }else
    {
        f=Fib(n-1)+Fib(n-2);
    }
    return f;
}

分析：

先算前几个月的数量，找规律。发现符合1 1 2 3 5 8 13。
规律：前两项相加等于第三项，上述代码是通过函数递归来实现。

而菜鸟教程是直接累加算的

#include<stdio.h>

int main()
{
    int f1=1,f2=1,i;//f1相当与单月，f2为双月
    for(i=1;i<=20;i++)//一个循环算的两个月，
    {
        printf("%12d%12d\n",f1,f2);
        f1=f1+f2;
        f2=f1+f2;
    }
    return 0;
}

day6

1、判断素数

判断 101 到 200 之间的素数

#include<math.h>
int main()
{
    int i,j;
    for(i=101;i<=200;i++)
    {
        for(j=2;j<i;j++)
        {
            if(i%j ==0)//判断非素数，跳出
                break;
        }
        if(j>=i)//最后判断本身,输出素数
            printf("素数:%d\n",i);
    }
    return 0;
}

分析：素数是除了1和它本身以外不再有其他因数;可以通过除以2到n-1(n本身)的结果,整除为素数;程序还需要判断自身来输出
开根号法：从2到\sqrt{}n均整除判断，时间复杂度O(\sqrt{}n)（原因：素数是因子为1和本身，如果数c不是素数，则还有其他因子，其中的因子，假如为a,b.其中必有一个大于sqrt(c) ，一个小于sqrt(c) 。所以m必有一个小于或等于其平方根的因数，那么验证素数时就只需要验证到其平方根就可以了。即一个合数一定含有小于它平方根的质因子。）

2、打印水仙花数

题目：打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。例如：153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方。

#include<stdio.h>
int main()
{
    int a,b,c,i;//a为百位
    for(i=100;i<1000;i++)
    {
        a = i/100;//百位
        b = i%100/10;//十位
        c = i%10;//个位
        if(i==a*a*a+b*b*b+c*c*c)
            printf("输出%d\n",i);
    }
    return 0;
}

分析：

利用取整和取余数求三位数的每个位数，通过循环求其他三位数

3、正整数分解质因数

题目：将一个正整数分解质因数。例如：输入90,打印出90=2*3*3*5。

#include<stdio.h>
int Su(int n); 
int main()
{
    int n,i;
    printf("请输入一个数字:\n");
    scanf("%d",&n);
    printf("%d=",n);
    for(i=2;i<=n;i++)//素数执行
    {
        while(n%i==0)//判断整除作为因子
        {
            printf("%d",i);
            n=n/i;
            if(n!=1)
            {
                printf("*");
            }
        }
    }
    printf("\n");
    return 0;
}

分析：

对n进行分解质因数，应先找到一个最小的质数k（从开始），然后按下述步骤完成

(1)如果这个质数恰等于（小于的时候，继续执行循环）n，则说明分解质因数的过程已经结束，另外打印出即可。
(2)但n能被k整除，则应打印出k的值，并用n除以k的商,作为新的正整数n.重复执行第二步。
(3)如果n不能被k整除，则用k+1作为k的值,重复执行第一步。

day7

1、成绩判断

题目：利用条件运算符的嵌套来完成此题：学习成绩>=90分的同学用A表示，60-89分之间的用B表示，60分以下的用C表示。

#include <stdio.h>

int main(){
    int score;
    printf("请输入成绩:\n");
    scanf("%d",&score);
    if(score<0 || score >100)
        printf("输入错误！");
    else
    {
        if(score<60)
            printf("成绩为C!\n");
        else if(score<=90)
            printf("成绩为B!\n");
        else
            printf("成绩为A!\n");
    }

}

分析：

通过条件语句判断，同时也可以通过switch语句做。

菜鸟教程通过：(a>b)?a:b——————将程序改成grade=(score>=90)?'A':((score>=60)?'B':'C');直接输出

2、求最大公约数和最小公倍数

题目：输入两个正整数m和n，求其最大公约数和最小公倍数。

#include <stdio.h>
int main(){
    int m,n,t;
    int a,b;
    printf("输入两个数字：\n");
    scanf("%d%d",&m,&n);
    a=m;
    b=n;
    if(m<n);//保证m>n
    {
        t=m;
        m=n;
        n=t;
    }
    while(m%n!=0)
    {
        t=m%n;//t作为余数
        m=n;
        n=t;
    }
    printf("最大公约数为%d\n",n);
    printf("最小公约数为%d\n",a*b/n);
}

分析：

最小公倍数=输入的两个数之积除于它们的最大公约数，关键是求出最大公约数；

求最大公约数用辗转相除法（又名欧几里德算法）:

a>b,c=a%b,c为余数，如果c的0,则b为最大公约数；c不为0，将b的值赋给a,c的赋给b,继续执行

3、统计字符个数

题目：输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。

#include <stdio.h>

int main(){
    char n;
    int a=0,b=0,c=0,d=0;
    printf("请输入一些字符串：\n");
    while((n=getchar()) != '\n')
    {
        if((n>='a' && n<='z') || (n>='A' && n<='Z'))//判断字母
            a++;
        else if(n>='0' && n<='9')//判断数字
            b++;
        else if(n==' ')//判断空格
            c++;
        else//其他判断
            d++;
    }
    printf("字母:%d,数字:%d,空格:%d,其他:%d\n",a,b,c,d);
    return 0;
}

利用while语句,条件为输入的字符不为'\n'。

每输入一个字符通过条件语句判断是哪一类，计数加一。

day8

1、求值大小

题目：求s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字。例如2+22+222+2222+22222(此时共有5个数相加)，几个数相加有键盘控制。

#include <stdio.h>
int main()
{
    int a,n,i,k;
    int sum=0;
    printf("请输入a,n:");
    scanf("%d,%d",&a,&n);
    k=a;
    for(i=1;i<=n;i++)
    {
        sum = sum+k;
        k=k*10+a;
    }
    printf("a+aa+...=%d",sum);
    return 0;
}

分析：一道数学题，通过k=k*10+a来保证每位数字一样，关键是求每一项的值

2、求完数

题目：一个数如果恰好等于它的因子之和，这个数就称为"完数"。例如6=1＋2＋3.编程找出1000以内的所有完数。


#include<stdio.h>
int main()
{
    int i,k,j,n;
    int N[300];
    int sum;
    N[0]=1;//因子首位为1
    for(i=2;i<=1000;i++)
    {
        sum=1;
        k=0;

        for(j=2;j<=i/2;j++)//判断质因子
        {
            if(i%j==0)
            {
                sum += j;
                N[++k]=j;
            }
        }
        if(sum==i)//判断是否符合要求，输出等式
        {
            printf("%d=1",i);
            for(n=1;n<=k;n++)//输出各因子相加
            {
                printf("+%d",N[n]);
            }
            printf("\n");
        }
    }

}

分析

这个题跟将一个正整数求质因子有点像，但是求得质因子要完全不一样，质因子存在数组内。

循环条件j<=i/2，是因为j>i/2的话就没有i的因子了

通过累加求和得到sum再与i对比。输出

3、求小球下落高度

#include<stdio.h>
int main()
{
    float h,sum,i;
    h=sum=100;
    h=h/2;
    for(i=2;i<=10;i++)
    {
        sum=sum+h*2;
        h=h/2;//落下后第二次的反弹高度
    }
    printf("共经过%f米\n",sum);
    printf("第10次反弹高度为%f米",h);
    return 0;
}

分析：注意循环为第二次弹起最高点开始。

day9

1、吃桃问题

题目：猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个 第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下 的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。

程序分析：采取逆向思维的方法，从后往前推断。
桃子数量：x前=(x后+1)*2；利用循环可以算出

#include<stdio.h>
int main()
{
    int x,i;
    x=1;
    for(i=0;i<9;i++)
    {
        x=(x+1)*2;//逆推算前一天的桃子
    }
    printf("第一天的桃子数为%d\n",x);
    return 0;
}

2、打出菱形图像

题目：打印出如下图案（菱形）。

分析：先把图形分成两部分来看待，前四行一个规律，后三行一个规律，利用双重for循环

第一层循环控制行，内部第一个循环输出空格；第二个循环输出*号，*号的数量是奇数

#include<stdio.h>
int main()
{
    int i,j,k;
    for(i=1;i<5;i++)
    {
        for(j=0;j<5-i;j++)//输出空格
        {
            printf(" ");
        }
        for(k=0;k<2*i-1;k++)
        {
            printf("*");
        }
        printf("\n");
    }
    for(i=0;i<=2;i++)
    {
        for(j=0;j<=i+1;j++)
        {
            printf(" ");
        }
        for(k=0;k<=4-2*i;k++)
        {
            printf("*");
        }
        printf("\n");
    }
}

day10 阶乘

1

题目：有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13...求出这个数列的前20项之和。

分析：观察分母分子之间的关系，发现下个分子为上个分母分子之和，下个分母为上个分子

#include<stdio.h>
int main()
{
    float a,b,sum,t;
    sum=0;
    a=2;
    b=1;
    for(int i=0;i<20;i++)
    {
        sum=sum+a/b;
        t=a;
        a=a+b;//分子
        b=t;//作为分母
    }
    printf("%f",sum);
}

2 求1+2!+3!+...+20!的和

题目：求1+2!+3!+...+20!的和。

分析：通过m计算在该位的阶乘，直接在上一个阶乘成一个本位就得到该数的阶乘；sum计算累加阶乘之和

#include<stdio.h>
int main()
{
    int i;
    long sum,m;
    m=1;
    sum=0;
    for(i=1;i<=20;i++)
    {
        m=m*i;//计算本位的阶乘
        sum=sum+m;//每个阶乘之和  
    }
    printf("%ld\n",sum);
}

3 递归方法求5！

题目：利用递归方法求5!。

分析：通过递归求阶乘，注意变量最好要设置long

#include<stdio.h>
long Fact(int n);
int main()
{
    int i,n;
    printf("请输入阶乘：\n");
    scanf("%d",&n);
    printf("%d的阶乘为%ld",n,Fact(n));
}

long Fact(int n)
{
    long sum;
    if(n==0)
        sum=1;
    else
        sum=n*Fact(n-1);
    return sum;
}

day11 字符顺序反向打印

题目：利用递归函数调用方式，将所输入的5个字符，以相反顺序打印出来。

分析

next = getchar();在控制面板输入字符串后，可以通过递归的方法输出。
方法有点像取下标，最小的数值对应的最后输出的字符串。

#include <stdio.h>
 
int main()
{
    int i=5;
    void palin(int n);
    printf("请输入5个字符:");
    palin(i);
    printf("\n");
}
void palin(n)
int n;
{
    char next;
    if(n<=1) 
    {
        next=getchar();
        printf("相反顺序输出结果:");
        putchar(next);
    } else {
        next=getchar();
        palin(n-1);
        putchar(next);
    }
}

day12 递归、分为位数

1、递归

题目：有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。问第4个人岁数，他说比第3个人大2岁。问第三个人，又说比第2人大两岁。问第2个人，说比第一个人大两岁。最后问第一个人，他说是10岁。请问第五个人多大？

分析：该题用了递归调用

递归首先要有终止条件，否则会无限递归。

流程：向上级递归，遇到条件，就逐渐回归。

理解：第1级调用
第2级调用
第3级调用
第3级返回
第2级返回
第1级返回

#include <stdio.h>
int Num(int n);
int main()
{
    printf("%d",Num(5));
    return 0;
}

int Num(int n)
{
    int c;//年龄
    if(n==1)//第1个人
        c=10;
    else
        c=Num(n-1)+2;
    return c;

}

2、分解位数

题目：给一个不多于5位的正整数，要求：一、求它是几位数，二、逆序打印出各位数字。

分析：分解得到每一位的数字

a=x%10000/1000 :分出千位；先求余数获取后四位数字，再取整得到千位上的数字。


#include <stdio.h>
int main()
{
    long a,b,c,d,e,x;
    printf("请输入数字:\n");
    scanf("%d",&x);
    a=x/10000;//分解万位
    b=x%10000/1000;
    c=x%1000/100;
    d=x%100/10;
    e=x%10;
    if(a!=0)
        printf("该数为5位数,逆序输出分别是:%ld %ld %ld %ld %ld\n",e,d,c,b,a);
    else if(b!=0)
        printf("该数为4位数,逆序输出分别是: %ld %ld %ld %ld\n",e,d,c,b);
    else if(c!=0)
        printf("该数为3位数,逆序输出分别是: %ld %ld %ld \n",e,d,c);
    else if(d!=0)
        printf("该数为2位数,逆序输出分别是: %ld %ld \n",e,d);
    else
        printf("该数为1位数,逆序输出分别是: %ld \n",e);
    return 0;
}

3、回文数

题目：一个5位数，判断它是不是回文数。即12321是回文数，个位与万位相同，十位与千位相同。

分析：首先得到分解位数的数字，再判断

#include <stdio.h>
int main()
{
    long a,b,c,d,e,x;
    printf("请输入5位数字:\n");
    scanf("%d",&x);
    a=x/10000;//分解万位
    b=x%10000/1000;
    c=x%1000/100;
    d=x%100/10;
    e=x%10;
    if(a==e && b==d)
        printf("该数位回文数\n");
    else
        printf("该数不是回文数\n");
    return 0;
}

day13 删除指定字母，字符判断

1、字符判断

题目：请输入星期几的第一个字母来判断一下是星期几，如果第一个字母一样，则继续判断第二个字母。

分析:字符判断

输入第二次字符时注意要吃掉上次输入的空格。

本题通过switch语句字符串选择

#include<stdio.h>
int main()
{
    char ch1,ch2;
    printf("请输入第一个字母:\n");
    ch1=getchar();
    getchar();//吃掉上次输入的空格
    switch(ch1)
    {
        case 'm':
            printf("this is monday\n");
            break;
        case 'w':
            printf("this is wednesday");
            break;
        case 'f':
            printf("this is friday");
            break;
        case 't':
            printf("请输入第二个字母:\n");
            ch2=getchar();
            if(ch2=='u')
                printf("this is tuesday\n");
                break;
            if(ch2='h')
                printf("this is thursday\n" );
                break;
        case 's':
            printf("请输入第二个字母:\n");
            ch2=getchar();
            if(ch2=='a')
                printf("this is saturday\n");
                break;
            if(ch2=='u')
                printf("this is sunday\n" );
                break;
        default:
            printf("error");
    }
    return 0;
}

2、删除指定字母

题目：删除一个字符串中的指定字母，如：字符串 "aca"，删除其中的 a 字母。

分析：本题需要用到字符串的知识。

建立函数删除字母的函数，注意返回的是字符串，所以要设置成指针型函数。

将字符串指针作为函数参数传入，并返回该指针。

字符串没有内容的都是'\0'，可以以他作为结束条件；

思路：
同样的道理，定位当前没有和目标字符相匹配的字符位置，当后面字符出现与目标字符不相匹配的字符时，只将其移动到前一个字符后面即可，后面未查询的字符不跟着往前移动。如此直到最后整个字符串匹配完。

#include<stdio.h>
#define N 10
char* Delchar(char *str,char ch);
int main()
{
    char ch;
    char str[N];
    printf("请输入字符串:\n");
    scanf("%s",&str);
    printf("输入需要删减的字符串:\n");
    scanf(" %c",&ch);
    printf("输出字符%s",Delchar(str,ch));
    return 0;
}

char* Delchar(char *str,char ch)
{
    int i,j=0;

    for(i=0;str[i] != '\0';i++)
    {
        if(str[i]!=ch)
            str[j++]=str[i];
    }
    str[j]='\0';
    return str;
}

day14 判断质数

题目：判断一个数字是否为质数。

分析：质数的因子不能有2（2除外），在判断条件中限制条件。

首先对2取余判断，然后再对奇数取余判断；奇数不大于本身的1/2。

#include<stdio.h>
int main()
{
    int n,i,j=0,k=0;
    printf("请输入一个数:");
    scanf("%d",&n);
    if(n%2==0 && n!=2)
    {
        k=1;
        //printf("该数不是素数");
    }else{
        for(i=2;i<=n/2+1;i++)
        {
            j=2*i-1;
            if(n%i==0 && n!=2)
            {
                k=1;
                //printf("该数不是素数");
                break;
            }
        }
    }
    if(k==0)
       printf("%d为素数",n); 
    else
        printf("%d不是素数",n);
    return 0;
}

day15 字符串反转

题目：字符串反转，如将字符串 "www.runoob.com" 反转为 "moc.boonur.www"。

分析：先建立一个空的字符数组，通过for循环来存储反向打印的字符串。

进而实现两组字符串数组首尾交换顺序来实现字符串反向打印。

#include<stdio.h>
#include<string.h>
#define N 50
int  main()
{
    char str[N];
    char str1[N];
    int n,i;
    printf("请输入字符串:");
    scanf("%s",&str);
    n=strlen(str);
    for(i=0;i<n;i++)
    {
        str1[n-1-i]=str[i];
    }
    str1[n]='\0';//字符串结束标志
    printf("输出相反字符串:%s",str1);
    return 0;
}

day17 选择法排序

题目：对10个数进行排序。

程序分析：可以利用选择法，即从后9个比较过程中，选择一个最小的与第一个元素交换，下次类推，即用第二个元素与后8个进行比较，并进行交换。

通过数组存储数字，在比较时的那个循环注意初始条件是j=i+1，if条件语句内是交换两数

#include<stdio.h>
#define N 10
int main()
{
    int n[N];
    int i,j,temp;
    printf("请输入10个数字:\n");
    for(i=0;i<10;i++)
    {
        scanf("%d",&n[i]);
    }
    for(i=0;i<10;i++)
    {
        for(j=1+i;j<10;j++)//j至少要比i大
        {
            if(n[i]>=n[j])//成立，交换顺序
            {
                temp=n[j];
                n[j]=n[i];
                n[i]=temp;

            }
        }
    }
    printf("排序如下\n");
    for(i=0;i<10;i++)
    {
        printf("%d ",n[i]);
    }
}

day18 二维数组求对角线之和

题目：求一个3*3矩阵对角线元素之和

分析：通过一个二维数组，两个for循环来实现数据输入和对角线求和

#include<stdio.h>
#define N 3
int main()
{
    int a[N][N];
    int i,j,sum=0;
    printf("请输入矩阵（3*3）:\n");
    for(i=0;i<3;i++)//控制行
    {
        for(j=0;j<3;j++)//控制列
        {
            scanf("%d",&a[i][j]);
            if(i==j)
                sum=sum+a[i][j];
        }
    }
    printf("斜右下对角线之和为:%d\n",sum);
    return 0;
}

day19 数组排序插入数字

题目：有一个已经排好序的数组。现输入一个数，要求按原来的规律将它插入数组中。

分析：用一组数组复制之前的原始数组内容；第二个for循环作为判断插入数字的位置；第三个for循环作为插入数字的排序并且输出

#include<stdio.h>
#define N 15
int  main()
{
    int a[N]={1,4,6,9,13,16,19,28,40,100};
    int b[N];
    int i,n,j;
    printf("输入插入的数字:");
    scanf("%d",&n);
    printf("原始数组:\n");
    for(i=0;i<10;i++)//输出数组，存储一组数组
    {
        printf("%d ",a[i]);
        b[i]=a[i];
    }
    printf("\n");
    for(i=0;i<10;i++)//判断插入数字的位置
    {
        if(n<=a[i])
            break;
    }
    printf("插入后的数组为:\n");
    for(j=0;j<11;j++)//重新排序
    {
        if(j>=i)//判断插入数据的位置
        {
            if(j==i)
                a[j]=n;
            else
                a[j]=b[j-1];
        }
        printf("%d ",a[j]);
    }
    return 0;
}

day20

static学习

题目：学习static定义静态变量的用法。

分析：static是静态存储，而内存分为四大区，其中全局变量和静态变量都存储在全局区，生存周期直到程序结束

可以理解成全局变量；

static int 不管在函数内还是函数外，都作为一个全局变量可以保存它被修改以后的值。

而 int 则没有这一功能，只有作为全局变量时能保存修改。放在函数内部时，每次调用都用的是一个新的数。

#include<stdio.h>
void Fun();
int main()
{
    int i;
    for(i=0;i<2;i++)
        Fun();
    return 0;
}

void Fun()
{
    int a=21;
    static int j=11;//静态变量；相当于全局变量
    printf("a=%d\n",a);
    printf("j=%d\n",j);
    j++;
    a++;
}

1.1另一种用法

#include <stdio.h>
int main()
{
    int i,num;
    num=2;
    for(i=0;i<3;i++)
    {
        printf("num 变量为 %d \n",num);
        num++;
        {
            static int num=1;
            printf("内置模块 num 变量为 %d\n",num);
            num++;
        }
    }
    return 0;
}

2、auto学习

题目：学习使用auto定义变量的用法。

分析：在C语言中，使用 auto 修饰的变量，是具有自动存储器的局部变量

#include <stdio.h>
int main()
{
    int i,num;
    num=2;
    for(i=0;i<3;i++)
    {
        printf("num 变量为 %d \n",num);
        num++;
        {
            auto int num=1;
            printf("内置模块 num 变量为 %d \n",num);
            num++;
        }
    }
    return 0;
}

register学习

在C语言中的register修饰的变量表示将此变量存储在CPU的寄存器中，由于CPU访问寄存器比访问内存快很多，可以大大提高运算速度

#include <stdio.h>
int main()
{
    register int i;
    int tmp=0;
    for(i=1;i<=100;i++)
        tmp+=i;
    printf("总和为 %d\n",tmp);
    return 0;
}

宏定义练习1

了解常见宏定义的方法

#include <stdio.h>
#define N 5   
#define G(x) 2*(x)*(x)//宏定义函数G(x);内容为2*x*x
#define exchange(a,b) { int t;t=a;a=b;b=t;}//注意放在一行里
int main()
{
    int n;
    n=N;
    printf("数字平方和:%d\n",G(n));
    float x=10.32;
    int y=20;
    printf("x=%f; y=%d\n",x,y);
    exchange(x,y);
    printf("x=%f; y=%d\n",x,y);
    return 0;
}

day21 打印杨辉三角形

题目：打印出杨辉三角形（要求打印出10行）。

通过二维数组来输出行和列，第一长度代表行，第二长度代表列；

写出第一行，第二行特殊值；

找出杨辉三角形规律，一行的第一个和最后一个都为1，其他全是上一行对应的两数之和，通过两层嵌套循环即可求出。

#include<stdio.h>
#define N 10
int main()
{
    int i,j;
    int a[N][N];
    int n;
    scanf("%d",&n);
    a[0][0]=1;
    a[1][0]=1;
    a[1][1]=1;
    if(n==1){
        printf("%d\n",a[0][0]);;
    }else if(n==2)
    {
        printf("%d\n",a[0][0]);
        printf("%d %d\n",a[1][0],a[1][1]);
    }
    else
    {
        printf("%d\n",a[0][0]);
        printf("%d %d\n",a[1][0],a[1][1]);
        for(i=2;i<n;i++)//从第三行开始
    {
        for(j=0;j<=i;j++)
        {
            if(j==0)//判断最左边
            {
                a[i][j]=1;
            }
            else if(j==i)//判断最右边
            {
                a[i][j]=1;
            }
            else{
                a[i][j]=a[i-1][j-1]+a[i-1][j];
            }
            printf("%d ",a[i][j]);            
        }
        printf("\n");
    }
    }
    return 0;
 
}

宏定义练习2

//宏定义还可以定义符号
#define LAG >
#define SMA <
#define EQ ==
#include <stdio.h>
int main()
{
    int i,j;
    printf("请输入两个数字：\n");
    scanf("%d %d",&i,&j);
    if(i LAG j)
        printf("%d 大于 %d \n",i,j);
    else if(i EQ j)
        printf("%d 等于 %d \n",i,j);
    else if(i SMA j)
        printf("%d 小于 %d \n",i,j);
    else
        printf("没有值。\n");
    return 0;
}

day22 指针练习1（两数交换）

题目：输入3个数a,b,c，按大小顺序输出。

程序分析：利用指针方法。

设置函数指针作为交换两个数字，实参变量的地址是指针形参；如果没用函数指针，普通函数要在最后有return 返回两个数。

#include <stdio.h>
void Exchange(int *par1,int *par2);
int main()
{
    int a,b,c;
    int *pa=&a,*pb=&b,*pc=&c;//指针初始化;等价下面4个语句
    // int *pa,*pb,*pc;
    // pa=&a;
    // pb=&b;
    // pc=&c;
    printf("输入三个数字:\n");
    scanf("%d%d%d",&a,&b,&c);
    if(a<b)
        Exchange(&a,&b);
    if(a<c)
        Exchange(&a,&c);
    if(b<c)
        Exchange(&b,&c);
    printf("从大到小顺序:%d,%d,%d\n",a,b,c);
}

void Exchange(int *par1,int *par2)//两数交换
{
    int temp;
    temp=*par1;
    *par1=*par2;
    *par2=temp;
}

day23 数组元素交换

题目：输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。

分析：首先初始化，通过第二个循环中的if语句来判断出数组中的最大值和最小值，再调用函数指针实现两数交换。

最后输出数组。

#include<stdio.h>
#define N 20
void Swipe(int *pstr1, int *pstr2);
int main()
{
    int a[N],i,j,max,min,k,n;
    printf("请输入数组个数:\n");
    scanf("%d",&n);
    printf("输入数组:\n");
    for(i=0;i<n;i++)//输入数组
    {
        scanf("%d",&a[i]);
    }

    max=a[0];//初始化
    min=a[0];
    k=0;
    j=0;

    for(i=1;i<n;i++)//判断数组中最大值和最小值
    {
        if(max<=a[i])//判断最大值
        {
            max=a[i];
            j=i;//记录位置
        }
        if(min>=a[i])//判断最小值
        {
            min=a[i];
            k=i;
        }
    }
    Swipe(&a[0],&a[j]);//最大值交换
    Swipe(&a[n-1],&a[k]);//最小值交换
    printf("转换后数组:\n");
    for(i=0;i<n;i++)
    {
        printf("%d  ",a[i]);
    }
}

void Swipe(int *pstr1,int *pstr2)//交换两数
{
    int temp;
    temp=*pstr1;
    *pstr1=*pstr2;
    *pstr2=temp;
}

day24 数组整体后移动

题目：有 n个整数，使其前面各数顺序向后移 m 个位置，最后m个数变成最前面的 m 个数。

分析：通过两个数组来实现功能，第二个循环是将数组内后面的m个数向前面移动，注意关系：b[m-1-i]=a[n-1-i]。

第三个循环是将前面的数字向后移动m个，关系：b[m+i]=a[i]。

#include <stdio.h>
#define N 20
int main()
{
    int n,i,m;
    int a[N];
    int b[N];
    printf("确定数组的数字个数：\n");
    scanf("%d",&n);
    printf("输入数组数字:\n");
    for(i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
        b[i]=a[i];
    }
    printf("输入向后移动m个数:\n");
    scanf("%d",&m);
    for(i=0;i<m;i++)//后面m个数前移
    {
        b[m-1-i]=a[n-1-i];
    }
    for(i=0;i<n-m;i++)//前面的数字往后面移动
    {
        b[m+i]=a[i];//
    }
    printf("输出数组为\n");
    for(i=0;i<n;i++)
    {
        printf("%d ",b[i] );
    }    
}

day25 求字符串长度

题目：写一个函数，求一个字符串的长度，在 main 函数中输入字符串，并输出其长度。

注意传入函数形参的要用字符串首地址；

可以通过字符串最后结尾的"\0"来判断是否结束。

循环通过字符数组地址加一（pstr1++）,内容*pstr1!="\0"作为作为条件判断

#include <stdio.h>
int Length(char *str1);
#define N 80
int main()
{
    char str[N];
    printf("输入字符串:\n");
    scanf("%s",str);
    printf("字符串长度为%d\n",Length(str));
    return 0;
}

int Length(char *str1)
{
    int i=0;
    while(*str1 != '\0')//字符串对应的内容不为"\0"
    {
        i++;
        str1++;//地址加一
    }
    return i;
}

day26 报数出圈问题

题目：有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，问最后留下的是原来第几号的那位

分析

利用数组的“0”和“1”的数值表示玩家存在与不存在的两种状态，对数组进行多次重复循环。

每次循环到最后一位数组元素后又从下标0开始循环，每次循环利用计数累加，计数器遇3重并把人数减1，直到人数减到1时循环结束。最后就是输出剩下人的号数。

#include <stdio.h>
#define N 80
int main()
{
    int n,i,j,k;
    int con=0;//记录
    int num[N];
    k=0;
    printf("请输入圈子里的人数:\n");
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
        num[i]=1;//1代表玩家存在
    }
    while((n-k) != 1)//
    {
        for(i=0;i<n;i++)
        {
            if(num[i]==1)
            {
                con++;//计数1到3
                if(con==3)
                {
                    num[i]=0;//0代表第三人出圈
                    con=0;//初始化计数
                    k++;//k代表着出局人数
                }
            }
            
        }
    }
    for(i=0;i<n;i++)//判断剩下的人
    {
        if(num[i]==1)
        {
            printf("最后留下是第%d号\n",i+1);
        }
    }
    return 0;
}

day27 结构体学习

题目：编写input()和output()函数输入，输出5个学生的数据记录

访问结构体成员：结构体变量名.成员名

向函数传递结构体：向函数传递结构体的首地址

#include <stdio.h>
#define N 80

typedef struct student
{
    char name[10];//姓名
    char sex[10];//性
    int age;//年龄
}STU;

void Input(STU *stu);
void Ouput(STU *stu);
int main()
{
    STU student[5];
    printf("输入5个学生信息:\n");
    Input(student);
    printf("输出5个学生信息：\n");
    Ouput(student);
    return 0;
}

void Input(STU *stu)
{
    int i;
    for(i=0;i<5;i++)
    {
        scanf("%s%s%d",&stu[i].name,&stu[i].sex,&stu[i].age);
    }
}

void Ouput(STU *stu)
{
    int i;
    for(i=0;i<5;i++)
    {
        printf("%s %s %d\n",stu[i].name,stu[i].sex,stu[i].age);
    }
}

day28 整数反转输出

题目：输入一个整数，并将其反转后输出。

分析：利用取余和取整之间的关心转换。

取余的数加上a*10就是反转的数.

#include <stdio.h>
int main()
{
    long n,a;
    a=0;
    printf("请输入数字:\n");
    scanf("%ld",&n);
    //初始化
    a=n%10;//取个位
    n=n/10;
    while(n!=0)
    {
        a= a*10+n%10;
        n= n/10;//取整
    }
    printf("反转的数字为:%ld\n",a);
    return 0;
}

day29 指针函数学习

题目：编写一个函数，输入n为偶数时，调用函数求1/2+1/4+...+1/n,当输入n为奇数时，调用函数1/1+1/3+...+1/n(利用指针函数)。

在本题中学习了指针函数的使用。

格式：数据类型（*指针变量名）（形参列表）；

#include <stdio.h>
void Fun(int a,double (*f)(int));
double Dou(int n);//偶数输入
double Jou(int n);//奇数输入

int main()
{
    int n;
    double (*f)(int,int);
    printf("请输入数字：\n");
    scanf("%d",&n);
    if(n%2==1)//奇数
    {
        Fun(n,Jou);
    }
    else//偶数
    {
        Fun(n,Dou);
    }
    return 0;
}
void Fun(int a,double (*f)(int))
{
    double result;
    result=(*f)(a);
    printf("输出的结果为；%lf",result);
}

double Dou(int n)
{
    double i;
    double sum=0;
    for(i=1;2*i<=n;i++)
    {
        sum = sum +1/(2*i);
    }
    return sum;
}

double Jou(int n)
{
    double i;
    double sum=0;
    for(i=1;2*i-1<=n;i++)
    {
        sum = sum +1/(2*i-1);
    }
    return sum;
}

day30 指向指针变量的学习

题目：（指向指针的指针）。

如果一个指针变量存放的又是另一个指针变量的地址，则称这个变量为指向指针的指针变量或指向指针的指针。

定义方式：数据类型 **变量名;

在指针变量说明中，“*”是类型说明符，表示其后的变量是指针类型，而表达式中出现的“*”则是一个运算符用以表示指针变量所指的变量。

int a=10;        //地址为&a
int *p=&a;        //指针地址为&p    如果是p就是a的地址
int **p1=&p;        //指针地址为&p1     如果是*p1就是&p</span>

#include<stdio.h>
#include<stdlib.h>
int main()
{
    const char *s[]={"man","woman","girl","boy","sister"};
    const char **q;//定义指向指针的指针变量
    int k;
    for(k=0;k<5;k++)
    {
        q=&s[k];       /*在这里填入内容*/
        printf("%s\n",*q);//*p指的对应地址的内容
    }
    return 0;
}

day31

#include<stdio.h>
#include<stdlib.h>
struct man{
    char name[20];
    int  age;
}
person[3]={"li",18,"wang",25,"sun",22};
int main()
{
    struct man *q,*p;
    int i,m=0;
    p=person;
    for(i=0;i<3;i++)
    {
        if(m<p->age)
        {
            m=p->age;
            q=p;
        }
        p++;
    }
    printf("%s %d\n",q->name,q->age);
    return 0;
}

三个年龄都是 0 的时候不行 q 没赋初值，下面加了个 q=p=person，再就是年龄相等且为最大值的时候应同时输出，改进之后程序如下

#include<stdio.h>
#include<stdlib.h>
struct man{
    char name[20];
    int  age;
}
person[3]={{"li",18},{"wang",22},{"sun",22}};
int main()
{
    struct man *q,*p;
    int i,m=0;
    p=q=person;
    for(i=0;i<3;i++)
    {
        if(m<p->age)//判断大小
        {
            m=p->age;//m记录最大值
            q=p;
        }
        p++;
    }
    for(int k=0;k<3;k++)//判断是否有年龄相同的人
    {
        if(m == person[k].age)
        {
            printf("%s %d\n",person[k].name,person[k].age);
        }
    }
    return 0;
}

桃子问题

题目：海滩上有一堆桃子，五只猴子来分。第一只猴子把这堆桃子平均分为五份，多了一个，这只猴子把多的一个扔入海中，拿走了一份。第二只猴子把剩下的桃子又平均分成五份，又多了一个，它同样把多的一个扔入海中，拿走了一份，第三、第四、第五只猴子都是这样做的，问海滩上原来最少有多少个桃子？

分析：最后一只猴子待分配的桃子数一定能被4整除。

若a表示本轮猴子拥有的桃子数，b表示下一个猴子拥有的桃子数。

那么他们要满足a=b*5/4+1这个关系，且b必须要被4整除才行，所有用if条件语句判断。

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int j,sum,i;
    j=1;
    while(i<5)
    {
        sum=4*j;//满足最开始
        for(i=0;i<5;i++)
        {
            if(sum%4!=0)//sum的值必须能被4整除
            {
                break;
            }
            sum=sum*5/4+1;
        }
        j++;
    }
    printf("最少得到的桃子数量为:%d\n",sum);

}

day32 求等式的解

题目：809*??=800*??+9*?? 其中??代表的两位数, 809*??为四位数，8*??的结果为两位数，9*??的结果为3位数。求??代表的两位数，及809*??后的结果。

分析：主要是对题目的条件判断求解

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int i;
    long sum1,sum2;
    for(i=10;i<100;i++)
    {
        sum1=809*i;//左边
        sum2=800*i+9*i;//右边
        if(sum1==sum2)//满足条件
        {
            if(809*i>=1000 && 809*i<10000 && 8*i>9 && 8*i<100 && 9*i>99 && 9*i<1000)
            {
                break;
            }
        }
    }
    printf("%ld=800*%d+9*%d",sum1,i,i);
    printf("求得的两位数为：%d\n",i);
    printf("求得的结果为:%ld\n",sum1);
    return 0;
}

day33 8进制转换10进制

题目：八进制转换为十进制

开始的写的代码，跳出循环有问题，就是最高位总是没有计算

#include<stdio.h>
#include<math.h>
int main()
{
    int i,n,a;
    long sum=0;
    i=0;
    printf("请输入8进制的数:\n",&n);
    scanf("%d",&n);
    do{
        a=n%10;//求每位的数
        n=n/10;
        sum=sum+a*pow(8,i);
        i++;
    }while(n/10!=0);
    printf("转换后的10进制的数为:%ld\n",sum);
    return 0;
}

改进分析;第一个循环是用来判断位数，第二个循环就用来转换成10进制。

#include<stdio.h>
#include<math.h>
int main()
{
    int i,n,a,j;
    long sum=0;
    j=0;
    printf("请输入8进制的数:\n",&n);
    scanf("%d",&n);
    i=n;
    while(i/10 != 0)//j就是来判断有几位
    {
        j++;
        i=i/10;
    }
    j++;
    for(i=0;i<j;i++)
    {
        a=n%10;//求每位的数
        n=n/10;
        sum=sum+a*pow(8,i);
    }
    printf("转换后的10进制的数为:%ld\n",sum);
    return 0;
}

day34 求0—7所能组成的奇数个数

题目：求0—7所能组成的奇数个数

这个问题其实是一个排列组合的问题，当一个数的最后一位为奇数时，那么这个数一定为奇数，不管前面几位是什么数字。如果最后一位数为偶数，则这个数一定为偶数。

=0。

从该数为一位数到该数为8位数开始统计奇数的个数：

1.当只有一位数时也就是该数的最后一位，奇数个数为4
2.当该数为两位数时，奇数个数为4*7=28
3.当该数为三位数时，奇数个数为：4*8*7=224
....以此类推

循环内用了if条件语句，主要是判断第几位时的计算

#include<stdio.h>
int main()
{
    int i;
    long sum,sum1=0;

    for(i=1;i<=8;i++)
    {
        if(i==1)
        {
            sum=4;
        }
        else if(i==2)
        {
            sum=sum*7;
        }
        else
        {
            sum=sum*8;
        }
        printf("第%d位数时有%ld个奇数\n",i,sum);
        sum1 += sum;
    }
    printf("总的奇数有%ld个\n",sum1);
    return 0;
}

day35 偶数表示两个素数之和

题目：一个偶数总能表示为两个素数之和。
分析：1不是素数，2是最小素数

首先要有一个函数来判断是否是素数。

通过循环同时判断i和n-i是否满足是素数的要求。

#include<stdio.h>
int Number_1(int b);
int main()
{
    int n,i,a;
    printf("请输入一个偶数\n");
    scanf("%d",&n);
    if(n==2)
    {
        printf("2不能分解素数之和:");
    }
    else
    {
        for(i=2;i<n;i++)
        {
            if(Number_1(i)==1)//判断为i为素数
            {
                if(Number_1(n-i)==1)//判断n-1是否为素数
                {
                    break;
                }
            }
        }
        printf("偶数%d可以分解为%d和%d之和",n,i,n-i);
    }
    return 0;
}

int Number_1(int b)//判断质数
{
    int i;
    int k=0;
    if(b==2)
    {
        k=1;
    }
    for(i=2;i<b;i++)
    {
        if(b%i==0)//判断非素数
        {
            break;
        }
        if(i==b-1)//判断本身，确定为素数
        {
            k=1;
        }
    }
    return k;
}

day 36 解密

题目：某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，加密规则如下：每位数字都加上5,然后用和除以10的余数代替该数字，再将第一位和第四位交换，第二位和第三位交换。

分析：用数组存储每个位数的数字，第一个循环判断加5后是否超值，第二个循环相当于交换数字。

#include<stdio.h>
int main()
{
    int n,i;
    int a[4];
    int sum;
    printf("输入4个数字:\n");
    scanf("%d",&n);
    a[0]=n/1000;
    a[1]=n%1000/100;
    a[2]=n%100/10;
    a[3]=n%10;
    for(i=0;i<4;i++)
    {
        if(a[i]+5>=10)
        {
            a[i] -= 5;
     
        }else{
            a[i] += 5;
        }
    }
    sum=a[3];
    for(i=1;i<4;i++)
    {
        sum=a[3-i]+sum*10;
    }
    printf("加密后的密码:%d",sum);
    return 0;
}

day38 十六进制转十进制

题目:从键盘输入一个不超过8位的正的十六进制数字符串，将它转换为正的十进制数后输出。
注：十六进制数中的10~15分别用大写的英文字母A、B、C、D、E、F表示。

分析：循环1次是为了执行16进制每一位转换成10进制，通过if条件语句来判断字符串中1到9，A到F，sum来存储十进制的值。

但是sum的数值大小最好用unsigned int 来定义，因为满足条件题目最大条件刚好是该类型的最大值。

同时要注意字符串输入的第一个字符是数字的最高位，转换时要开始要从最低位算起。

#include<stdio.h>
#include<string.h>
#include<math.h>
#define N 8
int main()
{
    int i,k,j;
    char s1[N];
    unsigned long sum=0;
    scanf("%s",s1);

    k=strlen(s1);
    for(j=k-1,i=0;j>=0;j--,i++)
    {
        if(s1[j]>='0' && s1[j]<='9')
        {
            sum += (s1[j]-'0')*pow(16,i);
        }
        if(s1[j]>='A' && s1[j]<='F')
        {
            sum += (s1[j]-'A'+10)*pow(16,i);
        }
    }
    printf("%u\n",sum);
    return 0;
}

day39 十进制转十六进制

题目：十六进制数是在程序设计时经常要使用到的一种整数的表示方式。它有0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F共16个符号，分别表示十进制数的0至15。十六进制的计数方法是满16进1，所以十进制数16在十六进制中是10，而十进制的17在十六进制中是11，以此类推，十进制的30在十六进制中是1E。
给出一个非负整数，将它表示成十六进制的形式。

分析：

第一个循环是判断16进制转换计算次数，同时在字符串后面加个'\000'来结束，否则会输出其他乱码。

第二循环是16进制转换成10进制，通过求余和取整来计算，求余得到的1到9直接用ASCLL码值转换，10到15用开关语句来转换。

注意输出的字符串要反转一下

#include<stdio.h>
#include<string.h>
#define N 10
char *Ex(char *str);
int main()
{
    int n,i,a,k,j;
    char s[N];
    scanf("%d",&n);
    k=1;
    i=n;
    while(i/16!=0)//计算n的位数
    {
        i=i/16;
        k++;
    }
    j=0;
    s[k]='\000';//字符串结束标志
    for(i=0;i<k;i++)
    {
        a=n%16;
        n=n/16;
        if(a>=0 && a<=9)
        {
            a+=48;
            s[j]=(char)a;
            j++;
        }else if(a>=10 && a<=15){
            switch(a){
                case 10:s[j]='A';j++;break;
                case 11:s[j]='B';j++;break;
                case 12:s[j]='C';j++;break;
                case 13:s[j]='D';j++;break;
                case 14:s[j]='E';j++;break;
                case 15:s[j]='F';j++;break;
            }

        }
    }
    printf("%s",Ex(s));
    return 0;
}
char *Ex(char *str)//返回字符串需要用到指针函数（函数名前加*）
{
    static char s3[N];//static将s3变为全局变量，不加则不能返回函数内定义的字符串
    int i,k;
    k=strlen(str);
    for(i=0;i<k;i++)
    {
        s3[k-1-i]=str[i];
    }
    return s3;
}

day40 特殊回文数

问题：123321是一个非常特殊的数，它从左边读和从右边读是一样的。
输入一个正整数n，编程求所有这样的五位和六位十进制数，满足各位数字之和等于n 。

输出要求：输出的数字是从小到大

回文数比较特殊，可以通过3层嵌套循环来实现每位数字的自加，再用一个条件语句来判断和值是否相等，注意最高位的数字范围是1到9，其他的数字范围是0到9。

用一个数组来存储满足条件的数字，最后可以在通过2层嵌套循环来实现交换数字，进而达到输出的数字从小到大

#include<stdio.h>
int main()
{
    int n,i,j,k,b;
    int a[100];
    scanf("%d",&n);
    b=-1;
    for(i=1;i<10;i++)//5位数判定
    {
        for(j=0;j<10;j++)
        {
            for(k=0;k<10;k++)
            {
                if((2*i+2*j+k)==n)
                {
                    b++;
                    a[b]=i*10000+j*1000+k*100+j*10+i;
                }
            }
        }
    }
    for(i=1;i<10;i++)//6位数判定
    {
        for(j=0;j<10;j++)
        {
            for(k=0;k<10;k++)
            {
                if((2*i+2*j+2*k)==n)
                {
                    b++;
                    a[b]=i*100000+j*10000+k*1000+k*100+j*10+i;
                }
            }
        }
    }
    for(i=0;i<=b;i++)//大小交换顺序
    {
        for(j=i+1;j<=b;j++)
        {
            if(a[i]>a[j])
            {
                k=a[i];
                a[i]=a[j];
                a[j]=k;
            }
        }
    }
    for(i=0;i<=b;i++)
    {
        printf("%d\n",a[i]);
    }
    return 0;
}