对具有重复值的数组进行排序

Question

I have to order an array with values from 0 to 9 that are repeated and obtain the vector initial index. The input array is:

[3, 1, 2, 0, 4, 5, 6, 7, 1, 0, 9, 5, 3, 9, 2, 7, 6, 4]

I would like to obtain the following order:

array([0, 1, 2, 3, 4, 5, 6, 7, 9, 0, 1, 2, 3, 4, 5, 6, 7, 9], dtype=uint8)

Instead of:

array([0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 9, 9])

which is given by:

import numpy as np
a = [3, 1, 2, 0, 4, 5, 6, 7, 1, 0, 9, 5, 3, 9, 2, 7, 6, 4]
np.argsort(a)

Is there a way to manipulate this function?

Answer 1

l = [1,2,3,4,5,6,7,8,9,4,3,5]
l_oredered = []
while len(l) != 0:
    unique_nums = list(set(l))
    unique_nums.sort()
    l_oredered.extend(unique_nums)
    for num in unique_nums:
        l.remove(num)

print(l_oredered)

This will result with:

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

You can apply the thinking with NumPy or convert the final result into a NumPy array.

Answer 2

Very interesting task! Here is my attempt at to solve the problem

import numpy as np

def groupsort(a: np.ndarray):
    uniques, counts = np.unique(a, return_counts=True)
    min_count = np.min(counts) # Use this to solve easy case
    counts -= min_count
    rest = []
    i = 0
    while any(counts): # Hard case
        if counts[i]:
            rest.append(i)
            counts[i] -= 1
        i = (i + 1) % 3
    return np.array(list(uniques) * min_count + rest)

a = np.array(list(range(4)) * 2 + [1,1,1,1,1,0,0,0,2,2])
np.random.shuffle(a)
print(a)
# [3 0 3 2 1 3 0 2 0 3 1 0 1 2 1 1 1]
print(groupsort(a))
# [0 1 2 3 0 1 2 3 0 1 2 3 0 1 3 1 1]

The idea is to split the problem in two cases. One easy case and one hard case. The easy case is to handle inputs like this: a = [0,1,2,3,0,1,2,3] , where the counts for each unique value are equal. Then you can simply count the number n of a specific value (eg 0), then just do list(range(max(a))) * n .

The hard case is to handle inputs such as a = [1,1,1,1,1,0,0,0,2,2] . Then the idea is to get the counts of each value, in this case counts = [3,5,2,0] . Then do:

rest = []
i = 0
while any(counts):
    if counts[i]:
        rest.append(i)
        counts[i] -= 1
    i = (i + 1) % 3

In my solution you see I have combined the two solutions.

Answer 3

For an array with a small number of elements @Mr.O's answer is faster. The code below is faster if there are more than around 100 ints in arr.

import numpy as np

def sort_groups( arr ):
    ct = np.ones( len(arr), dtype = np.int64 )
    for i in set( arr ):
        ct[arr == i] = ct[arr == i ].cumsum()
    # ct calculates a rank for each int in arr
    tosort = ( arr.max() + 1 ) * ct + arr 
    # tosort ranks by ct first then a if ct's are equal
    return arr[ np.argsort( tosort ) ]
     
a = np.array([3, 1, 2, 0, 4, 5, 6, 7, 1, 0, 9, 5, 3, 9, 2, 7, 6, 4])
sort_groups( a )
# array([0, 1, 2, 3, 4, 5, 6, 7, 9, 0, 1, 2, 3, 4, 5, 6, 7, 9])

Breaking the function out to see what's happening:

arr = a

ct = np.ones( len(arr), dtype = np.int64 )
for i in set( arr ):
    ct[arr == i] = ct[arr == i ].cumsum()

arr, ct
# (array([3, 1, 2, 0, 4, 5, 6, 7, 1, 0, 9, 5, 3, 9, 2, 7, 6, 4]),
#  array([1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2]))

tosort = ( arr.max() + 1 ) * ct + arr  # Assumes arr is > 0

tosort
# array([13, 11, 12, 10, 14, 15, 16, 17, 21, 20, 19, 25, 23, 29, 22, 27, 26, 24])

