c语言实现扫雷OJ版（北邮大作业）

最新推荐文章于 2024-09-07 01:14:50 发布
最新推荐文章于 2024-09-07 01:14:50 发布
阅读量194 收藏
点赞数 1
文章标签： c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Crsdle/article/details/131466476
版权
文章详细描述了扫雷游戏的在线判断（OJ）版本的代码实现，包括初始化棋盘、读取和处理操作、判断游戏状态等功能。代码实现了从读入数据到游戏结束的各种操作，如左键单击、右键标记等，并提供了游戏提示和状态输出。
摘要由CSDN通过智能技术生成

目录

问题描述

需求分析（游戏规则）；

OJ版本代码实现

                1.进行初始化

        2.读取操作步骤，更改单元状态

        3.判断当前游戏状态

        4.OJ版本全部代码

问题描述

有一个一定大小的矩阵（初级9x9，中级16x16，高级16x30或自定义大小)，矩阵中随机布置一定量的地雷 (初级为 10 个，中级为 40 个，高级为 99 个) ，但是雷区大小不能超过 24 × 30。由玩家逐个翻开格子，以找出所有地雷为最终游戏目标。如果玩家翻开的格子有地雷，则游戏失败。如果玩家翻开所有没有地雷的格子，则游戏胜利。

需求分析（游戏规则）；

扫雷规模类型

初级雷区，矩阵大小为9x9，内含有10个雷。

中级雷区，矩阵大小为16x16，内含有40雷。

高级雷区，矩阵大小为16x30，内含有99个类。

自定义雷区，矩阵大小不能小于9x9，不能超过24x30，雷数最小为10个，最多不能超过雷区的90%。

扫雷的操作规则和要求

操作规则

1. 左键单击。打开该格子，如果该格子周围 3 × 3 区域中有雷，则显示雷的个数；如果地雷个数为 0， 则显示为 0 并打开周围 3 × 3 区域中所有未被打开的格子。

2. 右键单击标记地雷。如果该位置为未被打开的格子或问题标记的格子，该位置可以被标记为地雷，以"!"显示。

3. 右键单击标记问题。如果该位置为未被打开的格子或地雷标记的格子，该位置可以被标记为问题，以"?"显示。

4. 右键单击取消标记。如果该位置为问题标记或地雷标记的格子，该位置可以被取消标记，恢复为未被 打开的格子。

5. 双击。当双击位置周围已标记雷数等于该位置数字时操作有效，相当于对该数字周围未标记且未打开的格子均进行一次左键单击操作。地雷未标记完全时使用双击无效。若数字周围有标错的地雷，则游戏结束。

OJ版本代码实现

游戏提示：

1. 如果玩家未触雷且游戏未胜利，提示"Game in progress"。

2. 如果玩家点开了所有没有雷的格子（不需要完全标记地雷），提示"Game over, you win"。

3. 如果玩家点开有雷的格子，提示"Hit mine, you lose"。

输入和输出

Input
第 一 行 一个 整数 1 − 4 表 示 ， 表 示 初 级 、 中 级 、 高 级 、 自 定 义 。 如 果 是 自 定 义 ， 则 紧 跟 着 三个 整数分别表示行数 N，列数 M 和雷数 C。
从 第 二 行 开 始 的 N 行 M 列 表 示 棋 盘 。 "." 表 示 没 有 雷 ， "*" 表 示 有 雷 ， 保 证 棋 盘 数 据 合 法 。
之 后 的 每 一 行 三个 整数 表 示 一个 操 作 ， 操 作 类 型 1 , 2 , 3 , 4 , 9 以 及 坐 标 ( x, y ) （
1 ≤ x ≤ N, 1 ≤ y ≤ M ），
表 示 对 x 行 y 列 进 行 操 作 。
Output
对 于 每 一个 操 作 ， 第 一 行 输 出 游 戏 提 示 。
第 二 行 输 出 两个 整数 ， 操 作 次 数 和 剩 余 地 雷 数 量 。
之 后 的 N 行 M 列 输 出 棋 盘 ， "." 表 示 没 点 开 的 格 子 ， "?" 表 示 问 题 标 记 ， "!" 表 示 地 雷 标 记 ， 用 0 − 8 表
示 已 经 点 开 的 格 子 。
如 果本 次 输 入 的 操 作 不 合 法 ， 则 忽 略 这 次 操 作 ， 只 增 加 操 作 次 数 但 不 会 对 棋 盘 进 行 改 动 。 胜 利 或 失 败 之
后 需 要 在 输 出 棋 盘 时 ， 所 有 地 雷 所 在 位 置 输 出 "*" ， 其 余位 置 输 出 当 前 操 作 后 的 棋 盘 状 态 。
整体思路：
首先通过创建数组实现对读入的存储和转换，再通过循环读入实现棋盘状态的迁移和转换，再通过函数判断游戏进行状态。主要运用有限状态机的思想和分治法，将整体步骤分成若干个函数模块依次解决，将操作步骤细分为一个个小步骤。
1.进行初始化
通过创建一个二维数组将读入的字符串转换为‘0’和‘1’的数字存储，‘0’表示无雷，‘1’表示有雷。 
 char a[maxsize][maxsize];//根据读入初始化棋盘
    int i, j;
    for (i = 1; i <= row; i++)
    {
        scanf("%s", a[i]);
    }
    for (i = 1; i <= row; i++)
    {
        for (j = 0; j < column; j++)
        {
            if (a[i][j] == '*')
                board[i][j + 1] = 1;
            else if (a[i][j] == '.')
            {
                board[i][j + 1] = 0;
            }
        }
    }
