10 класс Информатика ГДЗ учебник Поляков 2 часть Параграф 67

10 класс Информатика ГДЗ учебник Поляков 2 часть Параграф 67 Матрицы

Стр.254-255.

1. Матрицы — это прямоугольные таблицы, составленные из элементов одного типа (например, чисел или строк). Они используются для хранения и обработки данных, организованных в виде таблиц. Примеры применения матриц включают научные вычисления, компьютерную графику и обработку изображений.

2. Массив — это одномерная структура данных, состоящая из элементов одного типа, каждый из которых имеет один индекс. Матрица, напротив, является двумерной структурой данных, в которой каждый элемент имеет два индекса: номер строки и номер столбца. Матрицы можно рассматривать как массивы массивов.

3. Нет, принято считать, что первый индекс элемента матрицы обозначает номер строки, а второй — номер столбца. Это стандартный способ индексирования в большинстве языков программирования, включая Python.

4. Главная диагональ матрицы состоит из элементов, у которых номер строки равен номеру столбца (например, A[0][0], A[1][1], A[2][2] и так далее). Побочная диагональ состоит из элементов, у которых сумма номеров строки и столбца равна размеру матрицы минус один (например, A[0][n-1], A[1][n-2], A[2][n-3] и так далее).

5. Суммирование элементов главной диагонали можно выполнить с помощью одного цикла, так как индексы строки и столбца совпадают (A[i][i]). Для суммирования элементов под главной диагональю необходимо использовать вложенный цикл, так как нужно обойти все элементы, расположенные ниже главной диагонали, где индекс столбца меньше индекса строки (A[i][j] при j < i).

Проекты

а) Игра «Крестики-нолики»

def print_board(board):
    for row in board:
        print(" | ".join(row))
        print("-" * 5)

def check_winner(board, player):
    # Проверка строк
    for row in board:
        if all([cell == player for cell in row]):
            return True

    # Проверка столбцов
    for col in range(3):
        if all([board[row][col] == player for row in range(3)]):
            return True

    # Проверка диагоналей
    if all([board[i][i] == player for i in range(3)]) or all([board[i][2-i] == player for i in range(3)]):
        return True

    return False

def check_draw(board):
    return all([cell != " " for row in board for cell in row])

def tic_tac_toe():
    board = [[" " for _ in range(3)] for _ in range(3)]
    current_player = "X"

    while True:
        print_board(board)
        row = int(input(f"Игрок {current_player}, введите номер строки (0-2): "))
        col = int(input(f"Игрок {current_player}, введите номер столбца (0-2): "))

        if board[row][col] == " ":
            board[row][col] = current_player
            if check_winner(board, current_player):
                print_board(board)
                print(f"Игрок {current_player} победил!")
                break
            elif check_draw(board):
                print_board(board)
                print("Ничья!")
                break

            current_player = "O" if current_player == "X" else "X"
        else:
            print("Эта клетка уже занята. Попробуйте снова.")

if __name__ == "__main__":
    tic_tac_toe()

def print_board(board):

for row in board:

print(" | ".join(row))

print("-" * 5)

def check_winner(board, player):

# Проверка строк

for row in board:

if all([cell == player for cell in row]):

return True

# Проверка столбцов

for col in range(3):

if all([board[row][col] == player for row in range(3)]):

return True

# Проверка диагоналей

if all([board[i][i] == player for i in range(3)]) or all([board[i][2-i] == player for i in range(3)]):

return True

return False

def check_draw(board):

return all([cell != " " for row in board for cell in row])

def tic_tac_toe():

board = [[" " for _ in range(3)] for _ in range(3)]

current_player = "X"

while True:

print_board(board)

row = int(input(f"Игрок {current_player}, введите номер строки (0-2): "))

col = int(input(f"Игрок {current_player}, введите номер столбца (0-2): "))

if board[row][col] == " ":

board[row][col] = current_player

if check_winner(board, current_player):

print_board(board)

print(f"Игрок {current_player} победил!")

break

elif check_draw(board):

print_board(board)

print("Ничья!")

break

current_player = "O" if current_player == "X" else "X"

else:

print("Эта клетка уже занята. Попробуйте снова.")

if __name__ == "__main__":

tic_tac_toe()

Объяснение

