go

Lásd még: Go

Magyar

Kiejtés

IPA: [ ˈɡo]

Főnév

go

(játékok) Egy kínai eredetű (wéiqí) Japánból nyugatra is elterjedt táblás játék, szellemi sport, magyarul helyesírása: gó

Go játék leírása

Definíció

A Go egy kétszemélyes stratégiai táblajáték, amelynek célja, hogy a játékosok köveik segítségével területet foglaljanak a táblán. A játék a kínai eredetű táblajátékok egyik legrégebbi formája, és széles körben ismert a mély stratégiai elemeiről.

Játékszabályok

1. A játékosok és a tábla

A játékot általában egy 19×19-es táblán játsszák, de kisebb méretű táblák is használatosak (pl. 9×9 vagy 13×13).
A két játékos fekete és fehér kövekkel játszik.

2. A lépések menete

A játékosok felváltva helyeznek el egy-egy követ a tábla üres pontjaira (vonalak metszéspontjai).
A fekete kezdi a játékot.

3. A területfoglalás

A játékos célja, hogy a lehető legnagyobb területet foglalja el a táblán.
A területet a játékos kövei által körbezárt üres pontok alkotják.

4. Elfogott kövek

Egy követ vagy kőcsoportot akkor lehet elfogni, ha az összes „szabadságát” (szomszédos üres pontjait) elveszti.
Az elfogott köveket eltávolítják a tábláról.

5. Tiltott lépések

Ko szabály: Egy játékos nem léphet olyan helyre, amely azonnal megismétli az előző állapotot.
Önmegsemmisítés: Egy játékos nem helyezhet követ olyan helyre, amely azonnal elveszti az összes szabadságát, kivéve, ha ezzel elfog egy ellenfél-követ.

6. Játék vége

A játék akkor ér véget, amikor mindkét játékos passzol egymás után.
A pontszámot a játékos által körbezárt terület és az elfogott kövek alapján számolják ki.

Go Python Implementáció Ötletek

1. Tábla reprezentáció

A Go tábla egy 2D-s mátrixként ábrázolható, ahol: - 0 jelöli az üres mezőt. - 1 jelöli a fekete követ. - 2 jelöli a fehér követ.

Példa:

board = [
    [0, 0, 0, 0],
    [0, 1, 2, 0],
    [0, 2, 1, 0],
    [0, 0, 0, 0]
]

2. Alapvető osztály a játékhoz

Egy egyszerű osztály, amely kezeli a tábla állapotát és a lépéseket:

class GoGame:
    def __init__(self, size=19):
        self.size = size
        self.board = [[0 for _ in range(size)] for _ in range(size)]
        self.current_player = 1  # 1: fekete, 2: fehér

    def print_board(self):
        for row in self.board:
            print(" ".join(str(cell) for cell in row))
        print()

    def is_valid_move(self, x, y):
        """
        Ellenőrzi, hogy egy lépés érvényes-e.
        """
        if 0 <= x < self.size and 0 <= y < self.size and self.board[x][y] == 0:
            return True
        return False

    def place_stone(self, x, y):
        """
        Elhelyez egy követ a táblán, ha a lépés érvényes.
        """
        if not self.is_valid_move(x, y):
            print("Érvénytelen lépés!")
            return False
        
        self.board[x][y] = self.current_player
        self.current_player = 3 - self.current_player  # Váltás a másik játékosra
        return True

# Példa használat
game = GoGame(size=9)
game.print_board()
game.place_stone(4, 4)
game.print_board()
game.place_stone(4, 5)
game.print_board()

3. Szabadságok számítása

A szomszédos üres mezők (szabadságok) számítására:

def get_liberties(board, x, y):
    """
    Megszámolja egy kő szabadságait.
    """
    size = len(board)
    visited = set()
    liberties = 0

    def dfs(x, y):
        nonlocal liberties
        if (x, y) in visited:
            return
        visited.add((x, y))

        if board[x][y] == 0:
            liberties += 1
            return
        if board[x][y] != board[start[0]][start[1]]:
            return

        # Szomszédos pontok
        directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]
        for dx, dy in directions:
            nx, ny = x + dx, y + dy
            if 0 <= nx < size and 0 <= ny < size:
                dfs(nx, ny)

    start = (x, y)
    dfs(x, y)
    return liberties

