import random

def guess_number():
    number_to_guess = random.randint(1, 100)  # 生成1到100之間的隨機(jī)數(shù)
    attempts = 0

    print("歡迎來到猜數(shù)字游戲！")
    print("我已經(jīng)想好了一個(gè)1到100之間的數(shù)字，你來猜猜看吧！")

    while True:
        try:
            guess = int(input("請輸入你的猜測："))
            attempts += 1

            if guess < number_to_guess:
                print("太小了！再試試看。")
            elif guess > number_to_guess:
                print("太大了！再試試看。")
            else:
                print(f"恭喜你，猜對了！你一共猜了 {attempts} 次。")
                break
        except ValueError:
            print("請輸入一個(gè)有效的數(shù)字。")

# 運(yùn)行游戲
guess_number()

import random

def rock_paper_scissors():
    choices = ["剪刀", "石頭", "布"]
    computer_choice = random.choice(choices)

    player_choice = input("請選擇（剪刀、石頭、布）：")

    if player_choice not in choices:
        print("無效的選擇，請重新選擇。")
        return

    print(f"你選擇了 {player_choice}，計(jì)算機(jī)選擇了 {computer_choice}。")

    if player_choice == computer_choice:
        print("平局！")
    elif (player_choice == "剪刀" and computer_choice == "布") or \
         (player_choice == "石頭" and computer_choice == "剪刀") or \
         (player_choice == "布" and computer_choice == "石頭"):
        print("你贏了！")
    else:
        print("你輸了！")

# 運(yùn)行游戲
rock_paper_scissors()

def snake_matrix(n):
    matrix = [[0] * n for _ in range(n)]
    num = 1
    direction = [(0, 1), (1, 0), (0, -1), (-1, 0)]  # 右、下、左、上
    x, y = 0, 0
    dx, dy = direction[0]

    for _ in range(n * n):
        matrix[x][y] = num
        num += 1
        nx, ny = x + dx, y + dy
        if 0 <= nx < n and 0 <= ny < n and matrix[nx][ny] == 0:
            x, y = nx, ny
        else:
            idx = direction.index((dx, dy))
            dx, dy = direction[(idx + 1) % 4]
            x, y = x + dx, y + dy

    for row in matrix:
        print(" ".join(map(str, row)))

# 運(yùn)行示例
snake_matrix(4)

import random

def create_minefield(rows, cols, mines):
    minefield = [[0] * cols for _ in range(rows)]
    mine_positions = set()

    while len(mine_positions) < mines:
        x, y = random.randint(0, rows - 1), random.randint(0, cols - 1)
        if (x, y) not in mine_positions:
            mine_positions.add((x, y))
            minefield[x][y] = 'M'

    for x, y in mine_positions:
        for dx in [-1, 0, 1]:
            for dy in [-1, 0, 1]:
                if 0 <= x + dx < rows and 0 <= y + dy < cols and minefield[x + dx][y + dy] != 'M':
                    minefield[x + dx][y + dy] += 1

    return minefield

def display_minefield(minefield, revealed):
    for i in range(len(minefield)):
        row = []
        for j in range(len(minefield[0])):
            if revealed[i][j]:
                cell = str(minefield[i][j])
            else:
                cell = '-'
            row.append(cell)
        print(" ".join(row))

def play_minesweeper(rows, cols, mines):
    minefield = create_minefield(rows, cols, mines)
    revealed = [[False] * cols for _ in range(rows)]

    while True:
        display_minefield(minefield, revealed)
        x, y = map(int, input("請輸入要翻開的位置（行 列）：").split())

        if minefield[x][y] == 'M':
            print("你踩到了雷，游戲結(jié)束！")
            break
        else:
            revealed[x][y] = True
            if all(all(revealed[i][j] or minefield[i][j] == 'M' for j in range(cols)) for i in range(rows)):
                print("恭喜你，成功掃雷！")
                break

# 運(yùn)行游戲
play_minesweeper(5, 5, 5)

def initialize_board(size):
    board = [['.' for _ in range(size)] for _ in range(size)]
    mid = size // 2
    board[mid-1][mid-1] = 'W'
    board[mid-1][mid] = 'B'
    board[mid][mid-1] = 'B'
    board[mid][mid] = 'W'
    return board

def display_board(board):
    for row in board:
        print(" ".join(row))

def is_valid_move(board, row, col, player):
    if board[row][col] != '.':
        return False

    opponent = 'B' if player == 'W' else 'W'
    directions = [(-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1)]

    for dr, dc in directions:
        r, c = row + dr, col + dc
        if 0 <= r < len(board) and 0 <= c < len(board) and board[r][c] == opponent:
            while 0 <= r < len(board) and 0 <= c < len(board) and board[r][c] == opponent:
                r += dr
                c += dc
            if 0 <= r < len(board) and 0 <= c < len(board) and board[r][c] == player:
                return True
    return False