print_board(board): Функция для вывода текущего состояния игрового поля.
check_winner(board, player): Функция для проверки, есть ли победитель. Проверяет строки, столбцы и диагонали.
check_draw(board): Функция для проверки, есть ли ничья.
tic_tac_toe(): Основная функция игры. Инициализирует игровое поле и управляет ходами игроков.
if name == «main»: tic_tac_toe(): Запуск игры.

б) Игра «Морской бой»

import random

# Создаем пустое поле 5x5
def create_empty_board():
    return [["O" for _ in range(5)] for _ in range(5)]

# Расставляем корабли на поле
def place_ships(board):
    ships = 3
    while ships > 0:
        row = random.randint(0, 4)
        col = random.randint(0, 4)
        if board[row][col] == "O":
            board[row][col] = "S"
            ships -= 1

# Печать игрового поля
def print_board(board, hide_ships=True):
    for row in board:
        if hide_ships:
            print(" ".join(["O" if cell == "S" else cell for cell in row]))
        else:
            print(" ".join(row))
    print()

# Проверка, попал ли выстрел в корабль
def check_shot(board, row, col):
    if board[row][col] == "S":
        board[row][col] = "X"
        return True
    elif board[row][col] == "O":
        board[row][col] = "-"
        return False
    else:
        return None

# Основная функция игры
def battleship():
    player1_board = create_empty_board()
    player2_board = create_empty_board()

    place_ships(player1_board)
    place_ships(player2_board)

    player1_hits = 0
    player2_hits = 0

    while player1_hits < 3 and player2_hits < 3:
        print("Поле игрока 1:")
        print_board(player1_board)

        print("Поле игрока 2:")
        print_board(player2_board)

        print("Ход игрока 1:")
        row = int(input("Введите номер строки (0-4): "))
        col = int(input("Введите номер столбца (0-4): "))
        result = check_shot(player2_board, row, col)
        if result is True:
            print("Попадание!")
            player1_hits += 1
        elif result is False:
            print("Мимо!")
        else:
            print("Вы уже стреляли сюда.")

        if player1_hits == 3:
            print("Игрок 1 победил!")
            break

        print("Ход игрока 2:")
        row = int(input("Введите номер строки (0-4): "))
        col = int(input("Введите номер столбца (0-4): "))
        result = check_shot(player1_board, row, col)
        if result is True:
            print("Попадание!")
            player2_hits += 1
        elif result is False:
            print("Мимо!")
        else:
            print("Вы уже стреляли сюда.")

        if player2_hits == 3:
            print("Игрок 2 победил!")
            break

if __name__ == "__main__":
    battleship()

import random

# Создаем пустое поле 5x5

def create_empty_board():

return [["O" for _ in range(5)] for _ in range(5)]

# Расставляем корабли на поле

def place_ships(board):

ships = 3

while ships > 0:

row = random.randint(0, 4)

col = random.randint(0, 4)

if board[row][col] == "O":

board[row][col] = "S"

ships -= 1

# Печать игрового поля

def print_board(board, hide_ships=True):

for row in board:

if hide_ships:

print(" ".join(["O" if cell == "S" else cell for cell in row]))

else:

print(" ".join(row))

print()

# Проверка, попал ли выстрел в корабль

def check_shot(board, row, col):

if board[row][col] == "S":

board[row][col] = "X"

return True

elif board[row][col] == "O":

board[row][col] = "-"

return False

else:

return None

# Основная функция игры

def battleship():

player1_board = create_empty_board()

player2_board = create_empty_board()

place_ships(player1_board)

place_ships(player2_board)

player1_hits = 0

player2_hits = 0

while player1_hits < 3 and player2_hits < 3:

print("Поле игрока 1:")

print_board(player1_board)

print("Поле игрока 2:")

print_board(player2_board)

print("Ход игрока 1:")

row = int(input("Введите номер строки (0-4): "))

col = int(input("Введите номер столбца (0-4): "))

result = check_shot(player2_board, row, col)

if result is True:

print("Попадание!")

player1_hits += 1

elif result is False:

print("Мимо!")

else:

print("Вы уже стреляли сюда.")

if player1_hits == 3:

print("Игрок 1 победил!")

break

print("Ход игрока 2:")

