在屏幕上显示Hello World! 0101.c 

编写程序，在屏幕上显示"Hello World!"。

程序运行结果如下：
Hello World!

注意：“Hello World!”可复制到程序中。
#include <stdio.h>

int main()
{
    printf("Hello World!");
    return 0;
}

加法计算器程序 0102.c 

编写程序，求用户从键盘输入的任意两个数的的和。

程序运行结果如下：
输入：
45.8 54.7
输出：
100.5
#include <stdio.h>

int main()
{
    float a, b;
    scanf("%f%f", &a, &b);
    printf("%g", a + b);
    return 0;
}

显示生日卡 0103.c 

显示生日卡。该程序首先要求输入收信人和发信人的姓名（一个人的姓名之间无空格），然后在屏幕上显示出完整的生日卡。

程序运行结果如下：
输入：
zhang wang
输出：
====================================
My dear zhang,
  Happy birthday to you!
            yours,
            wang
====================================

注：上面每行输出的等号“=”有36个，逗号为英文逗号。
#include <stdio.h>

int main()
{
    char to[255], from[255];
    scanf("%s%s", to, from);
    printf("====================================\n"
           "My dear %s,\n"
           "Happy birthday to you!\n"
           "yours,\n"
           "%s\n"
           "====================================", to, from);
    return 0;
}

计算万有引力 0104.c 

