C语言程序设计代码

参考教材: C语言程序设计教程(第二版)王敬华版

从键盘输入的字符中统计数字字符的个数, 用换行符结束循环(填空题)

#include <stdio.h>

int main(int argc, const char *argv[])
{
    int n = 0, c;
    c = getchar();

    /*
        为什么while条件不是 c = getchar() != '\n'
        因为循环体内有c = getchar(), 每次循环c都会重新复制的
    */
    // while条件为填空题答案
    while (c != '\n')
    {
        // if条件为填空题答案
        if (c >= '0' && c < '9')
        {
            n++;
        }
        c = getchar();
    }

    printf("number count %d", n);
}

输出100以内能被3整除且个位数为6的所有整数(填空题)

#include <stdio.h>

int main(int argc, const char *argv[])
{
    int i, j;
    // for条件为填空答案
    for (i = 0; i < 10; i++)
    {

        j = i * 10 + 6;
        // if条件为填空答案, j % 3 != 0也是可以的
        if (j % 3)
        {
            /* 
                0 和 非0
                j % 3 = 0的话, 说明可以被3整除, if通过不了
                j % 3 != 0的话, 说明不能被3整除, 结果if通过
            */
            continue;
        }
        printf("%d", j);
    }
}

求Fibonacci数列的前40个数, 并按照4列一行输出(数列特点: 第1, 2个数都是1, 从第3个数开始, 每个数都是前面两个数之和)

#include <stdio.h>

int main(int argc, const char *argv[])
{
    long f1 = 1, f2 = 1;
    int i;
    for (i = 1; i <= 20; i++)
    {
        /*
            -: 左对齐
            12: 占用12个格子, 当数据长度小于12是, 用空格填补
        */
        printf("%-12d%-12d", f1, f2);
        // 每一次循环输出两个,两次输出4个
        // if条件是填空答案
        if (i % 2 == 0)
        {
            printf("\n");
        }
        /* 
            f1 = 1,
            f2 = 1, 
            f1 = f1 + f2(前面的f1, f2), 
            f2 = f2 + f1(这里的f1是前面 f1 = f1 + f2, f2是f2 = 1)
        */
        f1 = f1 + f2;
        f2 = f2 + f1;
    }
}

编程从键盘输入两个整数分别给变量a和b，要求在不借助于其他变量的条件下，将变量a和b的值实现交换。

#include <stdio.h>

void main(void)
{
    int a, b;
    scanf("%d%d", &a, &b); // 输入1□2
    printf("交换前: a = %d, b = %d\n", a, b);// 1, 2

    // a等于ab之和
    a = a + b;
    // 此时的a是ab之和, 然后减去b就等于a
    b = a - b;
    // 此时a是ab之和, 此时的b就是a, 将取的话, 就等于b
    a = a - b;

    printf("交换前: a = %d, b = %d\n", a, b);// 2, 1
}

编程从键盘输入圆的半径r，计算并输出圆的周长和面积

#include <stdio.h>
#define PI 3.14

void main(void)
{
    //r: 半径, l: 周长, s: 面积
    float r, l, s;

    scanf("%f", &r);

    l = 2 * PI * r;

    printf("周长为: %.2f", l);

    s = PI * r * r;

    printf("面积为: %.2f", s);
}

编程计算1×2×3十3×4×5十…+99×100×101的值

分区块, 累加法

#include <stdio.h>

void main()
{
    int i, temp = 0, sum = 0;

    for (i = 1; i < 100; i += 2)
    {
        temp = i * (i + 1) * (i + 2);
        sum += temp;
    }
    printf("sum: %d", sum);
}

编程计算1!十2!+3!＋…＋10!的值

分开算, 每一块的值就是当前循环的i乘以上一次的阶乘的值, 就等于当前阶乘的值
①: 1
②: ① * i = 1 * 2
③: ② * i = 1 * 2 * 3
…
然后累加

#include <stdio.h>

void main()
{
    int i, temp = 1, sum = 0;

    for (i = 1; i <= 10; i++)
    {
        temp *= i;
        sum += temp;
    }
    printf("sum: %d", sum);
}