row = int(input("Введите номер строки (0-4): "))

col = int(input("Введите номер столбца (0-4): "))

result = check_shot(player1_board, row, col)

if result is True:

print("Попадание!")

player2_hits += 1

elif result is False:

print("Мимо!")

else:

print("Вы уже стреляли сюда.")

if player2_hits == 3:

print("Игрок 2 победил!")

break

if __name__ == "__main__":

battleship()

Объяснение

create_empty_board(): Создает пустое поле 5×5, заполненное символами «O».
place_ships(board): Расставляет три корабля («S») на случайные позиции на поле.
print_board(board, hide_ships=True): Выводит игровое поле на экран, скрывая корабли, если hide_ships=True.
check_shot(board, row, col): Проверяет, попал ли выстрел в корабль, и обновляет состояние поля.
battleship(): Основная функция игры, в которой игроки поочередно стреляют по полям друг друга до тех пор, пока один из них не попадет три раза.

в) Игра «Жизнь»

«Игра «Жизнь»» — это клеточный автомат, придуманный математиком Джоном Конвеем. Она моделирует эволюцию клеток на плоскости по заданным правилам.

Правила игры:

Любая живая клетка с менее чем двумя живыми соседями умирает от одиночества.
Любая живая клетка с двумя или тремя живыми соседями продолжает жить.
Любая живая клетка с более чем тремя живыми соседями умирает от перенаселения.
Любая мертвая клетка с точно тремя живыми соседями становится живой.

import random
import time
import os

# Создание начального поля
def create_board(rows, cols):
    return [[random.choice([0, 1]) for _ in range(cols)] for _ in range(rows)]

# Печать игрового поля
def print_board(board):
    os.system('cls' if os.name == 'nt' else 'clear')
    for row in board:
        print("".join(['█' if cell else ' ' for cell in row]))
    print()

# Подсчет живых соседей
def count_neighbors(board, row, col):
    neighbors = [
        (-1, -1), (-1, 0), (-1, 1),
        (0, -1), (0, 1),
        (1, -1), (1, 0), (1, 1)
    ]
    count = 0
    for dr, dc in neighbors:
        r, c = row + dr, col + dc
        if 0 <= r < len(board) and 0 <= c < len(board[0]):
            count += board[r][c]
    return count

# Обновление игрового поля
def update_board(board):
    new_board = [[0 for _ in range(len(board[0]))] for _ in range(len(board))]
    for row in range(len(board)):
        for col in range(len(board[0])):
            alive_neighbors = count_neighbors(board, row, col)
            if board[row][col] == 1:
                if alive_neighbors < 2 or alive_neighbors > 3:
                    new_board[row][col] = 0
                else:
                    new_board[row][col] = 1
            else:
                if alive_neighbors == 3:
                    new_board[row][col] = 1
    return new_board

def game_of_life(rows, cols, generations):
    board = create_board(rows, cols)
    for _ in range(generations):
        print_board(board)
        board = update_board(board)
        time.sleep(1)

if __name__ == "__main__":
    game_of_life(20, 40, 100)

import random

import time

import os

# Создание начального поля

def create_board(rows, cols):

return [[random.choice([0, 1]) for _ in range(cols)] for _ in range(rows)]

# Печать игрового поля

def print_board(board):

os.system('cls' if os.name == 'nt' else 'clear')

for row in board:

print("".join(['█' if cell else ' ' for cell in row]))

print()

# Подсчет живых соседей

def count_neighbors(board, row, col):

neighbors = [

(-1, -1), (-1, 0), (-1, 1),

(0, -1), (0, 1),

(1, -1), (1, 0), (1, 1)

]

count = 0

for dr, dc in neighbors:

r, c = row + dr, col + dc

if 0 <= r < len(board) and 0 <= c < len(board[0]):

count += board[r][c]

return count

# Обновление игрового поля

def update_board(board):

new_board = [[0 for _ in range(len(board[0]))] for _ in range(len(board))]

for row in range(len(board)):

for col in range(len(board[0])):

alive_neighbors = count_neighbors(board, row, col)

if board[row][col] == 1:

if alive_neighbors < 2 or alive_neighbors > 3:

new_board[row][col] = 0

else:

new_board[row][col] = 1

else:

if alive_neighbors == 3:

new_board[row][col] = 1

return new_board

def game_of_life(rows, cols, generations):

board = create_board(rows, cols)

for _ in range(generations):

print_board(board)

board = update_board(board)

time.sleep(1)

if __name__ == "__main__":

game_of_life(20, 40, 100)

Объяснение

create_board(rows, cols): Создает начальное поле заданного размера, заполняя его случайными живыми (1) и мертвыми (0) клетками.
print_board(board): Выводит игровое поле на экран. Живые клетки обозначены символом ‘█’, мертвые клетки — пробелом.
count_neighbors(board, row, col): Подсчитывает количество живых соседей для клетки в позиции (row, col).
update_board(board): Обновляет состояние игрового поля на основе правил игры «Жизнь».
game_of_life(rows, cols, generations): Основная функция, которая инициализирует игровое поле и запускает обновление поля в течение заданного числа поколений.

Этот код можно запустить на вашем компьютере, чтобы наблюдать за эволюцией клеточного автомата «Жизнь» в реальном времени.

г) Игра «Найди пару»

Игра «Найди пару» (или «Память») — это классическая игра, где игрок должен найти все пары одинаковых карточек на игровом поле.

import random
import os
import time

# Создание игрового поля
def create_board(size):
    symbols = list("AABBCCDDEEFFGGHH")
    random.shuffle(symbols)
    board = [symbols[i * size:(i + 1) * size] for i in range(size)]
    return board

# Печать игрового поля
def print_board(board, revealed):
    os.system('cls' if os.name == 'nt' else 'clear')
    for i in range(len(board)):
        for j in range(len(board[i])):
            if revealed[i][j]:
                print(board[i][j], end=" ")
            else:
                print("*", end=" ")
        print()

# Проверка на завершение игры
def check_win(revealed):
    for row in revealed:
        if not all(row):
            return False
    return True

def find_pair():
    size = 4
    board = create_board(size)
    revealed = [[False] * size for _ in range(size)]
    turns = 0

    while not check_win(revealed):
        print_board(board, revealed)
        try:
            row1, col1 = map(int, input("Введите координаты первой карты (через пробел): ").split())
            row2, col2 = map(int, input("Введите координаты второй карты (через пробел): ").split())
        except ValueError:
            print("Пожалуйста, введите допустимые координаты.")
            time.sleep(1)
            continue

        if revealed[row1][col1] or revealed[row2][col2] or (row1 == row2 and col1 == col2):
            print("Вы выбрали недопустимые или уже открытые карты. Попробуйте снова.")
            time.sleep(1)
            continue

        revealed[row1][col1] = True
        revealed[row2][col2] = True
        print_board(board, revealed)
        turns += 1

        if board[row1][col1] != board[row2][col2]:
            print("Карты не совпадают.")
            revealed[row1][col1] = False
            revealed[row2][col2] = False
        else:
            print("Карты совпадают!")

        time.sleep(1)

    print(f"Поздравляем! Вы нашли все пары за {turns} ходов.")

if __name__ == "__main__":
    find_pair()

import random

import os

import time

# Создание игрового поля

def create_board(size):

symbols = list("AABBCCDDEEFFGGHH")

random.shuffle(symbols)

board = [symbols[i * size:(i + 1) * size] for i in range(size)]

return board

# Печать игрового поля

def print_board(board, revealed):

os.system('cls' if os.name == 'nt' else 'clear')

for i in range(len(board)):

for j in range(len(board[i])):

if revealed[i][j]:

print(board[i][j], end=" ")

else:

print("*", end=" ")

print()

# Проверка на завершение игры

def check_win(revealed):

for row in revealed:

if not all(row):

return False

return True

def find_pair():

size = 4

board = create_board(size)

revealed = [[False] * size for _ in range(size)]

turns = 0

while not check_win(revealed):

print_board(board, revealed)

try:

row1, col1 = map(int, input("Введите координаты первой карты (через пробел): ").split())

row2, col2 = map(int, input("Введите координаты второй карты (через пробел): ").split())

except ValueError:

print("Пожалуйста, введите допустимые координаты.")

time.sleep(1)

continue

if revealed[row1][col1] or revealed[row2][col2] or (row1 == row2 and col1 == col2):

