Rozważ zmienną setsize (może wymagać wartości 2 lub 3), a tablica numpy v . Liczba kolumn w v jest podzielna przez setsize . Oto mała próbka:

import numpy as np

setSize = 2

# the array spaces are shown to emphasize that the rows 
# are made up of sets having, in this case, 2 elements each. 

v = np.array([[2,5,  3,5,  1,8],
              [4,6,  2,7,  5,9],
              [1,8,  2,3,  1,4],
              [2,8,  1,4,  3,5],
              [5,7,  2,3,  7,8],
              [1,2,  4,6,  3,5],
              [3,5,  2,8,  1,4]])

Problem: W przypadku wierszy, które mają unikalne wszystkie elementy , muszę alfabetize zestawy. Na przykład: Ustaw 1,14 poprzedniby ustawiony 3,5, który poprzeczny ustawiony 5,1. Jako ostatni krok muszę wyeliminować duplikowane wiersze, które mogą wynikać.

W powyższym przykładzie, rzęsy tablicy mające wskaźniki 1,3,5 i 6 mają unikalne elementy, Więc te wiersze muszą być alfabetyczne. Inne wiersze nie są zmieniane. Ponadto wiersze v[3] i v[6], po alfabetycznie, są teraz identyczne. Jeden z nich może zostać upuszczony.

Ostateczny wynik wygląda następująco:

v =          [[2,5,  3,5,  1,8],
              [2,7,  4,6,  5,9],
              [1,8,  2,3,  1,4],
              [1,4,  2,8,  3,5],
              [5,7,  2,3,  7,8],
              [1,2,  3,5,  4,6]]

Mogę zidentyfikować wiersze o unikalnych elementach z poniższym kodem, ale utknąłem z kodem alfabetycznie.

s = np.sort(v,axis=1)
v[(s[:,:-1] != s[:,1:]).all(1)]
0
user109387 12 październik 2020, 00:03

1 odpowiedź

Najlepsza odpowiedź

Zakładając, że nie nadwrażliwe rzędy spadły z:

s = np.sort(v, axis=1)
idx = (s[:,:-1] != s[:,1:]).all(1)
w = v[idx]

Następnie możesz uzyskać zamówienia każdego rzędu z {x0}} na schowku

w = w.reshape(-1,3,2)
s = np.lexsort((w[:,:,1], w[:,:,0]))

Następnie możesz zastosować fantazyjne indeksowanie i przekształcić go z powrotem:

rows, orders = np.repeat(np.arange(len(s)), 3), s.flatten()
v[idx] = w[rows, orders].reshape((-1,6))

Jeśli musisz upuścić zduplikowane wiersze, możesz to zrobić tak:

u, idx = np.unique(v, return_index=True, axis=0)
output = v[np.sort(idx)]

Wizualizacja procesu:

enter image description here

Przykładowy przebieg:

>>> s
array([[1, 0, 2],
       [1, 0, 2],
       [0, 2, 1],
       [2, 1, 0]], dtype=int64)
>>> rows
array([0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3])
>>> orders
array([1, 0, 2, 1, 0, 2, 0, 2, 1, 2, 1, 0], dtype=int64)
>>> v[idx]
array([[2, 7, 4, 6, 5, 9],
       [1, 4, 2, 8, 3, 5],
       [1, 2, 3, 5, 4, 6],
       [1, 4, 2, 8, 3, 5]])
>>> v
array([[2, 5, 3, 5, 1, 8],
       [2, 7, 4, 6, 5, 9],
       [1, 8, 2, 3, 1, 4],
       [1, 4, 2, 8, 3, 5],
       [5, 7, 2, 3, 7, 8],
       [1, 2, 3, 5, 4, 6],
       [1, 4, 2, 8, 3, 5]])
>>> output
array([[2, 5, 3, 5, 1, 8],
       [2, 7, 4, 6, 5, 9],
       [1, 8, 2, 3, 1, 4],
       [1, 4, 2, 8, 3, 5],
       [5, 7, 2, 3, 7, 8],
       [1, 2, 3, 5, 4, 6]])
1
mathfux 13 październik 2020, 01:01