C语言经典题目4

关注

原创 2025-01-04 22:33:20 665 阅读 AI 写同款· GEO 优化 ›

c语言基础程序——100实例 /根据公示Π/4=1-1/3+1/5-1/7+1/9-1/11+......,计算Π的近似值，当最后一项的绝对值小于0.000001为止。int f=1;//变号用//i是分母，sum是Π/4的值while (fabs(1.0/i)>=1e-6)//当绝对值小于10的-5次方认为为0//累加每项的值f*=-1;//变号i+=2;//分母+2变化printf("Π的近似值为%.5lf",sum*4); 阅读详情

一.简单计算器

#include <stdio.h>

int main() {
    int num, result;
    char op;
    // 读取第一个数字
    scanf("%d", &result);
    while (1) {
        scanf("%c", &op);
        if (op == '=') {
            break;
        }
        scanf("%d", &num);
        // 根据运算符进行相应的运算
        if (op == '+') {
            result += num;
        } else if (op == '-') {
            result -= num;
        } else if (op == '*') {
            result *= num;
        } else if (op == '/') {
            if (num == 0) {
                // 除数为 0 时输出错误信息
                printf("ERROR");
                return 0;
            } else {
                result /= num;
            }
        } else {
            // 遇到非法运算符时输出错误信息
            printf("ERROR");
            return 0;
        }
    }
    printf("%d", result);
    return 0;
}

二.寻找202最帅

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

// 找到与优秀成绩最接近的分数
// arr: 成绩数组
// size: 数组大小
// n: 优秀成绩
int findClosest(int *arr, int size, int n) {
    int closest = arr[0]; // 初始化最接近的分数为数组第一个元素
    int minDistance = abs(arr[0] - n); // 初始化最近距离为第一个元素与优秀成绩的绝对差

    // 遍历数组，找出最接近优秀成绩的分数
    for (int i = 1; i < size; i++) {
        int distance = abs(arr[i] - n); // 计算当前元素与优秀成绩的绝对差
        if (distance < minDistance) {  // 如果当前差值小于之前记录的最小差值
            closest = arr[i];          // 更新最接近的分数
            minDistance = distance;    // 更新最小差值
        }
    }
    return closest; // 返回与优秀成绩最接近的分数
}

int main() {
    int n; // 优秀成绩
    scanf("%d", &n); // 读取优秀成绩

    int arr[6]; // 六位同学的成绩
    for (int i = 0; i < 6; i++) {
        scanf("%d", &arr[i]); // 依次读取六位同学的成绩
    }

    int higher[6], higherCount = 0; // 存储高于优秀成绩的分数及其数量
    int lower[6], lowerCount = 0;   // 存储低于优秀成绩的分数及其数量
    int equal[6], equalCount = 0;   // 存储等于优秀成绩的分数及其数量

    // 分类成绩
    for (int i = 0; i < 6; i++) {
        if (arr[i] > n) { // 如果当前分数大于优秀成绩
            higher[higherCount++] = arr[i]; // 添加到 higher 数组，并增加计数
        } else if (arr[i] < n) { // 如果当前分数小于优秀成绩
            lower[lowerCount++] = arr[i]; // 添加到 lower 数组，并增加计数
        } else { // 如果当前分数等于优秀成绩
            equal[equalCount++] = arr[i]; // 添加到 equal 数组，并增加计数
        }
    }

    // 判断分类结果并输出对应的结果
    if (higherCount == 6) { 
        // 如果所有分数都高于优秀成绩
        printf("202 zui shuai\n"); // 输出“202 zui shuai”
    } else if (lowerCount == 6) { 
        // 如果所有分数都低于优秀成绩
        printf("come on!\n"); // 输出“come on!”
    } else {
        // 如果分数既有高于也有低于优秀成绩的
        printf("zui shuai\n");

        // 找到与优秀成绩最近的分数
        int closest = findClosest(arr, 6, n);
        printf("%d\n", closest); // 输出最接近的分数

        // 输出所有高于优秀成绩的分数
        if (higherCount > 0) { 
            printf("%d", higher[0]); // 输出第一个分数
            for (int i = 1; i < higherCount; i++) { // 输出其余分数，前面加空格
                printf(" %d", higher[i]);
            }
            printf("\n"); // 换行
        }
    }

    return 0; // 程序结束
}