print("Вы выбрали недопустимые или уже открытые карты. Попробуйте снова.")

time.sleep(1)

continue

revealed[row1][col1] = True

revealed[row2][col2] = True

print_board(board, revealed)

turns += 1

if board[row1][col1] != board[row2][col2]:

print("Карты не совпадают.")

revealed[row1][col1] = False

revealed[row2][col2] = False

else:

print("Карты совпадают!")

time.sleep(1)

print(f"Поздравляем! Вы нашли все пары за {turns} ходов.")

if __name__ == "__main__":

find_pair()

Объяснение

create_board(size): Создает игровое поле размером size x size, заполняя его парными символами и перемешивая их.
print_board(board, revealed): Выводит игровое поле на экран. Если карта открыта (revealed=True), отображается ее символ, иначе отображается ‘*’.
check_win(revealed): Проверяет, все ли карты были найдены (все ли элементы в revealed равны True).
find_pair(): Основная функция игры, которая инициализирует игровое поле, обрабатывает ввод игрока и контролирует процесс игры.

Этот код можно запустить на вашем компьютере, чтобы играть в игру «Найди пару». Игрок вводит координаты двух карт, чтобы попытаться найти совпадающие пары. Игра продолжается до тех пор, пока все пары не будут найдены.

д) Игра «Тетрис»

Игра «Тетрис» — это популярная игра-головоломка, где игроки размещают падающие фигурки различной формы, чтобы заполнить горизонтальные линии на игровом поле. Когда линия полностью заполнена, она исчезает, и игрок получает очки.

import random
import pygame
import sys

# Настройки игры
colors = [
    (0, 0, 0),
    (255, 0, 0),
    (0, 255, 0),
    (0, 0, 255),
    (255, 255, 0),
    (255, 165, 0),
    (128, 0, 128),
    (0, 255, 255)
]

tetris_shapes = [
    [[1, 1, 1],
     [0, 1, 0]],

    [[0, 2, 2],
     [2, 2, 0]],

    [[3, 3, 0],
     [0, 3, 3]],

    [[4, 4, 4, 4]],

    [[5, 5],
     [5, 5]],

    [[0, 6, 0],
     [6, 6, 6]],

    [[0, 7, 7],
     [7, 7, 0]]
]

class Tetris:
    def __init__(self, height, width):
        self.height = height
        self.width = width
        self.field = [[0 for _ in range(width)] for _ in range(height)]
        self.score = 0
        self.gameover = False
        self.figure = None
        self.figure_x = 0
        self.figure_y = 0

    def new_figure(self):
        self.figure = random.choice(tetris_shapes)
        self.figure_x = int(self.width / 2) - int(len(self.figure[0]) / 2)
        self.figure_y = 0

    def intersects(self):
        intersection = False
        for i in range(len(self.figure)):
            for j in range(len(self.figure[i])):
                if self.figure[i][j] and self.field[i + self.figure_y][j + self.figure_x]:
                    intersection = True
        return intersection

    def break_lines(self):
        lines = 0
        for i in range(1, self.height):
            zeros = 0
            for j in range(self.width):
                if self.field[i][j] == 0:
                    zeros += 1
            if zeros == 0:
                lines += 1
                for i1 in range(i, 1, -1):
                    for j in range(self.width):
                        self.field[i1][j] = self.field[i1 - 1][j]
        self.score += lines ** 2

    def go_space(self):
        while not self.intersects():
            self.figure_y += 1
        self.figure_y -= 1
        self.freeze()

    def freeze(self):
        for i in range(len(self.figure)):
            for j in range(len(self.figure[i])):
                if self.figure[i][j]:
                    self.field[i + self.figure_y][j + self.figure_x] = self.figure[i][j]
        self.break_lines()
        self.new_figure()
        if self.intersects():
            self.gameover = True

    def go_down(self):
        self.figure_y += 1
        if self.intersects():
            self.figure_y -= 1
            self.freeze()

    def go_side(self, dx):
        self.figure_x += dx
        if self.intersects():
            self.figure_x -= dx

    def rotate(self):
        old_figure = self.figure
        self.figure = list(zip(*self.figure[::-1]))
        if self.intersects():
            self.figure = old_figure

