Как найти максимальный элемент матрицы python

Given a matrix, the task is to find the maximum element of each row.
Examples: 

Input :  [1, 2, 3]
         [1, 4, 9]
         [76, 34, 21]

Output :
3
9
76

Input : [1, 2, 3, 21]
        [12, 1, 65, 9]
        [1, 56, 34, 2]
Output :
21
65
56

Method 1: The idea is to run the loop for no_of_rows. Check each element inside the row and find for the maximum element. Finally, print the element. 
Below is the implementation : 

Output :

8
11
76
5

Time Complexity: O(N^2), where N is the number of rows in the matrix.

Space Complexity: O(1), as no extra space is required for the algorithm.

Method  2: By calculating max element Each list of list of lists using the max() function

Time complexity: O(n*m), where n is the number of rows and m is the number of columns in the matrix.

Auxiliary space: O(1), as we are only using a constant amount of extra space to store the maximum value of each row.

Another approach that could be used to find the maximum element of each row in a matrix is to use the built-in map() function. The map() function applies a given function to each element of a given iterable (such as a list or a matrix). In this case, we can use the map() function to apply the max() function to each row of the matrix.

Here is an example of how this approach could be implemented:

 Time complexity: O(n * m), where n is the number of rows and m is the number of columns in the matrix. 
 Auxiliary Space: O(n), as we are creating a new list to store the maximum elements of each row.

Method#4: Using the Recursive method.

The find_max_recursive function takes a matrix as input, along with an optional index variable i (which is initially set to 0) and a result list res (which is initially empty). The function returns a list of the maximum element in each row of the matrix.

The function first checks if it has reached the end of the matrix (i.e., if i is equal to the length of the matrix). If so, it returns the result list. Otherwise, it finds the maximum element in the current row using the built-in max function, and appends it to the result list. It then recursively calls itself with the index of the next row and the updated result list.

The time complexity of this function is O(n^2), where n is the size of the input matrix. This is because the function iterates over each element in the matrix once to find the maximum value in each row, resulting in n iterations. Additionally, finding the maximum value in each row requires iterating over each element in the row, resulting in another n iterations. Therefore, the total number of iterations is n^2.

The auxiliary space of this function is also O(n^2), as the result array ‘res’ is being appended with the maximum element from each row in the matrix. Since the matrix has n^2 elements, the result array will also have a maximum of n^2 elements, leading to the O(n^2) space complexity.

Method#5: Using the lambda function + list comprehension 

In this method, we define a lambda function that takes a matrix as input and uses a list comprehension to print the maximum element of each row using the NumPy max() function.

Note: Before using numpy you first need to install it by using the following command: pip install numpy

Below is the code for the following method: 

Output: 

Time complexity:  O(n*m),  where n is the number of rows and m is the number of columns in the matrix.
Auxiliary Space: O(1)

Please refer complete article on Find maximum element of each row in a matrix for more details!

Last Updated :
29 Mar, 2023

Like Article

Save Article

Все нормально Выводит. Просто диапазон чисел 1-9 маленький, и большая вероятность что в матрице будут числа 1 и 9.
Возьмите больше диапазон чисел и результат будет чаще уже другой. Или берите ранг матрицы равным 3, тогда вероятность что выведет другие значения , будет выше.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

import random
N=int(input("Введите размер матрицы:"))
arr=[[random.randint(1,9) for i in range(N)] for j in range(N)]
min = arr[0][0]
max = 0
for i in range(N):
    for j in range(N):
        if(arr[i][j]<min):
            min=arr[i][j]
        elif(arr[i][j]>max):
            max=arr[i][j]
for i in range(N):
    print(arr[i])
print(max, min)

Пример
Введите размер матрицы:3
[8, 4, 2]
[6, 3, 7]
[7, 2, 1]
8 1

Матрица — это двумерный массив, состоящий из M строк и N столбцов. Матрицы часто используются в математических вычислениях. Программисты работают с матрицами в основном в научной области, однако их можно использовать и для других вещей, например, для быстрой генерации уровней в видео-игре.

Матрицы и библиотека NumPy

Программист может самостоятельно реализовать все функции для работы с матрицами: умножение, сложение, транспонирование и т. д. На Python это сделать гораздо проще, чем на более низкоуровневых языках, таких как C.

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