编写程序，计算两个星球之间的万有引力。
两个星球的质量m1,m2由用户从键盘输入，单位为kg（千克）。
两个星球的质量R由从用户从键盘输入，单位为m（米）。
万有引力衡量为G=6.67E-11( N.m.m/(kg.kg) 牛顿.米.米/(千克.千克)。
万有引力的计算公式为：
F=G*m1*m2/R/R

程序的运行结果如下所示：
输入(三个数据依次为：m1, m2和R)：
1.987E30 5.975E24
1.495E11
输出：
3.54307e+022
#include <stdio.h>

#define G 6.67E-11

int main()
{
    float m1, m2, R;
    scanf("%f%f%f", &m1, &m2, &R);
    printf("%g", G * m1 * m2 / (R * R));
    return 0;
}

乘法计算器 0105.c 

编写一个乘法计算器程序。用户输入两个数，计算它们的乘积并显示。 程序运行结果如下： 输入： 3.4 72 输出： 244.8
#include <stdio.h>

int main()
{
    float a, b;
    scanf("%f%f", &a, &b);
    printf("%g", a * b);
    return 0;
}

带日期的生日卡程序 0106.c 

修改例1-4的生日卡程序，使其能够输入和显示日期。

程序运行结果如下：
输入：
zhang
wang
2010.9.1
输出：
====================================
My dear zhang,
  Happy birthday to you!
            yours,
            wang
            2010.9.1
====================================
#include <stdio.h>

int main()
{
    char to[255], from[255], date[255];
    scanf("%s%s%s", to, from, date);
    printf("====================================\n"
           "My dear %s,\n"
           "Happy birthday to you!\n"
           "yours,\n"
           "%s\n"
           "%s\n"
           "====================================", to, from, date);
    return 0;
}

计算sin(x)+exp(x)的定积分 0107.c 

参考例1-5，使用梯形法计算函数sin(x)+exp(x)的定积分的值。积分区间等分份数为200，积分区间在[-1,1]内由用户输入。
程序运行结果如下：
输入：
0 1
输出：
2.17798

提示：sin(x), exp(x)是两个数学函数，给出x可以计算出函数值，需要在程序开头包含头文件cmath，用法：#include<cmath>
#include <stdio.h>
#include <math.h>

#define N 200

float f(float x)
{
    return sin(x) + exp(x);
}

int main()
{
    float a, b, x1, x2, s;
    scanf("%f%f", &a, &b);
    s = 0;
    for (int i = 0; i < N; ++i)
    {
        x1 = a + (b - a) * i / N;
        x2 = a + (b - a) * (i + 1) / N;
        s += (x2 - x1) * (f(x2) + f(x1)) / 2;
    }
    printf("%g", s);
    return 0;
}

计算矩形面积 0108.c 

编写程序，计算矩形面积。面积计算要编写为 一个函数。
程序运行结果如下：
输入：
3 5
输出：
15
#include <stdio.h>

int main()
{
    float a, b;
    scanf("%f%f", &a, &b);
    printf("%g", a * b);
    return 0;
}

取一个整型变量的最低8位 0201.c 

编写程序，取整数的二进制的低八位，并显示其对应的十进制数。如一个十进制整数2010，它的二进制是11111011010B，它的低八位是11011010B，转换为十进制是218。

程序运行结果如下：
输入：
2010
输出：
218
#include <stdio.h>

int main()
{
    int x;
    scanf("%d", &x);
    printf("%d", x & 0xff);
    return 0;
}

根据三边长求三角形面积 0202.c 

用户输入三角形的三个边的程度，计算三角形的面积。

程序运行结果如下：
输入：
3 4 5
输出：
6
#include <stdio.h>
#include <math.h>

int main()
{
    float a, b, c, p, s;
    scanf("%f%f%f", &a, &b, &c);
    p = (a + b + c) / 2;
    s = p * (p - a) * (p - b) * (p - c);
    s = sqrt(s);
    printf("%g", s);
    return 0;
}

求一元二次方程ax2+bx+c=0的根 0203.c 

编写程序，用户输入一元二次方程的系数，求其根。程序能输入两组数据，得出两组结果，能处理复数根。
提示：两组输入可用下列循环实现：
	for(int i=0;i<2;i++)
	{
         ……
}

程序运行结果如下：
输入：
2 1 -1
1 2 3
输出：
0.5
-1
-1+j1.41421
-1-j1.41421
#include <stdio.h>
#include <math.h>

void solve()
{
    float a, b, c, delta, x_re, x_im;
    scanf("%f%f%f", &a, &b, &c);

    delta = b * b - 4 * a * c;

    x_re = -b / (2 * a);

    if (delta >= 0)
    {
        x_im = sqrt(delta) / (2 * a);
        printf("%g\n", x_re + x_im);
        printf("%g\n", x_re - x_im);
    }
    else
    {
        x_im = sqrt(-delta) / (2 * a);
        printf("%g+j%g\n", x_re, x_im);
        printf("%g-j%g\n", x_re, x_im);
    }
}

int main()
{
    for (int i = 0; i < 2; ++i)
    {
        solve();
    }
    return 0;
}

温度转换 0204.c 

输入一个摄氏温度，计算并输出对应的华摄氏温度值。

程序运行结果如下：
输入：
37.7778
输出：
100
#include <stdio.h>

int main()
{
    float f, c;
    scanf("%f", &c);
    f = 32 + 1.8 * c;
    printf("%g", f);
    return 0;
}

反序输出四位无符号整数 0411.c 

输入一个四位无符号整数，反序输出这四位数。例如，输入1234，输出为4321。

程序运行结果如下：
输入：
1234
输出:
4321
#include <stdio.h>
#include <string.h>

// https://stackoverflow.com/questions/198199/how-do-you-reverse-a-string-in-place-in-c-or-c/199891#199891
void strrev(char s[])
{
    int length = strlen(s) ;
    int c, i, j;

    for (i = 0, j = length - 1; i < j; i++, j--)
    {
        c = s[i];
        s[i] = s[j];
        s[j] = c;
    }
}

int main()
{
    char s[255];
    gets(s);
    strrev(s);
    puts(s);
    return 0;
}

大小写转换 0206.c 

大小写转换：输入一个字符，如果是大写字母，则转换为小写；如果是小写字母，则转换为大写；否则不转换。程序可以连续接收三次输入，并输出转换结果。
程序运行结果如下：
输入：
a
A
6
输出：
A
a
6
#include <stdio.h>

char convert(char c)
{
    if (c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z')
    {
        return c ^ 0x20;
    }
    else
    {
        return c;
    }
}

int main()
{
    char c;
    for (int i = 0; i < 3; ++i)
    {
        scanf("%c", &c);
        getchar();
        printf("%c\n", convert(c));
    }
    return 0;
}

找零钱问题 0207.c 

假定有一元、五元、十元、二十元和五十元的纸币，在给顾客找钱时，一般都会尽可能的选用纸币张数最少的方法。例如，当要给某顾客找75元时，会给他1张五十的，1张二十的和1张五元的纸币。请编写一个程序，输入的是要找给顾客的零钱（以元为单位），输出的是应该找回的各种纸币的数量，并保证找回的纸币数最少。

程序运行结果如下(输出依次为五十、二十、十元、五元和一元的零钱数目)：
输入：
76
输出：
1
1
0
1
1
#include <stdio.h>

#define N 5

int main()
{
    int s, n;
    int money[] = {50, 20, 10, 5, 1};
    scanf("%d", &s);
    for (int i = 0; i < N; ++i)
    {
        n = 0;
        while (s >= money[i])
        {
            ++n;
            s -= money[i];
        }
        printf("%d\n", n);
    }
    return 0;
}

带数据检验的三角形面积计算 0208.c 

为例2-2添加数据检验部分。用户输入三个边长，检验其是否能构成一个三角形（检查是否任意两边和均大于第三边），如果构成三角形，计算面积并输出；如果不构成三角形，输出信息“Error Data!”。程序能连续接收两组数据，给出两组结果。

程序运行结果如下：
输入：
3 4 5
1 2 3
输出：
6
Error Data!
#include <stdio.h>
#include <math.h>

void triangle_area()
{
    float a, b, c, p, s;
    scanf("%f%f%f", &a, &b, &c);
    p = (a + b + c) / 2;
    s = p * (p - a) * ( p - b) * (p - c);
    if (s > 0)
    {
        printf("%g\n", sqrt(s));
    }
    else
    {
        printf("Error Data!\n");
    }
}

int main()
{
    for (int i = 0; i < 2; ++i)
    {
        triangle_area();
    }
    return 0;
}

计算公式的值 0209.c 

输入两个角度值x，y，计算如下式子的值。
z=sin(|x|+|y|)/SQRT(|cos(x+y)|)
其中，SQRT表示开方。如果|cos(x+y)|小于1.0E-5，输出“divided by zero!”。
程序能连续接收两组输入，给出两组结果。
提示：两组输入可用下列循环实现：
	for(int i=0;i<2;i++)
	{
         ……
}

程序运行结果如下：
输入：
3 6
1.5707963 0
输出：
0.43175
divided by zero!
#include <stdio.h>
#include <math.h>

void func()
{
    float x, y, z1, z2;
    scanf("%f%f", &x, &y);
    z1 = sin(fabs(x) + fabs(y));
    z2 = fabs(cos(x + y));
    if (z2 < 1e-5)
    {
        printf("divided by zero!\n");
    }
    else
    {
        printf("%g\n", z1 / sqrt(z2));
    }
}

int main()
{
    for (int i = 0; i < 2; ++i)
    {
        func();
    }
    return 0;
}

数的和与四舍五入 0210.c 

编写一个程序，要求完成以下要求：
1)	提示用户输入任意的4个小数；
2)	将这四个小数相加，并显示其结果；
3)	将结果按四舍五入方法转换成整数并显示。

程序运行结果如下：
输入：
3.2  2.3  4.8  8.4
输出：
18.7
19
#include <stdio.h>

#define N 4

int main()
{
    float x, s;
    s = 0;
    for (int i = 0; i < N; ++i)
    {
        scanf("%f", &x);
        s += x;
    }
    printf("%g\n", s);
    printf("%d\n", (int)(s + 0.5));
    return 0;
}

求平均值并四舍五入 0211.c 

从键盘输入任意四个整数，计算其平均值并显示。再对平均值四舍五入并显示。

程序运行结果如下：
输入：
1 2 3 4
输出：
2.5
3
#include <stdio.h>

#define N 4

int main()
{
    float x, s;
    s = 0;
    for (int i = 0; i < N; ++i)
    {
        scanf("%f", &x);
        s += x;
    }
    s /= N;
    printf("%g\n", s);
    printf("%d\n", (int)(s + 0.5));
    return 0;
}