pygame.init()
screen = pygame.display.set_mode((400, 500))
pygame.display.set_caption('Тетрис')

clock = pygame.time.Clock()
game = Tetris(20, 10)

counter = 0

while not game.gameover:
    if game.figure is None:
        game.new_figure()
    counter += 1
    if counter > 100000:
        counter = 0

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            sys.exit()
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_UP:
                game.rotate()
            if event.key == pygame.K_DOWN:
                game.go_down()
            if event.key == pygame.K_LEFT:
                game.go_side(-1)
            if event.key == pygame.K_RIGHT:
                game.go_side(1)
            if event.key == pygame.K_SPACE:
                game.go_space()

    game.go_down()
    
    screen.fill((0, 0, 0))
    
    for i in range(game.height):
        for j in range(game.width):
            pygame.draw.rect(screen, colors[game.field[i][j]], [j * 20, i * 20, 20, 20])

    for i in range(len(game.figure)):
        for j in range(len(game.figure[i])):
            if game.figure[i][j]:
                pygame.draw.rect(screen, colors[game.figure[i][j]], [(j + game.figure_x) * 20, (i + game.figure_y) * 20, 20, 20])

    pygame.display.flip()
    clock.tick(25)

pygame.quit()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

import random

import pygame

import sys

# Настройки игры

colors = [

(0, 0, 0),

(255, 0, 0),

(0, 255, 0),

(0, 0, 255),

(255, 255, 0),

(255, 165, 0),

(128, 0, 128),

(0, 255, 255)

]

tetris_shapes = [

[[1, 1, 1],

[0, 1, 0]],

[[0, 2, 2],

[2, 2, 0]],

[[3, 3, 0],

[0, 3, 3]],

[[4, 4, 4, 4]],

[[5, 5],

[5, 5]],

[[0, 6, 0],

[6, 6, 6]],

[[0, 7, 7],

[7, 7, 0]]

]

class Tetris:

def __init__(self, height, width):

self.height = height

self.width = width

self.field = [[0 for _ in range(width)] for _ in range(height)]

self.score = 0

self.gameover = False

self.figure = None

self.figure_x = 0

self.figure_y = 0

def new_figure(self):

self.figure = random.choice(tetris_shapes)

self.figure_x = int(self.width / 2) - int(len(self.figure[0]) / 2)

self.figure_y = 0

def intersects(self):

intersection = False

for i in range(len(self.figure)):

for j in range(len(self.figure[i])):

if self.figure[i][j] and self.field[i + self.figure_y][j + self.figure_x]:

intersection = True

return intersection

def break_lines(self):

lines = 0

for i in range(1, self.height):

zeros = 0

for j in range(self.width):

if self.field[i][j] == 0:

zeros += 1

if zeros == 0:

lines += 1

for i1 in range(i, 1, -1):

for j in range(self.width):

self.field[i1][j] = self.field[i1 - 1][j]

self.score += lines ** 2

def go_space(self):

while not self.intersects():

self.figure_y += 1

self.figure_y -= 1

self.freeze()

def freeze(self):

for i in range(len(self.figure)):

for j in range(len(self.figure[i])):

if self.figure[i][j]:

self.field[i + self.figure_y][j + self.figure_x] = self.figure[i][j]

self.break_lines()

self.new_figure()

if self.intersects():

self.gameover = True

def go_down(self):

self.figure_y += 1

if self.intersects():

self.figure_y -= 1

self.freeze()

def go_side(self, dx):

self.figure_x += dx

if self.intersects():

self.figure_x -= dx

def rotate(self):

old_figure = self.figure

self.figure = list(zip(*self.figure[::-1]))

if self.intersects():

self.figure = old_figure

pygame.init()

screen = pygame.display.set_mode((400, 500))

pygame.display.set_caption('Тетрис')

clock = pygame.time.Clock()

game = Tetris(20, 10)

counter = 0

while not game.gameover:

if game.figure is None:

game.new_figure()

counter += 1

if counter > 100000:

counter = 0

for event in pygame.event.get():

if event.type == pygame.QUIT:

sys.exit()

if event.type == pygame.KEYDOWN:

if event.key == pygame.K_UP:

game.rotate()

if event.key == pygame.K_DOWN:

game.go_down()

if event.key == pygame.K_LEFT:

