【明解c语言中级篇第三章练习答案】

最新推荐文章于 2024-10-19 11:17:13 发布
最新推荐文章于 2024-10-19 11:17:13 发布
阅读量354 收藏 7
点赞数 5
分类专栏： 明解C语言 文章标签： c语言 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jokr_/article/details/140205712
版权

明解c语言中级篇第三章练习答案

3-1

练习3-1编写一个程序，把List3-9程序中的函数count_no和disp_result整合成一个函数，然后讨论更改前和更改后的程序。

//List 3-9
#include <time.h>
#include <stdio.h>
#include <stdlib.h>

int human; /* 玩家手势 */
int comp; /* 计算机手势 */
int win_no; /* 胜利次数 */
int lose_no; /* 失败次数 */
int draw_no; /* 平局次数 */

char *hd[] = {"石头", "剪刀", "布"}; /* 手势 */

/* 初始处理 */
void initialize(void) {
    win_no = 0; /* 胜利次数 */
    lose_no = 0; /* 失败次数 */
    draw_no = 0; /* 平局次数 */
    srand(time(NULL)); /* 设定随机数种子 */
    printf("猜拳游戏开始！\n");
}

/* 运行猜拳游戏（读取/生成手势） */
void jyanken(void) {
    int i;
    comp = rand() % 3; /* 用随机数生成计算机的手势（0~2） */
    do {
        printf("\n\a石头剪刀布...");
        for (i = 0; i < 3; i++)
            printf("(%d)%s ", i, hd[i]);
        printf(": ");
        scanf("%d", &human); /* 读取玩家的手势 */
    } while (human < 0 || human > 2);
}

/* 计数胜利/失败/平局次数 */
void count_no(int result) {
    switch (result) {
        case 0: draw_no++; break;
        case 1: lose_no++; break;
        case 2: win_no++; break;
    }
}

/* 显示判断结果 */
void disp_result(int result) {
    switch (result) {
        case 0: puts("平局。"); break;
        case 1: puts("你输了。"); break;
        case 2: puts("你赢了。"); break;
    }
}

/* 确认是否再次挑战 */
int confirm_retry(void) {
    int x;
    printf("再来一次吗...（0）否（1）是：");
    scanf("%d", &x);
    return x;
}

int main(void) {
    int judge; /* 胜负 */
    int retry; /* 再来一次？ */

    initialize(); /* 初始处理 */

    do {
        jyanken(); /* 运行猜拳游戏 */

        /* 显示计算机和玩家的手势 */
        printf("我出%s，你出%s。\n", hd[comp], hd[human]);

        judge = (human - comp + 3) % 3; /* 判断胜负 */
        count_no(judge); /* 更新胜利/失败/平局次数 */
        disp_result(judge); /* 显示判断结果 */

        retry = confirm_retry(); /* 确认是否再次挑战 */
    } while (retry == 1);

    printf("%d胜 %d负 %d平。\n", win_no, lose_no, draw_no);
    return 0;
}


//答案
#define _CRT_SECURE_NO_WARNINGS 1
#include <time.h>
#include <stdio.h>
#include <stdlib.h>

int human; /* 玩家手势 */
int comp; /* 计算机手势 */
int win_no; /* 胜利次数 */
int lose_no; /* 失败次数 */
int draw_no; /* 平局次数 */

const char* hd[] = { "石头", "剪刀", "布" }; /* 手势 */

/* 初始处理 */
void initialize(void) {
    win_no = 0; /* 胜利次数 */
    lose_no = 0; /* 失败次数 */
    draw_no = 0; /* 平局次数 */
    srand(time(NULL)); /* 设定随机数种子 */
    printf("猜拳游戏开始！\n");
}

/* 运行猜拳游戏（读取/生成手势） */
void jyanken(void) {
    int i;
    comp = rand() % 3; /* 用随机数生成计算机的手势（0~2） */
    do {
        printf("\n\a石头剪刀布...");
        for (i = 0; i < 3; i++)
            printf("(%d)%s ", i, hd[i]);
        printf(": ");
        scanf("%d", &human); /* 读取玩家的手势 */
    } while (human < 0 || human > 2);
}

/* 更新和显示结果 */
void update_and_display_result(int result) {
    switch (result) {
    case 0:
        draw_no++;
        puts("平局。");
        break;
    case 1:
        lose_no++;
        puts("你输了。");
        break;
    case 2:
        win_no++;
        puts("你赢了。");
        break;
    }
}

/* 确认是否再次挑战 */
int confirm_retry(void) {
    int x;
    printf("再来一次吗...（0）否（1）是：");
    scanf("%d", &x);
    return x;
}

int main(void) {
    int judge; /* 胜负 */
    int retry; /* 再来一次？ */

    initialize(); /* 初始处理 */

    do {
        jyanken(); /* 运行猜拳游戏 */

        /* 显示计算机和玩家的手势 */
        printf("我出%s，你出%s。\n", hd[comp], hd[human]);

        judge = (human - comp + 3) % 3; /* 判断胜负 */
        update_and_display_result(judge); /* 更新和显示结果 */

        retry = confirm_retry(); /* 确认是否再次挑战 */
    } while (retry == 1);

    printf("%d胜 %d负 %d平。\n", win_no, lose_no, draw_no);
    return 0;
}

更改前:
模块化清晰：原始程序中，count_no 和 disp_result 分别负责不同的功能，职责单一，模块化清晰。
可维护性高：单独的函数使得每个函数更容易维护和修改。

更改后:
简化结构：整合后的函数减少了函数调用的次数，使代码更加简洁。
功能合并：合并后的函数使得逻辑更加集中，不需要在不同函数间跳转。