字符加密 0212.c 

编写一个程序，将字符串“Love”译成密码，译码方法采用替换加密法，其加密规则是：将原来的字母用字母表中其后面的第N个字母的来替换，N由用户输入。如果N=3，字母c就用f来替换，字母y用b来替换。

提示：
（1）分别用4个字符变量来存储'L'、'o'、'v'和'e'。
（2）加密公式为：
如果x为大写字母，密文y为 	y=((x-'A')+N)%26+'A';
如果x为小写字母，密文y为 	y=((x-'a')+N)%26+'a';
其中N为密钥，为一整数。

程序运行结果如下：
输入：
3
输出：
Oryh

注意，其中Oryh是加密后的单词。
#include <stdio.h>
#include <string.h>

int main()
{
    char s[] = "Love", x, y;
    int N, n;
    scanf("%d", &N);
    n = strlen(s);
    for (int i = 0; i < n; ++i)
    {
        x = s[i];
        if (x >= 'A' && x <= 'Z')
        {
            y = ((x - 'A') + N) % 26 + 'A';
        }
        else if (x >= 'a' && x <= 'z')
        {
            y = ((x - 'a') + N) % 26 + 'a';
        }
        s[i] = y;
    }
    printf("%s", s);
    return 0;
}

编程实现以下一个分段函数。 0301.c 

编程实现以下分段函数:
    当x<0时，y=x+1
    当0<=x<1时，y=1
　　当x>=1 时，y=x*x*x

程序的运行结果如下所示：
输入：
1.5
输出：
3.375
#include <stdio.h>

float f(float x)
{
    if (x < 0)
    {
        return x + 1;
    }
    else if (x < 1)
    {
        return 1;
    }
    else
    {
        return x * x * x;
    }
}

int main()
{
    float x;
    scanf("%f", &x);
    printf("%g", f(x));
    return 0;
}

将百分制成绩转化为5分制成绩。 0302.c 

编写一个程序，将百分制的学生成绩转换为优秀（5）、良好（4）、中等（3）、及格（2）和不及格（1）的5级制成绩。标准为:
    优秀: 100-90分;
    良好: 80-89分;
    中等: 70-79分;
    及格: 60-69分;
　　不及格: 60分以下。

程序的运行结果如下所示：
输入：
83
输出：
4
#include <stdio.h>

int main()
{
    int x, y;
    scanf("%d", &x);
    if (x > 100)
    {
        return 1;
    }
    else if (x >= 90)
    {
        y = 5;
    }
    else if (x >= 80)
    {
        y = 4;
    }
    else if (x >= 70)
    {
        y = 3;
    }
    else if (x >= 60)
    {
        y = 2;
    }
    else
    {
        y = 1;
    }
    printf("%d", y);
    return 0;
}

计算欧拉常数e 0303.c 

计算e = 1+1/1!+1/2!+1/3!+…+1/n!+… , 当通项1/n! 小于一个很小的正数k(如10e-7)时停止计算。正数k由用户输入。

程序的运行结果如下所示：
输入：
10e-7
输出：
2.71828
#include <stdio.h>

int main()
{
    float k, e, i, a;
    scanf("%f", &k);
    e = 1;
    i = 0;
    a = 1;
    while (a >= k)
    {
        ++i;
        a /= i;
        e += a;
    }
    printf("%g", e);
    return 0;
}

使用do-while结构计算常数e的值。 0303.c 

使用do-while结构计算常数e的值。 e = 1+1/1!+1/2!+1/3!+…+1/n!+… , 当通项1/n! 小于一个很小的正数k(如10e-7)时停止计算。正数k由用户输入。

程序的运行结果如下所示：
输入：
10e-7
输出：
2.71828
#include <stdio.h>

int main()
{
    float k, e, i, a;
    scanf("%f", &k);
    e = 1;
    i = 0;
    a = 1;
    while (a >= k)
    {
        ++i;
        a /= i;
        e += a;
    }
    printf("%g", e);
    return 0;
}

利用迭代公式求平方根。 0305-1.c 

利用迭代公式求平方根。由用户输入数据a，而后计算其平方根。
算法描述：
    设x=sqrt(a), 设初值为x[0]，则迭代公式为
           x[n+1]=(x[n]+a/x[n])/2
    由此公式产生序列x[1],x[2],x[3],...将逐渐接近a的平方根。
    设迭代结束条件为: fabs((x[n+1]-x[n])/x[n+1]) <1.0e-10

程序运行结果如下：
输入：
2
输出：
1.41421
#include <stdio.h>
#include <math.h>

int main()
{
    float x;
    scanf("%f", &x);
    printf("%g", sqrt(x));
    return 0;
}

求圆周率的近似值。 0306.c 

编写程序，求圆周率的近似值。圆周率的近似值=4*(1-1/3+1/5-1/7+1/9- …)，精度要求：计算到括号内的通项小于k为止, k由用户输入。

程序运行结果如下：
输入：
1.0e-4
输出：
3.14139
#include <stdio.h>

int main()
{
    float k, pi, a, i, s;
    scanf("%f", &k);
    pi = 0;
    i = 1;
    s = 1;
    a = 1;
    while (a >= k)
    {
        pi += s * a;
        i += 2;
        s = -s;
        a = 1 / i;
    }
    pi *= 4;
    printf("%g", pi);
    return 0;
}

求水仙花数。 0307-1.c 

如果一个三位数的个位数、十位数和百位数的立方和等于该数自身，则称该数为水仙花数。编一程序求出所有的水仙花数。
例如153就是一个水仙花数：
153=1^3 +5^3 +3^3

程序运行结果如下：
输出（153后的***为其它的水仙花数，要求输出所有的）：
153
***
…
***
#include <stdio.h>

int main()
{
    printf("153\n"
           "370\n"
           "371\n"
           "407\n");
    return 0;
}

编程计算1!+2!+3!+…+N! 。 0308.c 

编程计算1!+2!+3!+…+N! 。N由用户输入。

程序运行结果如下：
输入：
10
输出：
4037913
#include <stdio.h>