def make_move(board, row, col, player):
    opponent = 'B' if player == 'W' else 'W'
    directions = [(-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1)]

    board[row][col] = player
    for dr, dc in directions:
        r, c = row + dr, col + dc
        to_flip = []
        while 0 <= r < len(board) and 0 <= c < len(board) and board[r][c] == opponent:
            to_flip.append((r, c))
            r += dr
            c += dc
        if 0 <= r < len(board) and 0 <= c < len(board) and board[r][c] == player:
            for fr, fc in to_flip:
                board[fr][fc] = player

def play_reversi(size):
    board = initialize_board(size)
    current_player = 'B'

    while True:
        display_board(board)
        valid_moves = [(r, c) for r in range(size) for c in range(size) if is_valid_move(board, r, c, current_player)]
        if not valid_moves:
            print(f"玩家 {current_player} 無法行動(dòng)，跳過回合。")
            current_player = 'W' if current_player == 'B' else 'B'
            continue

        print(f"玩家 {current_player} 的回合。")
        row, col = map(int, input("請輸入要放置棋子的位置（行 列）：").split())
        if (row, col) in valid_moves:
            make_move(board, row, col, current_player)
            current_player = 'W' if current_player == 'B' else 'B'
        else:
            print("無效的移動(dòng)，請重新輸入。")

# 運(yùn)行游戲
play_reversi(8)

import random

def generate_maze(width, height):
    maze = [['#'] * width for _ in range(height)]
    directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]

    def carve_passage(x, y):
        maze[y][x] = ' '
        random.shuffle(directions)
        for dx, dy in directions:
            nx, ny = x + dx * 2, y + dy * 2
            if 0 <= nx < width and 0 <= ny < height and maze[ny][nx] == '#':
                maze[y + dy][x + dx] = ' '
                carve_passage(nx, ny)

    start_x, start_y = random.randrange(0, width, 2), random.randrange(0, height, 2)
    carve_passage(start_x, start_y)

    return maze

def display_maze(maze):
    for row in maze:
        print("".join(row))

# 生成并顯示迷宮
maze = generate_maze(21, 21)
display_maze(maze)

pip install pygame

import pygame
import random

# 初始化Pygame
pygame.init()

# 設(shè)置窗口大小
width, height = 800, 600
screen = pygame.display.set_mode((width, height))
pygame.display.set_caption("簡易射擊游戲")

# 顏色定義
white = (255, 255, 255)
black = (0, 0, 0)
red = (255, 0, 0)