总体来说: 更改后的程序更加简洁，但在某些情况下，过度简化可能会降低代码的可维护性和可读性。在实际开发中，应根据具体情况选择合适的方案。

3-2

把List3-10中的猜赢3次拳泛化为猜赢n次拳。在游戏一开始就问“要猜赢几次？”，让玩家来输人n的值。

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <time.h>
#include <stdlib.h>

int human; /* 玩家手势 */
int comp; /* 计算机手势 */
int win_no; /* 胜利次数 */
int lose_no; /* 失败次数 */
int draw_no; /* 平局次数 */
int target_wins; /* 目标胜利次数 */

const char* hd[] = { "石头", "剪刀", "布" }; /* 手势 */

/* 初始处理 */
void initialize(void) {
    win_no = 0; /* 胜利次数 */
    lose_no = 0; /* 失败次数 */
    draw_no = 0; /* 平局次数 */
    srand(time(NULL)); /* 设定随机数种子 */
    printf("猜拳游戏开始！\n");

    /* 询问目标胜利次数 */
    printf("要猜赢几次？");
    scanf("%d", &target_wins);
}

/* 运行猜拳游戏（读取/生成手势） */
void jyanken(void) {
    int i;
    comp = rand() % 3; /* 用随机数生成计算机的手势（0~2） */
    do {
        printf("\n\a石头剪刀布...");
        for (i = 0; i < 3; i++) {
            printf("(%d)%s ", i, hd[i]);
        }
        printf(": ");
        scanf("%d", &human); /* 读取玩家的手势 */
    } while (human < 0 || human > 2);
}

/* 更新和显示结果 */
void update_and_display_result(int result) {
    switch (result) {
    case 0:
        draw_no++;
        puts("平局。");
        break;
    case 1:
        lose_no++;
        puts("你输了。");
        break;
    case 2:
        win_no++;
        puts("你赢了。");
        break;
    }
}

int main(void) {
    int judge; /* 胜负 */

    initialize(); /* 初始处理 */

    do {
        jyanken(); /* 运行猜拳游戏 */

        /* 显示计算机和玩家的手势 */
        printf("我出%s，你出%s。\n", hd[comp], hd[human]);

        judge = (human - comp + 3) % 3; /* 判断胜负 */
        update_and_display_result(judge); /* 更新和显示结果 */

    } while (win_no < target_wins && lose_no < target_wins);

    printf(win_no == target_wins ? "\n你赢了。\n" : "\n我赢了。\n");
    printf("%d胜 %d负 %d平。\n", win_no, lose_no, draw_no);
    return 0;
}

3-3

编写一个“猜拳游戏”，让计算机只能出石头和布

因为计算机只能出石头和布，而且控制手势的数组是char *hd[] = {"石头", "剪刀", "布"};，所以，只能让计算机生成 0和2，我们可以按照下面的代码来控制：

comp = rand() % 2 * 2; /* 生成0（石头）或2（布） */

这样 com 就只会生成 0和2 了。

完整代码如下：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <time.h>
#include <stdlib.h>

int human; /* 玩家手势 */
int comp; /* 计算机手势 */
int win_no; /* 胜利次数 */
int lose_no; /* 失败次数 */
int draw_no; /* 平局次数 */

const 
char* hd[] = { "石头", "剪刀", "布" }; /* 手势 */

/* 初始处理 */
void initialize(void) {
    win_no = 0; /* 胜利次数 */
    lose_no = 0; /* 失败次数 */
    draw_no = 0; /* 平局次数 */
    srand(time(NULL)); /* 设定随机数种子 */
    printf("猜拳游戏开始！\n");
}

/* 运行猜拳游戏（读取/生成手势） */
void jyanken(void) {
    int i;
    comp = (rand() % 2) * 2; /* 生成0（石头）或2（布） */
    do {
        printf("\n\a石头剪刀布...");
        for (i = 0; i < 3; i++) {
            printf("(%d)%s ", i, hd[i]);
        }
        printf(": ");
        scanf("%d", &human); /* 读取玩家的手势 */
    } while (human < 0 || human > 2);
}

/* 更新和显示结果 */
void update_and_display_result(int result) {
    switch (result) {
    case 0:
        draw_no++;
        puts("平局。");
        break;
    case 1:
        lose_no++;
        puts("你输了。");
        break;
    case 2:
        win_no++;
        puts("你赢了。");
        break;
    }
}

/* 确认是否再次挑战 */
int confirm_retry(void) {
    int x;
    printf("再来一次吗...（0）否（1）是：");
    scanf("%d", &x);
    return x;
}

int main(void) {
    int judge; /* 胜负 */
    int retry; /* 再来一次？ */

    initialize(); /* 初始处理 */

    do {
        jyanken(); /* 运行猜拳游戏 */

        /* 显示计算机和玩家的手势 */
        printf("我出%s，你出%s。\n", hd[comp], hd[human]);

        judge = (human - comp + 3) % 3; /* 判断胜负 */
        update_and_display_result(judge); /* 更新和显示结果 */

        retry = confirm_retry(); /* 确认是否再次挑战 */
    } while (retry == 1);

    printf("%d胜 %d负 %d平。\n", win_no, lose_no, draw_no);
    return 0;
}

3-4

编写一个“猜拳游戏”，让计算机第1次一定出石头。
※让计算机从第2次开始随机出石头、剪刀或者布。

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <time.h>
#include <stdlib.h>

