from random import randint

class Conteneur(object):
    def __init__(self, ma_liste):
        self.c = []
        self.liste = ma_liste
        self.compteur = 0
    def retirer(self):
        maxi = max(self.liste)
        index = self.liste.index(maxi)
        pop = self.liste.pop(index)
        return pop
    def ajouter(self):
        value = self.retirer()
        if value not in self.c:
            self.c.append(value)
            self.compteur += 1
    def __repr__(self):
        return repr(self.c)

def main(a, b, n_randint, n_maxi):
    liste = [randint(a, b) for i in range(n_randint)]
    c = Conteneur(liste)
    while c.compteur != n_maxi:
        c.ajouter()
    print(c)

main(1, 500, 30, 10)

from random import randint

class Conteneur(list):
    def __init__(self, ma_liste):
        super(Conteneur, self).__init__(self)
        self.liste = ma_liste
        self.compteur = 0
    def retirer(self):
        maxi = max(self.liste)
        index = self.liste.index(maxi)
        pop = self.liste.pop(index)
        return pop
    def ajouter(self):
        value = self.retirer()
        if value not in self:
            self.append(value)
            self.compteur += 1
    def __str__(self):
        return repr(self)

def main(a, b, n_randint, n_maxi):
    liste = [randint(a, b) for i in range(n_randint)]
    c = Conteneur(liste)
    while c.compteur != n_maxi:
        c.ajouter()
    print(c)

main(1, 500, 30, 10)

def maximums(iterable,n=10):
    out = []
    it = iterable[:]
    while it and len(out)<10: out.append(it.pop(it.index(max(it))))
    return out

def maximums(iterable,n=10):
    it = iterable[:]
    return [it.pop(it.index(max(it))) for i in range(10) if len(it)]

from random import randint

gen = lambda n, a, b: (randint(a,b) for i in range(n))

def maxi(liste):
    liste = set(liste)
    for i in range(10):
        if liste:
            m = max(liste)
            liste.remove(m)
            yield m

print [i for i in maxi(gen(10000,1,1000000))]

def extract_best( tmp, best, n ) :
    best.extend(tmp)
    best.sort()
    return best[-n:]

def n_maxi( seq, n = 10 ) :
    best = []
    tmp = []
    for i in seq :
        tmp.append(i)
        if len(tmp) == n :
            best = extract_best(tmp, best, n)
            tmp = []
    best = extract_best(tmp, best, n)
    return best

print n_maxi(gen(1000000,-1000000, 1000000), 1000)

f = lambda it, n: list(set(it))[-n:]

def n_maxi( seq, n = 10 ) :
    best = []
    for i in seq :
        best.append(i)
        if len(best) == 2 * n:
            best = sorted(best)[-n:]
    return sorted(best)[-n:]

from random import randint
import heapq

N = 1000
MAX = 10000

def gen(n, a, b):
    for i in range(n):
        yield randint(a, b)

def dix_maxi(g):
    hp, res = [], []
    for value in g:
        heapq.heappush(hp, -value)

    for _ in range(10):
        res.append(-heapq.heappop(hp))

    return res


print dix_maxi(gen(N, 0, MAX))

def n_maxi(g, n = 10):
    hp, res = [], []
    for value in g:
        heapq.heappush(hp, -value)

    for _ in range(n):
        res.append(-heapq.heappop(hp))

    return res

from heapq import *

def n_premiers(generator, n=10):
    result = []
    for elt in iter(generator):
        if len(result) < n:
            heappush(result, elt)
        elif elt > result[0]:
            heapreplace(result, elt)
    return [heappop(result) for i in range(10)]

# -*- coding:utf-8 -*-

from __future__ import print_function


# -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-
# quelqun_dautre :
def quelqun_dautre_nmax(liste, n=10):
    liste = iter(liste)
    bar = [ next(liste) for _ in range(n) ]
    while True:
        indice, minimum = min(enumerate(bar), key=lambda a:a[1])
        try:
            i = next(liste)
        except StopIteration:
            break
        if i> minimum:
            bar[indice] = i
    return bar


# -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-
# quark :
def quark_extract_best( tmp, best, n ) :
    best.extend(tmp)
    best.sort()
    return best[-n:]

def quark_nmax( seq, n = 10 ) :
    best = []
    tmp = []
    for i in seq :
        tmp.append(i)
        if len(tmp) == n :
            best = quark_extract_best(tmp, best, n)
            tmp = []
    best = quark_extract_best(tmp, best, n)
    return best


# -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-
# josmiley :
def josmiley_nmax(iterable, n=10):
    it = iterable[:]
    return [ it.pop(it.index(max(it))) for i in range(n) if len(it) ]


# -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-
# GurneyH :
import heapq

def GurneyH_nmax(g, n):
    hp, res = [], []
    for value in g:
        heapq.heappush(hp, -value)

    for _ in range(n):
        res.append(-heapq.heappop(hp))

    return res

 
# -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-
# yoch :
import heapq

def yoch_nmax(generator, n=10):
    result = []
    for elt in iter(generator):
        if len(result) < n:
            heapq.heappush(result, elt)
        elif elt > result[0]:
            heapq.heapreplace(result, elt)
    return [ heapq.heappop(result) for i in range(len(result)) ]




# -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-
# -*-*-*-*-*-*-*-*-*-*-*-*-*- Benchmark -*-*-*-*-*-*-*-*-*-*-*-*-*-*-
# -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-
if __name__ == "__main__":
    from random import randint
    from timeit import Timer
    
    gen = lambda a, b, n: [ randint(a, b) for _ in range(n) ]

    val_min = 1     # Valeur minimal contenu dans l'itérable.
    val_max = 10000 # Valeur maximal contenu dans l'itérable.
    it_size = 5000  # Taille de l'itérable.

    n = 500         # Nombre de valeurs à extraire de l'itérable.

    repeat = 100    # see help(Timer.timeit) 

    iterable = list(gen(val_min, val_max, it_size))
    
    players = [ # Proprio des algos (ça sonne bien en plus... 
        "quelqun_dautre",
        "quark",
        "josmiley",
        "GurneyH",
        "yoch"
    ]

    # La réponse attendu :
    resp = iterable[:]
    resp.sort()
    resp = resp[-n:]
    
    # Validation des algos :
    discalified = []
    for i, name in enumerate(players[:]):
        if resp != sorted(list(eval(name + "_nmax(iterable[:], n)"))):
            print("L'algo de", name, "est incorrect !")
            discalified.append(name)
        else:
            print("L'algo de", name, "est correct.")

    print("\nBenchmark")
    setup = "from __main__ import heapq, {}_nmax, iterable, n"
    stmt = "_ = list({}_nmax(iterable[:], n))"
    ls = []
    for name in players:
        if name in discalified:
            continue # on ne teste pas les algos erronés
        t = Timer(stmt.format(name), setup.format(name))
        print(name, end=" : ")
        t = t.timeit(repeat)
        print(t, " seconde", 's' if t > 1 else '', sep='')
        ls.append((t, name))
    ls.sort()


    print("\nPodium")
    for t, name in ls:
        print("{} : {} seconde{}".format(
            name.center(15), t,
            's' if t > 1 else ''))

#EOF#