# Példa
board = [
    [0, 0, 0, 0],
    [0, 1, 2, 0],
    [0, 2, 1, 0],
    [0, 0, 0, 0]
]
liberties = get_liberties(board, 1, 1)
print("Szabadságok száma:", liberties)

4. Kövek elfogása

Ha egy kő vagy kőcsoport szabadságai elfogynak, eltávolítjuk őket a tábláról:

def remove_captured_stones(board, x, y):
    """
    Eltávolítja a szabadság nélküli köveket a tábláról.
    """
    size = len(board)
    visited = set()
    group = []
    liberties = 0

    def dfs(x, y):
        nonlocal liberties
        if (x, y) in visited:
            return
        visited.add((x, y))
        group.append((x, y))

        if board[x][y] == 0:
            liberties += 1
            return
        if board[x][y] != board[start[0]][start[1]]:
            return

        directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]
        for dx, dy in directions:
            nx, ny = x + dx, y + dy
            if 0 <= nx < size and 0 <= ny < size:
                dfs(nx, ny)

    start = (x, y)
    dfs(x, y)

    if liberties == 0:
        for px, py in group:
            board[px][py] = 0

# Példa
board = [
    [0, 0, 0, 0],
    [0, 1, 2, 0],
    [0, 2, 1, 0],
    [0, 0, 0, 0]
]
remove_captured_stones(board, 1, 2)
for row in board:
    print(row)

Bonyolultabb Implementációk

Játékállapot értékelése:
- Körbezárt területek meghatározása.
Ko szabály implementációja:
- Tároljuk a korábbi állapotokat, hogy elkerüljük az ismétléseket.
AI implementáció:
- Monte-Carlo Tree Search (MCTS): Nagyon hatékony algoritmus Go játékban.
- Heurisztikák: Az egyszerű értékelési függvények használata.

Alkalmazások

Szórakoztatás: Emberi játék Go ellenfelekkel.
AI fejlesztés: Stratégiai döntéshozó algoritmusok tesztelése.
Oktatás: Programozás és algoritmusok tanítása.

Összegzés

A Go játék szabályai egyszerűek, de a játék stratégiai mélysége miatt rendkívül izgalmas projekt lehet egy programozónak. Pythonban a Go játék megvalósítása remek kihívás, amely a mátrixkezelést, rekurziót és játéklogikát kombinálja. A fejlettebb AI megközelítések, mint a MCTS, tovább növelhetik a projekt kihívásait és tanulságait.

Fordítások

angol: go (en)
német: Go (de)

További információk

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

Angol

Kiejtés

IPA: /gəʊ/ érvénytelen IPA-karakterek (g), replace g with ɡ
hallgatás (US)

Ige

go (alapjelen, egyes szám harmadik személy goes, folyamatos melléknévi igenév going, második alak went vagy (archaic) yode, harmadik alak gone)

megy

Vonzatok

Szókapcsolatok

go to sleep

Főnév

go (tsz. gos)

go

További információk

go - Szótár.net (en-hu)
go - Sztaki (en-hu)
go - Merriam–Webster
go - Cambridge
go - WordNet
go - Яндекс (en-ru)
go - Google (en-hu)
go - Wikidata
go - Wikipédia (angol)

Szerbhorvát

(го)

Melléknév

go

Etimológia

Rövidített alak, lásd a gol melléknevet.

További információk

go - Lingea (hr-hu)
go - Lingea (sr-hu)
go - Hrvatski jezični portal
go - Szótár.net (sr-hu)
go - Яндекс (hr-ru)
go - Wikipédia (horvát)
go - Wikipédia (szerb)
go - Wikidata
go - Wikipédia (szerbhorvát)