Googleの最新LLM「Gemini 2.0 Pro」とは？概要から使い方、実際に試した結果まで解説！

import gradio as gr
import numpy as np

def initial_board():
    """初期盤面を作成する関数"""
    board = np.zeros((8, 8), dtype=int)
    board[3, 3] = board[4, 4] = 1  # 白石
    board[3, 4] = board[4, 3] = -1 # 黒石
    return board

def is_valid_move(board, row, col, player):
    """指定されたマスに石を置けるか判定する関数"""
    if board[row, col] != 0:
        return False

    for dr in [-1, 0, 1]:
        for dc in [-1, 0, 1]:
            if dr == 0 and dc == 0:
                continue

            r, c = row + dr, col + dc
            if 0 <= r < 8 and 0 <= c < 8 and board[r, c] == -player:
                while 0 <= r < 8 and 0 <= c < 8:
                    if board[r, c] == player:
                        return True
                    if board[r, c] == 0:
                        break
                    r += dr
                    c += dc
    return False

def flip_stones(board, row, col, player):
    """石をひっくり返す関数"""
    board[row, col] = player
    for dr in [-1, 0, 1]:
        for dc in [-1, 0, 1]:
            if dr == 0 and dc == 0:
                continue

            r, c = row + dr, col + dc
            if 0 <= r < 8 and 0 <= c < 8 and board[r, c] == -player:
                to_flip = []
                while 0 <= r < 8 and 0 <= c < 8:
                    if board[r, c] == player:
                        for flip_r, flip_c in to_flip:
                            board[flip_r, flip_c] = player
                        break
                    if board[r, c] == 0:
                        break
                    to_flip.append((r, c))
                    r += dr
                    c += dc
    return board

def get_possible_moves(board, player):
    """可能な手のリストを返す関数"""
    possible_moves = []
    for row in range(8):
        for col in range(8):
            if is_valid_move(board, row, col, player):
                possible_moves.append((row, col))
    return possible_moves

def check_game_over(board):
    """ゲーム終了判定"""
    return len(get_possible_moves(board, 1)) == 0 and len(get_possible_moves(board, -1)) == 0

def count_stones(board):
    """石の数を数える"""
    black_count = np.count_nonzero(board == -1)
    white_count = np.count_nonzero(board == 1)
    return black_count, white_count

def othello_game(row, col, current_board_str, current_player):
    """オセロゲームのロジック"""

    # 現在の盤面をNumPy配列に変換
    current_board = np.array(eval(current_board_str))

    player = int(current_player)  # playerを整数型に

    # 入力が有効な手か確認
    if not is_valid_move(current_board, row, col, player):
      message = "そこには置けません"
      return current_board.tolist(), str(current_board.tolist()), str(player) ,message  # 同じ盤面とプレイヤーを返す


    # 石をひっくり返す
    updated_board = flip_stones(current_board.copy(), row, col, player)

    # ターンを交代 (1 -> -1, -1 -> 1)
    next_player = -player

    # パスの処理: 次のプレイヤーが打てる手がない場合、現在のプレイヤーが続行
    if not get_possible_moves(updated_board, next_player):
        next_player = player
        if not get_possible_moves(updated_board, next_player):
            message = "ゲーム終了" # 両者とも打てない場合

            black_count, white_count = count_stones(updated_board)
            if black_count > white_count:
              message += f"黒の勝ち！ 黒:{black_count}、白:{white_count}"
            elif white_count > black_count:
              message += f"白の勝ち！ 黒:{black_count}、白:{white_count}"
            else:
              message += f"引き分け！ 黒:{black_count}、白:{white_count}"

            return updated_board.tolist(), str(updated_board.tolist()), str(next_player), message


        message = "置ける場所がないので、ターンが継続されます" #相手が置けない場合
    else:
      message = " "

    return updated_board.tolist(), str(updated_board.tolist()), str(next_player) ,message




def create_board_display(board):
  """盤面表示用のリストを作成"""
  display_board = []
  for row in board:
    display_row = []
    for cell in row:
      if cell == 1:
        display_row.append("⚪️") # 白石
      elif cell == -1:
        display_row.append("⚫️") # 黒石
      else:
        display_row.append("🟩") # 空きマス
    display_board.append(display_row)
  return display_board


