Uzyskaj drugie minimalne wartości na kolumnę w tablicy 2D

Jak mogę uzyskać drugą minimalną wartość z każdej kolumny? Mam tę tablicę:

A = [[72 76 44 62 81 31]
     [54 36 82 71 40 45]
     [63 59 84 36 34 51]
     [58 53 59 22 77 64]
     [35 77 60 76 57 44]]

Chcę mieć dane wyjściowe takie jak:

A = [54 53 59 36 40 44]

Wypróbuj to, w jednej linii:

[sorted(i)[1] for i in zip(*A)]

w akcji:

In [12]: A = [[72, 76, 44, 62, 81, 31], 
    ...:      [54 ,36 ,82 ,71 ,40, 45], 
    ...:      [63 ,59, 84, 36, 34 ,51], 
    ...:      [58, 53, 59, 22, 77 ,64], 
    ...:      [35 ,77, 60, 76, 57, 44]] 

In [18]: [sorted(i)[1] for i in zip(*A)]                                                                                                                                                                           
Out[18]: [54, 53, 59, 36, 40, 44]

zip(*A) przetransponuje listę, aby kolumny stały się wierszami.

a jeśli masz zduplikowaną wartość, na przykład:

In [19]: A = [[72, 76, 44, 62, 81, 31], 
    ...:  [54 ,36 ,82 ,71 ,40, 45], 
    ...:  [63 ,59, 84, 36, 34 ,51], 
    ...:  [35, 53, 59, 22, 77 ,64],   # 35
    ...:  [35 ,77, 50, 76, 57, 44],]  # 35

Jeśli musisz pominąć oba 35, możesz użyć set():

In [29]: [sorted(list(set(i)))[1] for i in zip(*A)]                                                                                                                                                                
Out[29]: [54, 53, 50, 36, 40, 44]

Operacje na numpytablicach należy wykonywać za pomocą numpyfunkcji, więc spójrz na to:

np.sort(A, axis=0)[1, :]

Out[61]: array([54, 53, 59, 36, 40, 44])

możesz użyć heapq.nsmallest

from heapq import nsmallest

[nsmallest(2, e)[-1] for e in zip(*A)]

wynik:

[54, 53, 50, 36, 40, 44]

Dodałem prosty test porównawczy, aby porównać wydajność różnych już opublikowanych rozwiązań:

from simple_benchmark import BenchmarkBuilder
from heapq import nsmallest


b = BenchmarkBuilder()

@b.add_function()
def MehrdadPedramfar(A):
    return [sorted(i)[1] for i in zip(*A)]

@b.add_function()
def NicolasGervais(A):
    return np.sort(A, axis=0)[1, :]

@b.add_function()
def imcrazeegamerr(A):
    rotated = zip(*A[::-1])

    result = []
    for arr in rotated:
        # sort each 1d array from min to max
        arr = sorted(list(arr))
        # add the second minimum value to result array
        result.append(arr[1])

    return result

@b.add_function()
def Daweo(A):
    return np.apply_along_axis(lambda x:heapq.nsmallest(2,x)[-1], 0, A)

@b.add_function()       
def kederrac(A):
    return [nsmallest(2, e)[-1] for e in zip(*A)]


@b.add_arguments('Number of row/cols (A is  square matrix)')
def argument_provider():
    for exp in range(2, 18):
        size = 2**exp
        yield size, [[randint(0, 1000) for _ in range(size)] for _ in range(size)]

r = b.run()
r.plot()

Korzystanie zipz sortedfunkcji jest najszybszym rozwiązaniem dla małych list 2d, a używanie zipz heapq.nsmallestprogramami jest najlepszym rozwiązaniem na dużych listach 2d

Mam nadzieję, że dobrze zrozumiałem twoje pytanie, ale tak czy inaczej, oto moje rozwiązanie, jestem pewien, że jest bardziej elegancki sposób, ale to działa

A = [[72,76,44,62,81,31]
 ,[54,36,82,71,40,45]
 ,[63,59,84,36,34,51]
 ,[58,53,59,22,77,64]
 ,[35,77,50,76,57,44]]

#rotate the array 90deg
rotated = zip(*A[::-1])

result = []
for arr in rotated:
    # sort each 1d array from min to max
    arr = sorted(list(arr))
    # add the second minimum value to result array
    result.append(arr[1])
print(result)

Zakładając, że Atak numpy.array(jeśli to prawda, rozważ dodanie numpytagu do pytania), możesz użyć apply_along_axistego w następujący sposób:

import heap
import numpy as np
A = np.array([[72, 76, 44, 62, 81, 31],
              [54, 36, 82, 71, 40, 45],
              [63, 59, 84, 36, 34, 51],
              [58, 53, 59, 22, 77, 64],
              [35, 77, 60, 76, 57, 44]])
second_mins = np.apply_along_axis(lambda x:heapq.nsmallest(2,x)[-1], 0, A)
print(second_mins)  # [54 53 59 36 40 44]

Zauważ, że użyłem heapq.nsmallest, ponieważ wykonuje tyle sortowania, ile jest wymagane, aby uzyskać 2 najmniejsze elementy, w przeciwieństwie do tego, sortedktóre wykonuje pełne sortowanie.

>>> A = np.arange(30).reshape(5,6).tolist()
>>> A
[[0, 1, 2, 3, 4, 5], 
 [6, 7, 8, 9, 10, 11], 
 [12, 13, 14, 15, 16, 17], 
 [18, 19, 20, 21, 22, 23],
 [24, 25, 26, 27, 28, 29]]

Zaktualizowano : Użyj, setaby zapobiec duplikowaniu i transponowaniu listy za pomocązip(*A)

>>> [sorted(set(items))[1] for items in zip(*A)]
[6, 7, 8, 9, 10, 11]

stary: drugi minimalny element w każdym rzędzie

>>> [sorted(set(items))[1] for items in A]
[1, 7, 13, 19, 25]