int human; /* 玩家手势 */
int comp; /* 计算机手势 */
int win_no; /* 胜利次数 */
int lose_no; /* 失败次数 */
int draw_no; /* 平局次数 */
int round_no; /* 游戏轮数 */

const char* hd[] = { "石头", "剪刀", "布" }; /* 手势 */

/* 初始处理 */
void initialize(void) {
    win_no = 0; /* 胜利次数 */
    lose_no = 0; /* 失败次数 */
    draw_no = 0; /* 平局次数 */
    round_no = 0; /* 游戏轮数 */
    srand(time(NULL)); /* 设定随机数种子 */
    printf("猜拳游戏开始！\n");
}

/* 运行猜拳游戏（读取/生成手势） */
void jyanken(void) {
    int i;
    if (round_no == 0) {
        comp = 0; /* 第1次一定出石头 */
    }
    else {
        comp = rand() % 3; /* 从第2次开始随机生成手势（0, 1, 2） */
    }
    do {
        printf("\n\a石头剪刀布...");
        for (i = 0; i < 3; i++) {
            printf("(%d)%s ", i, hd[i]);
        }
        printf(": ");
        scanf("%d", &human); /* 读取玩家的手势 */
    } while (human < 0 || human > 2);
}

/* 更新和显示结果 */
void update_and_display_result(int result) {
    switch (result) {
    case 0:
        draw_no++;
        puts("平局。");
        break;
    case 1:
        lose_no++;
        puts("你输了。");
        break;
    case 2:
        win_no++;
        puts("你赢了。");
        break;
    }
}

/* 确认是否再次挑战 */
int confirm_retry(void) {
    int x;
    printf("再来一次吗...（0）否（1）是：");
    scanf("%d", &x);
    return x;
}

int main(void) {
    int judge; /* 胜负 */
    int retry; /* 再来一次？ */

    initialize(); /* 初始处理 */

    do {
        jyanken(); /* 运行猜拳游戏 */
        round_no++; /* 增加轮数 */

        /* 显示计算机和玩家的手势 */
        printf("我出%s，你出%s。\n", hd[comp], hd[human]);

        judge = (human - comp + 3) % 3; /* 判断胜负 */
        update_and_display_result(judge); /* 更新和显示结果 */

        retry = confirm_retry(); /* 确认是否再次挑战 */
    } while (retry == 1);

    printf("%d胜 %d负 %d平。\n", win_no, lose_no, draw_no);
    return 0;
}

3-5

编写一个“猜拳游戏”，让计算机每5次就会“后出”编写两个版本，一个是只要玩家愿意就能不断重复玩的“猜拳游戏”，另一个是猜赢n次就会结束的“猜拳游戏”。

//版本一
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <time.h>
#include <stdlib.h>

int human; /* 玩家手势 */
int comp; /* 计算机手势 */
int win_no; /* 胜利次数 */
int lose_no; /* 失败次数 */
int draw_no; /* 平局次数 */
int round_no; /* 游戏轮数 */

const 
char* hd[] = { "石头", "剪刀", "布" }; /* 手势 */

/* 初始处理 */
void initialize(void) {
    win_no = 0; /* 胜利次数 */
    lose_no = 0; /* 失败次数 */
    draw_no = 0; /* 平局次数 */
    round_no = 0; /* 游戏轮数 */
    srand(time(NULL)); /* 设定随机数种子 */
    printf("猜拳游戏开始！\n");
}

/* 运行猜拳游戏（读取/生成手势） */
void jyanken(void) {
    int i;
    if (round_no % 5 == 4) {
        printf("请你先出：\n");
        for (i = 0; i < 3; i++) {
            printf("(%d)%s ", i, hd[i]);
        }
        printf(": ");
        scanf("%d", &human); /* 读取玩家的手势 */
        comp = rand() % 3; /* 随机生成计算机手势 */
    }
    else {
        comp = rand() % 3; /* 随机生成计算机手势 */
        do {
            printf("\n\a石头剪刀布...");
            for (i = 0; i < 3; i++) {
                printf("(%d)%s ", i, hd[i]);
            }
            printf(": ");
            scanf("%d", &human); /* 读取玩家的手势 */
        } while (human < 0 || human > 2);
    }
}

/* 更新和显示结果 */
void update_and_display_result(int result) {
    switch (result) {
    case 0:
        draw_no++;
        puts("平局。");
        break;
    case 1:
        lose_no++;
        puts("你输了。");
        break;
    case 2:
        win_no++;
        puts("你赢了。");
        break;
    }
}

/* 确认是否再次挑战 */
int confirm_retry(void) {
    int x;
    printf("再来一次吗...（0）否（1）是：");
    scanf("%d", &x);
    return x;
}

int main(void) {
    int judge; /* 胜负 */
    int retry; /* 再来一次？ */

    initialize(); /* 初始处理 */

    do {
        jyanken(); /* 运行猜拳游戏 */
        round_no++; /* 增加轮数 */

        /* 显示计算机和玩家的手势 */
        printf("我出%s，你出%s。\n", hd[comp], hd[human]);

        judge = (human - comp + 3) % 3; /* 判断胜负 */
        update_and_display_result(judge); /* 更新和显示结果 */

        retry = confirm_retry(); /* 确认是否再次挑战 */
    } while (retry == 1);

    printf("%d胜 %d负 %d平。\n", win_no, lose_no, draw_no);
    return 0;
}


//版本二
#include <stdio.h>
#include <time.h>
#include <stdlib.h>

int human; /* 玩家手势 */
int comp; /* 计算机手势 */
int win_no; /* 胜利次数 */
int lose_no; /* 失败次数 */
int draw_no; /* 平局次数 */
int round_no; /* 游戏轮数 */
int target_wins; /* 目标胜利次数 */