# Gradioインターフェース
with gr.Blocks() as demo:
    # 状態変数
    board_state = gr.State(str(initial_board().tolist()))
    player_state = gr.State("1")   # 1: 黒, -1: 白


    with gr.Row():

        with gr.Column():
          # 入力
          row_input = gr.Slider(0, 7, step=1, label="行 (Row)")
          col_input = gr.Slider(0, 7, step=1, label="列 (Column)")

          # メッセージ表示
          message_output = gr.Textbox(label="メッセージ")
          # 実行ボタン
          play_button = gr.Button("Play")

        with gr.Column():
          # 盤面表示
          board_output = gr.Dataframe(value = create_board_display(initial_board()), label="オセロ盤面", interactive=False, every=1)


    # ボタンクリック時の処理
    play_button.click(
        othello_game,
        [row_input, col_input, board_state, player_state],
        [board_output, board_state, player_state, message_output]
    )
    # 盤面表示の更新関数
    def update_board_display(board):
      return create_board_display(board)

    # 定期的に盤面表示を更新するためのイベントハンドラ
    board_state.change(update_board_display, board_state, board_output)

demo.launch()

import gradio as gr
import numpy as np

class OthelloGame:
    def __init__(self):
        self.board = np.zeros((8, 8), dtype=int)
        # 初期配置
        self.board[3:5, 3:5] = [[1, -1], [-1, 1]]
        self.current_player = 1  # 1: 黒, -1: 白

    def is_valid_move(self, row, col):
        if self.board[row, col] != 0:
            return False
        
        directions = [(0, 1), (1, 0), (0, -1), (-1, 0),
                     (1, 1), (-1, -1), (1, -1), (-1, 1)]
        
        valid = False
        for dr, dc in directions:
            r, c = row + dr, col + dc
            pieces_to_flip = []
            
            while 0 <= r < 8 and 0 <= c < 8 and self.board[r, c] == -self.current_player:
                pieces_to_flip.append((r, c))
                r, c = r + dr, c + dc
                
            if pieces_to_flip and 0 <= r < 8 and 0 <= c < 8 and self.board[r, c] == self.current_player:
                valid = True
                break
                
        return valid

    def make_move(self, row, col):
        if not self.is_valid_move(row, col):
            return False
        
        directions = [(0, 1), (1, 0), (0, -1), (-1, 0),
                     (1, 1), (-1, -1), (1, -1), (-1, 1)]
        
        pieces_flipped = False
        for dr, dc in directions:
            r, c = row + dr, col + dc
            pieces_to_flip = []
            
            while 0 <= r < 8 and 0 <= c < 8 and self.board[r, c] == -self.current_player:
                pieces_to_flip.append((r, c))
                r, c = r + dr, c + dc
                
            if pieces_to_flip and 0 <= r < 8 and 0 <= c < 8 and self.board[r, c] == self.current_player:
                pieces_flipped = True
                for flip_r, flip_c in pieces_to_flip:
                    self.board[flip_r, flip_c] = self.current_player
        
        if pieces_flipped:
            self.board[row, col] = self.current_player
            self.current_player = -self.current_player
            return True
        return False

    def get_valid_moves(self):
        valid_moves = []
        for i in range(8):
            for j in range(8):
                if self.board[i, j] == 0 and self.is_valid_move(i, j):
                    valid_moves.append((i, j))
        return valid_moves

    def get_score(self):
        black = np.sum(self.board == 1)
        white = np.sum(self.board == -1)
        return black, white

