Как матрицу сделать обратной: Обратная матрица онлайн

В Python существует множество пользовательских и встроенных методов для реверсирования массива. Определение правильного оптимального алгоритма, совместимого с вашим кодом, действительно важно, чтобы избежать ошибок и сэкономить время. Рассмотрим несколько методов подробно.

Обратите внимание, что здесь мы имеем дело с массивами, а не со списками!

Начнем с обращения массива в Python без использования встроенной функции. Чаще всего вы можете поменять местами элементы с противоположными/аналогичными индексами. Для лучшего понимания посмотрите на код ниже:

 # импорт модуля массива
импортировать массив как обр

# инициализация массива целыми числами
a = массив.массив("i", [1, 2, 3, 4, 5])
print("Массив: ", а)
# получить размер массива с помощью метода len()
л = лен(а)
# обход массива только наполовину!!
для i в диапазоне (l // 2):
    # поменять местами элементы
    а[i], а[l - i - 1] = а[l - i - 1], а[i]

print("Перевернутый массив: ", а)
 

Замена местами сбивает с толку, не так ли?? Не волнуйтесь, взгляните на презентацию ниже:

Надеюсь, теперь все понятно.

Посмотрите на вывод кода выше: 

 Массив: array('i', [1, 2, 3, 4, 5])
Перевернутый массив: array('i', [5, 4, 3, 2, 1])
 

Это всего лишь пример того, как инвертировать массив без использования какого-либо встроенного метода. Далее вы увидите больше таких методов.

Метод 02) Использование метода reverse()

Чтобы перевернуть массив в Python, вы можете использовать метод reverse() непосредственно как для списков, так и для массивов. Использование метода reverse() полезно, когда у вас есть ограничение по объему памяти, поскольку он выполняет операцию в той же памяти и не требует дополнительного места. Помните, как мы поменяли местами элементы выше, без дополнительной памяти. reverse() делает почти то же самое.

Код:

 # импорт модуля массива
импортировать массив как обр

# инициализация массива целыми числами
a = массив.массив("i", [1, 2, 3, 4, 5])
print("Массив: ", а)

#вызов метода reverse() для массива a
а. обратный()

print("Перевернутый массив: ", а)
 

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

Вывод: 

 Массив: array('i', [1, 2, 3, 4, 5])
Перевернутый массив: array('i', [5, 4, 3, 2, 1])
 

Метод reverse() вызывается для массива (как объект, вызывающий метод).

Чтобы перевернуть массив, Python также предлагает метод reversed(). Метод reversed() не создает копии массива и не вносит никаких изменений в исходный массив. Вместо этого возвращает итератор. Этот метод создан для облегчения обратной итерации последовательностей.

Посмотрите код ниже:

 # импорт модуля массива
импортировать массив как обр

# инициализация массива целыми числами
a = массив.массив("i", [1, 2, 3, 4, 5])
print("Массив: ", а)

#передача массива в обратном порядке()
перевернутый (а)

print("Перевернутый массив: ", а)
 

Вывод:

 Массив: массив('i', [1, 2, 3, 4, 5])
Перевернутый массив: array('i', [1, 2, 3, 4, 5])
 

Обратите внимание на отсутствие изменений в исходном массиве. Теперь давайте попробуем сохранить reversed(arrayName) в другой переменной:

 # импортируем модуль массива
импортировать массив как обр

# инициализация массива целыми числами
a = массив.массив("i", [1, 2, 3, 4, 5])
print("Массив: ", а)

#передача массива в обратном порядке()
reversed_a = перевернутый (а)

print("Перевернутый массив: ", reversed_a)
 

Вы будете очень удивлены, увидев результат:

 Массив: массив('i', [1, 2, 3, 4, 5])
Перевернутый массив: <обратный объект по адресу 0x0000025EC428EC88>
 