还需要创建一个一维数组用来存储每个单元周围雷数 
  int i, j, sum, i1, j1, i2, j2, i3, j3;
    for (i = 1; i <= row; i++)
    {
        for (j = 1; j <= column; j++)
        {
            range(i,j, &i1, &i2, &j1, &j2, row,  column);//确定周围8块的范围
            sum = 0;
            for (i3 = i1; i3 <= i2; i3++)
            {
                for (j3 = j1; j3 <= j2; j3++)
                {
                    sum += board[i3][j3];
                }
            }
            sum = sum - board[i][j];
            ThunderNumber[i][j] = sum;
        }
    }
这个range函数可以通过设置空区间（缓冲区，即在原有棋盘下多增设两行两列）来避免 
void range(int i, int j, int* i1, int* i2, int* j1, int* j2, int row, int column)
{
    *i1 = i - 1;
    *i2 = i + 1;
    if (i == 1)
    {
        *i1 = 1;
    }
    else if (i == row)
    {
        *i2 = row;
    }
    *j1 = j - 1;
    *j2 = j + 1;
    if (j == 1)
    {
        *j1 = 1;
    }
    else if (j == column)
    {
        *j2 = column;
    }
}
同时可以创建一个二维数组存储各个单元的状态，‘0’表示未被打开（故初始化全为0），‘2’
表示标记为问号，‘3’表示标记为插旗，‘4’表示为已经被打开。（初始情况默认全部未被打开）

2.读取操作步骤，更改单元状态

循环读入操作步骤以及操作位置，实现对相应单元状态的迁移和更改

void transform(int Boardstatue[][maxsize], int row, int column, int ThunderNumber[maxsize][maxsize], int board[][maxsize], int thunderleft, int thunder)
{
    int operation, x, y;
    int Is = 1, times = 0;
    while (Is == 1 && scanf("%d", &operation) != EOF && scanf("%d %d", &x, &y) != EOF)//当操作不合法时
    { 
        times++;
        if (x<1 || x>row || y<1 || y>column||(operation!=1&&operation!=4&&operation!=2&&operation!=3&&operation!=9))
        {
            operation = 11;//操作不合法时直接选择跳出本次循环
        }
        switch (operation)
        {
        case 1:
            Leftclick(Boardstatue,board, x, y, row, column, ThunderNumber);
            break;
        case 2:
            Rightclick1(Boardstatue, x, y);
            break;
        case 3:
            Rightclick2(Boardstatue, x, y);
            break;
        case 4:
            Rightclick3(Boardstatue, x, y);
            break;
        case 9:
            Doubleclick(Boardstatue, board, x, y, row, column, ThunderNumber);
            break;
        default:
            break;
        }
        thunderleft = Thunderleft(thunder, row, column, Boardstatue);
        Is = judge(board, Boardstatue, ThunderNumber, row, column, thunderleft, times);
    }
}

左键单击函数代码实现，注意操作无效的情况（x，y越界或者该单元已经被打开或该单元为插旗状态）

