给我一个可以计算扫雷格子里是否有雷的概率的程序

以下是一个简单的程序，可以计算扫雷格子里是否有雷的概率：

import random

def calculate_probability(n, m, k):
    # n 表示格子的行数，m 表示格子的列数，k 表示雷的数量
    total = n * m
    probability = 1.0

    for i in range(k):
        probability *= (total - i) / (n * m - i)

    return probability

n = 10  # 格子的行数
m = 10  # 格子的列数
k = 10  # 雷的数量

probability = calculate_probability(n, m, k)
print("概率为：{:.2f}%".format(probability * 100))

这个程序使用了组合数学的知识，计算出在 $n \times m$ 的格子中放置 $k$ 个雷的概率。程序中使用了一个循环来计算概率，每次循环都将总格子数减少一个，同时将雷的数量减少一个，最后将所有概率相乘即可得到答案。这个程序的时间复杂度为 $O(k)$，当雷的数量较大时可能会比较慢，但在实际情况中，雷的数量通常不会太大。

相关问题

给我一个matlab的扫雷游戏代码

以下是一个简单的 MATLAB 扫雷游戏代码：

clc;
clear;
close all;

% 游戏设置
n = 10; % 网格大小
num_mines = 10; % 地雷数量

% 初始化游戏板
board = zeros(n);

% 随机放置地雷
mines = randperm(n^2, num_mines);
board(mines) = -1;

% 计算每个格子周围的地雷数量
for i = 1:n
    for j = 1:n
        if board(i,j) ~= -1
            % 计算周围8个格子的坐标
            coords = [i-1,j-1; i-1,j; i-1,j+1; i,j-1; i,j+1; i+1,j-1; i+1,j; i+1,j+1];
            % 去除越界坐标
            coords(coords(:,1)<1 | coords(:,1)>n | coords(:,2)<1 | coords(:,2)>n,:) = [];
            % 计算周围地雷数量
            board(i,j) = sum(board(sub2ind([n,n],coords(:,1),coords(:,2))) == -1);
        end
    end
end

% 游戏开始
game_over = false;
while ~game_over
    % 显示当前游戏板
    disp(board)
    
    % 玩家输入下一步操作
    choice = input('Enter your choice (row, column, flag[f]/unflag[u]): ');
    row = choice(1);
    col = choice(2);
    action = choice(3);
    
    % 标记/取消标记地雷
    if action == 'f'
        board(row,col) = -2;
    elseif action == 'u'
        board(row,col) = 0;
    end
    
    % 挖开格子
    if board(row,col) == -1
        disp('You lose!');
        board(row,col) = -3;
        game_over = true;
    elseif board(row,col) == 0
        board(row,col) = -4;
        % 递归挖开相邻的空格子
        coords = [row-1,col-1; row-1,col; row-1,col+1; row,col-1; row,col+1; row+1,col-1; row+1,col; row+1,col+1];
        coords(coords(:,1)<1 | coords(:,1)>n | coords(:,2)<1 | coords(:,2)>n,:) = [];
        for i = 1:size(coords,1)
            if board(coords(i,1),coords(i,2)) >= 0
                board(coords(i,1),coords(i,2)) = -4;
            end
        end
    end
    
    % 检查游戏是否结束
    if sum(sum(board == 0)) == num_mines
        disp('You win!');
        game_over = true;
    end
end

运行这个代码将会生成一个 $10\times 10$ 的扫雷游戏板，其中包含 $10$ 个地雷。你可以根据提示逐步操作，尝试标记/取消标记地雷，并挖开格子，直到游戏结束。

写一个可以自动扫雷的程序用python

以下是一个简单的 Python 扫雷程序，可以自动扫雷：

import random

# 定义常量
BOMB = -1
COVERED = -2
FLAGGED = -3

# 初始化游戏棋盘
def init_board(width, height, num_bombs):
    board = []
    for i in range(height):
        row = []
        for j in range(width):
            row.append(COVERED)
        board.append(row)

    # 布雷
    bombs = set()
    while len(bombs) < num_bombs:
        i = random.randint(0, height-1)
        j = random.randint(0, width-1)
        if board[i][j] != BOMB:
            bombs.add((i, j))
            board[i][j] = BOMB

    # 计算数字
    for i in range(height):
        for j in range(width):
            if board[i][j] == BOMB:
                continue
            count = 0
            for ni in range(max(0, i-1), min(height, i+2)):
                for nj in range(max(0, j-1), min(width, j+2)):
                    if board[ni][nj] == BOMB:
                        count += 1
            board[i][j] = count

    return board

# 显示游戏棋盘
def show_board(board):
    for row in board:
        line = ""
        for cell in row:
            if cell == COVERED:
                line += "."
            elif cell == FLAGGED:
                line += "F"
            elif cell == BOMB:
                line += "*"
            else:
                line += str(cell)
        print(line)

# 扫雷
def sweep(board, i, j):
    if board[i][j] == BOMB:
        return False
    elif board[i][j] != COVERED:
        return True
    else:
        board[i][j] = 0
        for ni in range(max(0, i-1), min(len(board), i+2)):
            for nj in range(max(0, j-1), min(len(board[0]), j+2)):
                if board[ni][nj] == BOMB:
                    board[i][j] += 1
        if board[i][j] == 0:
            for ni in range(max(0, i-1), min(len(board), i+2)):
                for nj in range(max(0, j-1), min(len(board[0]), j+2)):
                    sweep(board, ni, nj)
        return True

# 标记旗子
def flag(board, i, j):
    if board[i][j] == COVERED:
        board[i][j] = FLAGGED
        return True
    elif board[i][j] == FLAGGED:
        board[i][j] = COVERED
        return True
    else:
        return False

# 判断游戏是否结束
def game_over(board):
    for row in board:
        for cell in row:
            if cell == COVERED:
                return False
            elif cell == BOMB:
                return True

# 自动扫雷
def auto_sweep(board):
    for i in range(len(board)):
        for j in range(len(board[0])):
            if board[i][j] >= 0:
                count_flagged = 0
                count_covered = 0
                for ni in range(max(0, i-1), min(len(board), i+2)):
                    for nj in range(max(0, j-1), min(len(board[0]), j+2)):
                        if board[ni][nj] == FLAGGED:
                            count_flagged += 1
                        elif board[ni][nj] == COVERED:
                            count_covered += 1
                if board[i][j] == count_flagged and count_covered > 0:
                    for ni in range(max(0, i-1), min(len(board), i+2)):
                        for nj in range(max(0, j-1), min(len(board[0]), j+2)):
                            if board[ni][nj] == COVERED:
                                sweep(board, ni, nj)
                                if game_over(board):
                                    return True
                elif board[i][j] == count_flagged and count_covered == 0:
                    continue
                elif board[i][j] - count_flagged == count_covered:
                    for ni in range(max(0, i-1), min(len(board), i+2)):
                        for nj in range(max(0, j-1), min(len(board[0]), j+2)):
                            if board[ni][nj] == COVERED:
                                flag(board, ni, nj)
                                if game_over(board):
                                    return True
    return False

# 测试
board = init_board(10, 10, 10)
show_board(board)
while not game_over(board):
    if not auto_sweep(board):
        print("Game over!")
        break
    show_board(board)
print("Game over!")

这个程序使用了一个简单的自动扫雷算法，但并不完美，可能无法解决所有情况。