Смотрите! Метод reversed() вернул итератор, который был сохранен и распечатан дальше. Чтобы получить перевернутый список, т. е. копию исходного массива, вывернутую наизнанку, вам нужно применить list() к переменной reversed_a. Косвенно вам нужно преобразовать итератор в список, чтобы получить перевернутый массив.

 # импорт модуля массива
импортировать массив как обр

# инициализация массива целыми числами
a = массив. массив("i", [1, 2, 3, 4, 5])
print("Массив: ", а)

#передача массива в обратном порядке()
reversed_a = список (обратный (а))

print("Перевернутый массив: ", reversed_a)
 

Теперь перевернутый массив сохраняется в reversed_a, и, следовательно, мы получаем перевернутый массив.

 Массив: массив('i', [1, 2, 3, 4, 5])
Перевернутый массив: [5, 4, 3, 2, 1]
 

Вам должно быть интересно, в чем разница между методами reverse() и reversed(). Это просто “д”?

Нет!! Хотя reverse() и reversed() выполняют одну и ту же функцию, они разные. Хотя reverse() работает с тем же массивом, не занимая дополнительного места в памяти, reversed() требуется новый массив для хранения копии перевернутого массива. Кроме того, в то время как reverse() просто переворачивает исходный массив, reversed() не влияет на исходный массив и возвращает итератор для обратного перебора последовательности.

Обратите внимание: поскольку reversed() возвращает итератор, он работает только с последовательными объектами. Метод reversed() неприменим к множествам и итераторам.

Это самый простой и часто используемый метод реверсирования массива. Это не влияет на исходный массив; вместо этого он возвращает обратную копию исходного массива. Метод Slicing перебирает массив от начала до конца (последний индекс).

Как разрезать массив? Нарезка — это выбор определенной части массива, а не всего массива. Нарезка — это процесс выбора/вызова части массива с учетом начального и конечного индексов. Для нарезки массива используется следующий синтаксис:

имя_массива[начало: конец: шаг]

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

конец представляет конечный индекс массива срезов (конец исключен)

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

Для реверсирования массива наиболее важную роль играет параметр шага.

Например, разрежьте массив a = [1, 2, 3, 4]

1. от start= 0 до end = 2        =>     a[:3]

2. от start = 2 до остальной части array           =>       a[2:]

3. от start = 1 до остальной части массива, пропуская следующий элемент        => a[1::1]

Вам нужно обратить внимание на индекс массива, чтобы понять нарезку.

В Python мы также можем представить индекс массива с отрицательными числами, где конец массива отмечен -1.

Синтаксис нарезки для обращения массива в Python:

имя_массива[::-1]

Поскольку начальный индекс массива по умолчанию равен 0. Следовательно, прибавляя (-1) к 0, заканчиваются -1, то есть последним индексом массива.

Сложение (-1) с (-1) приводит к (-2), который является предпоследним индексом массива. Это продолжается до тех пор, пока не будет достигнут последний (первый) индекс массива.

Пример:

 # импорт модуля массива
массив импорта

#функция для обращения массива
защита реверсивного массива (а):
    вернуть[::-1]
    
# объявить массив
а = массив.массив("я", [1, 2, 3, 4, 5])
print('Исходный массив: ', а)
print('Перевернутый массив ',reversingArray(a))

реверсивный массив (а)
# Вышеприведенное утверждение не будет работать. Можете ли вы догадаться, почему?
печать (а)
 

Обратите внимание, что команда reversingArray(a) не будет работать, так как мы возвращаем массив в нашей функции, но мы не назначили никакой переменной для хранения вывода.

Вывод:

 Исходный массив: array('i', [1, 2, 3, 4, 5])
Обратный массив - это массив ('i', [5, 4, 3, 2, 1])
массив('i', [1, 2, 3, 4, 5])
 

Вместо создания функции вы всегда можете напрямую использовать [::-1].

Другой пример:

 # импорт модуля массива
массив импорта
    
# объявить массив
а = массив. массив("я", [1, 2, 3, 4, 5])
print('Исходный массив: ', а)
#нарезка массива
print('Перевернутый массив равен ', a[::-1])
# повторная печать исходного массива
print('Воздействие на исходный массив: ', а)
 