const char* hd[] = { "石头", "剪刀", "布" }; /* 手势 */

/* 初始处理 */
void initialize(void) {
    win_no = 0; /* 胜利次数 */
    lose_no = 0; /* 失败次数 */
    draw_no = 0; /* 平局次数 */
    round_no = 0; /* 游戏轮数 */
    srand(time(NULL)); /* 设定随机数种子 */
    printf("猜拳游戏开始！\n");

    /* 询问目标胜利次数 */
    printf("要猜赢几次？");
    scanf("%d", &target_wins);
}

/* 运行猜拳游戏（读取/生成手势） */
void jyanken(void) {
    int i;
    if (round_no % 5 == 4) {
        printf("请你先出：\n");
        for (i = 0; i < 3; i++) {
            printf("(%d)%s ", i, hd[i]);
        }
        printf(": ");
        scanf("%d", &human); /* 读取玩家的手势 */
        comp = rand() % 3; /* 随机生成计算机手势 */
    }
    else {
        comp = rand() % 3; /* 随机生成计算机手势 */
        do {
            printf("\n\a石头剪刀布...");
            for (i = 0; i < 3; i++) {
                printf("(%d)%s ", i, hd[i]);
            }
            printf(": ");
            scanf("%d", &human); /* 读取玩家的手势 */
        } while (human < 0 || human > 2);
    }
}

/* 更新和显示结果 */
void update_and_display_result(int result) {
    switch (result) {
    case 0:
        draw_no++;
        puts("平局。");
        break;
    case 1:
        lose_no++;
        puts("你输了。");
        break;
    case 2:
        win_no++;
        puts("你赢了。");
        break;
    }
}

int main(void) {
    int judge; /* 胜负 */

    initialize(); /* 初始处理 */

    do {
        jyanken(); /* 运行猜拳游戏 */
        round_no++; /* 增加轮数 */

        /* 显示计算机和玩家的手势 */
        printf("我出%s，你出%s。\n", hd[comp], hd[human]);

        judge = (human - comp + 3) % 3; /* 判断胜负 */
        update_and_display_result(judge); /* 更新和显示结果 */

    } while (win_no < target_wins && lose_no < target_wins);

    printf(win_no == target_wins ? "\n你赢了。\n" : "\n我赢了。\n");
    printf("%d胜 %d负 %d平。\n", win_no, lose_no, draw_no);
    return 0;
}

3-6

编写一个“猜拳游戏”，让游戏结束时显示玩家和计算机出过的所有手势和胜负的历史记录。
编写两个版本，一个是只要玩家愿意就能不断重复玩的“猜拳游戏”，另一个是猜赢n次就会结束的“猜拳游戏”。
※关于历史记录的保存可参见第5章。

//版本一
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define MAX_ROUNDS 1000 /* 最大记录轮数 */

int human; /* 玩家手势 */
int comp; /* 计算机手势 */
int win_no; /* 胜利次数 */
int lose_no; /* 失败次数 */
int draw_no; /* 平局次数 */
int round_no; /* 游戏轮数 */

char *hd[] = {"石头", "剪刀", "布"}; /* 手势 */

int human_history[MAX_ROUNDS]; /* 保存玩家手势 */
int comp_history[MAX_ROUNDS]; /* 保存计算机手势 */
int result_history[MAX_ROUNDS]; /* 保存胜负记录 */

/* 初始处理 */
void initialize(void) {
    win_no = 0; /* 胜利次数 */
    lose_no = 0; /* 失败次数 */
    draw_no = 0; /* 平局次数 */
    round_no = 0; /* 游戏轮数 */
    srand(time(NULL)); /* 设定随机数种子 */
    printf("猜拳游戏开始！\n");
}

/* 运行猜拳游戏（读取/生成手势） */
void jyanken(void) {
    int i;
    if (round_no % 5 == 4) {
        printf("请你先出：\n");
        for (i = 0; i < 3; i++) {
            printf("(%d)%s ", i, hd[i]);
        }
        printf(": ");
        scanf("%d", &human); /* 读取玩家的手势 */
        comp = rand() % 3; /* 随机生成计算机手势 */
    } else {
        comp = rand() % 3; /* 随机生成计算机手势 */
        do {
            printf("\n\a石头剪刀布...");
            for (i = 0; i < 3; i++) {
                printf("(%d)%s ", i, hd[i]);
            }
            printf(": ");
            scanf("%d", &human); /* 读取玩家的手势 */
        } while (human < 0 || human > 2);
    }
}

/* 更新和显示结果 */
void update_and_display_result(int result) {
    switch (result) {
        case 0:
            draw_no++;
            puts("平局。");
            break;
        case 1:
            lose_no++;
            puts("你输了。");
            break;
        case 2:
            win_no++;
            puts("你赢了。");
            break;
    }
}

/* 记录历史 */
void record_history(int human, int comp, int result) {
    if (round_no < MAX_ROUNDS) {
        human_history[round_no] = human;
        comp_history[round_no] = comp;
        result_history[round_no] = result;
    }
}

/* 显示历史记录 */
void display_history(void) {
    printf("\n历史记录：\n");
    for (int i = 0; i < round_no; i++) {
        printf("第%d轮：你出%s，我出%s -> %s\n", 
            i + 1, hd[human_history[i]], hd[comp_history[i]], 
            result_history[i] == 0 ? "平局" : (result_history[i] == 1 ? "你输了" : "你赢了"));
    }
}

