aknakereső

• IPA:

aknakereső

1. (matematika)

• Cél: Egy rácsos táblán az összes mezőt fel kell fedni, kivéve az aknákat.
• Játékmező:
  • Egy adott számú akna (bomba) van elrejtve a táblán.
  • A nem aknás mezők számokat mutatnak, amelyek jelzik, hogy hány akna található a szomszédos mezőkön (legfeljebb 8 szomszédos mező).
• Felderítés:
  • A játékos mezőket kattint (felderít), hogy kiderítse, mi található ott.
  • Ha aknára kattint, a játék véget ér (vesztettél).
  • Ha nincs szomszédos akna, a szomszédos mezők automatikusan felfedésre kerülnek.
• Győzelem:
  • Ha az összes nem aknás mezőt felfeded, a játékos nyer.

A tábla egy kétdimenziós lista, ahol: - -1: akna (bomba). - 0: üres mező, nincs szomszédos akna. - 1-8: a szomszédos aknák száma. - F: zászló, amely jelzi, hogy a játékos aknát gyanít ott.

Példa tábla (10x10, néhány aknával):

board = [
    ,
    ,
    ...
]

Egy másik lista tárolja a játékos által ismert információt: - ?: még nem felfedett mező. - 0-8: felfedett mező a szomszédos aknák számával. - F: zászló.

Példa állapot:

state = [
    ,
    ,
    ...
]

• Véletlenszerűen helyezd el az aknákat a táblán.
• Számítsd ki az aknák körüli mezők értékét (a szomszédos aknák száma).

• Ha egy mezőre kattintasz:
  • Ha akna, a játék véget ér.
  • Ha nincs szomszédos akna, tárd fel rekurzívan az összes szomszédos mezőt.
  • Ha van szomszédos akna, csak azt az egy mezőt tárd fel.
• Zászlózás (a játékos megjelölhet egy mezőt, amelyet aknának gondol).

A solver algoritmus automatikusan megoldja a táblát: 1. Közvetlen következtetések: - Ha egy mező számának megfelelő számú zászló van a szomszédságában, az összes többi szomszédos mező biztonságos. - Ha egy mező összes szomszédja biztonságos, a fennmaradó ismeretlen mezők aknák. 2. Heurisztikus keresés: - Ha nincs közvetlen következtetés, véletlenszerűen választ a lehetséges lépések közül.

function generate_board(rows, cols, num_mines):
    board = create_empty_board(rows, cols)
    place_mines_randomly(board, num_mines)
    calculate_adjacent_numbers(board)
    return board

function calculate_adjacent_numbers(board):
    for each cell in board:
        if cell is a mine:
            increment_all_neighbors(cell)

function solve_minesweeper(board, state):
    while not is_solved(state):
        made_progress = False

        for each cell in state:
            if cell is revealed and has known adjacent mines:
                reveal_safe_neighbors(cell)
                made_progress = True

            if cell has exactly the number of flags as its value:
                flag_all_unknown_neighbors(cell)
                made_progress = True

        if not made_progress:
            make_random_guess()

import random

def generate_board(rows, cols, num_mines):
    board =  for _ in range(rows)]
    mines = set()

    while len(mines) < num_mines:
        r, c = random.randint(0, rows - 1), random.randint(0, cols - 1)
        mines.add((r, c))

    for r, c in mines:
        board = -1
        for dr in range(-1, 2):
            for dc in range(-1, 2):
                nr, nc = r + dr, c + dc
                if 0 <= nr < rows and 0 <= nc < cols and board != -1:
                    board += 1

    return board

def print_board(board):
    for row in board:
        print(" ".join(str(cell) if cell != -1 else '*' for cell in row))

def reveal(board, state, r, c):
    if state != '?' or board == -1:
        return False
    state = str(board)
    if board == 0:
        for dr in range(-1, 2):
            for dc in range(-1, 2):
                nr, nc = r + dr, c + dc
                if 0 <= nr < len(board) and 0 <= nc < len(board):
                    reveal(board, state, nr, nc)
    return True

def flag(state, r, c):
    if state == '?':
        state = 'F'

def solve_minesweeper(board):
    rows, cols = len(board), len(board)
    state =  for _ in range(rows)]

    # Automatikus lépések
    while not is_solved(board, state):
        made_progress = False

        for r in range(rows):
            for c in range(cols):
                if state == '?' and board != -1:
                    reveal(board, state, r, c)
                    made_progress = True

        if not made_progress:
            # Ha nem tud tovább következtetni, véletlenszerűen választ
            r, c = random.randint(0, rows - 1), random.randint(0, cols - 1)
            while state != '?':
                r, c = random.randint(0, rows - 1), random.randint(0, cols - 1)
            reveal(board, state, r, c)

    print("Solved State:")
    for row in state:
        print(" ".join(row))

def is_solved(board, state):
    for r in range(len(board)):
        for c in range(len(board)):
            if board != -1 and state == '?':
                return False
    return True

# Példa futtatás
board = generate_board(10, 10, 15)
print("Generated Board:")
print_board(board)
solve_minesweeper(board)

#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>

using namespace std;

const int MINE = -1;

vector<vector<int>> generateBoard(int rows, int cols, int numMines) {
    vector<vector<int>> board(rows, vector<int>(cols, 0));
    srand(time(0));

    for (int i = 0; i < numMines; ) {
        int r = rand() % rows, c = rand() % cols;
        if (board != MINE) {
            board = MINE;
            i++;
            for (int dr = -1; dr <= 1; dr++) {
                for (int dc = -1; dc <= 1; dc++) {
                    int nr = r + dr, nc = c + dc;
                    if (nr >= 0 && nr < rows && nc >= 0 && nc < cols && board != MINE) {
                        board++;
                    }
                }
            }
        }
    }

    return board;
}

void printBoard(const vector<vector<int>>& board) {
    for (const auto& row : board) {
        for (int cell : row) {
            if (cell == MINE) cout << "* ";
            else cout << cell << " ";
        }
        cout << endl;
    }
}

int main() {
    int rows = 10, cols = 10, numMines = 15;
    auto board = generateBoard(rows, cols, numMines);

    cout << "Generated Board:" << endl;
    printBoard(board);

    return 0;
}

Ez a megoldás alkalmas alap Minesweeper generálására és megoldására.

• aknakereső - Értelmező szótár (MEK)
• aknakereső - Etimológiai szótár (UMIL)
• aknakereső - Szótár.net (hu-hu)
• aknakereső - DeepL (hu-de)
• aknakereső - Яндекс (hu-ru)
• aknakereső - Google (hu-en)
• aknakereső - Helyesírási szótár (MTA)
• aknakereső - Wikidata
• aknakereső - Wikipédia (magyar)