Python/最小正整数

我完成了以下演示任务 编写一个函数：

def解决方案

给定一个由N个整数组成的数组A，返回在A中不出现的大于0的最小正整数

例如，给定A=[1,3,6,4,1,2]，函数应该返回5

给定A=[1，2，3]，函数应该返回4

给定A=[−1.−3] ，函数应返回1

为以下假设编写有效的算法：

N是[1..100000]范围内的整数； 数组A的每个元素都是范围内的整数[−1000000..1000000]

我的解决方案

def解决方案A： 用Python 3.6编写代码 l=lenA B=[] 结果=0 n=0 对于我在兰格尔： 如果A[i]>=1： 附录A[i] 如果B=[]： 返回1 其他： B.分类 B=listdict.fromkeysB n=透镜 对于rangen-1中的j： 如果B[j+1]>B[j]+1： 结果=B[j]+1 如果有结果！=0: 返回结果 其他： returnB[n-1]+1

---

虽然我得到了所有输入的正确输出，但我的分数只有22%。有人能指出我哪里出了问题吗

试试这个，我假设列表没有排序，但是如果它已排序，您可以删除number\u list=sortednumber\u 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))

输出：

>>4

>>1

>>1

>>2

>>4

输入：

number_list = [1,2,3]

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

number_list = [2]

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

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

输出：

>>4

>>1

>>1

>>2

>>4

输入：

number_list = [1,2,3]

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

number_list = [2]

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

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

输出：

>>4

>>1

>>1

>>2

>>4

输入：

number_list = [1,2,3]

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

number_list = [2]

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

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

输出：

>>4

>>1

>>1

>>2

>>4

输入：

number_list = [1,2,3]

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

number_list = [2]

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

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

输出：

>>4

>>1

>>1

>>2

>>4

---

试试这个，我假设列表没有被排序，但是如果它被排序，你可以删除number\u list=sortednumber\u 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))

输出：

>>4

>>1

>>1

>>2

>>4

输入：

number_list = [1,2,3]

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

number_list = [2]

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

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

输出：

>>4

>>1

>>1

>>2

>>4

输入：

number_list = [1,2,3]

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

number_list = [2]

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

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

输出：

>>4

>>1

>>1

>>2

>>4

输入：

number_list = [1,2,3]

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

number_list = [2]

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

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

输出：

>>4

>>1

>>1

>>2

>>4

输入：

number_list = [1,2,3]

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

number_list = [2]

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

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

输出：

>>4

>>1

>>1

>>2

>>4

---

我认为这应该很容易，从1开始，检查哪个数字首先没有出现

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

    return i

你也可以考虑将一个元素放在一个集合中以更好的搜索性能，但我不确定它是否适合这个案例。

更新： 我做了一些测试，测试的数字从负百万到正百万，还有100000个元素

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

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

---

我认为这应该很容易，从1开始，检查哪个数字首先没有出现

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

    return i

你也可以考虑将一个元素放在一个集合中以更好的搜索性能，但我不确定它是否适合这个案例。

更新： 我做了一些测试，测试的数字从负百万到正百万，还有100000个元素

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

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

---

具有时间复杂度和空间复杂度的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

我的主要想法是：

为所有积极的可能性创建一个零初始化存储桶。 迭代A。每当你遇到一个正数时，把它的bucket标记为1。 迭代存储桶并返回第一个零存储桶。

---

具有时间复杂度和空间复杂度的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

我的主要想法是：

为所有积极的可能性创建一个零初始化存储桶。 迭代A。每当你遇到一个正数时，把它的bucket标记为1。 迭代存储桶并返回第一个零存储桶。

---

在Codibility中，您必须正确预测其他输入，不仅是样本输入，还必须获得良好的性能。我是这样做的：

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%明白了。如果是lenA==1的数组A，则将调用函数maior\u menos\u zero。此外，如果它是lenA>1，但其元素是相同的计数器，则将再次调用函数maior_menos_zero。最后，如果1不在数组中，那么1是数组中最小的正整数，否则1在数组中，我们将对范围1中的X进行a，maxA+2，并检查其元素是否在a中，此外，为了节省时间，不在a中的X的第一次出现是最小的正整数。

在可编码性中，您必须正确预测其他输入，不仅是样品，而且性能也很好。我是这样做的：

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%明白了。如果是lenA==1的数组A，则将调用函数maior\u menos\u zero。此外，如果它是lenA>1，但其元素是相同的计数器，则将再次调用函数maior_menos_zero。最后，如果1不在数组中，那么1是数组中最小的正整数，否则1在数组中，我们将对范围1中的X进行a，maxA+2，并检查其元素是否在a中，更进一步，为了节省时间，不在a中的X的第一次出现是最小的正整数。

我的Javascript解决方案。解决方案是对数组进行排序并比较数组的相邻元素。复杂性正在显现

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;
}

---

我的Javascript解决方案。解决方案是对数组进行排序并比较数组的相邻元素。复杂性正在显现

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;
}

---

这是一个效率低下、n²时间复杂度的解决方案。至少将A转换为集合是值得的。这是一个效率低下、n²时间复杂度的解决方案。至少把A转换成A组，这绝对值得。我的分数只有22%，你能说吗

---

你这是什么意思？是否有自动测试会导致错误的结果？你能提供你失败案例的输入、预期输出和实际输出吗？我的分数只有22%，你能澄清你的意思吗？是否有自动测试会导致错误的结果？您能否提供您失败案例的输入、预期输出和实际输出？分数：100%。通过所有测试用例。分数：100%。通过所有测试用例。