int main(void) {
    int judge; /* 胜负 */
    int retry; /* 再来一次？ */

    initialize(); /* 初始处理 */

    do {
        jyanken(); /* 运行猜拳游戏 */
        judge = (human - comp + 3) % 3; /* 判断胜负 */
        update_and_display_result(judge); /* 更新和显示结果 */
        record_history(human, comp, judge); /* 记录历史 */
        round_no++; /* 增加轮数 */

        printf("再来一次吗...（0）否（1）是：");
        scanf("%d", &retry);
    } while (retry == 1);

    display_history(); /* 显示历史记录 */

    printf("%d胜 %d负 %d平。\n", win_no, lose_no, draw_no);
    return 0;
}


//版本二
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define MAX_ROUNDS 1000 /* 最大记录轮数 */

int human; /* 玩家手势 */
int comp; /* 计算机手势 */
int win_no; /* 胜利次数 */
int lose_no; /* 失败次数 */
int draw_no; /* 平局次数 */
int round_no; /* 游戏轮数 */
int target_wins; /* 目标胜利次数 */

const char *hd[] = {"石头", "剪刀", "布"}; /* 手势 */

int human_history[MAX_ROUNDS]; /* 保存玩家手势 */
int comp_history[MAX_ROUNDS]; /* 保存计算机手势 */
int result_history[MAX_ROUNDS]; /* 保存胜负记录 */

/* 初始处理 */
void initialize(void) {
    win_no = 0; /* 胜利次数 */
    lose_no = 0; /* 失败次数 */
    draw_no = 0; /* 平局次数 */
    round_no = 0; /* 游戏轮数 */
    srand(time(NULL)); /* 设定随机数种子 */
    printf("猜拳游戏开始！\n");

    /* 询问目标胜利次数 */
    printf("要猜赢几次？");
    scanf("%d", &target_wins);
}

/* 运行猜拳游戏（读取/生成手势） */
void jyanken(void) {
    int i;
    if (round_no % 5 == 4) {
        printf("请你先出：\n");
        for (i = 0; i < 3; i++) {
            printf("(%d)%s ", i, hd[i]);
        }
        printf(": ");
        scanf("%d", &human); /* 读取玩家的手势 */
        comp = rand() % 3; /* 随机生成计算机手势 */
    } else {
        comp = rand() % 3; /* 随机生成计算机手势 */
        do {
            printf("\n\a石头剪刀布...");
            for (i = 0; i < 3; i++) {
                printf("(%d)%s ", i, hd[i]);
            }
            printf(": ");
            scanf("%d", &human); /* 读取玩家的手势 */
        } while (human < 0 || human > 2);
    }
}

/* 更新和显示结果 */
void update_and_display_result(int result) {
    switch (result) {
        case 0:
            draw_no++;
            puts("平局。");
            break;
        case 1:
            lose_no++;
            puts("你输了。");
            break;
        case 2:
            win_no++;
            puts("你赢了。");
            break;
    }
}

/* 记录历史 */
void record_history(int human, int comp, int result) {
    if (round_no < MAX_ROUNDS) {
        human_history[round_no] = human;
        comp_history[round_no] = comp;
        result_history[round_no] = result;
    }
}

/* 显示历史记录 */
void display_history(void) {
    printf("\n历史记录：\n");
    for (int i = 0; i < round_no; i++) {
        printf("第%d轮：你出%s，我出%s -> %s\n", 
            i + 1, hd[human_history[i]], hd[comp_history[i]], 
            result_history[i] == 0 ? "平局" : (result_history[i] == 1 ? "你输了" : "你赢了"));
    }
}

int main(void) {
    int judge; /* 胜负 */

    initialize(); /* 初始处理 */

    do {
        jyanken(); /* 运行猜拳游戏 */
        judge = (human - comp + 3) % 3; /* 判断胜负 */
        update_and_display_result(judge); /* 更新和显示结果 */
        record_history(human, comp, judge); /* 记录历史 */
        round_no++; /* 增加轮数 */
    } while (win_no < target_wins && lose_no < target_wins);

    display_history(); /* 显示历史记录 */

    printf(win_no == target_wins ? "\n你赢了。\n" : "\n我赢了。\n");
    printf("%d胜 %d负 %d平。\n", win_no, lose_no, draw_no);
    return 0;
}

3-7

练习3-7编写一个3人对战的“猜拳游戏”。由计算机来担任2个角色，这2个角色的手势都用随机数来生成。
编写两个版本，一个是只要玩家愿意就能不断重复玩的“猜拳游戏”，另一个是猜赢n次就会结束的“猜拳游戏”。

//版本一
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define MAX_ROUNDS 1000 /* 最大记录轮数 */

int human; /* 玩家手势 */
int comp1; /* 计算机1手势 */
int comp2; /* 计算机2手势 */
int win_no; /* 胜利次数 */
int lose_no; /* 失败次数 */
int draw_no; /* 平局次数 */
int round_no; /* 游戏轮数 */

const char* hd[] = { "石头", "剪刀", "布" }; /* 手势 */

int human_history[MAX_ROUNDS]; /* 保存玩家手势 */
int comp1_history[MAX_ROUNDS]; /* 保存计算机1手势 */
int comp2_history[MAX_ROUNDS]; /* 保存计算机2手势 */
int result_history[MAX_ROUNDS]; /* 保存胜负记录 */

/* 初始处理 */
void initialize(void) {
    win_no = 0; /* 胜利次数 */
    lose_no = 0; /* 失败次数 */
    draw_no = 0; /* 平局次数 */
    round_no = 0; /* 游戏轮数 */
    srand(time(NULL)); /* 设定随机数种子 */
    printf("猜拳游戏开始！\n");
}