void Leftclick(int Boardstatue[][maxsize],int board[][maxsize], int x, int y, int row, int column, int ThunderNumber[maxsize][maxsize])
{
    int i, i1, i2, i3, j, j1, j2, j3;
    int x1, y1;
    if (x<1 || x>row || y<1 || y>column || Boardstatue[x][y]==4||Boardstatue[x][y]==3)//操作无效时
    {
        return;
    }
       Boardstatue[x][y] = 4;
       if (ThunderNumber[x][y] == 0&&board[x][y]!=1)
       {
           range(x, y, &i1, &i2, &j1, &j2, row, column);
           for (i3 = i1; i3 <= i2; i3++)
           {
               for (j3 = j1; j3 <= j2; j3++)
               {
                   if (i3 == x && j3 == y)
                   {
                       continue;
                   }
                   Leftclick(Boardstatue,board, i3,j3, row, column, ThunderNumber);
               }
           }
       }
       else if (board[x][y] == 1)
       {
           return;
       }
}

右键单击代码实现，完成相应状态的迁移（0是未被打开，2是标记为问号，3是标记为插雷，4是已经被打开）

void Rightclick2(int Boardstatue[][maxsize], int x, int y)
{
    if (Boardstatue[x][y] == 0)
    {
        Boardstatue[x][y] = 2;
    }
    else if (Boardstatue[x][y] == 3)
    {
        Boardstatue[x][y] = 2;
    }
}
void Rightclick3(int Boardstatue[][maxsize], int x, int y)
{
    if (Boardstatue[x][y] == 2 || Boardstatue[x][y] == 3)
    {
        Boardstatue[x][y] = 0;
    }
}

双击代码的实现，注意操作无效的情况和双击打开周围格子中有周围雷数为0时（递归打开周围所有格子）

void Doubleclick(int Boardstatue[][maxsize], int board[][maxsize], int x, int y, int row, int column, int ThunderNumber[maxsize][maxsize])
{
    int i1, i2, i3, j1, j2, j3;
    int sum = 0, is = 1;
    if (Boardstatue[x][y] !=4)//该块没被打开时，该操作无效
    {
        return;
    }
    range(x, y, &i1, &i2, &j1, &j2, row, column);
    for (i3 = i1; i3 <= i2; i3++)//计算周围棋数
    {
        for (j3 = j1; j3 <= j2; j3++)
        {
            if (Boardstatue[i3][j3] == 3)
            {
                sum++;
            }
        }
    }
    if (sum == ThunderNumber[x][y])//棋数等于雷数时，才可以被打开
    {
        for (i3 = i1; i3 <= i2; i3++)
        {
            for (j3 = j1; j3 <= j2; j3++)
            {
                if (Boardstatue[i3][j3] != 3 && board[i3][j3] == 1)
                {
                    is = 0;
                    Boardstatue[i3][j3] = 4;
                }
            }
        }

        if (is == 1)
        {
            for (i3 = i1; i3 <= i2; i3++)
            {
                for (j3 = j1; j3 <= j2; j3++)
                {
                    if ( Boardstatue[i3][j3] != 3)
                    { 
                        if (ThunderNumber[i3][j3] == 0)
                        {
                            Leftclick(Boardstatue,board, i3, j3, row, column, ThunderNumber);//递归打开周围所有单元
                        }
                        Boardstatue[i3][j3] = 4;
                     }
                 } 
            }
        }
    }

}

3.判断当前游戏状态

首先是要确定当前剩余雷数，总格子数减去打开的单元数，剩下的就是剩余雷数,代码实现

int Thunderleft(int thunder, int row, int column, int Boardstatue[][maxsize])//确定剩余的雷数
{
    int i, j;
    int sum = 0;
    for (i = 1; i <= row; i++)
    {
        for (j = 1; j <= column; j++)
        {
            if (Boardstatue[i][j] == 3)
            {
                sum++;
            }
        }
    }
    thunder = thunder - sum;
    return thunder;
}

对所有单元格进行遍历，检查是否有雷单元已经被打开，如果有返回1，若所有非雷都被打开，返回2，其他返回0（表示游戏正在进行）

int Iscontinue(int Board[][maxsize], int Boardstatue[][maxsize], int row, int column)
{
    int i, j, IS = 1, win = 1;
    for (i = 1; i <= row && IS == 1; i++)
    {
        for (j = 1; j <= column && IS == 1; j++)
        {
            if (Board[i][j] == 1 && Boardstatue[i][j] == 4)
            {
                IS = 0;
                break;
            }
            if (Board[i][j] == 0 && Boardstatue[i][j] != 4)
            {
                win = 0;
            }
        }
    }
    if (IS == 1 && win == 1)
        return 2;
    else
        return IS;
}