def create_board_image(game):
    board = game.board
    valid_moves = game.get_valid_moves()
    
    import matplotlib.pyplot as plt
    
    fig, ax = plt.subplots(figsize=(8, 8))
    ax.set_facecolor('green')
    
    # グリッドを描画
    for i in range(9):
        ax.plot([i, i], [0, 8], 'black')
        ax.plot([0, 8], [i, i], 'black')
    
    # 石を描画
    for i in range(8):
        for j in range(8):
            if board[i, j] == 1:  # 黒
                circle = plt.Circle((j + 0.5, 7.5 - i), 0.4, color='black')
                ax.add_artist(circle)
            elif board[i, j] == -1:  # 白
                circle = plt.Circle((j + 0.5, 7.5 - i), 0.4, color='white')
                ax.add_artist(circle)
    
    # 有効な手を表示
    for i, j in valid_moves:
        circle = plt.Circle((j + 0.5, 7.5 - i), 0.15, color='red')
        ax.add_artist(circle)
    
    ax.set_xlim(-0.5, 8.5)
    ax.set_ylim(-0.5, 8.5)
    ax.set_aspect('equal')
    ax.axis('off')
    
    return fig

def play_game(row, col, state):
    game = OthelloGame()
    game.board = np.array(eval(state))
    game.current_player = 1 if np.sum(game.board == 0) % 2 == 0 else -1
    
    if game.make_move(row, col):
        black_score, white_score = game.get_score()
        valid_moves = game.get_valid_moves()
        
        if not valid_moves:
            game.current_player = -game.current_player
            valid_moves = game.get_valid_moves()
            if not valid_moves:
                return create_board_image(game), str(game.board.tolist()), f"ゲーム終了！\n黒: {black_score} 白: {white_score}"
        
        return create_board_image(game), str(game.board.tolist()), f"黒: {black_score} 白: {white_score}"
    else:
        return create_board_image(game), state, "無効な手です。もう一度お試しください。"

def reset_game():
    game = OthelloGame()
    return create_board_image(game), str(game.board.tolist()), "新しいゲームを開始しました。"

# Gradioインターフェースの作成
with gr.Blocks() as demo:
    gr.Markdown("# オセロゲーム")
    gr.Markdown("黒が先手です。赤い点は有効な手を示しています。")
    
    with gr.Row():
        board_display = gr.Plot()
        
    with gr.Row():
        row_input = gr.Number(label="行 (0-7)", minimum=0, maximum=7, step=1)
        col_input = gr.Number(label="列 (0-7)", minimum=0, maximum=7, step=1)
    
    state = gr.State(str(OthelloGame().board.tolist()))
    message = gr.Markdown("")
    
    with gr.Row():
        play_button = gr.Button("Play")
        reset_button = gr.Button("Reset")
    
    play_button.click(
        play_game,
        inputs=[row_input, col_input, state],
        outputs=[board_display, state, message]
    )
    
    reset_button.click(
        reset_game,
        outputs=[board_display, state, message]
    )

if __name__ == "__main__":
    demo.launch()

<!DOCTYPE html>
<html lang="ja">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>五目並べ</title>
    <style>
        body {
            font-family: sans-serif;
            display: flex;
            flex-direction: column;
            align-items: center;
        }

        .board {
            display: grid;
            grid-template-columns: repeat(15, 30px); /* 15x15のマス */
            grid-template-rows: repeat(15, 30px);
            border: 2px solid black;
            margin-bottom: 10px;
        }

        .cell {
            width: 30px;
            height: 30px;
            border: 1px solid #ccc;
            text-align: center;
            font-size: 24px;
            line-height: 30px;
            cursor: pointer;
        }

        .cell.black {
            background-color: black;
            color: white;
            border-radius: 50%; /* 円形にする */
        }

        .cell.white {
            background-color: white;
            color: black;
            border: 1px solid black;  /* 白石の境界線 */
            border-radius: 50%; /* 円形にする */
        }
        
        #message {
            font-size: 1.2em;
            font-weight: bold;
            margin-top: 10px;
            min-height: 1.5em; /* メッセージがない時も高さを確保 */
        }

        button {
            padding: 8px 16px;
            font-size: 1em;
            margin-top: 10px;
        }
    </style>