Смотрите! Нарезка фактически не изменит массив для вас. Вместо этого он предоставит способ перебора массива в обратном порядке.

Вывод:

 Исходный массив: array('i', [1, 2, 3, 4, 5])
Обратный массив - это массив ('i', [5, 4, 3, 2, 1])
Влияние на исходный массив: array('i', [1, 2, 3, 4, 5]) 

Итак, в чем разница между реверсивной и обратной итерацией массива? Обращение массива в Python означает обращение содержимого массива, будь то изменение исходного массива или создание его перевернутой копии. В то время как выполнение обратной итерации по массиву просто подразумевает итерацию по циклу с конца массива.

Ознакомьтесь с приведенным ниже кодом для лучшего понимания:

 # импорт модуля массива
массив импорта

# объявить массив
а = массив. массив('я', [1,2,3,4,5])
print('Исходный массив:', а)

#перебор массива в обратном порядке
print('Обратный проход по массиву: ')
для i в диапазоне (len (a) -1, -1, -1):
    распечатать (а [я])

print('Исходный массив:', а)

# переворачивание массива
а.обратный()
print('Перевернутый массив: ', а)
 

Обратите внимание, что на исходный массив не повлияло перебор массива в обратном порядке. При выполнении reverse() исходный массив был перевернут. В этом разница между обращением массива в Python и обратным перебором массива в Python.

Вывод:

 Исходный массив: array('i', [1, 2, 3, 4, 5])
Обратная итерация по массиву:
5
4
3
2
1
Исходный массив: array('i', [1, 2, 3, 4, 5])
Перевернутый массив: array('i', [5, 4, 3, 2, 1])
 

Рекурсия также является одним из способов обращения массива в Python без использования каких-либо встроенных функций. Когда во время выполнения функция вызывает сама себя, это называется рекурсией. При работе с рекурсией нужно быть осторожным, так как это может привести к бесконечному циклу или выполнению до тех пор, пока стек не переполнится. Следовательно, необходимо добавить в функцию завершающее условие .

Взгляните на приведенный ниже код, чтобы перевернуть массив в Python с помощью рекурсии:

 #импорт модуля массива
массив импорта


#функция для реверсирования массива
защита обратного массива (обр):
    если len(arr) == 1:
        обратный прилет
    #print(arr) ->Вы можете раскомментировать это, чтобы узнать, как работает рекурсия
    вернуть reverseArray(arr[1:]) + arr[0:1]

#объявление массива
a = массив.массив('i', [10, 20, 30, 40, 50])
print("Исходный массив: ", а)
print('Перевернутый массив: ',reverseArray(a))

#объявление массива с длиной = 1
б = массив.массив('я', [1])
print('Исходный массив: ', б)
print('Перевернутый массив: ', reverseArray(b))
 

Вы можете раскомментировать оператор печати в функции, чтобы узнать, как происходит рекурсия и как она переворачивает массив в Python. Условие if выше является завершающим оператором. Необходимо добавить условие, иначе функция не перестанет делать рекурсивные вызовы и это приведет к ошибке.

Вывод:

 Исходный массив: array('i', [10, 20, 30, 40, 50])
Обратный массив: массив('i', [50, 40, 30, 20, 10])
Исходный массив: массив('i', [1])
Перевернутый массив: array('i', [1])
 

Трудно понять? Ознакомьтесь с представленным ниже представлением.

Вы заметите, как при рекурсии массив разбивается на отдельные элементы, пока функция наконец не вернет отдельные элементы. Затем, когда функция возвращается к своей вызывающей функции, она суммирует уединенный элемент (здесь число в начале каждого массива). Следовательно, это приводит к нашему обращенному массиву.

Хотя рекурсия не является лучшим способом обращения массива, это лучший способ понять, как происходит рекурсия и обращение массива.

Вы часто можете столкнуться с обращением массива при работе с соревновательным программированием.