/* 运行猜拳游戏（读取/生成手势） */
void jyanken(void) {
    int i;
    comp1 = rand() % 3; /* 随机生成计算机1手势 */
    comp2 = rand() % 3; /* 随机生成计算机2手势 */
    do {
        printf("\n\a石头剪刀布...");
        for (i = 0; i < 3; i++) {
            printf("(%d)%s ", i, hd[i]);
        }
        printf(": ");
        scanf("%d", &human); /* 读取玩家的手势 */
    } while (human < 0 || human > 2);
}

/* 更新和显示结果 */
void update_and_display_result(int result) {
    switch (result) {
    case 0:
        draw_no++;
        puts("平局。");
        break;
    case 1:
        lose_no++;
        puts("你输了。");
        break;
    case 2:
        win_no++;
        puts("你赢了。");
        break;
    }
}

/* 记录历史 */
void record_history(int human, int comp1, int comp2, int result) {
    if (round_no < MAX_ROUNDS) {
        human_history[round_no] = human;
        comp1_history[round_no] = comp1;
        comp2_history[round_no] = comp2;
        result_history[round_no] = result;
    }
}

/* 显示历史记录 */
void display_history(void) {
    printf("\n历史记录：\n");
    for (int i = 0; i < round_no; i++) {
        printf("第%d轮：你出%s，计算机1出%s，计算机2出%s -> %s\n",
            i + 1, hd[human_history[i]], hd[comp1_history[i]], hd[comp2_history[i]],
            result_history[i] == 0 ? "平局" : (result_history[i] == 1 ? "你输了" : "你赢了"));
    }
}

/* 判断三者之间的胜负 */
int judge_result(int human, int comp1, int comp2) {
    if (human == comp1 && comp1 == comp2) {
        return 0; // 平局
    }

    int win = 0, lose = 0;
    
    if(comp2 == comp1&& (human - comp2 + 3) % 3 == 2)   return 2;
    if (comp2 == comp1 && (human - comp2 + 3) % 3 == 1)   return 1;


    if (human == comp1 && (human - comp2 + 3) % 3 == 2)    return 2;
    if (human == comp1 && (human - comp2 + 3) % 3 == 1)   return 1;
    
    if (human == comp2 && (human - comp1 + 3) % 3 == 2)   return 2;
    if (human == comp2 && (human - comp1 + 3) % 3 == 1)   return 1;

    return 0;

}

int main(void) {
    int judge; /* 胜负 */
    int retry; /* 再来一次？ */

    initialize(); /* 初始处理 */

    do {
        jyanken(); /* 运行猜拳游戏 */
        judge = judge_result(human, comp1, comp2); /* 判断胜负 */
        update_and_display_result(judge); /* 更新和显示结果 */
        record_history(human, comp1, comp2, judge); /* 记录历史 */
        round_no++; /* 增加轮数 */

        printf("再来一次吗...（0）否（1）是：");
        scanf("%d", &retry);
    } while (retry == 1);

    display_history(); /* 显示历史记录 */

    printf("%d胜 %d负 %d平。\n", win_no, lose_no, draw_no);
    return 0;
}


//版本二
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define MAX_ROUNDS 1000 /* 最大记录轮数 */

int human; /* 玩家手势 */
int comp1; /* 计算机1手势 */
int comp2; /* 计算机2手势 */
int win_no; /* 胜利次数 */
int lose_no; /* 失败次数 */
int draw_no; /* 平局次数 */
int round_no; /* 游戏轮数 */
int target_wins; /* 目标胜利次数 */

const char* hd[] = { "石头", "剪刀", "布" }; /* 手势 */

int human_history[MAX_ROUNDS]; /* 保存玩家手势 */
int comp1_history[MAX_ROUNDS]; /* 保存计算机1手势 */
int comp2_history[MAX_ROUNDS]; /* 保存计算机2手势 */
int result_history[MAX_ROUNDS]; /* 保存胜负记录 */

/* 初始处理 */
void initialize(void) {
    win_no = 0; /* 胜利次数 */
    lose_no = 0; /* 失败次数 */
    draw_no = 0; /* 平局次数 */
    round_no = 0; /* 游戏轮数 */
    srand(time(NULL)); /* 设定随机数种子 */
    printf("猜拳游戏开始！\n");

    /* 询问目标胜利次数 */
    printf("要猜赢几次？");
    scanf("%d", &target_wins);
}

/* 运行猜拳游戏（读取/生成手势） */
void jyanken(void) {
    int i;
    comp1 = rand() % 3; /* 随机生成计算机1手势 */
    comp2 = rand() % 3; /* 随机生成计算机2手势 */
    do {
        printf("\n\a石头剪刀布...");
        for (i = 0; i < 3; i++) {
            printf("(%d)%s ", i, hd[i]);
        }
        printf(": ");
        scanf("%d", &human); /* 读取玩家的手势 */
    } while (human < 0 || human > 2);
}

/* 更新和显示结果 */
void update_and_display_result(int result) {
    switch (result) {
    case 0:
        draw_no++;
        puts("平局。");
        break;
    case 1:
        lose_no++;
        puts("你输了。");
        break;
    case 2:
        win_no++;
        puts("你赢了。");
        break;
    }
}

/* 记录历史 */
void record_history(int human, int comp1, int comp2, int result) {
    if (round_no < MAX_ROUNDS) {
        human_history[round_no] = human;
        comp1_history[round_no] = comp1;
        comp2_history[round_no] = comp2;
        result_history[round_no] = result;
    }
}