Вместо того чтобы писать десятки строк кода для выполнения простых операций над матрицами, программист может использовать одну функцию из NumPy. Библиотека написана на Python, C и Фортране, поэтому функции работают даже быстрее, чем на чистом Python.

Подключение библиотеки NumPy

NumPy не встроена в интерпретатор Python, поэтому перед импортом её необходимо установить. Для этого в можно воспользоваться утилитой pip. Введите в консоле команду:

pip install numpy

Теперь, когда библиотека установлена, её можно подключить с помощью команды import. Для удобства переименуем numpy при импорте в np следующим образом:

import numpy as np

Ниже в примерах будет использован именно такой импорт, поэтому обращение к библиотеке будет через np, а не numpy!

Создание

Для создании матрицы используется функция array(). В функцию передаётся список. Вот пример создания, мы подаём в качестве аргумента функции двумерный список:

a = np.array([[3, 3, 3], [2, 5, 5]])

Вторым параметром можно задать тип элементов матрицы:

a = np.array([[3, 3, 3],[2, 5, 5]], int)
print(a)

Тогда в консоль выведется:

[[3 3 3]
 [2 5 5]]

Обратите внимание, что если изменить int на str, то тип элементов изменился на строковый. Кроме того, при выводе в консоль NumPy автоматически отформатировал вывод, чтобы он выглядел как матрица, а элементы располагались друг под другом.

В качестве типов элементов можно использовать int, float, bool, complex, bytes, str, buffers. Также можно использовать и другие типы NumPy: логические, целочисленные, беззнаковые целочисленные, вещественные, комплексные. Вот несколько примеров:

• np.bool8 — логическая переменная, которая занимает 1 байт памяти.
• np.int64 — целое число, занимающее 8 байт.
• np.uint16 — беззнаковое целое число, занимающее 2 байта в памяти.
• np.float32 — вещественное число, занимающее 4 байта в памяти.
• np.complex64 — комплексное число, состоящее из 4 байтового вещественного числа действительной части и 4 байтов мнимой.

Вы также можете узнать размер матрицы, для этого используйте атрибут shape:

size = a.shape
print(size) # Выведет (2, 3)

Первое число (2) — количество строк, второе число (3) — количество столбцов.

Нулевая матрица

Если необходимо создать матрицу, состоящую только из нулей, используйте функцию zeros():

a_of_zeros = np.zeros((2,2))
print(a_of_zeros)

Результат этого кода будет следующий:

[[0. 0.]
 [0. 0.]]

Получение строки, столбца и элемента

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

temp = a[0]
print(temp) #Выведет [3 3 3]

Получить столбец уже не так просто. Используем срезы, в качестве первого элемента среза мы ничего не указываем, а второй элемент — это номер искомого столбца. Пример:

arr = np.array([[3,3,3],[2,5,5]], str)
temp = arr[:,2]
print(temp) # Выведет ['3' '5']

Чтобы получить элемент, нужно указать номер столбца и строки, в которых он находится. Например, элемент во 2 строке и 3 столбце — это 5, проверяем (помним, что нумерация начинается с 0):

arr = np.array([[3,3,3],[2,5,5]], str)
temp = arr[1][2]
print(temp) # Выведет 5

Умножение и сложение

Чтобы сложить матрицы, нужно сложить все их соответствующие элементы. В Python для их сложения используется обычный оператор «+».

Пример сложения:

arr1 = np.array([[3,3,3],[2,5,5]])
arr2 = np.array([[2,4,2],[1,3,8]])
temp = arr1 + arr2
print(temp)

Результирующая матрица будет равна:

[[ 5  7  5]
 [ 3  8 13]]

Важно помнить, что складывать можно только матрицы с одинаковым количеством строк и столбцов, иначе программа на Python завершится с исключением ValueError.

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

Умножение в NumPy выполняется с помощью метода dot().

Пример умножения:

arr1 = np.array([[3,3],[2,5]])
arr2 = np.array([[2,4],[1,3]])
temp = arr1.dot(arr2)
print(temp)

Результат выполнения этого кода будет следующий:

[[ 9 21]
 [ 9 23]]

