diagonal.py - master - k2709/matrix_task

diagonal.py
214 строк10 KB
urik
Initial commit
06 янв 2025, 18:02
06 янв 2025, 18:029d2fadf
"""
# https://proglib.io/p/obrabotka-vlozhennyh-spiskov-i-matric-v-python-
# 5-zadach-s-resheniyami-dlya-sovershenstvovaniya-navykov-2022-07-04
Заполнение матрицы по диагоналям
Напишите программу, которая принимает два натуральных
числа n и m, создает матрицу размером n × m, и заполняет
ее по диагоналям, направленным справа-сверху влево-вниз.
Формат ввода
Строка с числами n и m, разделенными пробелом.
Формат вывода
Матрица, заполненная в соответствии с условием задачи.

Пример ввода и вывода
Ввод #1:
12 12
Вывод #1:

1   2   4   7   11  16  22  29  37  46  56  67
3   5   8   12  17  23  30  38  47  57  68  79
6   9   13  18  24  31  39  48  58  69  80  90
10  14  19  25  32  40  49  59  70  81  91  100
15  20  26  33  41  50  60  71  82  92  101 109
21  27  34  42  51  61  72  83  93  102 110 117
28  35  43  52  62  73  84  94  103 111 118 124
36  44  53  63  74  85  95  104 112 119 125 130
45  54  64  75  86  96  105 113 120 126 131 135
55  65  76  87  97  106 114 121 127 132 136 139
66  77  88  98  107 115 122 128 133 137 140 142
78  89  99  108 116 123 129 134 138 141 143 144

"""

# Мой вариант заполнения матрицы по диагоналям
# w = 10 # w по строке (ширина)
# h = 10 # h по столбцу (высота)
#
# numbers_max = w * h # количество элементов в матрице
# matrix = [["" for i in range(w)] for j in range(h)]
#
# ri = 0 # номер диагонали r_max = w + h
# count_elem_diag = 1 # количество элементов в диагонали
# numbers_i = 1 #  значение элемента в ячейке матрицы
# while numbers_i <= numbers_max:
#     if numbers_i != 1:
#         i = 0
#         while i < count_elem_diag:
#             if ri < w:
#                 col = ri - count_elem_diag + i + 1
#                 row = ri - col
#             else:
#                 col = ri - w  + i + 1
#                 row = ri - col
#             matrix[col][row] = str(numbers_i).rjust(3)
#             i += 1
#             numbers_i += 1
#         ri += 1
#         if ri < w:
#             count_elem_diag += 1
#         else:
#             count_elem_diag -= 1
#     else:
#         matrix[0][0] = str(numbers_i).rjust(3)
#         ri += 1
#         numbers_i += 1
#         count_elem_diag += 1
#
# [print(*r, sep='  ') for r in matrix]


# Решение с сайта задачи
# n = 5
# m = 7
# matrix = [['0']*m for _ in range(n)]
# num = 0
# for d in range(m + n - 1):
#     for i in range(n):
#         j = d - i
#         if 0 <= i < n and 0 <= j < m:
#             num += 1
#             matrix[i][j] = str(num).ljust(3)
# for i in range(n):
#     print(*matrix[i])


# ChatGPT предложил вариант без отдельного if 0 <= i < n and 0 <= j < m:
# а пометить его внутрь for

# w = 9 # Размер матрицы (ширина и высота одинаковы)
# h = 7
# matrix = [["" for _ in range(w)] for _ in range(h)]
# numbers_i = 1  # Текущее значение для заполнения
# for d in range(h + w - 1):  # Диагонали от 0 до h+w-2
#     for i in range(min(h - 1, w + h - d - 2), max(-1, h - d - 2), -1): # движение снизу вверх
#         j = i + d - h + 1 # Заполнение с нижнего левого в верхний правый
#         matrix[i][j] = str(numbers_i).rjust(3)
#         numbers_i += 1
# # Печать матрицы
# [print(*row, sep=" ") for row in matrix]


#---------------------------------------------------------------------------
# for i in range(max(0, d - w + 1), min(d + 1, h)): # Движение сверху вниз
# j = d - i # Прямое заполнение с верхнего левого угла к нижнему правому

# for i in range(max(0, d - w + 1), min(d + 1, h)): # Движение сверху вниз
    # j = w - d - 1 + i  # Заполнение с правого верхнего в нижний левый

# for i in range(max(0, h - d - 1), min(h, w + h - d - 1)): # Движение сверху вниз
#     j = h + w - 2 - d - i  # Заполнение с нижнего правого в верхний левый

# for i in range(max(0, h - d - 1), min(h, w + h - d - 1)): # Движение сверху вниз
#     j = i + d - h + 1 # Заполнение с нижнего левого в верхний правый

