Python / 最小正整數

Question

我接受了以下 codility 演示任務編寫一個函數：

解決方案(A)

給定一個由 N 個整數組成的數組 A，返回 A 中不出現的最小正整數（大於 0）。

例如，給定 A = [1, 3, 6, 4, 1, 2]，函數應該返回 5。

給定 A = [1, 2, 3]，函數應該返回 4。

給定 A = [−1, −3]，函數應該返回 1。

為以下假設編寫一個有效的算法：

N 是 [1..100,000] 范圍內的整數； 數組 A 的每個元素都是 [−1,000,000..1,000,000] 范圍內的整數。

我的解決方案

def solution(A):
    # write your code in Python 3.6
    l = len(A)
    B = []
    result = 0
    n = 0
    for i in range(l):
        if A[i] >=1:
            B.append(A[i]) 
    if B ==[]:
        return(1)
    else:    
       B.sort() 
       B = list(dict.fromkeys(B))
       n = len(B)
       for j in range(n-1):
           if B[j+1]>B[j]+1:
                result = (B[j]+1)
       if result != 0:
            return(result)
       else:
            return(B[n-1]+1)

盡管我嘗試的所有輸入都得到了正確的輸出，但我的分數僅為 22%。 有人可以請強調我哪里出錯了。

Answer 1

時間復雜度為 O(N) 空間復雜度為 O(N) 的 Python 解決方案：

def solution(A):
    arr = [0] * 1000001
    for a in A:
        if a>0:
            arr[a] = 1
    for i in range(1, 1000000+1):
        if arr[i] == 0:
            return i

我的主要想法是：

1. 為所有積極的可能性創建一個零初始化的“桶”。
2. 迭代 A。當你遇到一個正數時，將它的桶標記為已訪問 (1)。
3. 迭代“桶”並返回第一個零“桶”。

Answer 2

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
    # write your code in Python 3.6
    i = 1;
    B = set(A);
    while True:
        if i not in B:
            return i;
        i+=1;

Answer 3

在 Codility 中，您必須正確預測其他輸入，不僅是樣本輸入，而且還必須獲得良好的性能。 我已經這樣做了：

from collections import Counter
def maior_menos_zero(A):
    if A < 0:
        return 1

    else:
        return 1 if A != 1 else 2

def solution(A):
    if len(A) > 1:
        copia = set(A.copy())
        b = max(A)
        c = Counter(A)
        if len(c) == 1:
            return maior_menos_zero(A[0])

        elif 1 not in copia:
            return 1

        else:
            for x in range(1,b+2):
                if x not in copia:
                    return x
    else:
        return maior_menos_zero(A[0])

得到它100％。 如果是len(A) == 1的數組A ，則將調用函數maior_menos_zero 。 此外，如果它是len(A) > 1但其元素相同 (Counter) ，則將再次調用函數maior_menos_zero 。 最后，如果1不在數組中，那么1是數組中最小的正整數，否則1在數組中，我們將在 range(1,max(A)+2) 中創建一個for X並檢查它的元素是否是在A 中，此外，為了節省時間， X 不在 A 中的第一次出現是最小的正整數。

Answer 4

我的 Javascript 解決方案。 解決方法是對數組進行排序，比較數組的相鄰元素。 復雜度為 O(N)

function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
  A.sort((a, b) => a - b);

  if (A[0] > 1 || A[A.length - 1] < 0 || A.length <= 2) return 1;

  for (let i = 1; i < A.length - 1; ++i) {
    if (A[i] > 0 && (A[i + 1] - A[i]) > 1) {
        return A[i] + 1;
    }
  }

  return A[A.length - 1] + 1;
}

Answer 5

我的解決方案（100% 接受）：

def solution(nums):

    nums_set = set()
    for el in nums:
        if el > 0 and el not in nums_set:
            nums_set.add(el)

    sorted_set = sorted(nums_set)

    if len(sorted_set) == 0:
        return 1

    if sorted_set[0] != 1:
        return 1

    for i in range(0, len(sorted_set) - 1, 1):
        diff = sorted_set[i + 1] - sorted_set[i]
        if diff >= 2:
            return sorted_set[i] + 1

    return sorted_set[-1] + 1

Answer 6

定義解決方案（A）：

s = set(A)
for x in range(1,100002):
    if x not in s:
        return x
pass

並且得到 100%

Answer 7

試試這個，我假設列表沒有排序，但如果它已排序，您可以刪除number_list = sorted(number_list)以使其更快一點。

def get_smallest_positive_integer(number_list):
    if all(number < 0 for number in number_list) or 1 not in number_list:
        #checks if numbers in list are all negative integers or if 1 is not in list
        return 1
    else:
        try:
            #get the smallest number in missing integers
            number_list = sorted(number_list) # remove if list is already sorted by default
            return min(x for x in range(number_list[0], number_list[-1] + 1) if x not in number_list and x != 0)
        except:
            #if there is no missing number in list get largest number + 1
            return max(number_list) + 1


print(get_smallest_positive_integer(number_list))

輸入：

number_list = [1,2,3]

輸出：

>>4

輸入：

number_list = [-1,-2,-3]

輸出：

>>1

輸入：

number_list = [2]

輸出：

>>1

輸入：

number_list = [12,1,23,3,4,5,61,7,8,9,11]

輸出：

>>2

輸入：

number_list = [-1,3,2,1]

輸出：

>>4

Answer 8

我認為這應該像從 1 開始並檢查哪個數字首先沒有出現一樣簡單。

def solution(A):
    i = 1
    while i in A:
        i += 1

    return i

您也可以考慮將 A 的元素放入一個集合中（以獲得更好的搜索性能），但我不確定在這種情況下是否值得。

更新：我一直在用 OP 給出的數字（從負百萬到正百萬和 100000 個元素的數字）進行一些測試。

100000 elements:
Linear Search: 0.003s
Set Search: 0.017s

1000000 elements (extra test):
Linear Search: 0.8s
Set Search: 2.58s