【Kimi k1.5】GPT-4oやClaude Sonnet 3.5に匹敵する最新AIモデル！概要や使い方を徹底解説！

Think in English, Output in Japanese
2048ゲームをPythonで作ってください。

以下は、Pythonで2048ゲームを実装するコードです。これは、キーボード入力を使用してプレイできるシンプルなコマンドラインバージョンです。

import numpy as np
import random
import os

def initialize_game():
    board = np.zeros((4, 4), dtype=int)
    add_new_number(board)
    add_new_number(board)
    return board

def add_new_number(board):
    empty_cells = [(r, c) for r in range(4) for c in range(4) if board[r][c] == 0]
    if empty_cells:
        r, c = random.choice(empty_cells)
        board[r][c] = 2 if random.random() < 0.9 else 4

def compress(row):
    new_row = [i for i in row if i != 0]
    new_row += [0] * (4 - len(new_row))
    return new_row

def merge(row):
    for i in range(3):
        if row[i] == row[i + 1] and row[i] != 0:
            row[i] *= 2
            row[i + 1] = 0
    return row

def move_left(board):
    new_board = np.zeros((4, 4), dtype=int)
    for r in range(4):
        new_row = compress(board[r])
        new_row = merge(new_row)
        new_row = compress(new_row)
        new_board[r] = new_row
    return new_board

def move_right(board):
    return np.fliplr(move_left(np.fliplr(board)))

def move_up(board):
    return np.rot90(move_left(np.rot90(board, -1)), 1)

def move_down(board):
    return np.rot90(move_left(np.rot90(board, 1)), -1)

def print_board(board):
    os.system('cls' if os.name == 'nt' else 'clear')
    print(board)

def check_game_over(board):
    for move in [move_left, move_right, move_up, move_down]:
        if not np.array_equal(move(board), board):
            return False
    return True

def main():
    board = initialize_game()
    print_board(board)
    while True:
        move = input("W(上) A(左) S(下) D(右) Q(終了): ").lower()
        if move == 'q':
            print("ゲーム終了")
            break
        elif move == 'a':
            board_new = move_left(board)
        elif move == 'd':
            board_new = move_right(board)
        elif move == 'w':
            board_new = move_up(board)
        elif move == 's':
            board_new = move_down(board)
        else:
            continue

        if not np.array_equal(board, board_new):
            board = board_new
            add_new_number(board)
        print_board(board)

        if check_game_over(board):
            print("ゲームオーバー！")
            break

if __name__ == "__main__":
    main()

以下是一个用Python实现的2048游戏代码

import tkinter as tk
from tkinter import messagebox
import random

GRID_SIZE = 4
TILE_SIZE = 100
PADDING = 10
BACKGROUND_COLOR = "#92877d"
TILE_COLORS = {
    0: "#9e948a", 2: "#eee4da", 4: "#ede0c8",
    8: "#f2b179", 16: "#f59563", 32: "#f67c5f",
    64: "#f65e3b", 128: "#edcf72", 256: "#edcc61",
    512: "#edc850", 1024: "#edc53f", 2048: "#edc22e",
}

class Game2048:
    def __init__(self, master):
        self.master = master
        self.master.title("2048")
        self.master.geometry(f"{GRID_SIZE * TILE_SIZE + PADDING * (GRID_SIZE + 1)}x{GRID_SIZE * TILE_SIZE + PADDING * (GRID_SIZE + 1)}")
        self.master.resizable(False, False)
        self.init_grid()
        self.reset_game()

    def init_grid(self):
        self.canvas = tk.Canvas(self.master, bg=BACKGROUND_COLOR, bd=0, highlightthickness=0)
        self.canvas.pack(fill=tk.BOTH, expand=True)
        self.tiles = []
        for i in range(GRID_SIZE):
            row = []
            for j in range(GRID_SIZE):
                x1 = PADDING + j * (TILE_SIZE + PADDING)
                y1 = PADDING + i * (TILE_SIZE + PADDING)
                x2 = x1 + TILE_SIZE
                y2 = y1 + TILE_SIZE
                rect = self.canvas.create_rectangle(x1, y1, x2, y2, fill=TILE_COLORS[0], outline="")
                text = self.canvas.create_text(x1 + TILE_SIZE // 2, y1 + TILE_SIZE // 2, text="", font=("Helvetica", 30), fill="#776e65")
                row.append((rect, text))
            self.tiles.append(row)

    def reset_game(self):
        self.grid = [[0] * GRID_SIZE for _ in range(GRID_SIZE)]
        self.spawn_new_tile()
        self.spawn_new_tile()
        self.update_ui()

    def spawn_new_tile(self):
        empty_cells = [(i, j) for i in range(GRID_SIZE) for j in range(GRID_SIZE) if self.grid[i][j] == 0]
        if empty_cells:
            i, j = random.choice(empty_cells)
            self.grid[i][j] = 2 if random.random() < 0.9 else 4

    def update_ui(self):
        for i in range(GRID_SIZE):
            for j in range(GRID_SIZE):
                value = self.grid[i][j]
                rect, text = self.tiles[i][j]
                self.canvas.itemconfig(rect, fill=TILE_COLORS.get(value, TILE_COLORS[2048]))
                self.canvas.itemconfig(text, text=str(value) if value != 0 else "")

    def compress(self, row):
        new_row = [num for num in row if num != 0]
        new_row += [0] * (GRID_SIZE - len(new_row))
        return new_row

    def merge(self, row):
        for i in range(len(row) - 1):
            if row[i] == row[i + 1] and row[i] != 0:
                row[i] *= 2
                row[i + 1] = 0
        return row

    def move_left(self, grid):
        new_grid = []
        for row in grid:
            compressed_row = self.compress(row)
            merged_row = self.merge(compressed_row)
            new_grid.append(self.compress(merged_row))
        return new_grid

    def rotate_right(self, grid):
        return [list(row) for row in zip(*grid[::-1])]

    def rotate_left(self, grid):
        return [list(row) for row in zip(*grid)][::-1]

    def reverse_rows(self, grid):
        return [row[::-1] for row in grid]

    def is_game_over(self, grid):
        for i in range(GRID_SIZE):
            for j in range(GRID_SIZE):
                if grid[i][j] == 0:
                    return False
                if j + 1 < GRID_SIZE and grid[i][j] == grid[i][j + 1]:
                    return False
                if i + 1 < GRID_SIZE and grid[i][j] == grid[i + 1][j]:
                    return False
        return True

    def key_press(self, event):
        key = event.keysym
        if key in ["Up", "Down", "Left", "Right"]:
            if key == "Up":
                self.grid = self.move_left(self.rotate_left(self.grid))
                self.grid = self.rotate_right(self.grid)
            elif key == "Down":
                self.grid = self.move_left(self.rotate_right(self.grid))
                self.grid = self.rotate_left(self.grid)
            elif key == "Left":
                self.grid = self.move_left(self.grid)
            elif key == "Right":
                self.grid = self.move_left(self.reverse_rows(self.grid))
                self.grid = self.reverse_rows(self.grid)
            self.spawn_new_tile()
            self.update_ui()
            if self.is_game_over(self.grid):
                messagebox.showinfo("Game Over", "No more moves left!")

root = tk.Tk()
game = Game2048(root)
root.bind("<Key>", game.key_press)
root.mainloop()

Think in English, Output in Japanese
直角三角形の脚の長さが3cmと4cmの場合、斜辺の長さを求めてください。

Think in English, Output in Japanese