game.go_side(-1)

if event.key == pygame.K_RIGHT:

game.go_side(1)

if event.key == pygame.K_SPACE:

game.go_space()

game.go_down()

screen.fill((0, 0, 0))

for i in range(game.height):

for j in range(game.width):

pygame.draw.rect(screen, colors[game.field[i][j]], [j * 20, i * 20, 20, 20])

for i in range(len(game.figure)):

for j in range(len(game.figure[i])):

if game.figure[i][j]:

pygame.draw.rect(screen, colors[game.figure[i][j]], [(j + game.figure_x) * 20, (i + game.figure_y) * 20, 20, 20])

pygame.display.flip()

clock.tick(25)

pygame.quit()

Объяснение

Настройки игры: Задает цвета для фигур и их формы.
Класс Tetris:
- __init__: Инициализирует поле, счет, состояние игры и текущую фигуру.
- new_figure(): Создает новую фигуру и размещает ее наверху поля.
- intersects(): Проверяет, пересекается ли текущая фигура с уже установленными фигурами на поле.
- break_lines(): Удаляет заполненные линии и увеличивает счет.
- go_space(): Падает фигура до самого низа.
- freeze(): Устанавливает фигуру на поле и создает новую фигуру.
- go_down(): Перемещает фигуру вниз.
- go_side(dx): Перемещает фигуру влево или вправо.
- rotate(): Поворачивает фигуру.
Основной цикл игры:
- Создает окно игры с помощью Pygame.
- Обрабатывает события клавиатуры для управления фигурой.
- Обновляет состояние игры и отрисовывает текущее состояние поля и фигур.

Этот код можно запустить на вашем компьютере, чтобы играть в игру «Тетрис». Игрок управляет падающими фигурами с помощью клавиш стрелок и пробела.

е) Программа для построения магических квадратов

Магический квадрат — это квадратная матрица размером $\times n$ , в которой суммы чисел в каждом столбце, каждой строке и обеих диагоналях одинаковы.

Ниже приведен код на Python для построения магического квадрата нечетного порядка с использованием метода Сиама.

def create_magic_square(n):
    if n % 2 == 0:
        raise ValueError("Размер магического квадрата должен быть нечетным.")

    magic_square = [[0] * n for _ in range(n)]
    num = 1
    i, j = 0, n // 2

    while num <= n * n:
        magic_square[i][j] = num
        num += 1
        newi, newj = (i - 1) % n, (j + 1) % n

        if magic_square[newi][newj]:
            i += 1
        else:
            i, j = newi, newj

    return magic_square

def print_magic_square(magic_square):
    for row in magic_square:
        print(" ".join(f"{num:2d}" for num in row))

if __name__ == "__main__":
    n = int(input("Введите размер магического квадрата (нечетное число): "))
    magic_square = create_magic_square(n)
    print_magic_square(magic_square)

def create_magic_square(n):

if n % 2 == 0:

raise ValueError("Размер магического квадрата должен быть нечетным.")

magic_square = [[0] * n for _ in range(n)]

num = 1

i, j = 0, n // 2

while num <= n * n:

magic_square[i][j] = num

num += 1

newi, newj = (i - 1) % n, (j + 1) % n

if magic_square[newi][newj]:

i += 1

else:

i, j = newi, newj

return magic_square

def print_magic_square(magic_square):

for row in magic_square:

print(" ".join(f"{num:2d}" for num in row))

if __name__ == "__main__":

n = int(input("Введите размер магического квадрата (нечетное число): "))

magic_square = create_magic_square(n)

print_magic_square(magic_square)

Объяснение

create_magic_square(n): Функция для создания магического квадрата нечетного порядка.
- Проверяет, что $n$ нечетное. Если $n$ четное, выбрасывает исключение.
- Инициализирует пустой магический квадрат размером $\times n$ .
- Заполняет квадрат числами от 1 до $n^{2}$ по правилу Сиама:
  - Начинает с середины верхней строки.
  - Помещает текущее число в текущую ячейку.
  - Переходит в следующую ячейку по диагонали вверх вправо.
  - Если ячейка занята, переходит в ячейку сразу под текущей.
- Повторяет, пока все числа не будут размещены.
print_magic_square(magic_square): Функция для печати магического квадрата в читаемом виде.