</head>
<body>
    <h1>五目並べ</h1>

    <div class="board"></div>

    <div id="message"></div>

    <button id="reset-button">リセット</button>


    <script>
        const boardSize = 15;
        const board = document.querySelector('.board');
        const message = document.getElementById('message');
        const resetButton = document.getElementById('reset-button');
        let currentPlayer = 'black'; // 'black' or 'white'
        let gameBoard = [];  // 盤面の状態を保持する配列

        // 盤面の初期化
        function initBoard() {
            gameBoard = []; // 盤面データをクリア
            board.innerHTML = ''; // 盤面表示をクリア
            for (let i = 0; i < boardSize; i++) {
                gameBoard[i] = [];
                for (let j = 0; j < boardSize; j++) {
                    gameBoard[i][j] = null; // null: 空, 'black', 'white'
                    const cell = document.createElement('div');
                    cell.classList.add('cell');
                    cell.dataset.row = i;
                    cell.dataset.col = j;
                    cell.addEventListener('click', handleCellClick);
                    board.appendChild(cell);
                }
            }
            currentPlayer = 'black';  // 先手は黒
            message.textContent = "黒の番です";
        }


        function handleCellClick(event) {
            const row = parseInt(event.target.dataset.row);
            const col = parseInt(event.target.dataset.col);

            // すでに石がある場合は何もしない
            if (gameBoard[row][col]) {
                return;
            }

            // 石を置く
            gameBoard[row][col] = currentPlayer;
            event.target.classList.add(currentPlayer);

            // 勝敗判定
            if (checkWin(row, col, currentPlayer)) {
                message.textContent = `${currentPlayer === 'black' ? '黒' : '白'}の勝ち！`;
                // 全てのセルのクリックイベントを無効にする
                document.querySelectorAll('.cell').forEach(cell => {
                    cell.removeEventListener('click', handleCellClick);
                });
                return;
            }

            // 引き分け判定 (盤面が全て埋まったら)
            if (checkDraw()) {
                message.textContent = "引き分け！";
                return;
            }

            // プレイヤー交代
            currentPlayer = currentPlayer === 'black' ? 'white' : 'black';
            message.textContent = `${currentPlayer === 'black' ? '黒' : '白'}の番です`;
        }



        function checkWin(row, col, player) {
            // 横方向
            let count = 1;
            for (let i = col - 1; i >= 0 && gameBoard[row][i] === player; i--) count++;
            for (let i = col + 1; i < boardSize && gameBoard[row][i] === player; i++) count++;
            if (count >= 5) return true;

            // 縦方向
            count = 1;
            for (let i = row - 1; i >= 0 && gameBoard[i][col] === player; i--) count++;
            for (let i = row + 1; i < boardSize && gameBoard[i][col] === player; i++) count++;
            if (count >= 5) return true;

            // 斜め (右上から左下)
            count = 1;
            for (let i = 1; row - i >= 0 && col - i >= 0 && gameBoard[row - i][col - i] === player; i++) count++;
            for (let i = 1; row + i < boardSize && col + i < boardSize && gameBoard[row + i][col + i] === player; i++) count++;
            if (count >= 5) return true;

            // 斜め (左上から右下)
            count = 1;
            for (let i = 1; row - i >= 0 && col + i < boardSize && gameBoard[row - i][col + i] === player; i++) count++;
            for (let i = 1; row + i < boardSize && col - i >= 0 && gameBoard[row + i][col - i] === player; i++) count++;
            if (count >= 5) return true;


            return false;
        }



        function checkDraw() {
          for (let i = 0; i < boardSize; i++) {
            for (let j = 0; j < boardSize; j++) {
              if (gameBoard[i][j] === null) {
                return false; // 空きマスがあれば引き分けではない
              }
            }
          }
          return true; // 全て埋まっていれば引き分け
        }


        // リセットボタンの処理
        resetButton.addEventListener('click', initBoard);

        // 初期化
        initBoard();

    </script>
</body>
</html>