再根据当前游戏状态输出游戏提示和当前棋盘状态

int judge(int Board[][maxsize], int Boardstatue[][maxsize], int ThunderNumber[][maxsize], int row, int column, int thunderleft, int times)
{
    if (Iscontinue(Board, Boardstatue, row, column) == 1)
    {
        printf("Game in progress\n");
        print1(Board, Boardstatue, ThunderNumber, row, column, thunderleft, times);
        return 1;
    }
    else if (Iscontinue(Board, Boardstatue, row, column) == 0)
    {
        printf("Hit mine, you lose\n");
        printf("%d %d\n", times, thunderleft);
        print2(Board, Boardstatue, ThunderNumber, row, column);
        return 0;
    }
    else if (Iscontinue(Board, Boardstatue, row, column) == 2)
    {
        printf("Game over, you win\n");
        printf("%d %d\n", times, thunderleft);
        print2(Board, Boardstatue, ThunderNumber, row, column);
        return 2;
    }
}

输出函数print1和print2

void print1(int Board[][maxsize], int Boardstatue[][maxsize], int ThunderNumber[][maxsize], int row, int column, int thunderleft, int times)
{
    int i, j;
    printf("%d %d\n", times, thunderleft);
    for (i = 1; i <= row; i++)
    {
        for (j = 1; j <= column; j++)
        {
            if (Boardstatue[i][j] == 0)
                printf(".");
            else if (Boardstatue[i][j] == 2)
                printf("?");
            else if (Boardstatue[i][j] == 3)
                printf("!");
            else if (Boardstatue[i][j] == 4)
                printf("%d", ThunderNumber[i][j]);
        }
        printf("\n");
    }
}
void print2(int Board[][maxsize], int Boardstatue[][maxsize], int ThunderNumber[][maxsize], int row, int column)
{
    int i, j;
    for (i = 1; i <= row; i++)
    {
        for (j = 1; j <= column; j++)
        {
            if (Board[i][j] == 1)
                printf("*");
            else if (Boardstatue[i][j] == 0)
                printf(".");
            else if (Boardstatue[i][j] == 2)
                printf("?");
            else if (Boardstatue[i][j] == 3)
                printf("!");
            else if (Boardstatue[i][j] == 4)
                printf("%d", ThunderNumber[i][j]);
        }
        printf("\n");
    }
}

4.OJ版本全部代码

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define maxsize 35

void initial_(int row, int column, int board[maxsize][maxsize], int ThunderNumber[maxsize][maxsize]);
int Thunderleft(int thunder, int row, int column, int Boardstatue[][maxsize]);
void CreatlistThunderNumber0(int row, int column, int board[maxsize][maxsize], int ThunderNumber[maxsize][maxsize]);
void Leftclick(int Boardstatue[][maxsize], int board[maxsize][maxsize], int x, int y, int row, int column, int ThunderNumber[maxsize][maxsize]);
void Rightclick1(int Boardstatue[][maxsize], int x, int y);
void Rightclick2(int Boardstatue[][maxsize], int x, int y);
void Rightclick3(int Boardstatue[][maxsize], int x, int y);
void Doubleclick(int Boardstatue[][maxsize], int Board[][maxsize], int x, int y, int row, int column, int ThunderNumber[maxsize][maxsize]);
void transform(int Boardstatue[][maxsize], int row, int column, int ThunderNumber[maxsize][maxsize], int board[][maxsize], int thunderleft, int thunder);
int judge(int Board[][maxsize], int Boardstatue[][maxsize], int ThunderNumber[][maxsize], int row, int column, int thunderleft, int times);
int Iscontinue(int Board[][maxsize], int Boardstatue[][maxsize], int row, int column);
void print1(int Board[][maxsize], int Boardstatue[][maxsize], int ThunderNumber[][maxsize], int row, int column, int thunderleft, int times);
void print2(int Board[][maxsize], int Boardstatue[][maxsize], int ThunderNumber[][maxsize], int row, int column); 