三.玩玩轮盘

解题思路

1. 理解题目

提莫和她的朋友玩俄罗斯轮盘游戏，目标是模拟轮盘旋转后，确定最终的弹巢状态，以及谁最终中枪。

输入包括初始弹巢状态（6个位置是否有子弹）、起始玩家名，以及旋转次数。
输出两部分：
1. 旋转后的弹巢状态。
2. 最后未中枪的玩家名字。

2. 分析关键逻辑

弹巢旋转：通过顺时针旋转 mmm 次来更新弹巢状态，计算方式为 newIndex = (i + m) % 6。
玩家轮流开枪：轮流检查弹巢中当前孔是否有子弹，如果有子弹，则当前玩家中枪，另一个玩家获胜。
起始玩家的轮换：根据起始玩家，使用一个标志变量 num 来控制玩家切换。

3. 代码实现

分成以下步骤：

输入弹巢状态。
旋转弹巢：
- 使用函数 revolve 实现旋转逻辑。
输出旋转后的状态。
模拟游戏：
- 使用循环轮流检查每个弹巢孔。
- 当前孔有子弹时结束游戏并输出结果。
输出胜者名字。

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

// 函数：顺时针旋转弹巢
// 参数：arr 为弹巢状态数组，m 为旋转次数
void revolve(int arr[], int m) {
    int newarr[6]; // 临时数组存储旋转后的状态
    for (int i = 0; i < 6; i++) {
        newarr[(i + m) % 6] = arr[i]; // 计算旋转后的新位置
    }
    // 将临时数组内容复制回原数组
    for (int i = 0; i < 6; i++) {
        arr[i] = newarr[i];
    }
}

