c语言必刷代码题1

🎯适合基础小白，期末复习，计算机二级考试，考研复试…🚀

一、判断选取控制

1.1🤺a²+b²

题目：编制程序要求输入整数ａ和b,若ａ²+b²大于100，则输出a²+b²百位以上的数字，否则输出两数之和。

#include<stdio.h>
int main()
{
 int a,b;
//输入
 scanf("%d %d",&a,&b);
 if((a*a+b*b)>=100)
 //通过除法取高位
  printf("\n %d",(a*a+b*b)/100);
 else
  printf("\n %d",a+b);
}

1.2🤺同除357

题目：编程实现：输入一个整数，判断它能否被3，5，7整除，并输出以下信息之一：
（1）能同时被3,5,7 整除;
（2）能被其中两数(要指出哪两个)整除；
（3）能被其中一个数（要指出哪一个)整除;
（4）不能被3,5,7任一个整除。

#include <stdio.h>

int main() {
    int num;
    scanf("%d", &num);
    // 判断能否被 3、5、7 整除
    int divisible_by_3 = num % 3 == 0;
    int divisible_by_5 = num % 5 == 0;
    int divisible_by_7 = num % 7 == 0;
    // 统计能被整除的个数
    int count = divisible_by_3 + divisible_by_5 + divisible_by_7;
    if (count == 3) {
        printf("能同时被3,5,7 整除\n");
    } else if (count == 2) {
        if (divisible_by_3 && divisible_by_5) {
            printf("能被其中两数(3和5)整除\n");
        } else if (divisible_by_3 && divisible_by_7) {
            printf("能被其中两数(3和7)整除\n");
        } else {
            printf("能被其中两数(5和7)整除\n");
        }
    } else if (count == 1) {
        if (divisible_by_3) {
            printf("能被其中一个数(3)整除\n");
        } else if (divisible_by_5) {
            printf("能被其中一个数(5)整除\n");
        } else {
            printf("能被其中一个数(7)整除\n");
        }
    } else {
        printf("不能被3,5,7任一个整除\n");
    }
    return 0;
}

1.3🤺switch

#include <stdio.h>

int main() {
    int x, y;
    printf("请输入一个整数x: ");
    scanf("%d", &x);
    switch (x > 0) {
    case 1:
        y = 1;
        break;
    case 0:
        switch (x == 0) {
        case 1:
            y = 0;
            break;
        case 0:
            y = -1;
            break;
        }
        break;
    }
    printf("y的值为: %d\n", y);
    return 0;
}

二、循环控制

2.1🤺同构数

试编程序，找出1至99之间的全部同构数。同构数是这样一组数：它出现在平方数的右边。例如：5是25右边的数，25是625右边的数，5和25都是同构数。

#include <stdio.h>

int main() {
    int i;
    for (i = 1; i <= 99; i++) {
        int square = i * i;
        // 对于 1 到 9 的数，判断其平方的个位数是否等于该数
        if (i < 10) {
            if (square % 10 == i) {
                printf("%d 是同构数，其平方是 %d\n", i, square);
            }
        } 
        // 对于 10 到 99 的数，判断其平方的后两位数是否等于该数
        else {
            if (square % 100 == i) {
                printf("%d 是同构数，其平方是 %d\n", i, square);
            }
        }
    }
    return 0;
}

2.2🤺x^y的最后三位数

试编程序，求一个整数任意次方的最后三位数。即求x^y的最后三位数，要求
x,y从键盘输入。

#include <stdio.h>

int main() {
    int x, y;
    int result = 1;

    // 从键盘输入 x 和 y
    scanf("%d %d", &x, &y);

    // 计算 x 的 y 次方的最后三位数
    for (int i = 0; i < y; i++) {
        result = (result * x) % 1000;
    }

    // 输出结果
    printf("%d 的 %d 次方的最后三位数是：%03d\n", x, y, result);

    return 0;
}

🎈注意：为什么要在每次乘法后取模？
防止数值溢出：当 x 和 y 的值比较大时，x 的 y 次方可能会超出 int 类型所能表示的范围。例如，如果 x = 100，y = 10，100 的 10 次方是一个非常大的数（100000000000000000000），远远超出了 int 类型的最大值（通常是 2147483647）。而我们只关心这个结果的最后三位数，所以在每次乘法操作后对 1000 取模，就可以保证结果始终在 0 到 999 这个范围内，避免了数值溢出的问题。
不影响最后三位数的结果：根据取模运算的性质，一个数对 1000 取模得到的余数就是这个数的最后三位数。而且在求幂的过程中，每次乘法后取模不会影响最终结果的最后三位数。例如，假设我们要计算 (a * b * c) % 1000，可以先计算 (a * b) % 1000 = d，然后再计算 (d * c) % 1000，这样得到的结果和直接计算 (a * b * c) % 1000 是一样的。

2.3🤺学生平均成绩

编写程序，从键盘输入6名学生的5门成绩，分别统计出每个学生的平均成绩。