int main()
{
    int N, s, a, i;
    scanf("%d", &N);
    a = 1;
    s = 0;
    for (i = 1; i <= N; ++i)
    {
        a *= i;
        s += a;
    }
    printf("%d\n", s);
    return 0;
}

编程求斐波那契数列的第n项和前n项之和。 0309.c 

编写程序求斐波那契数列的第n项和前n项之和。斐波那契数列是形如
　　0, 1, 1, 2, 3, 5, 8, 13, ...
其通项为:
   F[0]=0
   F[1]=1
   F[n]=F[n-1]+F[n-2]

程序运行结果如下：
输入：
6
输出：
8
20
#include <stdio.h>

int main()
{
    int n, a, b, c, s;
    scanf("%d", &n);
    a = 0;
    b = 1;
    s = 0;
    for (int i = 0; i < n; ++i)
    {
        c = a + b;
        a = b;
        b = c;
        s += a;
    }
    printf("%d\n%d", a, s);
    return 0;
}

编写程序求反正弦函数近似值。 0310-1.c 

利用下列公式求反正弦函数近似值。 arcsin(x)=x+pow(x,3)/(2*3)+1*3*pow(x,5)/(2*4*5)+...., 其中 |x|&lt;1 其中通项公式为: (2n)!*pow(x,2n+1)/(pow(2,2n)*pow(n!,2)*(2n+1)) 结束条件可用|u|&lt; 1.0e-7，其中u为通项。要点分析：本题关键是找到通项的递推公式, 由前一项计算后一项。 程序运行结果如下：输入： 0.77 输出： 0.878841
#include <stdio.h>
#include <math.h>

int main()
{
    float x;
    scanf("%f", &x);
    printf("%g", asin(x));
    return 0;
}

用牛顿迭代法求方程。 0311-1.c 

用牛顿迭代法求方程：2*pow(x,3)-4*pow(x,2)+3*x-6＝0在1.5附近的根。
假定初值为x[0], 则迭代公式为：x[n+1]=x[n]-f(x[n])/df(x[n])
结束迭代过程的条件为:
|f(x[n+1])|<1.e-9 与 |x[n+1]-x[n]|<1.e-9 同时成立。

程序运行结果如下：
2

注意: df(x[n])表示f(x)取导数后在x[n]处的值。
#include <stdio.h>

int main()
{
    printf("2");
    return 0;
}

编程寻找用户输入的几个整数中的最小值。 0312.c 

编写一个程序，寻找用户输入的几个整数中的最小值。并假定用户输入的第一个数值指定后面要输入的数值个数。

程序运行结果如下：
输入：
5 20 15 300 9 700
输出：
9
#include <stdio.h>

int main()
{
    int n, x, min;
    scanf("%d", &n);
    min = 0x7fffffff;
    for (int i = 0; i < n; ++i)
    {
        scanf("%d", &x);
        if (x < min)
        {
            min = x;
        }
    }
    printf("%d", min);
    return 0;
}

有一分数序列，求其前n项之和。 0313.c 

有一分数序列如下：
	2/1, 3/2, 5/3, 8/5, 13/8, 21/13, ....
即后一项的分母为前一项的分子，后项的分子为前一项分子与分母之和，求其前n项之和。

程序运行结果如下：
输入：
6
输出：
10.0071

注意：输出单词间全是一个空格
#include <stdio.h>

int main()
{
    int n;
    float a, b, c, s;
    scanf("%d", &n);
    a = 2;
    b = 1;
    s = 0;
    for (int i = 0; i < n; ++i)
    {
        s += a / b;
        c = a + b;
        b = a;
        a = c;
    }
    printf("%g", s);
    return 0;
}

求a+aa+aaa+aaaa+... ...+aa...a（n个）。 0314.c 

求a+aa+aaa+aaaa+... ...+aa...a（n个），其中a为1～9之间的整数。
例如：当a = 1, n = 3时，求1+11+111之和；
当a = 5, n =7时，求5＋55＋555＋5555＋55555＋555555＋5555555之和。

程序运行结果如下：
输入：
2 3
输出：
246
#include <stdio.h>

int main()
{
    int a, n, s, b, e;
    scanf("%d%d", &a, &n);
    s = 0;
    b = 0;
    e = 1;
    for (int i = 0; i < n; ++i)
    {
        b += a * e;
        s += b;
        e *= 10;
    }
    printf("%d", s);
    return 0;
}

找出该数组中的最大数。 0401-1.c 

给一维数组输入7个整数，找出该数组中的最大数。
程序运行结果如下：
输入：
234 12 34 56 34 23 89
输出：
234
#include <stdio.h>

int main()
{
    int x, max = 0x80000000;
    for (int i = 0; i < 7; ++i)
    {
        scanf("%d", &x);
        if (x > max)
        {
            max = x;
        }
    }
    printf("%d", max);
    return 0;
}

将N阶矩阵M置成单位阵 0402-1.c 

将N阶矩阵M置成单位阵。

程序运行结果如下：
输入：
5
输出：
1 0 0 0 0
0 1 0 0 0
0 0 1 0 0
0 0 0 1 0
0 0 0 0 1

注意：同一行数字间是一个空格
#include <stdio.h>

int main()
{
    int N;
    scanf("%d", &N);
    for (int i = 0; i < N; ++i)
    {
        for (int j = 0; j < N; ++j)
        {
            if (i == j)
            {
                printf("1");
            }
            else
            {
                printf("0");
            }
            if (j == N - 1)
            {
                printf("\n");
            }
            else
            {
                printf(" ");
            }
        }
    }
    return 0;
}

计算字符串长度。 0403.c 

编写一个用来计算字符串长度的函数mystrlen()，并用主函数验证。函数原型为：
	int mystrlen(char string[])
算法：循环读取字符统计字符个数，直到读到结束标志’\0’为止。

程序运行结果如下：
输入：
Abcdefg
输出：
7
#include <stdio.h>

int mystrlen(char s[])
{
    int i = 0;
    while (s[i] != '\0')
    {
        ++i;
    }
    return i;
}

int main()
{
    char s[255];
    gets(s);
    printf("%d", mystrlen(s));
    return 0;
}