Пример использования

Запустите программу и введите нечетное число для создания магического квадрата. Программа создаст и выведет магический квадрат.

Этот код можно запустить на вашем компьютере, чтобы построить и распечатать магический квадрат для заданного нечетного размера.

ж) Программа для построения случайного лабиринта

Ниже приведен код на Python для построения случайного лабиринта с использованием алгоритма поиска в глубину (DFS).

import random

def create_maze(width, height):
    maze = [["#" for _ in range(width)] for _ in range(height)]
    stack = [(1, 1)]
    maze[1][1] = " "

    while stack:
        x, y = stack[-1]
        neighbors = []

        # Проверка соседей
        for dx, dy in [(-2, 0), (2, 0), (0, -2), (0, 2)]:
            nx, ny = x + dx, y + dy
            if 0 < nx < width - 1 and 0 < ny < height - 1 and maze[ny][nx] == "#":
                neighbors.append((nx, ny))

        if neighbors:
            nx, ny = random.choice(neighbors)
            maze[(y + ny) // 2][(x + nx) // 2] = " "
            maze[ny][nx] = " "
            stack.append((nx, ny))
        else:
            stack.pop()

    # Установка входа и выхода
    maze[1][0] = " "
    maze[height - 2][width - 1] = " "

    return maze

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

if __name__ == "__main__":
    width = int(input("Введите ширину лабиринта (нечетное число): "))
    height = int(input("Введите высоту лабиринта (нечетное число): "))
    maze = create_maze(width, height)
    print_maze(maze)

import random

def create_maze(width, height):

maze = [["#" for _ in range(width)] for _ in range(height)]

stack = [(1, 1)]

maze[1][1] = " "

while stack:

x, y = stack[-1]

neighbors = []

# Проверка соседей

for dx, dy in [(-2, 0), (2, 0), (0, -2), (0, 2)]:

nx, ny = x + dx, y + dy

if 0 < nx < width - 1 and 0 < ny < height - 1 and maze[ny][nx] == "#":

neighbors.append((nx, ny))

if neighbors:

nx, ny = random.choice(neighbors)

maze[(y + ny) // 2][(x + nx) // 2] = " "

maze[ny][nx] = " "

stack.append((nx, ny))

else:

stack.pop()

# Установка входа и выхода

maze[1][0] = " "

maze[height - 2][width - 1] = " "

return maze

def print_maze(maze):

for row in maze:

print("".join(row))

if __name__ == "__main__":

width = int(input("Введите ширину лабиринта (нечетное число): "))

height = int(input("Введите высоту лабиринта (нечетное число): "))

maze = create_maze(width, height)

print_maze(maze)

Объяснение

create_maze(width, height): Функция для создания случайного лабиринта.
- Инициализирует лабиринт размером $width \times height$ , заполняя его стенами («#»).
- Использует алгоритм поиска в глубину (DFS) для создания путей:
  - Начинает с точки (1, 1).
  - Добавляет текущую точку в стек.
  - Пока стек не пуст, выбирает случайного соседа на два шага в любом направлении.
  - Если соседняя точка находится в пределах лабиринта и еще не посещена, удаляет стену между текущей и соседней точкой, перемещается в соседнюю точку и добавляет ее в стек.
  - Если у текущей точки нет непосещенных соседей, возвращается к предыдущей точке.
- Создает вход и выход в лабиринт.
print_maze(maze): Функция для печати лабиринта на экран.

Пример использования

Запустите программу и введите нечетные числа для ширины и высоты лабиринта. Программа создаст и распечатает случайный лабиринт.

Этот код можно запустить на вашем компьютере, чтобы построить и распечатать случайный лабиринт для заданных размеров.

10 класс Информатика ГДЗ учебник Поляков 2 часть Параграф 67

Проекты

а) Игра «Крестики-нолики»

Объяснение

б) Игра «Морской бой»

Объяснение

в) Игра «Жизнь»

Правила игры:

Объяснение

г) Игра «Найди пару»

Объяснение

д) Игра «Тетрис»

Объяснение

е) Программа для построения магических квадратов

Объяснение

Пример использования

ж) Программа для построения случайного лабиринта

Объяснение

Пример использования

Добавить комментарий Отменить ответ