arr[ np.argsort( tosort ) ]
array([0, 1, 2, 3, 4, 5, 6, 7, 9, 0, 1, 2, 3, 4, 5, 6, 7, 9])

Answer 4

Here's a 2-liner:

unique, counts = np.unique(a, return_counts=True)
b = [x for y in [[u for i, u in enumerate(unique) if counts[i] > n] for n in range(counts.max())] for x in y]

Output:

>>> b
[0, 1, 2, 3, 4, 5, 6, 7, 9, 0, 1, 2, 3, 4, 5, 6, 7, 9, 1, 5, 9]
#^ reset                    ^ reset                    ^ reset

Answer 5

I prefer using np.bincount instead of np.unique , np.sort or np.argsort because it's much faster in cases maximum item of data is small.

def count_out(arr):
    bins = np.bincount(arr, minlength=N) 
    threshold_idx = np.unique(bins[bins!=0]) 
    counts = np.diff(threshold_idx, prepend=0)
    mask = (bins >= threshold_idx[:, None])
    full_mask = np.repeat(mask, counts, axis=0)
    blocks = np.repeat([np.arange(N)], np.sum(counts), axis=0)
    return blocks[full_mask]

N = 10
X = np.array([3, 5, 3, 9, 9, 9, 9, 0, 0, 6, 8, 8, 7, 0, 5, 9, 7, 8, 1, 5, 8, 8, 1, 0, 7, 1, 9])
print(X)
print(count_out(X))
>>> [3 5 1 3 9 7 5 9 0 9 9 0 0 6 8 8 8 9 7 0 5 9 7 8 3 1 5 8 8 1 0 7 1 9 9 8]
>>> [0 1 3 5 6 7 8 9 0 1 3 5 7 8 9 0 1 3 5 7 8 9 0 1 5 7 8 9 0 8 9 8 9 8 9 9]

The key idea is to find counts of how many times does each block repeat. Then create unique mask for each block:

Blocks:

[[0 1 2 3 4 5 6 7 8 9]
 [0 1 2 3 4 5 6 7 8 9]
 [0 1 2 3 4 5 6 7 8 9]
 [0 1 2 3 4 5 6 7 8 9]
 [0 1 2 3 4 5 6 7 8 9]
 [0 1 2 3 4 5 6 7 8 9]]

Unique masks:

[[1 1 0 1 0 1 1 1 1 1]
 [1 1 0 1 0 1 0 1 1 1]
 [1 1 0 0 0 1 0 1 1 1]
 [1 0 0 0 0 0 0 0 1 1]
 [0 0 0 0 0 0 0 0 1 1]
 [0 0 0 0 0 0 0 0 0 1]]

Finally, reconstruct all the masks by the counts we've got.

Counts: [1 2 1 1 2 1]

Full masks:

[[1 1 0 1 0 1 1 1 1 1]
 [1 1 0 1 0 1 0 1 1 1]
 [1 1 0 1 0 1 0 1 1 1]
 [1 1 0 0 0 1 0 1 1 1]
 [1 0 0 0 0 0 0 0 1 1]
 [0 0 0 0 0 0 0 0 1 1]
 [0 0 0 0 0 0 0 0 1 1]
 [0 0 0 0 0 0 0 0 0 1]]

By the way, it seems this can be optimised further. At first, creation of repetitive blocks is redundant since there should be a way to create a pointer to one single block. Secondly, it's slow in case full mask is sparse. In this case you should consider implementing your own way to repeat blocks with no masking.

I hope it's helpful for you at the current point.

Answer 6

IIUC, you want to have a duplicated, sorted, array.

Remove the duplicated values using numpy.unique , sort, and tile to the expected size:

a = np.array([3, 1, 2, 0, 4, 5, 6, 7, 1, 0, 9, 5, 3, 9, 2, 7, 6, 4])
b = np.unique(a)
b = np.tile(b, len(a)//len(b))

output:

array([0, 1, 2, 3, 4, 5, 6, 7, 9, 0, 1, 2, 3, 4, 5, 6, 7, 9])