int main() {
    int arr[6]; // 存储弹巢初始状态，1 表示有子弹，0 表示无子弹

    // 输入弹巢状态
    for (int i = 0; i < 6; i++) {
        scanf("%d", &arr[i]);
    }

    char name[10]; // 存储第一个开枪的玩家名字
    scanf("%s", name);

    int m; // 旋转次数
    scanf("%d", &m);

    // 计算有效旋转次数（因为旋转 6 次后状态恢复原状）
    m = m % 6;

    // 调用函数旋转弹巢
    revolve(arr, m);

    // 输出旋转后的弹巢状态
    for (int i = 0; i < 6; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n"); // 换行，格式符合要求

    // 确定起始玩家，sheep=0，fish=1
    int num = (strcmp(name, "sheep") == 0) ? 0 : 1;

    // 定义玩家名称数组，用于输出结果
    char *str[2] = {"sheep", "fish"};

    // 模拟轮流开枪
    for (int i = 0; i < 6; i++) {
        if (arr[i] == 1) { // 如果当前孔有子弹
            printf("%s", str[1 - num]); // 输出对手获胜
            return 0; // 游戏结束
        }
        // 切换玩家
        num = 1 - num;
    }

    return 0;
}

四.求最大最小值

#include<stdio.h>

int main(){
    int n;
    // 读取输入的n，表示有多少条记录
    scanf("%d",&n);
    
    // 初始化min_age为一个大值（最大可能值是100），用于找到最小年龄
    int min_age = 101; 
    
    // 初始化max_time为0，最大时间的初始值
    int max_time = 0; 
    
    // 初始化max_sum为0，用于存储最大 age + time 的值
    int max_sum = 0; 
    
    // 循环n次，每次读取一个人的记录
    for(int i = 0; i < n; i++){
        int age, time;
        
        // 读取当前的age和time
        scanf("%d", &age);
        scanf("%d", &time);
        
        // 检查并更新最小年龄
        if(age < min_age){
            min_age = age;  // 如果当前age小于min_age，更新min_age
        }
        
        // 检查并更新最大时间
        if(time > max_time){
            max_time = time;  // 如果当前time大于max_time，更新max_time
        }
        
        // 计算当前记录的age + time，并检查是否更新最大和时间之和
        int sum = age + time;
        if(sum > max_sum){
            max_sum = sum;  // 如果sum大于max_sum，更新max_sum
        }
    }
    
    // 输出结果：最小年龄，最大时间，和最大age + time的和
    printf("%d %d %d", min_age, max_time, max_sum);
    
    return 0;
}

五.再玩轮盘，左移左轮

#include<stdio.h>

// 将数组左移 times 位
void revolve(int arr[], int times, int n) {
    times = (times % n + n) % n;  // 规范化 times，使其在 [0, n) 范围内
    for (int i = 0; i < times; i++) {
        int first = arr[0];  // 保存第一个元素
        for (int j = 0; j < n-1; j++) {
            arr[j] = arr[j+1];  // 左移
        }
        arr[n-1] = first;  // 将第一个元素放到最后一个位置
    }
}

int main() {
    int count = 0;
    int n, m;
    scanf("%d %d", &n, &m);  // 输入 n 和 m

    int arr[n];  // 动态分配数组
    for (int i = 0; i < n; i++) {
        scanf("%d", &arr[i]);  // 输入数组
    }

    for (int i = 0; i < m; i++) {
        int times;
        scanf("%d", &times);
        revolve(arr, times, n);  // 调用旋转函数
        if (arr[0] == 1) {
            count++;  // 如果第一个元素是 1，计数器加 1
        }
    }

    printf("%d\n", count);  // 输出结果
    return 0;
}

六.调整数组使奇数全部都位于偶数前面其他数字顺序不变

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

int main() {
    char str[11];     // 输入的字符串，长度不超过10
    char jistr[11];   // 存储奇数字符
    char oustr[11];   // 存储偶数字符
    int jicount = 0;  // 记录奇数的个数
    int oucount = 0;  // 记录偶数的个数

    // 输入一个长度不超过10的字符串
    scanf("%s", str);

    // 遍历输入字符串
    for (int i = 0; str[i] != '\0'; i++) {
        int num = str[i] - '0';  // 将字符转换为整数
        if (num % 2 == 1) {      // 判断是否为奇数
            jistr[jicount++] = str[i];  // 如果是奇数，存入 jistr 数组
        } else {
            oustr[oucount++] = str[i];  // 如果是偶数，存入 oustr 数组
        }
    }

    // 添加字符串结束符，确保 jistr 和 oustr 是合法的 C 字符串
    jistr[jicount] = '\0';
    oustr[oucount] = '\0';

    // 将奇数部分复制到 str 中
    strcpy(str, jistr);

    // 将偶数部分拼接到 str 中
    strcat(str, oustr);

    // 输出最终结果
    printf("%s", str);

    return 0;
}

七.判断回文字符串

#include<stdio.h>
#include<string.h>
int main(){
    char str[81]; // 定义字符串数组，最大长度为80，加1存储结束符
    fgets(str, sizeof(str), stdin);  // 读取字符串，包括空格和特殊字符
    str[strcspn(str, "\n")] = '\0';  // 去除末尾的换行符
    
    int length=strlen(str);
    for(int i=0;i<length/2;i++){
        if(str[i]!=str[length-i-1]){
            printf("%s\n",str);
            printf("No\n");
            return 0;
        }
    }
    printf("%s\n",str);
    printf("Yes\n");
    return 0;
}

八.数字加密

#include<stdio.h>

int main() {
    int x;
    int digits[4];

    // 读取输入的四位整数
    scanf("%d", &x);

    // 将每一位数字加密：加9后对10取余
    for (int i = 3; i >= 0; i--) {
        digits[i] = (x % 10 + 9) % 10;
        x /= 10;
    }

    // 交换千位和十位，百位和个位
    int temp = digits[0];
    digits[0] = digits[2];
    digits[2] = temp;

    temp = digits[1];
    digits[1] = digits[3];
    digits[3] = temp;

    // 输出加密后的数字
    printf("The encrypted number is ");
    for (int i = 0; i < 4; i++) {
        printf("%d", digits[i]);
    }
    printf("\n");

    return 0;
}

七.组个最小数

#include<stdio.h>

int main(){
    int arr[10];  // 数组 arr 用于存储每个数字 (0-9) 的出现次数
    int index = 0;  // 结果字符串 result 的当前索引位置
    char result[51];  // 字符数组 result 存储最终的数字字符串，最多能存储 50 个数字 + 1 个终止符

    // 读取输入，获取每个数字 0-9 出现的次数
    for(int i = 0; i < 10; i++){
        scanf("%d", &arr[i]);
    }

    // 处理首位数字：确保首位不是 0，选择最小的非零数字作为首位
    for(int i = 1; i < 10; i++){  // 从数字 1 到 9 中寻找最小的非零数字
        if(arr[i] > 0){  // 找到第一个出现次数大于 0 的数字
            result[index++] = '0' + i;  // 将该数字添加到结果中
            arr[i]--;  // 减少该数字的个数
            break;  // 一旦找到并处理了首位数字，跳出循环
        }
    }

    // 将剩余的数字按升序添加到结果字符串中
    for(int i = 0; i < 10; i++){  // 遍历 0 到 9
        while(arr[i] > 0){  // 只要该数字的出现次数大于 0
            result[index++] = '0' + i;  // 将该数字添加到结果中
            arr[i]--;  // 减少该数字的个数
        }
    }

    result[index] = '\0';  // 添加字符串结束符，确保结果是一个合法的字符串

    // 输出加密后的结果字符串
    printf("%s", result);  // 输出结果
}

八.矩阵A乘以B

#include <stdio.h>

int main() {
    int Ra, Ca, Rb, Cb;
    
    // 读取矩阵 A 的行列数和元素
    scanf("%d %d", &Ra, &Ca);
    int A[Ra][Ca];
    for (int i = 0; i < Ra; i++) {
        for (int j = 0; j < Ca; j++) {
            scanf("%d", &A[i][j]);
        }
    }
    
    // 读取矩阵 B 的行列数和元素
    scanf("%d %d", &Rb, &Cb);
    int B[Rb][Cb];
    for (int i = 0; i < Rb; i++) {
        for (int j = 0; j < Cb; j++) {
            scanf("%d", &B[i][j]);
        }
    }

    // 检查矩阵乘法的条件 Ca == Rb
    if (Ca != Rb) {
        printf("Error: %d != %d\n", Ca, Rb);
        return 0;
    }

    // 矩阵乘法，计算 AB
    int AB[Ra][Cb];
    for (int i = 0; i < Ra; i++) {
        for (int j = 0; j < Cb; j++) {
            AB[i][j] = 0;  // 初始化 AB[i][j]
            for (int k = 0; k < Ca; k++) {
                AB[i][j] += A[i][k] * B[k][j];
            }
        }
    }

    // 输出结果矩阵 AB 的行列数
    printf("%d %d\n", Ra, Cb);
    for (int i = 0; i < Ra; i++) {
        for (int j = 0; j < Cb; j++) {
            printf("%d", AB[i][j]);
            if (j != Cb - 1) printf(" ");  // 控制空格，避免行末多空格
        }
        printf("\n");
    }

    return 0;
}

九.IP地址转换

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

int main(){
    char str[33];  // 用于存储输入的32位二进制字符串，最大长度为33（包含末尾的'\0'）

    // 输入一个32位二进制字符串
    scanf("%s", str);

    // 循环遍历每一组8位（共4组，每组代表一个字节）
    for(int i = 0; i < 4; i++){
        int sum = 0;  // 用于存储当前字节的十进制值
        
        // 遍历当前字节中的每一位，注意二进制从右到左是逐步加权的（2的幂次）
        for(int j = 0; j < 8; j++){
            // 将字符'0'或'1'转换为数字0或1，乘以2的相应幂次（从7到0）
            sum += (str[i * 8 + j] - '0') * (int)pow(2, 7 - j);
        }
        
        // 如果是最后一组（即i == 3），不输出小数点，否则输出小数点
        if(i == 3){
            printf("%d", sum);  // 输出最后一个数字，不加点
        } else {
            printf("%d.", sum);  // 输出当前数字后加上点
        }
    }
    
    return 0;  // 程序执行完毕，返回0
}

十.出租

#include<stdio.h>

// 函数 exist 检查数字 num 是否已经在 newarr 数组中出现过
int exist(int newarr[], int num, int count) {
    // 遍历 newarr 数组，检查 num 是否已经存在
    for (int i = 0; i < count; i++) {
        if (newarr[i] == num) {
            return 1;  // 如果找到了，返回 1，表示 num 已经存在
        }
    }
    return 0;  // 如果遍历完没有找到，返回 0，表示 num 不存在
}

// 函数 order 对 arr 数组中的元素进行递减排序
void order(int arr[], int count) {
    // 使用冒泡排序算法，按递减顺序排序数组
    for (int i = 0; i < count - 1; i++) {
        for (int j = 0; j < count - i - 1; j++) {
            // 如果 arr[j] 小于 arr[j+1]，则交换它们的位置
            if (arr[j] < arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main() {
    int index[11];  // 存储每个数字在 newarr 中的索引，长度为 11，因为手机号有 11 位
    char str[12];   // 存储手机号，长度为 12 以便能存储一个完整的 11 位手机号 + '\0'
    int newarr[10]; // 用于存储手机号中不同的数字，最多有 10 个不同的数字
    int count = 0;  // 记录 newarr 中有效数字的个数

    // 输入手机号字符串
    scanf("%s", str);

    // 初始化 index 数组为 -1，表示未找到任何有效的索引
    for (int i = 0; i < 11; i++) {
        index[i] = -1;
    }

    // 提取手机号中的不同数字并存储到 newarr 数组中
    for (int i = 0; i < 11; i++) {
        int num = str[i] - '0';  // 将字符转为对应的数字
        // 检查 num 是否已经存在于 newarr 中，如果不存在，则添加它
        if (exist(newarr, num, count) == 0) {  
            newarr[count++] = num;  // 将 num 添加到 newarr 数组中，count 自增
        }
    }

    // 对 newarr 数组进行递减排序，排列数字从大到小
    order(newarr, count);

    // 输出 arr 数组的内容
    printf("int[] arr = new int[]{%d", newarr[0]);  // 打印第一个数字
    for (int i = 1; i < count; i++) {  // 从第二个数字开始依次打印
        printf(",%d", newarr[i]);
    }
    printf("};\n");  // 输出完整的 arr 数组

    // 为每个数字在原手机号中的位置赋值到 index 数组中
    for (int i = 0; i < 11; i++) {
        int num = str[i] - '0';  // 获取当前手机号位置上的数字
        // 查找该数字在 newarr 数组中的索引
        for (int j = 0; j < count; j++) {
            if (newarr[j] == num) {
                index[i] = j;  // 将该数字在 newarr 中的索引赋值给 index 数组
                break;  // 找到对应的索引后可以提前跳出内层循环
            }
        }
    }

    // 输出 index 数组的内容
    printf("int[] index = new int[]{");
    for (int i = 0; i < 11; i++) {
        printf("%d", index[i]);  // 打印 index 数组中的每个元素
        if (i != 10) {  // 如果不是最后一个元素，后面加逗号
            printf(",");
        }
    }
    printf("};\n");  // 输出完整的 index 数组

    return 0;
}