int main()
{
    int n, row, column;
    int board[maxsize][maxsize] = { 0 };//将原有字符棋盘转换为0和1的二维数组排列（0表示无雷，1表示有雷）
    int Boardstatue[maxsize][maxsize] = { 0 };//存储每个块的状态0表示未打开，
    int ThunderNumber[maxsize][maxsize] = { 0 };//计算并存储每个块周围的雷数
    int  thunderleft = 0;//剩余的雷数=雷数-插旗数
    int thunder;
    int number = 0;

    //0 未打开  1 有雷  2问号  3插旗  4已打开

    scanf("%d", &n);//确定棋盘规模
    switch (n) {
    case 1:
        row = 9;
        column = 9;
        thunder = 10;
        break;
    case 2:
        row = 16;
        column = 16;
        thunder = 40;
        break;
    case 3:
        row = 16;
        column = maxsize;
        thunder = 99;
        break;
    case 4:
        scanf("%d", &row);
        scanf("%d", &column);
        scanf("%d", &thunder);
        break;
    }
    getchar();
    initial_(row, column, board, ThunderNumber);//初始化Board[][]和ThunderNumber[][]
    thunderleft = thunder;
    transform(Boardstatue, row, column, ThunderNumber, board, thunderleft, thunder);//进行连续的操作
}
void initial_(int row, int column, int board[][maxsize], int ThunderNumber[maxsize][maxsize])
{
    char a[maxsize][maxsize];
    int i, j;
    for (i = 1; i <= row; i++)
    {
        scanf("%s", a[i]);
    }
    for (i = 1; i <= row; i++)
    {
        for (j = 0; j < column; j++)
        {
            if (a[i][j] == '*')
                board[i][j + 1] = 1;
            else if (a[i][j] == '.')
            {
                board[i][j + 1] = 0;
            }
        }
    }
    CreatlistThunderNumber0(row, column, board, ThunderNumber);//创建ThunderNumber[][]
}
void CreatlistThunderNumber0(int row, int column, int board[maxsize][maxsize], int ThunderNumber[maxsize][maxsize])
{
    int i, j, sum, i1, j1, i2, j2, i3, j3;
    for (i = 1; i <= row; i++)
    {
        for (j = 1; j <= column; j++)
        {
            range(i,j, &i1, &i2, &j1, &j2, row,  column);//确定周围8块的范围
            sum = 0;
            for (i3 = i1; i3 <= i2; i3++)
            {
                for (j3 = j1; j3 <= j2; j3++)
                {
                    sum += board[i3][j3];
                }
            }
            sum = sum - board[i][j];
            ThunderNumber[i][j] = sum;
        }
    }
}