#---------------------------------------------------------------------------
# for i in range(min(d, h - 1), max(-1, d - w), -1):  # движение снизу вверх
#     j = d - i  # Прямое заполнение с верхнего левого угла к нижнему правому

# for i in range(min(d, h - 1), max(-1, d - w), -1):  # движение снизу вверх
#     j = w - d - 1 + i  # Заполнение с правого верхнего в нижний левый

# for i in range(min(h - 1, w + h - d - 2), max(-1, h - d - 2), -1):  # движение снизу вверх
#     j = h + w - 2 - d - i  # Заполнение с нижнего правого в верхний левый

# for i in range(min(h - 1, w + h - d - 2), max(-1, h - d - 2), -1):  # движение снизу вверх
#     j = i + d - h + 1  # Заполнение с нижнего левого в верхний правый


# После анализа этого алгоритма я его развил по заполнению со всех углов во всех напралениях

def diagonal(w, h, n_corner, dir_zig):
    matrix = [["" for _ in range(w)] for _ in range(h)]
    numbers_i = 1  # Текущее значение для заполнения
    for d in range(h + w - 1):  # Диагонали от 0 до h+w-2
        match n_corner:
            case 1 | 2: # 1 - Заполнение с верхнего левого угла к нижнему правому
                        # 2 - Заполнение с правого верхнего в нижний левый
                if dir_zig == 'dn':
                    start_iter = max(0, d - w + 1)
                    finis_iter = min(d + 1, h)
                    step = 1
                elif dir_zig == 'up':
                    start_iter = min(d, h - 1)
                    finis_iter = max(-1, d - w)
                    step = -1
                elif dir_zig == 'zig_odd_dn':
                    if d % 2 == 0:
                        start_iter = min(d, h - 1)
                        finis_iter = max(-1, d - w)
                        step = -1
                    else:
                        start_iter = max(0, d - w + 1)
                        finis_iter = min(d + 1, h)
                        step = 1
                elif dir_zig == 'zig_odd_up':
                    if d % 2 == 0:
                        start_iter = max(0, d - w + 1)
                        finis_iter = min(d + 1, h)
                        step = 1
                    else:
                        start_iter = min(d, h - 1)
                        finis_iter = max(-1, d - w)
                        step = -1
                for i in range(start_iter, finis_iter, step):
                    if n_corner == 1:
                        j = d - i # Движение сверху вниз
                    else:
                        j = w - d - 1 + i # Движение снизу вверх
                    matrix[i][j] = str(numbers_i).rjust(3)
                    numbers_i += 1
            case 3 | 4:  # 3 - Заполнение с нижнего правого в верхний левый
                         # 4 - Заполнение с нижнего левого в верхний правый
                if dir_zig == 'dn':
                    start_iter = max(0, h - d - 1)
                    finis_iter = min(h, w + h - d - 1)
                    step = 1
                elif dir_zig == 'up':
                    start_iter = min(h - 1, w + h - d - 2)
                    finis_iter = max(-1, h - d - 2)
                    step = -1
                elif dir_zig == 'zig_odd_dn':
                    if d % 2 == 0:
                        start_iter = min(h - 1, w + h - d - 2)
                        finis_iter = max(-1, h - d - 2)
                        step = -1
                    else:
                        start_iter = max(0, h - d - 1)
                        finis_iter = min(h, w + h - d - 1)
                        step = 1
                elif dir_zig == 'zig_odd_up':
                    if d % 2 == 0:
                        start_iter = max(0, h - d - 1)
                        finis_iter = min(h, w + h - d - 1)
                        step = 1
                    else:
                        start_iter = min(h - 1, w + h - d - 2)
                        finis_iter = max(-1, h - d - 2)
                        step = -1
                for i in range(start_iter, finis_iter, step):
                    if n_corner == 3:
                        j = h + w - 2 - d - i # Движение сверху вниз
                    else:
                        j = i + d - h + 1 # Движение снизу вверх
                    matrix[i][j] = str(numbers_i).rjust(3)
                    numbers_i += 1
    return matrix

width = 9 # Размер матрицы (ширина и высота)
height = 7
num_corner = 4 # 1 - левый верхний, 2 - правый верхний, 3 - левый нижний, 4 - правый нижний
direct_or_zigzag_tuple = ('up', 'dn' 'zig_odd_up', 'zig_odd_dn')
direct_zig = 'zig_odd_dn'
matrix_good = diagonal(w=width, h=height, n_corner=num_corner, dir_zig=direct_zig)
# Печать матрицы
[print(*row, sep=" ") for row in matrix_good]