<!DOCTYPE html>
<html>
<head>
    <title>五目並べ</title>
    <style>
        .board {
            display: grid;
            grid-template-columns: repeat(15, 40px);
            grid-template-rows: repeat(15, 40px);
            gap: 1px;
            background-color: #deb887;
            padding: 10px;
            border: 2px solid #8b4513;
        }

        .cell {
            width: 40px;
            height: 40px;
            background-color: #deb887;
            border: 1px solid #8b4513;
            display: flex;
            align-items: center;
            justify-content: center;
            cursor: pointer;
            position: relative;
        }

        .cell::before {
            content: '';
            position: absolute;
            width: 30px;
            height: 30px;
            border-radius: 50%;
        }

        .black::before {
            background-color: black;
        }

        .white::before {
            background-color: white;
            border: 1px solid black;
        }

        .game-container {
            display: flex;
            flex-direction: column;
            align-items: center;
            gap: 20px;
            padding: 20px;
        }

        .status {
            font-size: 24px;
            font-weight: bold;
        }

        .reset-button {
            padding: 10px 20px;
            font-size: 16px;
            background-color: #4CAF50;
            color: white;
            border: none;
            border-radius: 5px;
            cursor: pointer;
        }

        .reset-button:hover {
            background-color: #45a049;
        }
    </style>
</head>
<body>
    <div class="game-container">
        <h1>五目並べ</h1>
        <div class="status" id="status">黒の番です</div>
        <div class="board" id="board"></div>
        <button class="reset-button" onclick="resetGame()">リセット</button>
    </div>

    <script>
        const BOARD_SIZE = 15;
        let currentPlayer = 'black';
        let gameBoard = Array(BOARD_SIZE).fill().map(() => Array(BOARD_SIZE).fill(null));
        let gameActive = true;

        function createBoard() {
            const board = document.getElementById('board');
            board.innerHTML = '';
            
            for (let i = 0; i < BOARD_SIZE; i++) {
                for (let j = 0; j < BOARD_SIZE; j++) {
                    const cell = document.createElement('div');
                    cell.className = 'cell';
                    cell.dataset.row = i;
                    cell.dataset.col = j;
                    cell.addEventListener('click', handleClick);
                    board.appendChild(cell);
                }
            }
        }

        function handleClick(event) {
            if (!gameActive) return;

            const row = parseInt(event.target.dataset.row);
            const col = parseInt(event.target.dataset.col);

            if (gameBoard[row][col]) return;

            gameBoard[row][col] = currentPlayer;
            event.target.classList.add(currentPlayer);

            if (checkWin(row, col)) {
                document.getElementById('status').textContent = 
                    `${currentPlayer === 'black' ? '黒' : '白'}の勝ちです！`;
                gameActive = false;
                return;
            }

            currentPlayer = currentPlayer === 'black' ? 'white' : 'black';
            document.getElementById('status').textContent = 
                `${currentPlayer === 'black' ? '黒' : '白'}の番です`;
        }

        function checkWin(row, col) {
            const directions = [
                [[0, 1], [0, -1]],  // 横
                [[1, 0], [-1, 0]],  // 縦
                [[1, 1], [-1, -1]], // 斜め（右下-左上）
                [[1, -1], [-1, 1]]  // 斜め（右上-左下）
            ];

            return directions.some(direction => {
                const count = countInDirection(row, col, direction[0])
                    + countInDirection(row, col, direction[1])
                    + 1;
                return count >= 5;
            });
        }

        function countInDirection(row, col, [dx, dy]) {
            let count = 0;
            let currentRow = row + dx;
            let currentCol = col + dy;

            while (
                currentRow >= 0 && 
                currentRow < BOARD_SIZE && 
                currentCol >= 0 && 
                currentCol < BOARD_SIZE && 
                gameBoard[currentRow][currentCol] === currentPlayer
            ) {
                count++;
                currentRow += dx;
                currentCol += dy;
            }

            return count;
        }

        function resetGame() {
            gameBoard = Array(BOARD_SIZE).fill().map(() => Array(BOARD_SIZE).fill(null));
            currentPlayer = 'black';
            gameActive = true;
            document.getElementById('status').textContent = '黒の番です';
            
            const cells = document.getElementsByClassName('cell');
            Array.from(cells).forEach(cell => {
                cell.classList.remove('black', 'white');
            });
        }

        // 初期化
        createBoard();
    </script>
</body>
</html>