#include <stdio.h>

#define STUDENT_NUM 6
#define COURSE_NUM 5

int main() {
    int student, course;
    float score,sum,average;

    // 外层循环控制学生数量
    for (student = 1; student <= STUDENT_NUM; student++) {
        sum = 0;
        // 内层循环控制每一个学生的课程数量
        for (course = 1; course <= COURSE_NUM; course++) {
            printf("请输入第 %d 名学生的第 %d 门成绩: ", student, course);
            scanf("%f", &score);
            sum += score;
        }
        // 计算当前学生的平均成绩
        average = sum / COURSE_NUM;
        printf("第 %d 名学生的平均成绩是: %.2f\n", student, average);
    }

    return 0;
}

三、数组

3.1🤺统计每个整数个数

从键盘输入若干整数（数据个数应少于50)，其值在0至4的范围内，用-1作为输入结束的标志。统计每个整数的个数。试编程。

#include <stdio.h>

#define MAX_INPUT 50

int main() {
    int numbers[5] = {0};  // 用于存储 0 - 4 每个整数的个数，初始化为 0
    int input;
    int count = 0;

    printf("请输入 0 至 4 范围内的整数，以 -1 结束输入：\n");

    while (count < MAX_INPUT) {
        scanf("%d", &input);
        if (input == -1) {
            break;  // 输入 -1 时结束循环
        }
        if (input >= 0 && input <= 4) {
            numbers[input]++;  // 对应整数的计数加 1
            count++;
        } else {
            printf("输入无效，请输入 0 至 4 范围内的整数。\n");
        }
    }

    // 输出每个整数的个数
    for (int i = 0; i < 5; i++) {
        printf("整数 %d 的个数是：%d\n", i, numbers[i]);
    }

    return 0;
} 

🎈计数统计思想
数组映射：利用数组 numbers 来记录每个特定整数（0 到 4）出现的次数。数组的下标与要统计的整数一一对应，例如 numbers[0] 用于统计整数 0 出现的次数，numbers[1] 用于统计整数 1 出现的次数，以此类推。这种通过数组下标来映射不同元素的方式，能够高效地进行计数统计，避免了使用复杂的逻辑判断来区分不同的整数。

3.2🤺每五个数平均值放入另一个数组

定义一个含有30个整型元素的数组，按顺序分别赋予从2开始的偶数;然后按顺序每五个数求出一个平均值，放在另一个数组中并输出。试编程。

#include <stdio.h>

#define ARRAY_SIZE 30
#define GROUP_SIZE 5

int main() {
    int numbers[ARRAY_SIZE];
    float averages[ARRAY_SIZE / GROUP_SIZE];

    // 给数组 numbers 赋值从 2 开始的偶数
    for (int i = 0; i < ARRAY_SIZE; i++) {
        numbers[i] = 2 + 2 * i;
    }

    // 每五个数求一个平均值，并存入数组 averages
    for (int i = 0; i < ARRAY_SIZE / GROUP_SIZE; i++) {
        int sum = 0;
        for (int j = 0; j < GROUP_SIZE; j++) {
            sum += numbers[i * GROUP_SIZE + j];
        }
        averages[i] = (float)sum / GROUP_SIZE;
    }

    // 输出平均值数组
    printf("每五个数的平均值分别为：\n");
    for (int i = 0; i < ARRAY_SIZE / GROUP_SIZE; i++) {
        printf("第 %d 组平均值: %.2f\n", i + 1, averages[i]);
    }

    return 0;
}

3.3🤺输出下三角

通过循环按行顺序为一个5X5的二维数组a赋1到25的自然数，然后输出该数组的左下半三角。试编程。

#include <stdio.h>

#define ROWS 5
#define COLS 5

int main() {
    int a[ROWS][COLS];
    int num = 1;

    // 按行顺序为二维数组 a 赋 1 到 25 的自然数
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            a[i][j] = num++;
        }
    }

    // 输出数组的左下半三角
    printf("该数组的左下半三角为：\n");
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j <= i; j++) {
            printf("%d ", a[i][j]);
        }
        printf("\n");
    }

    return 0;
}

🎈输出昨下三角关键：对于左下半三角，列的范围是从 0 到当前行号 i（即 j <= i），输出满足条件的元素。

3.4🤺输出螺旋方阵

#include <stdio.h>

int main() {
    int n, i, j, num = 1, row_start = 0, row_end, col_start = 0, col_end;
    printf("请输入方阵的阶数 n (n < 10): ");
    scanf("%d", &n);
    row_end = n - 1;
    col_end = n - 1;
    int arr[10][10];

    while (num <= n * n) {
        // 从左到右
        for (j = col_start; j <= col_end; j++) {
            arr[row_start][j] = num++;
        }
        row_start++;
        // 从上到下
        for (i = row_start; i <= row_end; i++) {
            arr[i][col_end] = num++;
        }
        col_end--;
        // 从右到左
        for (j = col_end; j >= col_start; j--) {
            arr[row_end][j] = num++;
        }
        row_end--;
        // 从下到上
        for (i = row_end; i >= row_start; i--) {
            arr[i][col_start] = num++;
        }
        col_start++;
    }

    // 输出螺旋方阵
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("%4d", arr[i][j]);
        }
        printf("\n");
    }

    return 0;
}

