"Cut the sticks" Python implementation
You are repeatedly extracting the smallest remaining numbers.  

A data structure that is optimized for such operations is a priority queue, which is typically implemented using a heap.  A heap could be constructed in O(N log N) time, after which you would do N delete-min operations, each of which takes O(log N) time.  The total time to solve this challenge would be O(N log N).

Alternatively, you can sort the numbers in descending order (which takes O(N log N)), then repeatedly pop the smallest numbers off the end of the list (N times O(1)).

So, using a heapq would reduce the running time to O(N log N), and a simple sort would be a more efficient O(N log N).

In fact, after you perform the sort, you will see that it's just a simple counting exercise:

def cuts(sticks):
    sticks = list(reversed(sorted(sticks)))
    i = len(sticks)
    while i:
        # Avoid printing results in your algorithm; yield is more elegant.
        yield i
        shortest = sticks[i - 1]
        while i and sticks[i - 1] == shortest:
            i -= 1

raw_input()    # Discard first line, containing N
for result in cuts(int(s) for s in raw_input().split()):
    print(result)


Here's an implementation of the same idea, but using itertools.groupby to avoid keeping track of array indexes: 

from itertools import groupby

def cuts(sticks):
    sticks = list(sticks)
    sticks_remaining = len(sticks)
    stick_counts_by_len = groupby(sorted(sticks))
    while sticks_remaining:
        yield sticks_remaining
        number_of_shortest_sticks = len(list(next(stick_counts_by_len)[1]))
        sticks_remaining -= number_of_shortest_sticks