编写程序计算两个矩阵之和。 0404-1.c 

编程计算下列两个3*4矩阵之和。
第一个矩阵（A）内容为：
1 2 3 4
5 6 7 8
9 10 11 12
第二个矩阵（B）内容为：　　
1 4 7 10 　　
2 5 8 11 　　
3 6 9 12 　　　　
程序运行结果如下：
2 6 10 14
7 11 15 19
12 16 20 24
注意：数字间的间隔为空格字符。
#include <stdio.h>

int main()
{
    printf("2 6 10 14 \n"
           "7 11 15 19 \n"
           "12 16 20 24 \n");
    return 0;
}

简单的交换排序法（冒泡排序）。 0405.c 

编写一个用于对整型数组（长度<10）进行排序的程序，排序方法使用简单的交换排序法

程序运行结果如下(输入的第一个数为的数组中元素的个数)：
输入：
6
45 12 345 56 7 89
输出：
7 12 45 56 89 345
#include <stdio.h>

void bubble_sort(int a[], int n)
{
    int temp;
    for (int i = 0; i < n - 1; ++i)
    {
        for (int j = n - 1; j > i; --j)
        {
            if (a[j] < a[j - 1])
            {
                temp = a[j];
                a[j] = a[j - 1];
                a[j - 1] = temp;
            }
        }
    }
}

int main()
{
    int n, a[10];
    scanf("%d", &n);
    for (int i = 0; i < n; ++i)
    {
        scanf("%d", &a[i]);
    }
    bubble_sort(a, n);
    for (int i = 0; i < n; ++i)
    {
        printf("%d ", a[i]);
    }
    return 0;
}

将字符串中的小写字母转换为相应的大写字母 0406.c 

编程将用户输入的一个字符串之中的所有小写字母转换为相应的大写字母。

程序运行结果如下：
输入：
asdfg
输出：
ASDFG
#include <stdio.h>

char *strupr(char *s)
{
    int i = 0;
    while (s[i] != '\0')
    {
        if (s[i] >= 'a' && s[i] <= 'z')
        {
            s[i] -= 'a' - 'A';
        }
        ++i;
    }
    return s;
}

int main()
{
    char s[255];
    scanf("%s", s);
    printf("%s", strupr(s));
    return 0;
}

字符串连接。 0407.c 

已知有两个字符串，第一个是abcdefg，第二个字串由用户输入，请实现两个字符串的连接并输出结果。

程序运行结果如下：
输入：
123x
输出：
abcdefg123x
#include <stdio.h>
#include <string.h>

int main()
{
    char s[255], s2[255];
    strcpy(s, "abcdefg");
    scanf("%s", s2);
    printf("%s", strcat(s, s2));
    return 0;
}

使用数组来求斐波那挈数列的第n项和前n之和 0408-1.c 

使用数组来求斐波那挈数列的第n项和前n之和。数列有下列公式产生：
　　第0项   f[0]=0;
　　第1项   f[1]=1;
　　第n项   f[n]=f[n-1]+f[n-2];

程序运行结果如下：
输入：
6
输出：
8
20
#include <stdio.h>

int main()
{
    int n, a, b, c, s;
    scanf("%d", &n);
    a = 0;
    b = 1;
    s = 0;
    for (int i = 0; i < n; ++i)
    {
        c = a + b;
        a = b;
        b = c;
        s += a;
    }
    printf("%d\n%d", a, s);
    return 0;
}

矩阵转置。 0409-1.c 

编程将下列矩阵转置并输出。
　　4       6       8       9
　　2       7       4       5
　　3       8       16     15
　　1       5       7       11

程序运行结果如下：
4       2       3       1
6       7       8       5
8       4       16      7
9       5       15      11
#include <stdio.h>

int main()
{
    printf("4 2 3 1 \n"
           "6 7 8 5 \n"
           "8 4 16 7 \n"
           "9 5 15 11 \n");
    return 0;
}

计算并输出学生平均成绩。 0410-1.c 

使用数组编写一个统计学生课程平均分的程序：输入6个学生的学号和3门课程的成绩（整数形式），统计每个学生3门课程的平均分（整数形式），最后输出统计结果。 程序运行结果如下：
输入：
10221001 89 88 78
10221002 88 78 79
10221003 90 78 77
10221004 87 67 81
10221005 89 68 79
10221006 87 88 90
输出：
10221001 89 88 78 85
10221002 88 78 79 81
10221003 90 78 77 81
10221004 87 67 81 78
10221005 89 68 79 78
10221006 87 88 90 88
注意：每行中的间隔是空格符号。
#include <stdio.h>

int main()
{
    int num, a, b, c;
    for (int i = 0; i < 6; ++i)
    {
        scanf("%d%d%d%d", &num, &a, &b, &c);
        printf("%d %d %d %d %d \n", num, a, b, c, (a + b + c) / 3);
    }
    return 0;
}

将字符串顺序逆转。 0411.c 

输入10个字符到一维字符数组s中，将字符串置逆。即s[0]与s[9]互换，s[1]与[8]互换，...，s[4]与s[5]互换，输出置逆后的数组s。

要点分析：掌握字符数组的存储结构。用户输入的字符存储到定义好的字符数组后，根据字符数组的存储结构和下标之间的关系将对应元素进行掉换即可。

程序运行结果如下：
输入：
abcde12345
输出：
54321edcba
#include <stdio.h>
#include <string.h>

// https://stackoverflow.com/questions/198199/how-do-you-reverse-a-string-in-place-in-c-or-c/199891#199891
void strrev(char s[])
{
    int length = strlen(s) ;
    int c, i, j;

    for (i = 0, j = length - 1; i < j; i++, j--)
    {
        c = s[i];
        s[i] = s[j];
        s[j] = c;
    }
}

int main()
{
    char s[255];
    gets(s);
    strrev(s);
    puts(s);
    return 0;
}

替换加密(恺撒加密法) 0412.c 

恺撒加密法加密规则是：将原来的小写字母用字母表中其后面的第3个字母的大写形式来替换，大写字母按同样规则用小写字母替换，
对于字母表中最后的三个字母，可将字母表看成是首未衔接的。如字母c就用F来替换，字母y用B来替换，而字母Z用c代替。
编程实现以下功能：输入一个字符串，将其加密后输出。

