Question

我已经为这个问题写了两个解决方案。第一个是好的，但我不想使用任何外部库+其O（n）* log（n）复杂性。第二个解决方案＆＃34;我需要你的帮助来优化它＆＃34;当输入是混沌序列长度= 10005（带负号）时给出错误。

解决方案1：

from itertools import count, filterfalse 


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

解决方案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

注意：这是一个可靠性的演示测试，解决方案1获得了100％和   解决方案2得到77％   ＆＃34;解决方案2＆＃34;中的错误原因是：
  性能测试 - ＆gt;   中等混沌序列长度= 10005（减去）预期得到3   10000个
  性能测试 - ＆gt;大混乱+多-1,1,2,3（有   减）得到5预期10000

Answer 1

在Python中测试集合中是否存在数字很快就可以尝试这样的事情：

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

Answer 2

def solution(A):
    B = set(sorted(A))
    m = 1
    for x in B:
        if x == m:
            m+=1
    return m

Answer 3

如果指定了N的范围，则以下内容也适用：

A<int>

Answer 4

快速处理大型数组。

def minpositive(arr):
    if 1 not in arr: # protection from error if ( max(arr) < 0 )
        return 1
    else:
        maxArr = max(arr) # find max element in 'arr'
        c1 = set(range(2, maxArr+2)) # create array from 2 to max
        c2 = c1 - set(arr) # find all positive elements outside the array
        return min(c2)

Answer 5

def minpositive(A):
    """Given an list A of N integers, 
    returns the smallest positive integer (greater than 0) 
    that does not occur in A in O(n) time complexity

        Args:
            A: list of integers
        Returns:
            integer: smallest positive integer

        e.g:
            A = [1,2,3]
            smallest_positive_int = 4
    """
    len_nrs_list = len(A)
    N = set(range(1, len_nrs_list+1))
    
    try:
        return min(N-set(A)) #gets the min value using the N integers
    except:
        return list(set(A))[-1]+1 #in case N integers and set(A) are the same, gets the next smallest positive integer

Answer 6

在不使用设置的情况下，我提出了以下解决方案：

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)

Answer 7

我刚刚修改了@najeeb-jebreel 修改的答案，现在该函数给出了最佳解决方案。

def solution(A):
    sorted_set = set(sorted(A))
    sol = 1
    for x in sorted_set:
        if x == sol:
            sol += 1
        else:
            break
    return sol

Answer 8

从 Niroj Shrestha 和 najeeb-jebreel 继续，添加了一个初始部分，以避免在完整集的情况下进行迭代。如果数组非常大，则尤为重要。

    def smallest_positive_int(A):
      sorted_A = sorted(A)
      last_in_sorted_A = sorted_A[-1]
      #check if straight continuous list
      if len(sorted_A) == last_in_sorted_A:
        return last_in_sorted_A + 1
      else:
        #incomplete list, iterate to find smallest missing number
        sol=1
        for x in sorted_A:
            if x == sol:
              sol += 1
            else:
              break
        return sol
    
    #-----------------------------------------------
    A = [1,2,7,4,5,6]
    print(smallest_positive_int(A))

Answer 9

def solution(A):
    arr = set(A)
    N = set(range(1, 100001))
    while N in arr:
       N += 1
    return min(N - arr)

solution([1, 2, 6, 4])
#returns 3

给定N个整数的数组A的Python，返回O（n）时间复杂度中A中不出现的最小正整数（大于0）

9 个答案: