Python étant donné un tableau A de N entiers, renvoie le plus petit entier positif (supérieur à 0) qui ne se produit pas dans A O(n) complexité temporelle

Question

J'ai écrit deux solutions à ce problème. La première est bonne mais je ne souhaite utiliser aucune bibliothèque externe + sa complexité O (n) * log (n). La deuxième solution "Dans laquelle j'ai besoin de votre aide pour l'optimiser" donne une erreur lorsque l'entrée est une séquence chaotique longueur = 10005 (avec moins).

Solution 1:

from itertools import count, filterfalse 


def minpositive(a):
    return(next(filterfalse(set(a).__contains__, count(1))))

Solution 2:

def minpositive(a):
    count = 0
    b = list(set([i for i in a if i>0]))
    if min(b, default = 0)  > 1 or  min(b, default = 0)  ==  0 :
        min_val = 1
    else:
        min_val = min([b[i-1]+1 for i, x in enumerate(b) if x - b[i - 1] >1], default=b[-1]+1)

    return min_val

Remarque: Il s’agissait d’un test de démonstration en codilité, la solution 1 obtenant 100% et la solution 2 77%.
Une erreur dans "solution2" était due à:
Tests de performance -> Longueur moyenne des séquences chaotiques = 10005 (avec le moins) a 3 attendus 10 000
Les tests de performance -> grands chaotiques + nombreux -1, 1, 2, 3 (avec Moins) ont obtenu 5 sur 10000

Answer 1

Tester la présence d’un nombre dans un ensemble est rapide en Python, vous pouvez donc essayer quelque chose comme ceci:

def minpositive(a):
    A = set(a)
    ans = 1
    while ans in A:
       ans += 1
    return ans

Answer 2

Sans utiliser set je propose cette solution:

def smallest_missing_positive_integer(A):
    A.sort()
    N = len(A)
    
    i = 0
    previous = 0
    while i < N:
        current = A[i]

        if current > 0:
            if current > previous + 1: # breaks consecutiveness
                return previous + 1
            else:
                previous = current
        
        i += 1
    
    return max(previous+1, current+1)