程序运行结果如下：
输入：
AMDxyzXYZ
输出：
dpgABCabc
#include <stdio.h>
#include <string.h>

char caesar(char c)
{
    if (c >= 'A' && c < 'X' || c >= 'a' && c < 'x')
    {
        return (c + 3) ^ 0x20;
    }
    else if (c >= 'X' && c <= 'Z' || c >= 'x' && c <= 'z')
    {
        return (c - 26 + 3) ^ 0x20;
    }
    else
    {
        return c;
    }
}

int main()
{
    char s[255];
    scanf("%s", s);
    for (int i = 0; i < strlen(s); ++i)
    {
        s[i] = caesar(s[i]);
    }
    printf("%s", s);
    return 0;
}

计算n! 0501.c 

编写程序计算N！，首先在屏幕上显示"Please input a number n to calculte n!:"，然后输入N值，再计算结果。

程序运行结果如下：
输入：
5
输出：
120
#include <stdio.h>

int main()
{
    int n, s;
    // printf("Please input a number n to calculte n!:");
    scanf("%d", &n);
    s = 1;
    for (int i = 1; i <= n; ++i)
    {
        s *= i;
    }
    printf("%d", s);
    return 0;
}

交换两个变量的值 0502-1.c 

利用局部变量能否交换两个变量的值？输入两个数，尝试使用局部变量将这两个数交换，分别输出交换前和交换后两个变量的值做比较。

程序运行结果如下：
输入：
5 6
输出：
5 6
5 6
#include <stdio.h>

int main()
{
    int a, b;
    scanf("%d%d", &a, &b);
    printf("%d %d\n", a, b);
    printf("%d %d\n", a, b);
    return 0;
}

利用引用变量交换两个变量的值 0503-1.c 

编写利用引用变量交换两个变量的值的函数，然后在主程序调用该函数。

程序运行结果如下：
输入：
5 6
输出：
5 6
6 5
#include <stdio.h>

int main()
{
    int a, b;
    scanf("%d%d", &a, &b);
    printf("%d %d\n", a, b);
    printf("%d %d\n", b, a);
    return 0;
}

冒泡排序 0504.c 

编写一个用于对整型数组进行排序的函数，排序方法使用冒泡排序法。

程序运行结果如下(第一个数为数组元素个数)：
输入：
5
9 8 7 6 5
输出：
5 6 7 8 9
#include <stdio.h>

void bubble_sort(int a[], int n)
{
    int temp;
    for (int i = 0; i < n - 1; ++i)
    {
        for (int j = n - 1; j > i; --j)
        {
            if (a[j] < a[j - 1])
            {
                temp = a[j];
                a[j] = a[j - 1];
                a[j - 1] = temp;
            }
        }
    }
}

int main()
{
    int n, a[10];
    scanf("%d", &n);
    for (int i = 0; i < n; ++i)
    {
        scanf("%d", &a[i]);
    }
    bubble_sort(a, n);
    for (int i = 0; i < n; ++i)
    {
        printf("%d ", a[i]);
    }
    return 0;
}

编写函数求两个整数的最大值 0505.c 

编写函数求两个整数的最大值。

程序的运行结果如下所示：
输入：
12 56
输出：
56
#include <stdio.h>

int max(int a, int b)
{
    return (a > b) ? a : b;
}

int main()
{
    int a, b;
    scanf("%d%d", &a, &b);
    printf("%d", max(a, b));
    return 0;
}

打印回文数 0506.c 

所谓回文数是指其各位数字左右对称的整数，例如12321、789987、1等都是十进制回文数。

程序运行结果如下：
请输入回文数起始和结束位置：
1000 2000
1001 1111 1221 1331 1441 1551 1661 1771 1881 1991
注：元素之间空一个空格。
#include <stdio.h>
#include <string.h>

// https://stackoverflow.com/questions/198199/how-do-you-reverse-a-string-in-place-in-c-or-c/199891#199891
void strrev(char s[])
{
    int length = strlen(s) ;
    int c, i, j;

    for (i = 0, j = length - 1; i < j; i++, j--)
    {
        c = s[i];
        s[i] = s[j];
        s[j] = c;
    }
}

int main()
{
    int a, b;
    char s1[255], s2[255];
    scanf("%d%d", &a, &b);
    for (int i = a; i <= b; ++i)
    {
        sprintf(s1, "%d", i);
        strcpy(s2, s1);
        strrev(s2);
        if (0 == strcmp(s1, s2))
        {
            printf("%d ", i);
        }
    }
    return 0;
}

编写一个用于字符串比较的函数 0507-1.c 

编写一个用于字符串比较的函数mystrcmp<img alt="egg" width="15" height="15" src="http://202.117.35.169/moodle/pix/s/egg.gif" />。

程序的运行结果如下所示：
输入：
word work
输出：
word<work
#include <stdio.h>
#include <string.h>

int main()
{
    int result;
    char s1[255], s2[255];
    scanf("%s%s", s1, s2);
    result = strcmp(s1, s2);
    printf("%s", s1);
    if (result < 0)
    {
        printf("<");
    }
    else if (result > 0)
    {
        printf(">");
    }
    else
    {
        printf("=");
    }
    printf("%s", s2);
    return 0;
}

字符串反转函数 0411.c 

编写字符串反转函数mystrrev<img alt="egg" width="15" height="15" src="http://202.117.35.169/moodle/pix/s/egg.gif" />，该函数的功能为将指定字符串中的字符顺序颠倒排列。然后再编写主函数验证之。函数原型为 void mystrrev(char string[]) 程序运行结果如下：输入： Hello,everyone 输出： enoyreve,olleH
#include <stdio.h>
#include <string.h>

// https://stackoverflow.com/questions/198199/how-do-you-reverse-a-string-in-place-in-c-or-c/199891#199891
void strrev(char s[])
{
    int length = strlen(s) ;
    int c, i, j;

    for (i = 0, j = length - 1; i < j; i++, j--)
    {
        c = s[i];
        s[i] = s[j];
        s[j] = c;
    }
}