void range(int i, int j, int* i1, int* i2, int* j1, int* j2, int row, int column)
{
    *i1 = i - 1;
    *i2 = i + 1;
    if (i == 1)
    {
        *i1 = 1;
    }
    else if (i == row)
    {
        *i2 = row;
    }
    *j1 = j - 1;
    *j2 = j + 1;
    if (j == 1)
    {
        *j1 = 1;
    }
    else if (j == column)
    {
        *j2 = column;
    }
}
void transform(int Boardstatue[][maxsize], int row, int column, int ThunderNumber[maxsize][maxsize], int board[][maxsize], int thunderleft, int thunder)
{
    int operation, x, y;
    int Is = 1, times = 0;
    while (Is == 1 && scanf("%d", &operation) != EOF && scanf("%d %d", &x, &y) != EOF)//当操作不合法时
    { 
        times++;
        if (x<1 || x>row || y<1 || y>column||(operation!=1&&operation!=4&&operation!=2&&operation!=3&&operation!=9))
        {
            operation = 11;
        }
        switch (operation)
        {
        case 1:
            Leftclick(Boardstatue,board, x, y, row, column, ThunderNumber);
            break;
        case 2:
            Rightclick1(Boardstatue, x, y);
            break;
        case 3:
            Rightclick2(Boardstatue, x, y);
            break;
        case 4:
            Rightclick3(Boardstatue, x, y);
            break;
        case 9:
            Doubleclick(Boardstatue, board, x, y, row, column, ThunderNumber);
            break;
        default:
            break;
        }
        thunderleft = Thunderleft(thunder, row, column, Boardstatue);
        Is = judge(board, Boardstatue, ThunderNumber, row, column, thunderleft, times);
    }
}
int Thunderleft(int thunder, int row, int column, int Boardstatue[][maxsize])//确定剩余的雷数
{
    int i, j;
    int sum = 0;
    for (i = 1; i <= row; i++)
    {
        for (j = 1; j <= column; j++)
        {
            if (Boardstatue[i][j] == 3)
            {
                sum++;
            }
        }
    }
    thunder = thunder - sum;
    return thunder;
}
void Leftclick(int Boardstatue[][maxsize],int board[][maxsize], int x, int y, int row, int column, int ThunderNumber[maxsize][maxsize])
{
    int i, i1, i2, i3, j, j1, j2, j3;
    int x1, y1;
    if (x<1 || x>row || y<1 || y>column || Boardstatue[x][y]==4||Boardstatue[x][y]==3)//操作无效时
    {
        return;
    }
       Boardstatue[x][y] = 4;
       if (ThunderNumber[x][y] == 0&&board[x][y]!=1)
       {
           range(x, y, &i1, &i2, &j1, &j2, row, column);
           for (i3 = i1; i3 <= i2; i3++)
           {
               for (j3 = j1; j3 <= j2; j3++)
               {
                   if (i3 == x && j3 == y)
                   {
                       continue;
                   }
                   Leftclick(Boardstatue,board, i3,j3, row, column, ThunderNumber);
               }
           }
       }
       else if (board[x][y] == 1)
       {
           return;
       }
}
void Rightclick1(int Boardstatue[][maxsize], int x, int y)
{
    if (Boardstatue[x][y] == 0 || Boardstatue[x][y] == 2)
    {
        Boardstatue[x][y] = 3;
    }
}
void Rightclick2(int Boardstatue[][maxsize], int x, int y)
{
    if (Boardstatue[x][y] == 0)
    {
        Boardstatue[x][y] = 2;
    }
    else if (Boardstatue[x][y] == 3)
    {
        Boardstatue[x][y] = 2;
    }
}
void Rightclick3(int Boardstatue[][maxsize], int x, int y)
{
    if (Boardstatue[x][y] == 2 || Boardstatue[x][y] == 3)
    {
        Boardstatue[x][y] = 0;
    }
}
void Doubleclick(int Boardstatue[][maxsize], int board[][maxsize], int x, int y, int row, int column, int ThunderNumber[maxsize][maxsize])
{
    int i1, i2, i3, j1, j2, j3;
    int sum = 0, is = 1;
    if (Boardstatue[x][y] !=4)//该块没被打开直接时，该操作无效
    {
        return;
    }
    range(x, y, &i1, &i2, &j1, &j2, row, column);
    for (i3 = i1; i3 <= i2; i3++)//计算周围棋数
    {
        for (j3 = j1; j3 <= j2; j3++)
        {
            if (Boardstatue[i3][j3] == 3)
            {
                sum++;
            }
        }
    }
    if (sum == ThunderNumber[x][y])
    {
        for (i3 = i1; i3 <= i2; i3++)
        {
            for (j3 = j1; j3 <= j2; j3++)
            {
                if (Boardstatue[i3][j3] != 3 && board[i3][j3] == 1)
                {
                    is = 0;
                    Boardstatue[i3][j3] = 4;
                }
            }
        }

        if (is == 1)
        {
            for (i3 = i1; i3 <= i2; i3++)
            {
                for (j3 = j1; j3 <= j2; j3++)
                {
                    if ( Boardstatue[i3][j3] != 3)
                    { 
                        if (ThunderNumber[i3][j3] == 0)
                        {
                            Leftclick(Boardstatue,board, i3, j3, row, column, ThunderNumber);
                        }
                        Boardstatue[i3][j3] = 4;
                     }
                 } 
            }
        }
    }

}