编程计算a+aa+aaa十…+aa…a (n 个a）的值，a和n的值由键盘输入

输入2, 4
2 + 22 + 222 + 2222
前一项乘以10加上a等于当前项的值
然后累加

#include <stdio.h>

void main()
{
    int i, a, n, temp = 0, sum = 0;
    printf("Please input (a) and (n): ");
    scanf("%d%d", &a, &n);
    for (i = 1; i <= n; i++)
    {
        temp = temp * 10 + a;
        sum += temp;
    }
    printf("sum: %d", sum);
}

利用 $\frac{\pi }{2}$ $\approx$ $\frac{2}{1}$ $\times$ $\frac{2}{3}$ $\times$ $\frac{4}{3}$ $\times$ $\frac{4}{5}$ $\times$ $\frac{6}{5}$ $\times$ $\frac{6}{7}$ $\dots$计算π的值

#include <stdio.h>

int main()
{
    int i;
    float temp = 1, result = 1;
    for (i = 1; i <= 100; i++)
    {
        if (i % 2 == 0)
        {
            temp = (float)i / (i + 1);
        }
        else
        {
            temp = (float)(i + 1) / i;
        }
        result *= temp;
    }
    printf("sum: %f", 2 * result);
    return 0;
}

利用泰勒级数求sinx

计算sin(x)的值, 要求最后一项的绝对值小于x^-5, 并统计累计了多少项

初始化: temp = x = 3; result = x =3; 也就是第一项已经计算好了
进入循环第一次, i=1 也就是第二项: temp = temp * x * x / (i + 1) * (i + 2); temp拆开 𝑥/1, temp = (𝑥/1) × ((𝑥×𝑥)/(2∗3)) 还有符号, 正负=负
第二次循环, i=3,也就是第三项: temp拆开 (𝑥/1) × ((𝑥×𝑥)/(2∗3)), temp = (𝑥/1) × ((𝑥×𝑥)/(2∗3) × (𝑥×𝑥)/(4∗5))
初始化第一项, 用前一项推算后一项

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

int main()
{
    int i = 1, count = 0;
    float x;
    double temp, result;
    printf("Please input x: ");
    scanf("%f", &x);
    temp = x;
    result = x;
    while (fabs(temp) >= 1e-5)
    {
        temp = -temp * x * x / ((i + 1) * (i + 2));
        result += temp;
        i += 2;
        count++;
    }
    printf("sin(x) = %lf, count = %d", result, count);
}

打印所有的“水仙花数”。所谓“水仙花数”是指一个三位数，其各位数字的立方和等于该数本身。例如，153是“水仙花数”，因为153=1³+3³+5³。

#include <stdio.h>

int main(int argc, const char *argv[])
{

    int i, units, tens, hundreds;
    printf("水仙花数:\t");
    // 因为是一个三位数, 所以取值范围 100 ~ 1000

    for (i = 100; i < 1000; i++)
    {
        // 百位
        hundreds = i / 100;
        // 十位
        tens = (i - hundreds * 100) / 10;
        // 个位
        units = i % 10;
		
		/*
		// 百位
        hundreds = i / 100 % 10;
        // 十位
        tens = i / 10 % 10;
        // 个位
        units = i % 10;
		*/

        if (i == hundreds * hundreds * hundreds + tens * tens * tens + units * units * units)
        {
            printf("%d\t", i);
        }
    }
}

从键盘上任意输入一个整数x，编程计算x的每一位数字相加之和(忽略整数前的正负号)。例如，输入x为1234，则由1234分离出1、2、3、4四个数字，然后计算1＋2＋3＋4=10，并输出10。

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

int main(int argc, const char *argv[])
{
    int temp, num, units, tens, hundreds, thousands, result = 0;
    printf("请输入一个数: ");
    scanf("%d", &temp);
    num = abs(temp);

    /*
    thousands = num / 1000 % 10;
    hundreds = num / 100 % 10;
    tens = num / 10 % 10;
    units = num % 10;
    */

    // 由于 thousand是int类型, 进行除法运算就保留整数部分
    // 1234 / 1000 = 1
    thousands = num / 1000;
    // 1234 - 1 * 1000 = 234 / 100 = 2
    hundreds = (num - thousands * 1000) / 100;
    // 1234 - 1 * 1000 - 2  * 100 = 34 / 10  = 3
    tens = (num - thousands * 1000 - hundreds * 100) / 10;
    // 1234 % 10
    units = num % 10;

    result = thousands + hundreds + tens + units;
    printf("计算结果为: %d", result);
}

从键盘上输入任意正整数，编程判断该数是否为回文数。所谓回文数就是从左到右读这个数与从右到左读这个数是一样的。例如，12321、4004都是回文数。

#include <stdio.h>

int main(int argc, const char *argv[])
{
    int input, reverse = 0, s, r;
    printf("请输入正整数: ");
    scanf("%d", &input);
    s = input;
    while (s != 0)
    {
        // 每次循环都是低位做高位, 然后按照重新组合
        /**
         * 知识点: 4位数如何组成的, 最高位(也就是千位) thousands * 1000 + hundreds* 100 + tens * 10 + units
         * 假如输入121
         * 第一次: r = s % 10(取出最低位) = 1, 组成的数 reverse = 1(最高位), s = 12
         * 第二次: r = s % 10(取出最低位) = 2, 组成的数 reverse = 1(上一步的, 也就是最高位) * 10 + 2(第二高位) = 12, s = 1
         * 第三次: r = s % 10(取出最低位) = 1, 组成的数 reverse = 12 * 10 + 1 = 121, s = 0
         */
        r = s % 10;
        reverse = 10 * reverse + r;
        s = s / 10;
    }
    if (reverse == input)
    {
        printf("%d是一个回文数 \n", input);
    }
    else
    {
        printf("%d不是一个回文数 \n", input);
    }
}

用1元5角钱人民币兑换5分、2分和1分的硬币(每一种都要有）共100枚,问共有几种兑换方案?每种方案各换多少枚?

【设计思想】设5分、2分和1分的硬币各换x、y、z枚，依题意有x+y+z=100, 5x+2y＋z=150，由于每一种硬币都要有，故5分硬币最多可换28枚，2分硬币最多可换73枚，1分硬币可换100-x-y枚，x、y、z只需满足第二个方程即可打印，对每一组满足条件的x、y、z值用计数器计数即可得到兑换方案的数目。

#include <stdio.h>

int main(int argc, const char *argv[])
{
    int x, y, z, count = 0;

    for (x = 1; x <= 28; x++)
    {
        for (y = 1; y <= 73; y++)
        {
            z = 100 - x - y;
            if (5 * x + 2 * y + z == 150)
            {
                count++;
                printf("%02d, %02d, %02d\t", x, y, z);
                if (count % 6 == 0)
                {
                    printf("\n");
                }
            }
        }
    }
    printf("count = %d \n", count);
}

统计输入字符串中各个大写字母出现的次数

#include <stdio.h>
#include <memory.h>

// 统计输入字符中, 各个大写字母出现的次数;
void main(void)
{
    char ch;
    int num[26], i;

    // 初始化数组, 将每个元素设置为0;
    memset(num, 0, 26 * sizeof(int));

    while ((ch = getchar()) != '\n')
    {
        if (ch >= 'A' && ch <= 'Z')
        {
            // 当前字母在数组的哪个位置, 然后加+1;
            num[ch - 'A']++;
        }
    }

    for (i = 0; i < 26; i++)
    {
        //每行输出8个元素
        if (i % 8 == 0)
        {
            printf("\n");
        }
        printf("%c(%d) \t", 'A' + i, num[i]);
    }
}

输入一行字符, 统计其中单词的个数, 单词之间用空格间隔

#include <stdio.h>

int main(int argc, const char *argv[])
{
    char string[80], c;
    int i, num = 0, word = 0;

    // 英文要输入句子, 中间有空格, 如果用scanf遇到空格就停止了
    gets(string);

    /**
     * num 用于计算单词数量, isSpace用来标记是否是空格
     * 程序不认识单词, 但是认识空格, 而单词之间是用空格隔开的
     * 单词的数量 = 空格的数量 + 1
    */
    for (i = 0; (c = string[i]) != '\0'; i++)
    {
        if (c == ' ')
        {
            word = 0;
        }
        /**
         * 当word==0时，表示未遇到字母，即未遇到单词，或上一个单词已结束；
        */
        else if (word == 0)
        {
            word = 1; //那么设置word=1, 表示下一个新单词开始
            num++;
        }
    }
    printf("Therev are %d words in the line. \n", num);
}

编程实现从键盘任意输入20个整数，计算其中所有非负数之和。

#include <stdio.h>

int main(int argc, const char *argv[])
{
    int arr[20], count = 0, sum = 0, i, j;
    for (i = 0; i < 20; i++)
    {
        scanf("%d", &arr[i]);
    }
    for (j = 0; j < 20; j++)
    {
        if (arr[j] < 0)
        {
            continue;
        }
        count++;
        sum += arr[j];
    }
    printf("非负数个数 = %d, 非负数之和 = %d", count, sum);
}

输入10个整数，将这10个整数按升序排列输出，并且奇数在前，偶数在后。比如，如果输入的10个数是10 9 8 7 6 5 4 3 2 1，则输出1 3 5 7 9 2 4 6 8 10。

【设计思想】将输入的10个整数，按其奇偶性分别放在数组a的左部和右部。其具体方法就是设置两个整型变量odd和 even,分别表示奇数和偶数存放在数组a中元素的下标，odd 的初始值为0，每存放一个奇数odd 增1，even 的初始值为9，每存放-个偶数even减1，然后通过选择排序的方法分别对数组 a左边的奇数和右边的偶数进行排序。

#include <stdio.h>

int main(int argc, const char *argv[])
{
    int i, j, odd, even, arr[10], n;

    odd = 0;
    even = 9;

    // 获取输入的10个整数
    for (i = 0; i < 10; i++)
    {
        scanf("%d", &n);

        if (n % 2 == 0)
        {
            // 说明是偶数, 偶数放在数组最后面
            arr[odd++] = n;
        }
        else
        {
            // 说明是奇数, 奇数放在数组最前面
            arr[even--] = n;
        }
    }

    // 选择排序
    int k, temp;
    for (i = 0; i < odd; i++)
    {
        k = i;
        for (j = i + 1; j < odd; j++)
        {
            if (arr[k] > arr[j])
            {
                k = j;
            }
        }
        if (k != i)
        {
            temp = arr[i];
            arr[i] = arr[k];
            arr[k] = temp;
        }
    }

    for (i = even; i < 10; i++)
    {
        k = i;
        for (j = i + 1; j < 10; j++)
        {
            if (arr[k] > arr[j])
            {
                k = j;
            }
        }
        if (k != i)
        {
            temp = arr[i];
            arr[i] = arr[k];
            arr[k] = temp;
        }
    }

    /* 
    // 冒泡排序
    int temp;
    for (i = 0; i < odd; i++)
    {
        for (j = 0; j < odd - i; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }

    for (i = even; i < 10; i++)
    {
        for (j = even + 1; j < 10; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
 */
    for (i = 0; i < 10; i++)
    {
        printf("%d \t", arr[i]);
    }
}

从键盘输入10个整数，编程实现将其中最大数与最小数的位置对换后，再输出调整后的数组。

【设计思想】先将输入的10个整数存入数组 a中，然后通过比较找到最大值和最小值元素的下标，分别用变量 max和min表示，最后交换最大数a[max]与最小数a[min]，并输出结果。

#include <stdio.h>

int main(int argc, const char *argv[])
{
    int i, max, min, arr[10], temp;

    for (i = 0; i < 10; i++)
    {
        scanf("%d", &arr[i]);
    }

    printf("交换前: ");
    for (i = 0; i < 10; i++)
    {
        printf("%d\t", arr[i]);
    }

    printf("\n交换后: ");

    min = 0;
    max = 0;
    for (i = 0; i < 10; i++)
    {
        if (arr[i] < arr[min])
        {
            min = i;
        }
        if (arr[i] > arr[max])
        {
            max = i;
        }
    }
    temp = arr[min];
    arr[min] = arr[max];
    arr[max] = temp;
    for (i = 0; i < 10; i++)
    {
        printf("%d\t", arr[i]);
    }
}

编写一程序，其功能是给一维数组a输入任意的6个整数，假设为5 7 4 8 9 1，然后建立一个具有以下内容的方阵，并打印出来。

#include <stdio.h>

int main(int argc, const char *argv[])
{
    int i, j, arr[6], last;

    for (i = 0; i < 6; i++)
    {
        scanf("%d", &arr[i]);
    }

    /**
     * 6个数, 循环6趟, 每一趟把最后一个数放在第一位, 其他的往后挪动一个位置
     * 
    */
    for (i = 0; i < 6; i++)
    {
        for (j = 0; j < 6; j++)
        {
            printf("%d\t", arr[j]);
        }
        printf("\n");
        last = arr[5];
        for (j = 5; j > 0; j--)
        {
            // arr[j + 1] = arr[j]; // 这样会出界的
            arr[j] = arr[j - 1];
        }
        arr[0] = last;
    }
}

编程打印如下形式的杨辉三角形。

#include <stdio.h>

int main(int argc, const char *argv[])
{
    int i, j, arr[6][6] = {0};

    /**
     *  数组中应该是这样的, 不能被提供的图形迷惑了
     *  1 
        1  1
        1  2   1
        1  3   3   1
        1  4   6   4  1
        1  5 10 10  5  1 
    */

    for (i = 0; i < 6; i++)
    {
        // 开始和结束两个元素都为1, 对应着行数组第一位和最后一位
        arr[i][0] = 1;
        arr[i][i] = 1;

        // 第几行就有几个元素, 第一列都是1
        // 第二列开始
        for (j = 1; j < i; j++)
        {
            arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];
        }
    }

    for (i = 0; i < 6; i++)
    {
        for (j = 0; j < 6 - i - 1; j++)
        {
            printf(" ");
        }
        // 第一列开始
        for (j = 0; j <= i; j++)
        {
            printf("%2d", arr[i][j]);
        }
        printf("\n");
    }
}

编写一程序实现将用户输入的一字符串以反向形式输出。比如，输入的字符串是abcdefg，输出为gfedcba。

#include <stdio.h>
#include <string.h>

int main(int argc, const char *argv[])
{
    char str[66];
    int i;

    printf("请输入字符串: ");
    scanf("%s", str);

    printf("反向形式输出: ");
    for (i = strlen(str) - 1; i >= 0; i--)
    {
        printf("%c", str[i]);
    }
}

编写一程序实现将用户输入的一字符串中所有的字符c’删除，并输出结果。

#include <stdio.h>
#include <string.h>

int main(int argc, const char *argv[])
{
    char str[66];
    int i, j, len;

    printf("请输入字符串: ");
    scanf("%s", str);

    len = strlen(str);
    printf("删除字符'c'过后的字符串: ");

    // 投机取巧方法
    /*     for (i = 0; i < len; i++)
    {
        if (str[i] == 'c')
        {
            continue;
        }
        printf("%c", str[i]);
    } */

    /**
     * 思想: 如果碰到目标字符, 就会用后面的字符顶到前面
     * 看成两个指针:
     *      第一指针用来遍历, 
     *      第二个指针用来记录目标字符, 然后用后面数据覆盖第二个指针所指的数据
    */

    for (i = j = 0; str[i] != '\0'; i++)
    {
        if (str[i] != 'c')
        {
            str[j++] = str[i];
        }
    }
    str[j] = '\0'; // '\0'是字符串结束的标志，上面j++了以后放一个结束，字符串才完整
    printf("%s", str);
}

编写一个程序，将字符数组s2中的全部字符复制到字符数组s1中，不用strcpy函数。复制时，’\0’也要复制过去。’\0’后面的字符不复制。

#include <stdio.h>

int main(int argc, const char *argv[])
{
    char s1[20], s2[20] = "chenjiang\0lovecmt";
    int i = 0;

    while (1)
    {
        s1[i] = s2[i];
        // 上面已经将'\0'复制过去了, 这有时候终止循环
        if (s2[i] == '\0')
        {
            break;
        }
        i++;
    }
    printf("复制完后的字符串: %s", s1);
}

不用strcat函数编程实现字符串连接函数strcat 的功能，将字符串 srcStr连接到字符串dstStr的尾部。

#include <stdio.h>

int main(int argc, const char *argv[])
{
    char dstStr[20] = "chenjiang", srcStr[20] = "lovecmt";
    int i, j;

    for (i = 0; dstStr[i] != '\0'; i++)
        ; //找到dststr串中'\0'所在的位置i

    for (j = 0; srcStr[j] != '\0'; j++)
    {
        dstStr[i++] = srcStr[j];
    }
    
    printf("%s", dstStr);
}

有一个已排好序(升序）的整型数组，要求从键盘输入一整数按原来排序的规律将它插入数组中。并输出结果。比如，原来数据为1 3 5 7，需插入4，插入后为1 3 4 5 7.

#include <stdio.h>

int main(int argc, const char *argv[])
{
    int arr[20] = {1, 3, 5, 7}, num, i, len = 4;
    printf("请输入一个整数: ");
    scanf("%d", &num);

    // 找到要插入的位置, 这个位置后面的元素往后挪一个位置

    for (i = len - 1; i >= 0; i--)
    {
        if (arr[i] > num)
        {
            // 可以用一个变量用来存i, 例如 int k = i;
            // 循环外面就可以arr[k] = num;
            arr[i + 1] = arr[i];
        }
        else
        {
            // 如果arr[i]比要插入的数据大的话就不用考虑了, 因为是升序的后面的数一定比num大
            break;
        }
    }
    // 为什么是i+1呢? 因为循环要退出的话, 必须要不满足if, 
    // 多进行一次, 因此for循环外获取的就是i--过后的值
    arr[i + 1] = num;

    for (i = 0; i < len + 1; i++)
    {
        printf("%d \t", arr[i]);
    }
}

设计一个函数，用来判断一个整数是否为素数。

思路1：因此判断一个整数m是否是素数，只需把 m 被 2 ~ m-1 之间的每一个整数去除，如果都不能被整除，那么 m 就是一个素数。

---

思路2：另外判断方法还可以简化。m 不必被 2 ~ m-1 之间的每一个整数去除，只需被 2 ~ 之间的每一个整数去除就可以了。如果 m 不能被 2 ~ 间任一整数整除，m 必定是素数。例如判别 17 是是否为素数，只需使 17 被 2~4 之间的每一个整数去除，由于都不能整除，可以判定 17 是素数。
原因：因为如果 m 能被 2 ~ m-1 之间任一整数整除，其二个因子必定有一个小于或等于 ，另一个大于或等于 。例如 16 能被 2、4、8 整除，16=28，2 小于 4，8 大于 4，16=44，4=√16，因此只需判定在 2~4 之间有无因子即可。

#include <stdio.h>
#include <math.h>
/**
 * 判断素数, 能否被1和本身整除
 * 间接思路: 看看能不能被2 ~ n - 1之间的数整除, 
 * 如果出现一个那么就不是素数
 * 
*/
int isPrime(int n)
{
    int temp = n - 1, i;

    if (n <= 1) // 负数, 0, 1都不是素数
    {
        return 0;
    }
    /* for (i = 2; i < temp; i++)
    {
        if (n % i == 0)
        {
            return 0;
        }
    } */
    // 不过对任意值的number检验它是否为素数时，不必使用比其平方根大的整数去整除它。
    // 改进
    for (i = 2; i <= sqrt(n); i++)
    {
        if (n % i == 0)
        {
            return 0;
        }
    }
    return 1;
}

int main(int argc, const char *argv[])
{
    int n;
    printf("请输入一个整数: ");
    scanf("%d", &n);

    if (isPrime(n))
    {
        printf("%d是素数", n);
    }
    else
    {
        printf("%d不是素数", n);
    }
}

打印100以内的素数, 每行打印5个

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

void printPrime()
{
    int i, j, isPrime = 1, count = 0;
    printf("输出100以内的素数: \n");
    for (i = 2; i <= 100; i++)
    {
        isPrime = 1;
        for (j = 2; j <= sqrt(i); j++)
        {
            if (i % j == 0)
            {
                isPrime = 0;
                break;
            }
        }
        if (isPrime == 1)
        {
            printf("%d \t", i);
            count++;
            if (count % 5 == 0)
            {
                printf("\n");
            }
        }
    }
}

int main(int argc, const char *argv[])
{
    printPrime();
}