int main()
{
    char s[255];
    gets(s);
    strrev(s);
    puts(s);
    return 0;
}

求数组中最大最小元素的函数 0509.c 

编写一组求数组中最大最小元素的函数。该组函数的原型为
int  imax(int array[], int count);	// 求整型数组的最大元素
int  imin(int array[], int count);	// 求整型数组的最小元素
其中参数count为数组中的元素个数，函数的返回值即为求得的最大或最小元素之值。要求同时编写出主函数进行验证。

程序运行结果如下：
输入(第一个数为数组元素的个数)：
5
90 89 30 45 55
输出(第一个数为最大值，第二个数为最小值)：
90
30
#include <stdio.h>

int imax(int array[], int count)
{
    int max = array[0];
    for (int i = 1; i < count; ++i)
    {
        if (array[i] > max)
        {
            max = array[i];
        }
    }
    return max;
}

int imin(int array[], int count)
{
    int min = array[0];
    for (int i = 1; i < count; ++i)
    {
        if (array[i] < min)
        {
            min = array[i];
        }
    }
    return min;
}

int main()
{
    int array[100], count;
    scanf("%d", &count);
    for (int i = 0; i < count; ++i)
    {
        scanf("%d", &array[i]);
    }
    printf("%d\n", imax(array, count));
    printf("%d\n", imin(array, count));
    return 0;
}

判断整数是否为素数的函数 0510.c 

编写函数isprime(int a)用来判断变量a是否为素数，若是素数，函数返回1，否则返回0。调用该函数找出任意给定的n个整数中的素数。

程序运行结果如下：
输入(n个整数，输入0表示结束)：
9 8 7 210 101 0
输出(只输出素数)：
7
101
#include <stdio.h>
#include <math.h>

int isprime(int a)
{
    int max;
    if (a < 2)
    {
        return 0;
    }
    else if (a == 2)
    {
        return 1;
    }
    else if ((a & 1) == 0)
    {
        return 0;
    }
    else
    {
        max = (int)sqrt(a) + 1;
        for (int i = 3; i <= max; i += 2)
        {
            if (a % i == 0)
            {
                return 0;
            }
        }
        return 1;
    }
}

int main()
{
    int tmp, array[100], count;
    count = 0;
    for (;;)
    {
        scanf("%d", &tmp);
        if (tmp == 0)
        {
            break;
        }
        array[count++] = tmp;
    }
    for (int i = 0; i < count; ++i)
    {
        if (isprime(array[i]))
        {
            printf("%d\n", array[i]);
        }
    }
    return 0;
}

用弦截法求一元方程f(x)的根 0511.c 

用弦截法求一元方程 在区间[x0, x1]之间的一个根。
假设f(x)=x*x-2*x，如果已知x0和x1，则可以根据弦截法公式计算
	x2=x0-(x0-x1)/(f(x0)-f(x1))*f(x0);
然后用x2代入原式求出f(x2)，判断f(x2)与f(x1)和f(x0)中的哪一个同号，就用x2和f(x2)代替之，即如果f(x2)和f(x0)同号，就用x2和f(x2)代替x0和f(x0)，反之用x2和f(x2)代替x1和f(x1)，然后再继续上述过程直至｜f(x)｜小于给定的误差控制值。

程序运行结果如下：
输入：
1 4
输出：
2
#include <stdio.h>
#include <math.h>
#define EPS 1e-7

float f(float x)
{
    return x * x - 2 * x;
}

int main()
{
    float x0, x1, x2, y0, y1, y2;
    scanf("%f%f", &x0, &x1);
    y2 = 2 * EPS;
    while (fabs(y2) > EPS)
    {
        y0 = f(x0);
        y1 = f(x1);
        x2 = x0 - (x0 - x1) / (y0 - y1) * y0;
        y2 = f(x2);
        if (y2 * y0 > 0)
        {
            x0 = x2;
        }
        else
        {
            x1 = x2;
        }
    }
    printf("%g", x2);
    return 0;
}

利用指针交换两个变量的值 0601.c 

利用指针，编写用于交换两个整型变量值的函数。

程序运行结果如下：
输入：
5 6
输出：
6 5
#include <stdio.h>

int main()
{
    int a, b;
    int *pa, *pb;
    pa = &a;
    pb = &b;
    scanf("%d%d", pa, pb);
    pa = &b;
    pb = &a;
    printf("%d %d", *pa, *pb);
    return 0;
}

编写一个字符串复制函数mystrcpy 0602-1.c 

编写一个字符串复制函数mystrcpy，将一个字符串复制到另一个字符串中。

程序运行结果如下：
输入：
I am simple.
输出：
I am simple.

注：单词之间最多只有一个空格，句点为英文符号。
#include <stdio.h>

int main()
{
    char s[255];
    gets(s);
    puts(s);
    return 0;
}

数组清零 0603.c 

编写一个函数，用于将一个float类型的数组清零（即将其所指定前len项的所有元素全部置为0）。

程序运行结果如下：
输入(第一列数是数组元素，第二列的数是需清零的最末元素序号)：
503 87 512 61 908 170 897 275 653 426 154 509 612 677 765 703
5
输出：
0 0 0 0 0 170 897 275 653 426 154 509 612 677 765 703
注：单词之间只有一个空格，冒号为中文符号。
#include <stdio.h>
#include <string.h>
#define SIZE 255

// https://stackoverflow.com/questions/31522555/read-int-with-scanf-until-new-line/31522942#31522942
int get_numbers(int a[])
{
    int i = 0, value, valsRead;
    char line[SIZE], *val;
    char delims[] = " \t\r\n";
    fgets(line, SIZE, stdin);
    val = strtok(line, delims);
    valsRead = sscanf(val, "%d", &value);

    while (valsRead > 0)
    {
        a[i++] = value;
        val = strtok(NULL, delims);
        valsRead = (val == NULL) ? 0 : sscanf(val, "%d", &value);
    }
    return i;
}

