How to renumber reverse-sorted list of integers?

Question

I have a list of numbers like this:

[687, 687, 683, 683, 677, 662....] 

It is sorted in descending order and has many numbers.

I want to represent it like, the greater the number in the list, I want to give it the smallest value and so on. Like 687 becomes 0, then 683 becomes 1, then 677 becomes 2 and so on.

Is there a way to do this?

EDIT:

Actually, I want to represent the new_list as [0,0,4,4,10,25..] such that highest element gets 0, then the next element is the difference of the two numbers in the original list + the previous number in the new_list, like we get 4 by doing (687-683) + 0 and so on. How to do that?

Answer 1

myList = [687, 687, 683, 683, 677, 662]
unique_sorted_list = sorted(list(set(myList)), reverse = True)
result = []
for i in range(len(unique_sorted_list)):
    if i == 0:
        result.append((unique_sorted_list[i], i))
    else:
        result.append((unique_sorted_list[i], unique_sorted_list[i-1] - unique_sorted_list[i] + result[i-1][1]))

result = [j[1] for i in myList for j in result if i==j[0]]  
print result

And we get Output as:

[0, 0, 4, 4, 10, 25]

Answer 2

Create a Counter out of the list, replace the keys of the sorted result, and turn that back into a list:

from collections import Counter
from itertools import count

# Get counts of each element in the list
original_counter = Counter([687, 687, 683, 683, 677, 662])

# Get only the unique values, in descending order
values = (v for k, v in sorted(original_counter.items(), reverse=True))

# Create a new counter out of 0, 1, 2, … and the sorted, unique values
new_counter = Counter(dict(zip(count(), values)))

# Retrieve a sorted list from the new counter
new_list = sorted(new_counter.elements())

print(new_list) # [0, 0, 1, 1, 2, 3]

This doesn’t require the original list to be sorted, either. It makes for a compact function:

from collections import Counter
from itertools import count

def enumerate_unique(iterable):
    return sorted(Counter(dict(zip(count(),
        (v for k, v in sorted(Counter(iterable).items(), reverse=True)))))
        .elements())

On second thought, though, the straightforward way isn’t bad. It’s also a bit more efficient.

def enumerate_unique(iterable):
    seen = {}
    counter = 0

    for x in iterable:
        i = seen.get(x)

        if i is None:
            seen[x] = counter
            yield counter
            counter += 1
        else:
            yield i

That one works on any list. Since you have a sorted list, though, there’s a very nice O(n):

def enumerate_unique(sorted_iterable):
    last = None
    counter = -1

    for x in sorted_iterable:
        if x != last:
            counter += 1

        yield counter

To skip numbers as described, you could do this:

def enumerate_unique(sorted_iterable):
    last = None
    last_index = -1

    for i, x in enumerate(sorted_iterable):
        if x != last:
            last_index = i

        yield last_index