Как она получилась? Разберём число 21, его позиция это 1 строка и 2 столбец, тогда мы берем 1 строку первой матрицы и умножаем на 2 столбец второй. Причём элементы умножаются позиционно, то есть 1 на 1 и 2 на 2, а результаты складываются: [3,3] * [4,3] = 3 * 4 + 3 * 3 = 21.

Транспонированная и обратная

Транспонированная матрица — это матрица, у которой строки и столбцы поменялись местами. В библиотеки NumPy для транспонирования двумерных матриц используется метод transpose(). Пример:

arr1 = np.array([[3,3],[2,5]])
temp = arr1.transpose()
print(temp)

В результате получится матрица:

[[3 2]
 [3 5]]

Чтобы получить обратную матрицу, необходимо использовать модуль linalg (линейная алгебра). Используем функцию inv():

arr1 = np.array([[3,3],[2,5]])
temp = np.linalg.inv(arr1)
print(temp)

Результирующая матрица будет равна:

[[ 0.55555556 -0.33333333]
 [-0.22222222  0.33333333]]

Получение максимального и минимального элемента

Чтобы получить максимальный или минимальный элемент, можно пройтись по всем элементам матрицы с помощью двух циклов for. Это стандартный алгоритм перебора, который известен почти каждому программисту:

arr = np.array([[3,3],[2,5]])
min = arr[0][0]
for i in range(arr.shape[0]):
    for j in range(arr.shape[1]):
        if min > arr[i][j]:
            min = arr[i][j]
print("Минимальный элемент:", min) # Выведет "Минимальный элемент: 2"

NumPy позволяет найти максимальный и минимальный элемент с помощью функций amax() и amin(). В качестве аргумента в функции нужно передать саму матрицу. Пример:

arr1 = np.array([[3,3],[2,5]])
min = np.amin(arr1)
max = np.amax(arr1)
print("Минимальный элемент:", min) # Выведет "Минимальный элемент: 2"
print("Максимальный элемент:", max) # Выведет "Максимальный элемент: 5"

Как видим, результаты реализации на чистом Python и реализации с использованием библиотеки NumPy совпадают.

Заключение

На Python можно реализовать все необходимые функции для работы с матрицами. Чтобы упростить работу программистов, была создана библиотека NumPy. Она позволяет производить сложные математические вычисления легко и без ошибок, избавляя программиста от необходимости каждый раз писать один и тот же код.

Функция numpy.argmax() выводит индексы максимальных значений вдоль оси. В случае многократного вхождения максимальных значений она выводит индексы, соответствующие первому вхождению.

Синтаксис

numpy.argmax(a, axis=None, out=None)

Параметры

• массив: входной
• ось [int, необязательно]: по умолчанию индекс находится в сплющенном массиве, если нет, то вдоль указанной оси.
• out [необязательный массив]: если указано, результат будет вставлен в этот массив. Он должен соответствовать по форме и типу.

Что мы получим?

Массив индексов в массив. Он будет иметь ту же форму, что и array.shape, но короче.

Находим максимальный элемент из матрицы с помощью numpy.argmax()

import numpy as np    

a = np.matrix([[1,2,3,33],[4,5,6,66],[7,8,9,99]])

print(np.argmax(a)) 
print(np.argmax(a[:,:]))  
print(np.argmax(a[:1])) 
print(np.argmax(a[:,2]))  
print(np.argmax(a[1:,2])) 

Вывод

11
11
3
2
1

argmax() возвращает позицию или индекс наибольшего значения в массиве. Массив может быть единичным или многомерным.

Используем np.unravel_index при выводе argmax

Можно использовать функцию np.unravel_index, чтобы получить индекс, соответствующий 2D-массиву из вывода numpy.argmax.

import numpy as np
a = np.arange(6).reshape(2,3) + 10
print(a)

index = np.unravel_index(np.argmax(a), a.shape)
print(index)
print(a[index])

Вывод

[[10 11 12]
 [13 14 15]]
(1, 2)
15

Ищем максимальное количество элементов по столбцам с помощью numpy.argmax()

Приведенный ниже код выводит значение индекса максимального количества элементов в каждом столбце.

import numpy as np
a = np.arange(12).reshape(4,3) + 10
print(a)

print("Max elements", np.argmax(a, axis=0))

Вывод

[[10 11 12]
 [13 14 15]
 [16 17 18]
 [19 20 21]]
Max elements [3 3 3]

Просмотры: 1 299