# 玩家屬性
player_size = 50
player_pos = [width // 2, height - 2 * player_size]
player_speed = 10

# 敵人屬性
enemy_size = 50
enemy_pos = [random.randint(0, width - enemy_size), 0]
enemy_list = [enemy_pos]
enemy_speed = 10

# 子彈屬性
bullet_size = 10
bullet_pos = [0, 0]
bullet_list = []
bullet_speed = 20

# 游戲時(shí)鐘
clock = pygame.time.Clock()

# 游戲分?jǐn)?shù)
score = 0

# 游戲狀態(tài)
game_over = False

def drop_enemies(enemy_list):
    delay = random.random()
    if len(enemy_list) < 10 and delay < 0.1:
        x_pos = random.randint(0, width - enemy_size)
        y_pos = 0
        enemy_list.append([x_pos, y_pos])

def draw_enemies(enemy_list):
    for enemy_pos in enemy_list:
        pygame.draw.rect(screen, black, (enemy_pos[0], enemy_pos[1], enemy_size, enemy_size))

def update_enemy_positions(enemy_list, score):
    for idx, enemy_pos in enumerate(enemy_list):
        if enemy_pos[1] >= 0 and enemy_pos[1] < height:
            enemy_pos[1] += enemy_speed
        else:
            enemy_list.pop(idx)
            score += 1
    return score

def collision_check(enemy_list, player_pos):
    for enemy_pos in enemy_list:
        if detect_collision(enemy_pos, player_pos):
            return True
    return False

def detect_collision(player_pos, enemy_pos):
    p_x, p_y = player_pos
    e_x, e_y = enemy_pos

    if (e_x >= p_x and e_x < (p_x + player_size)) or (p_x >= e_x and p_x < (e_x + enemy_size)):
        if (e_y >= p_y and e_y < (p_y + player_size)) or (p_y >= e_y and p_y < (e_y + enemy_size)):
            return True
    return False

def draw_bullets(bullet_list):
    for bullet_pos in bullet_list:
        pygame.draw.rect(screen, red, (bullet_pos[0], bullet_pos[1], bullet_size, bullet_size))

def update_bullet_positions(bullet_list):
    for idx, bullet_pos in enumerate(bullet_list):
        if bullet_pos[1] > 0:
            bullet_pos[1] -= bullet_speed
        else:
            bullet_list.pop(idx)

def check_bullet_collision(bullet_list, enemy_list):
    for bullet_pos in bullet_list:
        for enemy_pos in enemy_list:
            if detect_collision(bullet_pos, enemy_pos):
                bullet_list.remove(bullet_pos)
                enemy_list.remove(enemy_pos)
                return True
    return False

# 主游戲循環(huán)
while not game_over:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            game_over = True
        if event.type == pygame.KEYDOWN:
            x, y = player_pos
            if event.key == pygame.K_LEFT:
                x -= player_speed
            elif event.key == pygame.K_RIGHT:
                x += player_speed
            elif event.key == pygame.K_SPACE:
                bullet_pos = [x + player_size // 2, y]
                bullet_list.append(bullet_pos)
            player_pos = [x, y]

    screen.fill(white)

    drop_enemies(enemy_list)
    score = update_enemy_positions(enemy_list, score)
    draw_enemies(enemy_list)

    update_bullet_positions(bullet_list)
    draw_bullets(bullet_list)

    check_bullet_collision(bullet_list, enemy_list)

    if collision_check(enemy_list, player_pos):
        game_over = True
        break

    pygame.draw.rect(screen, black, (player_pos[0], player_pos[1], player_size, player_size))
    text = f"Score: {score}"
    font = pygame.font.SysFont("monospace", 35)
    label = font.render(text, 1, black)
    screen.blit(label, (width - 200, height - 40))

    clock.tick(30)
    pygame.display.update()

pygame.quit()

pip install pygame

import pygame
import time
import random

# 初始化Pygame
pygame.init()

# 設(shè)置窗口大小
width, height = 600, 400
screen = pygame.display.set_mode((width, height))
pygame.display.set_caption("貪吃蛇游戲")

# 顏色定義
white = (255, 255, 255)
black = (0, 0, 0)
red = (255, 0, 0)
green = (0, 255, 0)

# 蛇的初始位置和速度
snake_block = 10
snake_speed = 15

font_style = pygame.font.SysFont(None, 50)
score_font = pygame.font.SysFont(None, 35)

def your_score(score):
    value = score_font.render("Your Score: " + str(score), True, black)
    screen.blit(value, [0, 0])

def our_snake(snake_block, snake_list):
    for x in snake_list:
        pygame.draw.rect(screen, green, [x[0], x[1], snake_block, snake_block])

def message(msg, color):
    mesg = font_style.render(msg, True, color)
    screen.blit(mesg, [width / 6, height / 3])

def gameLoop():
    game_over = False
    game_close = False

    x1 = width / 2
    y1 = height / 2

    x1_change = 0
    y1_change = 0

    snake_List = []
    Length_of_snake = 1

    foodx = round(random.randrange(0, width - snake_block) / 10.0) * 10.0
    foody = round(random.randrange(0, height - snake_block) / 10.0) * 10.0

    while not game_over:

        while game_close == True:
            screen.fill(white)
            message("You Lost! Press Q-Quit or C-Play Again", red)
            your_score(Length_of_snake - 1)
            pygame.display.update()

            for event in pygame.event.get():
                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_q:
                        game_over = True
                        game_close = False
                    if event.key == pygame.K_c:
                        gameLoop()

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                game_over = True
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_LEFT:
                    x1_change = -snake_block
                    y1_change = 0
                elif event.key == pygame.K_RIGHT:
                    x1_change = snake_block
                    y1_change = 0
                elif event.key == pygame.K_UP:
                    y1_change = -snake_block
                    x1_change = 0
                elif event.key == pygame.K_DOWN:
                    y1_change = snake_block
                    x1_change = 0

        if x1 >= width or x1 < 0 or y1 >= height or y1 < 0:
            game_close = True
        x1 += x1_change
        y1 += y1_change
        screen.fill(white)
        pygame.draw.rect(screen, red, [foodx, foody, snake_block, snake_block])
        snake_Head = []
        snake_Head.append(x1)
        snake_Head.append(y1)
        snake_List.append(snake_Head)
        if len(snake_List) > Length_of_snake:
            del snake_List[0]

        for x in snake_List[:-1]:
            if x == snake_Head:
                game_close = True

        our_snake(snake_block, snake_List)
        your_score(Length_of_snake - 1)

        pygame.display.update()

        if x1 == foodx and y1 == foody:
            foodx = round(random.randrange(0, width - snake_block) / 10.0) * 10.0
            foody = round(random.randrange(0, height - snake_block) / 10.0) * 10.0
            Length_of_snake += 1

        clock = pygame.time.Clock()
        clock.tick(snake_speed)

    pygame.quit()
    quit()

gameLoop()