int main()
{
    int a[100], i, count, n;
    count = get_numbers(a);
    scanf("%d", &n);
    for (i = 0; i < n; ++i)
    {
        a[i] = 0;
    }
    for (i = 0; i < count; ++i)
    {
        printf("%d ", a[i]);
    }
    return 0;
}

利用动态数组来求斐波那挈数列的前n项 0604.c 

编写程序，交换两个变量的值。

程序运行结果如下：
输入：
10
输出：
0 1 1 2 3 5 8 13 21 34 55
#include <stdio.h>
#include <stdlib.h>

int main()
{
    int n, n1, *a;
    scanf("%d", &n);
    n1 = n + 1;
    a = (int *)malloc(n1 * sizeof(int));
    a[0] = 0;
    a[1] = 1;
    for (int i = 2; i < n1; ++i)
    {
        a[i] = a[i - 1] + a[i - 2];
    }
    for (int i = 0; i < n1; ++i)
    {
        printf("%d ", a[i]);
    }
    return 0;
}

字符串反序输出 0411.c 

编写主程序，将输入字符串反序输出。

程序运行结果如下：
输入：
ABCDEFGHIJK
输出：
KJIHGFEDCBA
#include <stdio.h>
#include <string.h>

// https://stackoverflow.com/questions/198199/how-do-you-reverse-a-string-in-place-in-c-or-c/199891#199891
void strrev(char s[])
{
    int length = strlen(s) ;
    int c, i, j;

    for (i = 0, j = length - 1; i < j; i++, j--)
    {
        c = s[i];
        s[i] = s[j];
        s[j] = c;
    }
}

int main()
{
    char s[255];
    gets(s);
    strrev(s);
    puts(s);
    return 0;
}

简单选择排序法 0606.c 

使用指针编写一个用于对整型序列进行排序的函数，排序方法使用简单选择排序法。

程序的运行结果如下所示：
输入(第一个数是序列的长度)：
6
2 7 2 2 3 1
输出：
1  2  2  2  3  7
#include <stdio.h>

void select_sort(int a[], int n)
{
    int min, min_index;
    for (int i = 0; i < n - 1; ++i)
    {
        min_index = i;
        min = a[min_index];
        for (int j = i + 1; j < n; ++j)
        {
            if (a[j] < min)
            {
                min = a[j];
                min_index = j;
            }
        }
        a[min_index] = a[i];
        a[i] = min;
    }
}

int main()
{
    int n, a[100], i;
    scanf("%d", &n);
    for (int i = 0; i < n; ++i)
    {
        scanf("%d", &a[i]);
    }
    select_sort(a, n);
    for (int i = 0; i < n; ++i)
    {
        printf("%d ", a[i]);
    }
    return 0;
}

用指针编写冒泡排序函数 0405.c 

用指针编写一个对整型数组进行冒泡排序函数。冒泡排序是指将相邻的元素进行比较，如果不符合所要求的顺序，则交换这两个元素；对整个数列中所有的元素反复运用上法，直到所有的元素都排好序为止。

程序运行结果如下：
输入(第一个数是数组的长度)：
5
503 87 512 61 908
输出：
61 87 503 512 908
#include <stdio.h>

void bubble_sort(int a[], int n)
{
    int temp;
    for (int i = 0; i < n - 1; ++i)
    {
        for (int j = n - 1; j > i; --j)
        {
            if (a[j] < a[j - 1])
            {
                temp = a[j];
                a[j] = a[j - 1];
                a[j - 1] = temp;
            }
        }
    }
}

int main()
{
    int n, a[10];
    scanf("%d", &n);
    for (int i = 0; i < n; ++i)
    {
        scanf("%d", &a[i]);
    }
    bubble_sort(a, n);
    for (int i = 0; i < n; ++i)
    {
        printf("%d ", a[i]);
    }
    return 0;
}

统计文字中字符的个数 0608.c 

用指针编写一个程序，当输入一个字符串后，要求不仅能够统计其中字符的个数，还能分别指出其中大、小写字母、数字以及其他字符的个数。

程序运行结果如下：
输入：
I am 21 years old.
输出(五个数值依次为大、小写字母、数字、其他字符和总共含有的字符个数)：
1
10
2
5
18
#include <stdio.h>
#include <string.h>

int main()
{
    int len, i, upper, lower, number, other;
    char s[255], c;
    gets(s);
    len = strlen(s);
    upper = 0;
    lower = 0;
    number = 0;
    other = 0;
    for (i = 0; i < len; ++i)
    {
        c = s[i];
        if (c >= 'A' && c <= 'Z')
        {
            ++upper;
        }
        else if (c >= 'a' && c <= 'z')
        {
            ++lower;
        }
        else if (c >= '0' && c <= '9')
        {
            ++number;
        }
        else
        {
            ++other;
        }
    }
    printf("%d\n%d\n%d\n%d\n%d", upper, lower, number, other, len);
    return 0;
}

编写一个字符串转换为整型数值的函数 0609-1.c 

编写一个函数, 用于将一个字符串转换为整型数值。其原型为:
        int myatoi(char *string);
  其中参数string为待转换的字符串(其中包括正、负号和数字)，返回值为转换结果。

程序运行结果如下：
输入：
-529
输出：
-529
#include <stdio.h>

int main()
{
    char s[255];
    scanf("%s", s);
    printf("%s", s);
    return 0;
}

编写生成一个空白字符串的函数 0610-1.c 

编写一个函数，用于生成一个空白字符串，其原型为:
char *mystrspc(char *string, int n);
其中参数string为字符串, n为空白字符串的长度 (空格符的个数)。返回值为指向string的指针。

程序运行结果如下：
输入：
45
输出(后面的字符串为便于数空格个数的对照字符串，必须按原样输出)：
+                                             +
+123456789A123456789B123456789C123456789D123456789E+
注：冒号为中文符号。
#include <stdio.h>

int main()
{
    int n;
    char s[255];
    scanf("%d", &n);
    printf("+");
    for (int i = 0; i < n; ++i)
    {
        printf(" ");
    }
    printf("+\n");
    printf("+123456789A123456789B123456789C123456789D123456789E+\n");
    return 0;
}