int judge(int Board[][maxsize], int Boardstatue[][maxsize], int ThunderNumber[][maxsize], int row, int column, int thunderleft, int times)
{
    if (Iscontinue(Board, Boardstatue, row, column) == 1)
    {
        printf("Game in progress\n");
        print1(Board, Boardstatue, ThunderNumber, row, column, thunderleft, times);
        return 1;
    }
    else if (Iscontinue(Board, Boardstatue, row, column) == 0)
    {
        printf("Hit mine, you lose\n");
        printf("%d %d\n", times, thunderleft);
        print2(Board, Boardstatue, ThunderNumber, row, column);
        return 0;
    }
    else if (Iscontinue(Board, Boardstatue, row, column) == 2)
    {
        printf("Game over, you win\n");
        printf("%d %d\n", times, thunderleft);
        print2(Board, Boardstatue, ThunderNumber, row, column);
        return 2;
    }
}
int Iscontinue(int Board[][maxsize], int Boardstatue[][maxsize], int row, int column)
{
    int i, j, IS = 1, win = 1;
    for (i = 1; i <= row && IS == 1; i++)
    {
        for (j = 1; j <= column && IS == 1; j++)
        {
            if (Board[i][j] == 1 && Boardstatue[i][j] == 4)
            {
                IS = 0;
                break;
            }
            if (Board[i][j] == 0 && Boardstatue[i][j] != 4)
            {
                win = 0;
            }
        }
    }
    if (IS == 1 && win == 1)
        return 2;
    else
        return IS;
}
void print1(int Board[][maxsize], int Boardstatue[][maxsize], int ThunderNumber[][maxsize], int row, int column, int thunderleft, int times)
{
    int i, j;
    printf("%d %d\n", times, thunderleft);
    for (i = 1; i <= row; i++)
    {
        for (j = 1; j <= column; j++)
        {
            if (Boardstatue[i][j] == 0)
                printf(".");
            else if (Boardstatue[i][j] == 2)
                printf("?");
            else if (Boardstatue[i][j] == 3)
                printf("!");
            else if (Boardstatue[i][j] == 4)
                printf("%d", ThunderNumber[i][j]);
        }
        printf("\n");
    }
}
void print2(int Board[][maxsize], int Boardstatue[][maxsize], int ThunderNumber[][maxsize], int row, int column)
{
    int i, j;
    for (i = 1; i <= row; i++)
    {
        for (j = 1; j <= column; j++)
        {
            if (Board[i][j] == 1)
                printf("*");
            else if (Boardstatue[i][j] == 0)
                printf(".");
            else if (Boardstatue[i][j] == 2)
                printf("?");
            else if (Boardstatue[i][j] == 3)
                printf("!");
            else if (Boardstatue[i][j] == 4)
                printf("%d", ThunderNumber[i][j]);
        }
        printf("\n");
    }
}

