def dix_max(nb):
    dix=[]  # Liste qui va contenir les 10 plus grands nombres
    i=0
    liste=[]
    # On met les nombres du générateur dans une liste
    for elt in nb:
            liste.append(elt)
    while i<10:
            liste_max=max(liste)
            dix.append(liste_max)
            liste.remove(liste_max)
            i+=1
    return dix

from collections import deque
def macaque3_nmax(liste, n=10):
    length = len(liste)
    position = 2*n
    result = liste[:position]
    result.sort()
    result = deque(result[n:position])
    while position < length:
        newPosition = position+2*n
        current = liste[position:newPosition]
        position = newPosition
        current.sort()
        current = deque(current)
        listeFusion = deque([])
        a = result.pop()
        b = current.pop()
        i = 0
        while True:
            i += 1
            if a > b:
                listeFusion.appendleft(a)
                if i == n:
                    break
                a = result.pop()
            else:
                listeFusion.appendleft(b)
                if i == n:
                    break
                b = current.pop()
        result = listeFusion
    return result

from random import randint

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

class Memoize(object):
    def __init__(self, fn):
        self.fn = fn
        self.memo = {}
    def __call__(self, *args):
        if not self.memo.has_key(args):
            self.memo[args] = self.fn(*args)
        return self.memo[args]


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

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

from random import randint

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

def maxi(liste, n):
    liste = list(liste)
    for i in range(n):
        if liste:
            m = max(liste)
            liste.remove(m)
            yield m

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

def nmax(generator, n=10):
    result = []
    it = iter(generator)
    for i in range(n):
        heappush(result, next(it))
    for elt in it:
        if elt > result[0]:
            heapreplace(result, elt)
    return result

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

from __future__ import print_function
from itertools import islice
import heapq


# -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-
# mac.aque :
def mac_aque_nmax(generator, n=10):
    result = []
    for elt in iter(generator[:n]):
        heapq.heappush(result, elt)
    for elt in iter(generator[n:]):
        if elt > result[0]:
            heapq.heapreplace(result, elt)
    return result


# -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-
# Lord Casque Noir :

def Lord_Casque_Noir_nmax(generator, n=10):
    it = iter( generator )

    result = list(islice( it, n ))
    if not result: 
        return result
    heapq.heapify(result)

    for elt in it:
        if elt > result[0]:
            heapq.heapreplace(result, elt)

    return result




# -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-
# -*-*-*-*-*-*-*-*-*-*-*-*-*- Benchmark -*-*-*-*-*-*-*-*-*-*-*-*-*-*-
# -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-
if __name__ == "__main__":
    from random import randint
    from timeit import Timer
    
    print("\n[nmax] Benchmark")

    players = (
        "mac_aque",
        "Lord_Casque_Noir"
    )
    
    arguments = ( # (it_size, n)
        (1000, 10),
        (1000, 1000),
        (10000, 10),
        (10000, 10000),
        (100000, 10),
        (100000, 100000)
    )
    
    def test(funct, args):
        for _ in funct(*args):
            pass

    repeat = 100

    stmt = "test({}_nmax, (it, n))"
    setup = "from __main__ import test, it, n, {}_nmax, islice, heapq"
    
    gen = lambda a, b, n: [ randint(a, b) for _ in range(n) ]
    
    scores = []
    for name in players:
        
        print()
        
        ls = []
        for args in arguments:
            
            print(name, "[ it_size =", args[0], "| n =", args[1], ']')
            
            it = gen(10, 10000, args[0])
            n = args[1]
            
            # Tester si la fonction retourne bien le resultat attendu :
            r = sorted(list(it))[-n:][::-1]
            if r == sorted(list(eval(name + "_nmax(it, n)")), reverse=True):
                
                t = Timer(stmt.format(name),
                          setup.format(name)).timeit(repeat)
                print('\t', t, " seconde", 's' if t > 1 else '', sep='')
                ls.append(t)
            
            else:
                print("\tERROR : resultat incorrect !")
                break
        
        else:
            t = sum(ls)
            print("Total : ", t, " seconde", 's' if t > 1 else '', sep='')
            scores.append((t, name))
    
    print("\nPodium")
    
    scores.sort()
    for i, t in enumerate(scores):
        
        print(i + 1, '> ', t[1].rjust(25), ' : ', t[0],
              " seconde", 's' if t[0] > 1 else '', sep='')