🎈填充螺旋方阵：使用while循环，在方阵未填满（num <= n * n）时，按顺时针方向依次填充：
从左到右填充当前行，填充后row_start加 1。
从上到下填充当前列，填充后col_end减 1。
从右到左填充当前行，填充后row_end减 1。
从下到上填充当前列，填充后col_start加 1。
往里不断转！

3.4🤺 a中所有的后项除以前项之商

数组a包括10个整数，把a中所有的后项除以前项之商取整后存入数组b，并按每行3个元素的格式输出数组b。试编程。

#include <stdio.h>

#define ARRAY_SIZE 10

int main() {
    int a[ARRAY_SIZE];
    int b[ARRAY_SIZE - 1];
    int i;

    // 输入数组 a 的 10 个整数
    printf("请输入 10 个整数：\n");
    for (i = 0; i < ARRAY_SIZE; i++) {
        scanf("%d", &a[i]);
    }

    // 计算后项除以前项之商取整并存入数组 b
    for (i = 0; i < ARRAY_SIZE - 1; i++) {
        if (a[i] != 0) {
            b[i] = a[i + 1] / a[i];
        } else {
            // 处理除数为 0 的情况
            printf("错误：数组 a 中出现了 0，不能作为除数。\n");
            return 1;
        }
    }

    // 按每行 3 个元素的格式输出数组 b
    printf("数组 b 的元素为：\n");
    for (i = 0; i < ARRAY_SIZE - 1; i++) {
        printf("%d ", b[i]);
        if ((i + 1) % 3 == 0) {
            printf("\n");
        }
    }

    // 如果最后一行不足 3 个元素，手动换行
    if ((ARRAY_SIZE - 1) % 3 != 0) {
        printf("\n");
    }

    return 0;
}

3.5🤺折半查找法

从键盘输入一个字符，用折半查找法找出该字符在已排序的字符串a中的位置。若该字符不在a中，则打印出**。试编程。

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

// 折半查找函数
int binarySearch(char arr[], int left, int right, char target) {
    while (left <= right) {
        int mid = left + (right - left) / 2;

        if (arr[mid] == target) {
            return mid;  // 找到目标字符，返回其位置
        } else if (arr[mid] < target) {
            left = mid + 1;  // 目标字符在右半部分
        } else {
            right = mid - 1;  // 目标字符在左半部分
        }
    }
    return -1;  // 未找到目标字符
}

int main() {
    char a[] = "abcdefghijklmnopqrstuvwxyz";  // 已排序的字符串
    int len = strlen(a);
    char target;

    printf("请输入一个字符: ");
    scanf(" %c", &target);

    int position = binarySearch(a, 0, len - 1, target);

    if (position != -1) {
        printf("该字符在字符串中的位置是: %d\n", position);
    } else {
        printf("**\n");
    }

    return 0;
}

🎈解决整数溢出问题：
使用 left + (right - left) / 2 可以避免这个问题。具体分析如下：
right - left 计算的是 right 和 left 之间的差值，这个差值通常不会超出 int 类型的表示范围。计算出差值后再除以 2，得到的是从 left 开始到中间位置的偏移量。最后将这个偏移量加到 left 上，就能得到中间位置 mid。

3.6🤺ａ串中的最大元素后边插入字符串b

从键盘输入一个字符串a，并在ａ串中的最大元素后边插入字符串b（b[ ]="ab”)）。试编程

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

#define MAX_LEN 100

// 函数用于将字符串从指定位置后移
void shift_string(char *str, int start, int num_chars) {
    int len = strlen(str);
    for (int i = len; i >= start; i--) {
        str[i + num_chars] = str[i];
    }
}

int main() {
    char a[MAX_LEN];
    char b[] = "ab";
    int i, max_index = 0;

    // 从键盘输入字符串 a
    printf("请输入字符串 a: ");
    scanf("%s", a);

    // 找到字符串 a 中最大元素的索引
    for (i = 1; i < strlen(a); i++) {
        if (a[i] > a[max_index]) {
            max_index = i;
        }
    }

    // 计算要插入字符串 b 的长度
    int b_len = strlen(b);

    // 将最大元素后面的字符向后移动 b_len 个位置
    shift_string(a, max_index + 1, b_len);

    // 在最大元素后面插入字符串 b
    for (i = 0; i < b_len; i++) {
        a[max_index + 1 + i] = b[i];
    }

    // 输出插入后的字符串 a
    printf("插入后的字符串 a 为: %s\n", a);

    return 0;
}

🎈思路：就是找到最大元素下标，然后该下标后元素后移b的长度（提供位置插入b）