Python-сообщество

 N = 6 # int(input())
M = 3 # int(input())
index = 1
for x in range(1 , N+1):
    if x % 2 == 0: # чет
        index = index + M - 1
        for y in range(M):
            print(f"{index:>2}", end=' ')
            index -= 1
        index = index + M + 1  
    else: # нечет
        for y in range(M):
            print(f"{index:>2}", end=' ')
            index += 1
    print()

 1  2  3  4  5  6  7  8  9 10 
20 19 18 17 16 15 14 13 12 11 
21 22 23 24 25 26 27 28 29 30 
40 39 38 37 36 35 34 33 32 31 
41 42 43 44 45 46 47 48 49 50 
60 59 58 57 56 55 54 53 52 51 

 s = [1,2,3] 
s = s[::-1]
print (s)

 import math #подключаем модуль математических функций
def determinant(dim, data): #функция вычисления детерминанты
    if dim == 0:
        det = 0
    if dim == 1:
        det = data[0]
    if dim == 2:
        det = data[0] * data[3] - data[2] * data[1]
    if dim == 3:
        det = data[0] * data[4] * data[8] + data[1] * data[5] * data[6] + data[2] * data[3] * data[7] - data[6] * data[4] * data[2] - data[7] * data[5] * data[0] - data[8] * data[3] * data[1]
    if dim > 3:
        det = 0
        i = 0
        for  j in range(dim):
            det += data[i * dim + j] * cofactor(dim, data, i, j)
    return det
def minor(dim, data, i, j): 
    new_matrix = []
    for  k in range(dim*dim):
        if (math.floor(k / dim) != i and k % dim != j):
            new_matrix.append(data[k])
    return determinant(dim - 1, new_matrix)
def cofactor(dim, data, i, j): #функция вычисления кофактора
    return math.pow(-1, i + j) * minor(dim, data, i, j)
def cofactor_matrix(dim, data): #функция вычисления кофакторной матрицы
    new_matrix = []
    for  i in range(dim):
        for  j in range(dim):
            new_matrix.append(cofactor(dim, data, i, j))
    return new_matrix
def transpose_matrix(dim, data):
    new_matrix = []
    for  i in range(dim):
        for  j in range(dim):
            new_matrix.append(data[j * dim + i])
    return new_matrix
def adjoint_matrix(dim, data):
    return transpose_matrix(dim, cofactor_matrix(dim, data))
matix=[[2,2,1,2,5],[1,3,3,1,3],[1,2,2,1,3],[4,2,2,3,8],[1,5,2,1,1]] #Пример матрицы
data=[] #создаем пустую матрицу
for  i in range(len(matix)):  #создаем счетчик итераций на основе размера матрицы matix
    for  j in range(len(matix)):    #создаем счетчик итераций на основе размера матрицы matix
        data=data+[matix[i][j]]  #переводим квадратную матрицу matix в плоскую
dim = len(matix) #размер матрицы
dim2 = dim * dim #находим квадрат
det = determinant(dim,data) #находим детерминанту
print ('Детерминант: |A| =: ', det) #
print
print ('Обратная матрица : ')
print
if det!=0: #если матрица имеет детерминант не равный нулю
    adj_matrix = adjoint_matrix(dim, data) #находим значение строк матрицы
    for n in range(dim2): #создаем счетчик итерации
        cs=int((adj_matrix[n])/det) #находим значение ячейки матрицы 
        if cs<0: #условие при котором значение меньше нуля
            pr="   " #3 пробела для форматирования
        else:   #иначе
            pr="    " #4 пробела для форматирования
        g = pr+str(cs)+"    "  #конкатинация пробелов и значения ячейки матрицы
        print (g)  #выводим значение переменной g
        if (n % dim == dim - 1): #
            print  #пустая строка
else:  #иначе
   print ('Это вырожденная матрица, обратную матрицу найти невозможно')  #выводим сообщение о том что матрица вырождена

 import copy
import math
def print_matrix(A):
    for strA in A:
        print(strA)
def minor(A, i, j):
    M = copy.deepcopy(A)
    del M[i]
    for i in range(len(A[0]) - 1):
        del M[i][j]
    return M
def det(A):
    m = len(A)
    n = len(A[0])
    if m != n:
        return None
    if n == 1:
        return A[0][0]
    signum = 1
    determinant = 0
    for j in range(n):
        determinant += A[0][j] * signum * det(minor(A, 0, j))
        signum *= -1
    return determinant
def inverse(A):
    result = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
    for i in range(len(A)):
        for j in range(len(A[0])):
            tmp = minor(A, i, j)
            if i +j % 2 == 1:
                result[i][j] = -1 * det(tmp) / det(A)
            else:
                result[i][j] = 1 * det(tmp) / det(A)
    return result
def transpose(array):
    res = []
    n = len(array)
    m = len(array[0])
    for j in range(m):
        tmp=[]
        for i in range(n):
            tmp=tmp+[array[i][j]]
        res = res+[tmp]
    return res
A = [[6, 4, 3],
     [2, 1, 3],
     [7, 5, 2]]
print_matrix(A)
A = transpose(A)
C = inverse(A)
print("\n")
print_matrix(C)

  
>>> n = 4 # int(input())
>>> m = 5 # int(input())
>>> 
>>> index = 1
>>> for i in range(n):
...     row = []
...     for j in range(m):
...         row.append(index)
...         index += 1
...     if i % 2 == 1:
...         row = row[::-1]
...     rowstr = ' '.join('{:>2}'.format(i) for i in row)
...     print(rowstr)
... 
 1  2  3  4  5
10  9  8  7  6
11 12 13 14 15
20 19 18 17 16
>>>

  
row = 6
column = 8
n = 1
step = 1
for i in range(row):
    for j in range(column):
        print(f'{n:>4}', end=' ')
        n += step
    step *= -1
    n += (column * abs(step)) + step
    print()

 
   1    2    3    4    5    6    7    8 
  16   15   14   13   12   11   10    9 
  17   18   19   20   21   22   23   24 
  32   31   30   29   28   27   26   25 
  33   34   35   36   37   38   39   40 
  48   47   46   45   44   43   42   41 

  
step = -step

  
n += column + step

  
>>> row = 6
>>> column = 8
>>> 
>>> n = 1
>>> step = 1
>>> for i in range(row):
...     for j in range(column):
...         print(f'{n:>4}', end=' ')
...         n += step
...     step = -step
...     n += column + step
...     print()
... 
   1    2    3    4    5    6    7    8 
  16   15   14   13   12   11   10    9 
  17   18   19   20   21   22   23   24 
  32   31   30   29   28   27   26   25 
  33   34   35   36   37   38   39   40 
  48   47   46   45   44   43   42   41 
>>>

 n += column + step

  
row = 6
column = 8
n = 0
step = 5
for i in range(row):
    for j in range(column):
        print(f'{n:>4}', end=' ')
        n += step
    step = -step
    # n += (column * abs(step)) + step
    n += column + step
    print()

   0    5   10   15   20   25   30   35 
  43   38   33   28   23   18   13    8 
  16   21   26   31   36   41   46   51 
  59   54   49   44   39   34   29   24 
  32   37   42   47   52   57   62   67 
  75   70   65   60   55   50   45   40