/* 显示历史记录 */
void display_history(void) {
    printf("\n历史记录：\n");
    for (int i = 0; i < round_no; i++) {
        printf("第%d轮：你出%s，计算机1出%s，计算机2出%s -> %s\n",
            i + 1, hd[human_history[i]], hd[comp1_history[i]], hd[comp2_history[i]],
            result_history[i] == 0 ? "平局" : (result_history[i] == 1 ? "你输了" : "你赢了"));
    }
}

/* 判断三者之间的胜负 */
int judge_result(int human, int comp1, int comp2) {
    if (human == comp1 && comp1 == comp2) {
        return 0; // 平局
    }

    if (comp2 == comp1 && (human - comp2 + 3) % 3 == 2) return 2;
    if (comp2 == comp1 && (human - comp2 + 3) % 3 == 1) return 1;

    if (human == comp1 && (human - comp2 + 3) % 3 == 2) return 2;
    if (human == comp1 && (human - comp2 + 3) % 3 == 1) return 1;

    if (human == comp2 && (human - comp1 + 3) % 3 == 2) return 2;
    if (human == comp2 && (human - comp1 + 3) % 3 == 1) return 1;

    return 0;
}

int main(void) {
    int judge; /* 胜负 */

    initialize(); /* 初始处理 */

    do {
        jyanken(); /* 运行猜拳游戏 */
        judge = judge_result(human, comp1, comp2); /* 判断胜负 */
        update_and_display_result(judge); /* 更新和显示结果 */
        record_history(human, comp1, comp2, judge); /* 记录历史 */
        round_no++; /* 增加轮数 */
    } while (win_no < target_wins);

    display_history(); /* 显示历史记录 */

    printf("%d胜 %d负 %d平。\n", win_no, lose_no, draw_no);
    return 0;
}
jokr_q
关注
专栏目录
明解C语言两册
03-09
《明解C语言》是C语言学习者的一套经典教程，分为入门篇和中级篇，旨在帮助初学者和有一定基础的程序员深入理解C语言。这套书籍以其实例驱动、由浅入深的教学方式著称，让读者在实践中学习，提高理解和应用能力。 ...
李峰《C语言程序设计》第2版 教材答案+上机指导
04-10
《C语言程序设计》是李峰教授编著的一本经典的C语言教材，其第二版针对初学者和进阶者提供了全面且深入的C语言学习资源。该教材深受广大编程爱好者和计算机专业学生的喜爱，因其清晰的讲解和丰富的实例而广受好评。...
C语言中级能力提升适用于一定C基础
07-29
【C语言中级能力提升适用于一定C基础】 C语言是一种强大的编程语言，对于初学者来说，掌握基本语法和概念是入门的关键。本课程针对已经有一定C语言基础的学习者，旨在提升其在C语言中的中高级技能，使他们能够更...
C语言课件 第1章 C语言概述.pdf
05-27
C语言是从早期的编程语言BCPL发展而来的，它结合了汇编语言的直接硬件控制能力和高级语言的易读性与可移植性，因此被称为中级语言。 在C语言的发展过程中，经历了多个标准的制定。1978年，由Brian Kernighan和...
西北工业大学C语言第12周练习答案
05-23
本资源聚焦于西北工业大学C语言课程的第12周练习，旨在帮助学生巩固和提升C语言的编程技能。这个压缩包包含了第12周的作业源代码，对于那些在学习过程中遇到困难或者想进一步提高编程能力的学生来说，是一个宝贵的...
C语言——头插法和尾插法动态创建链表
weixin_45720999的博客
10-17 336
在C语言中，动态创建列表通常指的是使用链表（Linked List）这种数据结构。链表由一系列节点（Node）组成，每个节点包含数据部分和指向下一个节点的指针。根据插入节点的位置不同，链表的插入操作可以分为头插法和尾插法。下面将详细介绍这两种方法。
【算法】双指针
2303_80828380的博客
10-13 801
力扣oj题之双指针算法
C++中的vector介绍（常用函数）
zxybf_的博客
10-15 785
vector的文档介绍vector是序列容器，表示可以改变大小的数组。(constructor)构造函数声明接口说明vector()（重点）无参构造构造并初始化n个val（重点）拷贝构造使用迭代器进行初始化构造int main()//无参的构造//n个val的构造//拷贝构造//迭代器区间构造return 0;
Python 使用 Jarvis 算法或包装的凸包（Convex Hull using Jarvis’ Algorithm or Wrapping）
csdn_aspnet的专栏
10-14 1221
例如，当输入 (0, 3), (0, 0), (0, 1), (3, 0), (3, 3) 时，它产生 (0, 3) (0, 0) (3, 0) (3, 3) 的输出；当输入 (0, 3), (0, 1), (0, 0), (3, 0), (3, 3) 时，输出为 (0, 3) (0, 1) (0, 0) (3, 0) (3, 3)。下一个点被选为在逆时针方向上领先于所有其他点的点，即，如果对于任何其他点 r，我们有“orientation(p, q, r) = 逆时针”，则下一个点是 q。
数据结构常考基础代码题-数组倒置
qq_52291558的博客
10-16 456
根据题目中的“将数组中的元素顺序反转”，我们需要实现一个函数Reverse，用于反转数组中从start到end的元素。// 函数用于反转数组A中从start到end的元素int temp;// 使用while循环进行元素交换，直到start和end相遇或交叉// 保存A[start]的值// 将A[end]的值赋给A[start]// 将temp（原A[start]的值）赋给A[end]start++;// 移动start指针end--;// 移动end指针。
【从零开始的LeetCode-算法】3099. 哈沙德数
qq_40878316的博客
10-15 334
如果一个整数能够被其各个数位上的数字之和整除，则称之为。各个数位上的数字之和，否则，返回。各个数位上的数字之和为。各个数位上的数字之和为。不是哈沙德数，答案是。
端盘子问题（二分查找+广度优先）
u012011912的博客
10-16 289
终于中午放学铃声打响了，小明想要尽快地前往食堂打自己最喜欢吃的菜。小明觉得，他会准备好若干个盘子再出发，带了几个盘子就打几份菜。但是一路上人群拥挤程度不同，如果太过拥挤，小明会拿不稳太多盘子。经过观察，小明发现食堂的地形可以用一个(1,1)(n,n)小明行走，并且每次可以花费 1 秒，从当前位置(i, j)移动到相邻的(i+1, j)(i, j+1)(i-1, j)或(i, j-1)。(1,1)(n,n)如果无论如何也不能在规定时间内到达终点，输出0。第一行包含两个整数n和Tnn × nT接下来n。
「4.4」祖孙询问
no_play_no_games的博客
10-16 463
有 m 个询问，每个询问给出了一对节点的编号 x 和 y，询问 x 与 y 的祖孙关系。接下来 n 行每行一对整数对 a 和 b 表示 a 和 b 之间有连边。对于每一个询问，若 x 是 y 的祖先则输出 1，若 y 是 x 的祖先则输出 2，否则输出 0。对于 100% 的数据，1≤n,m≤4×10^4，每个节点的编号都不超过 4×10^4。接下来 m 行，每行两个正整数 x 和 y，表示一个询问。第 n+2 行是一个整数 m 表示询问个数；对于 30% 的数据，1≤n,m≤10^3；
详细说明如何使用C++编写A*算法
最新发布
zsy54577的博客
10-19 964
它结合了广度优先搜索的全面性和深度优先搜索的效率，通过估计当前路径代价和到达目标的预估代价，来找到从起点到目标的最短路径。类型的指针，它指向当前节点的父节点。在路径搜索树中，每个节点（除了根节点）都有一个父节点，指向它在树中的直接上级。这个指针用于重建从起点到终点的路径，一旦找到终点，可以通过追踪这些父节点指针回溯到起点。通过构建一个优先队列，A*算法每次从未探索的节点中选择f值最小的节点进行扩展，直至找到目标节点或遍历完整个搜索空间。
PMRF：一种新的图像恢复算法 高质量修复图像 降低图像失真还原跟自然逼真度
GDL_MPY的博客
10-14 1040
（Posterior-Mean Rectified Flow，后验均值修正流）是一种新提出的图像恢复算法，旨在解决图像恢复任务中的。在去噪、超分辨率、修复等不同图像恢复任务中，PMRF能够在多个图像质量评估指标（如PSNR、SSIM、FID等）上表现出色，且没有明显的弱点，展示了其在多任务环境下的稳健性。图像恢复任务（如去噪、超分辨率、盲恢复等）中，常常需要在（如均方误差MSE）和（如图像的真实感和自然度，使用FID、SSIM等衡量）之间做权衡。
深度解析RLS（Recursive Least Squares）算法
weixin_52734695的博客
10-15 1181
RLS（Recursive Least Squares）算法作为一种自适应滤波的强大工具，凭借其快速收敛和高精度的特性，广泛应用于信道均衡、噪声消除、系统辨识等场景中。虽然它的计算复杂度较高，但其优越的性能在许多高要求场景中展现了不可替代的价值。总的来说，RLS算法的核心在于最小化所有历史误差的平方和，并通过递归更新滤波器的系数。尽管其计算复杂，但通过合理优化，如引入遗忘因子或采用高效矩阵运算技术，可以显著提升其计算效率。
【博士每天一篇文献-算法】多任务学习之MGDA算法：Multi-Task Learning as Multi-Objective Optimization
BetterBench的博客
10-15 1261
本文提出了一种基于梯度的多目标优化算法，用于多任务学习，该算法通过优化一个上界来高效地找到帕累托最优解，且只需单次反向传播。
《深度学习》OpenCV EigenFaces算法 人脸识别
wx_AHao1004Y的博客
10-16 1013
EigenFaces算法，又称为基于主成分分析（Principal Component Analysis，PCA）的人脸识别方法，是一种在人脸识别领域具有重要地位的经典算法。主成分分析（PCA）是一种矩阵的压缩算法，在减少矩阵维数的同时尽可能的保留原矩阵的信息，简单来说就是将n×m的矩阵转换成n×k的矩阵，仅保留矩阵中所存在的主要特性，从而可以大大节省空间和数据量。
数据结构与算法：图的高级算法
weidl001的博客
10-15 970
本章深入介绍了图的高级算法，包括最短路径、最小生成树、网络流等问题的经典解决方案及其实现。通过理解这些算法，我们可以应对复杂的网络优化、路径规划等实际问题。图的高级算法不仅是解决理论问题的重要工具，也是解决许多实际场景中的优化问题的关键。下一章将探讨字符串匹配算法，包括基础字符串匹配、KMP 算法、Boyer-Moore 算法及其在实际系统中的应用。
C语言入门：第一章精华讲解
"C语言 第一章ppt讲解，包含了C语言程序设计的初步介绍，由讲师王凌主讲，提供课件下载，并分享了公共邮箱以获取更多学习资料。课程强调理论与实践相结合，鼓励多上机练习，通过阅读和理解不同复杂度的C语言程序来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值