Crsdle
关注
北邮OJ常见问题1
08-03
1. 问：我的程序是如何输入又是怎样输出的 2. 问：这个评判系统使用的是什么编译器 3. 问：那我的程序是怎样被评判的呢 4. 问：Judge 所返回的回复是
北邮java oj
linkcoder的博客
05-31 320
oj作业
912星球的研究生-北邮OJ104_z912星球
最新发布
2401_86950631的博客
09-07 297
首先输入一个整数T，表示一共有T组数据(0< T≤ 10)每组数据的第一行包括一个数字n，表示这组数据一共n行，并且保证最多只有n位研究生,0< n≤ 100。接下来每一行都有一条命令，形式如上所述。不会有两名拥有同样名字id的同学,并且保证名字id是自然数且小于等于1000，得分为自然数且小于等于10000。
c++扫雷游戏（oj题目）
M1stic的博客
12-24 743
在n行m列的雷区中有一些格子含有地雷（称之为地雷格），其他格子不含地雷（称之为非地雷格）。玩家翻开一个非地雷格时，该格将会出现一个数字——提示周围格子中有多少个是地雷格。游戏的目标是在不翻出任何地雷格的条件下，找出所有的非地雷格。接下来n行，每行m个字符，描述了雷区中的地雷分布情况。用’*’表示地雷格，用周围的地雷个数表示非地雷格。注：一个格子的周围格子包括其上、下、左、右、左上、右上、左下、右下八个方向上与之直接相邻的格子。现在给出n行m列的雷区中的地雷分布，要求计算出每个非地雷格周围的地雷格数。
校外如何登陆北邮oj
热门推荐
我是一块小石头
11-27 1万+
由于北邮oj不对外开放，准备复试的我需要进入北邮oj；其他小朋友也有这个想法。故写此博客。 先找北邮土著借北邮账号，包括一些认识的同学，直系学长学姐，他们都很乐意帮助的~ 下面是校外进北邮校内网的方法，做到第三步就可以了。（有些关键词屏蔽了，我发不出来） https://nic.bupt.edu.cn/content/content.php?p=5_13_337 然后右上角url填写再进入...
北邮java oj 1052 问题 B: 复数
linkcoder的博客
05-20 292
后边为n行，每行均为4个用空格分隔的浮点数，依次参与运算的两个复数c1、c2。第一个数代表c1的实部，第二个数代表c1的虚部，第三个数代表c2的实部，第四个数代表c2的虚部。编写ComplexDivException类，该类继承Exception类，且至少包含两个数据成员，一个为错误代码，一个为错误信息。前边的1001为错误代码，后边Divide by zero. 为错误信息。编写复数类，该类至少包括计算复数的加法、减法、乘法、除法的方法。第二行为一个整数n(0<n<100)，代表共n组测试用例。
C语言期末大作业之实现扫雷游戏.zip
05-04
c语言期末大作业 C语言期末大作业之实现扫雷游戏
C语言实现扫雷游戏及其优化
08-25
C语言实现扫雷游戏及其优化 本文将详细介绍C语言实现扫雷游戏及其优化，具体包括游戏的设计思想、实现代码和优化方法。 游戏设计思想 扫雷游戏的设计思想是使用两个二维数组，一个用于显示，一个用于后台雷的布置...
C语言实现扫雷小游戏（适合初学者）
08-19
C语言实现扫雷小游戏（适合初学者） 本文将详细介绍C语言实现扫雷小游戏的知识点，适合初学者练习，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下。 函数定义和声明 在game.h...
北邮java oj作业1
Rosie___的博客
09-04 692
记录java选修课作业
java课程作业+北邮+OJ+已通过+黑杰克
06-02
北邮java课程作业OJ黑杰克，已AC
常用OJ
努力中的老周的专栏
11-30 9246
首先没有排名比较，只是一个常用OJ记录，仅代表个人的观点，如果有好的推荐可以告诉我。 LeetCode 力扣。英文版，www.leetcode.com。中文版，www.leetcode-cn.com。想要提高自己的收入，来这里刷题不会错。 相对比较专业的OJ，很多程序猿，公司面试都会使用leetcode。 CodeForces 简称CF。一家俄罗斯的网站，英文的。这里有很好的比赛，很好的...
北邮oj题库刷题计划（更新ing）
cherish的技术博
01-15 3167
北邮oj题库刷题计划（更新ing）83. A + B Problem84 Single Number 83. A + B Problem Calculate the sum of two given integers A and B. 输入格式 The input consists of a line with A and B. (−104≤A,B≤104). 输出格式 Output the on...
c语言oj题北邮期末,九度OJ&北邮机考试题题解（北邮2010网院）
weixin_28832121的博客
05-19 270
九度OJ&北邮机试题题解(北邮2010网院)题目一、九度OJ-1173：查找(水题随便搞)ac.jobdu.com/problem.php?pid=1173题目描述：输入数组长度 n输入数组 a[1...n]输入查找个数m输入查找数字b[1...m]输出 YES or NO 查找有则YES 否则NO 。输入：输入有多组数据。每组输入n，然后输入n个整数，再输入m，然后再输入m个...
北邮oj---寻找宝藏
cqhblg的博客
02-11 787
题目：http://10.105.242.80/problem/p/105/ 树形结构问题，算是比较简单的了 #include<stdio.h> #include<bits/stdc++.h> using namespace std; struct TreeNode{ vector<int> son; int f; }; int main(){ in...
【数据结构】北邮国际学院大二下oj代码
qq_59362610的博客
11-28 667
北邮国院大二下电商数据结构平时作业oj代码
【北邮OJ】89.统计时间间隔
猫子猪的博客
03-21 526
总结： 1。处理字符串：一次性读入char数组，然后单个字符处理 2。默认最后一个数据输出也有回车 3。纯数字字符串转为数字的方法 4。超过时间限制(why?)，考虑用计数法#include <stdio.h> #include <iostream> using namespace std; char str1[100],str2[100]; int total[50000];int mai
北邮机试 | BUPT OJ | 104. 912星球的研究生
Vermouth_Su的博客
02-05 167
时间限制1000 ms内存限制65536 KB 题目描述 最近912星球的研究生入学了，912星球的教务处因此忙的焦头烂额，要求yzr做一个信息管理系统登陆查询研究生的考试成绩。但是yzr太弱了，你能帮帮忙么？ 912星球的每一位研究生都有一个名字id和一份星球考研成绩，可喜的是都是自然数。 信息管理系统需要完成两个命令： 1.“Insert空格id_number空格score_numb...
C语言实现扫雷游戏源代码解析
在C语言实现的扫雷游戏中，关键点包括以下几个方面： 1. **基本结构与变量定义**： - `size` 定义了每个方块的大小，例如，如果`size=15`，则每个方块是15x15像素的正方形。 - `pix` 和 `piy` 是矩阵的偏移量，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值