Question

我正在尝试解决以下提供的Codility问题，

编写函数：

class Solution { public int solution(int[] A); }

在给定一个由N个整数组成的数组A的情况下，返回不存在于A中的最小正整数（大于0）。

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

Given A = [1, 2, 3], the function should return 4.

Given A = [−1, −3], the function should return 1.

假设：

N是[1..100,000]范围内的整数；数组A的每个元素都是[-1,000,000..1,000,000]范围内的整数。复杂度：

预期的最坏情况下的时间复杂度为O（N）；预期的最坏情况下的空间复杂度为O（N）（不计算输入参数所需的存储空间）。

我编写了下面的解决方案，该解决方案的性能很低，但是我看不到该错误。

public static int solution(int[] A) {

        Set<Integer> set = new TreeSet<>();

        for (int a : A) {
            set.add(a);
        }

        int N = set.size();

        int[] C = new int[N];

        int index = 0;

        for (int a : set) {
            C[index++] = a;
        }

        for (int i = 0; i < N; i++) {

            if (C[i] > 0 && C[i] <= N) {
                C[i] = 0;
            }
        }

        for (int i = 0; i < N; i++) {

            if (C[i] != 0) {
                return (i + 1);
            }
        }

        return (N + 1);
    }

分数在此处提供

我将继续调查自己，但是如果您能看到更好的情况，请通知我。

谢谢。

Answer 1

如果期望的运行时间是线性的，则不能使用TreeSet来对输入进行排序，因此需要O(NlogN)。因此，您应该使用HashSet，这需要O(N)时间来添加N元素。

此外，您不需要4个循环。将所有正输入元素添加到HashSet（第一个循环），然后找到不在该Set中的第一个正整数（第二个循环）就足够了。

int N = A.length;
Set<Integer> set = new HashSet<>();
for (int a : A) {
    if (a > 0) {
        set.add(a);
    }
}
for (int i = 1; i <= N + 1; i++) {
    if (!set.contains(i)) {
        return i;
    }
}

Answer 2

使用JavaScript的100％结果解决方案：

function solution(A) {
    // only positive values, sorted
    A = A.filter(x => x >= 1).sort((a, b) => a - b)

    let x = 1

    for(let i = 0; i < A.length; i++) {
        // if we find a smaller number no need to continue, cause the array is sorted
        if(x < A[i]) {
            return x
        }
        x = A[i] + 1
    }

    return x
}

Answer 3

此答案给出了Python中的100％。最坏情况下的复杂度O（N）。

这个想法是我们不在乎序列中的负数，因为我们想找到不在序列A中的最小正整数。因此，我们可以将所有负数设置为零，并仅保留唯一的正值。然后，我们从1开始迭代检查数字是否在序列A的正值集中。

最坏的情况是序列是具有恒定差1的算术级数，导致迭代所有元素，从而导致O（N）复杂性。

在序列的所有元素均为负数（即最大值为负数）的极端情况下，我们可以立即返回1作为最小正数。

def solution(A):
    max_A=max(A)
    B=set([a if a>=0 else 0 for a in A ])
    b=1
    if max_A<=0:
        return(1)
    else:
        while b in B:
            b+=1
        return(b)

Answer 4

这是一个有效的python解决方案：

def solution(A):
    m = max(A)
    if m < 1:
       return 1

    A = set(A)
    B = set(range(1, m + 1))
    D = B - A
    if len(D) == 0:
        return m + 1
    else:
        return min(D)

Answer 5

您做得太多。您已经创建了一个TreeSet，它是整数的顺序集，然后尝试将其转换回数组。取而代之的是浏览列表，并跳过所有负值，然后一旦发现正值，便开始计算索引。如果索引大于数字，则表示该集合已跳过正值。

int index = 1;
for(int a: set){
    if(a>0){
        if(a>index){
            return index;
        } else{
            index++;
        }
    }
}
return index;

已更新为负值。

O（n）的另一种解决方案是使用数组。这就像哈希解决方案。

int N = A.length;
int[] hashed = new int[N];

for( int i: A){
    if(i>0 && i<=N){
        hashed[i-1] = 1;
    }
}

for(int i = 0; i<N; i++){
    if(hash[i]==0){
        return i+1;
    }
}
return N+1;

这可以进一步优化，减少第二个循环的上限。

Answer 6

这是 PHP 中的简单快速的代码。

任务得分： 100％
正确性： 100％
性能： 100％
检测到的时间复杂度： O（N）或O（N * log（N））

function solution($A) {

    $x = 1;

    sort($A);

    foreach($A as $i){

        if($i <=0) continue;

        if($x < $i) return $x;

        else $x = $i+1; 

    }

    return $x;
}

Performance tests

Answer 7

在Swift中100％的解决方案，我发现它here，真的比我的算法还漂亮。。。不需要按顺序旋转数组，而是使用字典[Int: Bool]并检查正项在字典中。

public func solution(_ A : inout [Int]) -> Int {
    var counter = [Int: Bool]()
    for i in A {
        counter[i] = true
    }

    var i = 1
    while true {
        if counter[i] == nil {
            return i
        } else {
            i += 1
        }
    }
}

Answer 8

我简单高效的Java解决方案：

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Set<Integer> set=new TreeSet<>();
        for (int x:A) {
            if (x>0) {
                set.add(x);
            }
        }

        int y=1;
        Iterator<Integer> it=set.iterator();
        while (it.hasNext()) {
            int curr=it.next();
            if (curr!=y) {
                return y;
            }
            y++;
        }
        return y;
    }
}

Answer 9

在Scala中运行所有测试用例的解决方案：

Class Solution {

  def smallestNumber(arrayOfNumbers: Array[Int]) = {
    val filteredSet = arrayOfNumbers.foldLeft(HashSet.empty[Int]){(acc, next) 
    => if(next > 0) acc.+(next) else acc}
    getSmallestNumber(filteredSet)

  }

  @tailrec
  private def getSmallestNumber(setOfNumbers: HashSet[Int], index: Int = 1): 
  Int = {
      setOfNumbers match {
        case emptySet if(emptySet.isEmpty) => index
        case set => if(!set.contains(index)) index else getSmallestNumber(set, 
          index + 1)
        }
      }

}

Answer 10

这是我的PHP解决方案，任务分数100％，正确性100％，性能100％。首先我们进行迭代并存储所有正元素，然后检查它们是否存在，

function solution($A) {

    $B = [];
    foreach($A as $key => $a){
        if($a > 0) $B[] = $a;   
    }

    $i = 1;
    $last = 0;
    sort($B);

    foreach($B as $b){

        if($last == $b) $i--; // This is the case when we find two elements repeated
        else if($i != $b) return $i;
        $i++;
        $last = $b;        

    }

    return $i;
}

我认为它是这里的clearsimple函数之一，该逻辑可以应用于所有其他语言。

Answer 11

我发现一种简单的方法是使用BitSet。

只需将所有正数添加到BitSet中即可。
完成后，返回位0之后的第一个清除位的索引。

public static int find(int[] arr) {
    BitSet b = new BitSet();
    for (int i : arr) {
        if (i > 0) {
            b.set(i);
        }
    }
    return b.nextClearBit(1);
}

Answer 12

我的 Javascript 解决方案。这得到了 100%。解决办法是对数组进行排序，比较数组的相邻元素。

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 13

JavaScript ES6 解决方案：

function solution(A) {
  if (!A.includes(1)) return 1;
  return A.filter(a => a > 0)
    .sort((a, b) => a - b)
    .reduce((p, c) => c === p ? c + 1 : p, 1);
}
console.log(solution([1, 3, 6, 4, 1, 2]));
console.log(solution([1, 2, 3]));
console.log(solution([-1, -3]));
console.log(solution([4, 5, 6]));
console.log(solution([1, 2, 4]));

Answer 14

这是我在 Kotlin 中的代码：

private fun soluction(A: IntArray): Int {
   val N = A.size
   val counter = IntArray(N + 1)

   for (i in A)
       if (i in 1..N)
           counter[i]++
   
   for (i in 1 until N + 1)
       if (counter[i] == 0)
           return i
     
   return N + 1
}

Answer 15

100% 在 Swift 中使用递归函数。 O(N) 或 O(N * log(N))

var promise = 1

public func solution(_ A : inout [Int]) -> Int {
    // write your code in Swift 4.2.1 (Linux)
    execute(A.sorted(), pos: 0)
    return promise

}

func execute(_ n:[Int], pos i:Int) {
    if n.count == i || n.count == 0 { return }
    if promise > 0 && n[i] > 0 && n[i]+1 < promise {
        promise = n[i] + 1
    } else if promise == n[i] {
        promise = n[i] + 1
    }
    execute(n, pos: i+1)
}

Answer 16

这是针对 C# 的，它使用 HashSet 和 Linq 查询，并且在 Codility 上有 100% 的分数

     public int solution(int[] A)
    {
        var val = new HashSet<int>(A).Where(x => x >= 1).OrderBy((y) =>y).ToArray();
        var minval = 1;
        for (int i = 0; i < val.Length; i++)
        {
            if (minval < val[i])
            {
                return minval;
            }
            minval = val[i] + 1;
        }

        return minval;
    }

Answer 17

使用JavaScript的100％结果解决方案：

function solution(A) {
 let N,i=1;
    A = [...new Set(A)]; // remove duplicated numbers form the Array
    A = A.filter(x => x >= 1).sort((a, b) => a - b); //  remove negative numbers & sort array
    while(!N){ // do not stop untel N get a value
      if(A[i-1] != i){N=i} 
      i++;
    }
    return N;
}

Answer 18

这是python中的代码，带有注释以了解代码- Codility 100% Missing Integer

代码-

def solution(A):
"""
solution at https://app.codility.com/demo/results/trainingV4KX2W-3KS/
100%
idea is to take temp array of max length of array items
for all positive use item of array as index and mark in tem array as 1 ie. present item
traverse again temp array if first found value in tem array is zero that index is the smallest positive integer
:param A:
:return:
"""
max_value = max(A)
if max_value < 1:
    # max is less than 1 ie. 1 is the smallest positive integer
    return 1
if len(A) == 1:
    # one element with 1 value
    if A[0] == 1:
        return 2
    # one element other than 1 value
    return 1
# take array of length max value
# this will work as set ie. using original array value as index for this array
temp_max_len_array = [0] * max_value
for i in range(len(A)):
    # do only for positive items
    if A[i] > 0:
        # check at index for the value in A
        if temp_max_len_array[A[i] - 1] != 1:
            # set that as 1
            temp_max_len_array[A[i] - 1] = 1
print(temp_max_len_array)
for i in range(len(temp_max_len_array)):
    # first zero ie. this index is the smallest positive integer
    if temp_max_len_array[i] == 0:
        return i + 1
# if no value found between 1 to max then last value should be smallest one
return i + 2


 arr = [2, 3, 6, 4, 1, 2]    
 result = solution(arr)

Answer 19

这是我的解决方案。首先，我们从1开始，循环遍历数组，并与数组中的2个元素进行比较，如果它与元素之一匹配，我们将加1，然后重新开始该过程。

private static int findSmallest(int max, int[] A) {

    if (A == null || A.length == 0)
        return max;

    for (int i = 0; i < A.length; i++) {
        if (i == A.length - 1) {
            if (max != A[i])
                return max;
            else
                return max + 1;
        } else if (!checkIfUnique(max, A[i], A[i + 1]))
            return findSmallest(max + 1, A);
    }
    return max;
}


private static boolean checkIfUnique(int number, int n1, int n2) {
    return number != n1 && number != n2;
}

Answer 20

这是我用红宝石编写的解决方案，简单正确，有效


def solution(arr)

  sorted = arr.uniq.sort
  last = sorted.last
  return 1 unless last > 0

  i = 1
  sorted.each do |num|
    next unless num > 0
    return i unless num == i

    i += 1
  end
  i

end

Answer 21

这是我的JavaScript解决方案，其O（N）或O（N * log（N））的检测时间复杂度得分为100％：

function solution(A) {
    let tmpArr = new Array(1);

    for (const currNum of A) {
        if (currNum > arr.length) {
            tmpArr.length = currNum;
        }
        tmpArr[currNum - 1] = true;
    }

    return (tmpArr.findIndex((element) => element === undefined) + 1) || (tmpArr.length + 1);
}

Answer 22

Javascript 解决方案：

function solution(A) {
A = [...new Set(A.sort( (a,b) => a-b))];
for (let i in A) {
    let nextNum = A[+i+1];
    if(A[i] === nextNum) continue;
    if((nextNum - A[i]) != 1) {
        if(A[i] < 0 ) {
            if(A.indexOf(1) != -1) continue;
            return 1;
        }
        return A[i] + 1;
    }
}

}

Answer 23

Java解决方案- 内部方法解决方案

int N = A.length;

Set<Integer> set = new HashSet<>();
for (int a : A) {
    if (a > 0) {
        set.add(a);
    }
}

if(set.size()==0) {
    return N=1;
}

for (int i = 1; i <= N + 1; i++) {
    if (!set.contains(i)) {
        N= i;
        break;
    }
}
return N;

Answer 24

科特林得分为100分检测到的时间复杂度：O（N）或O（N * log（N））

fun solution(A: IntArray): Int {
    var min = 1
    val b = A.sortedArray()
    for (i in 0 until b.size) {
        if (b[i] == min) {
            min++
        }
    }
    return min
}

Answer 25

Objective-C示例：

 int solution(NSMutableArray *array) {
     NSArray* sortedArray = [array sortedArrayUsingSelector: @selector(compare:)];
     int x = 1;
     for (NSNumber *number in sortedArray) {

       if (number.intValue < 0) {
         continue;
       }
       if (x < number.intValue){
         return x;
       }
      x = number.intValue + 1;
     }

     return x;
}

Answer 26

function solution(A = []) {
    return (A && A
        .filter(num => num > 0)
        .sort((a, b) => a - b)
        .reduce((acc, curr, idx, arr) => 
            !arr.includes(acc + 1) ? acc : curr, 0)
        ) + 1;
}

solution（）; // 1 解决方案（空）; // 1 解（[]）; // 1 solution（[0，0，0]）; // 1

Answer 27

下面的代码将在O（N）时间和O（N）空间复杂度下运行。检查此codility链接以获取完整的运行报告。

程序首先将所有值放入HashMap中，同时在数组中查找最大值。这样做的原因是在提供的数组中仅包含唯一值，然后在恒定时间内对其进行检查。此后，另一个循环将运行，直到找到最大数目，并将返回数组中不存在的第一个整数。

   static int solution(int[] A) {
      int max = -1;
      HashMap<Integer, Boolean> dict = new HashMap<>();
      for(int a : A) {
         if(dict.get(a) == null) {
            dict.put(a, Boolean.TRUE);
         }
         if(max<a) {
            max = a;
         }
      }
      for(int i = 1; i<max; i++) {
         if(dict.get(i) == null) {
            return i;
         }
      }
      return max>0 ? max+1 : 1;
   }

Answer 28

在C＃中

static int solutionA(int[] A)
    {
        Array.Sort(A);

        int minNumber = 1;

        if(A.Max() < 0)
        {
            return minNumber;
        }

        for (int i = 0; i < A.Length; i++)
        {
            if (A[i] == minNumber)
            {
                minNumber++;
            }
            
            if (A[i] > minNumber)
            {
                break;
            }
        }

        return minNumber;
    }

100% Test Pass https://i.stack.imgur.com/FvPR8.png

Answer 29

Swift 版本使用函数而非迭代方法

“该解决方案获得了满分”-Codility

此解决方案使用函数而不是迭代方法。因此，解决方案在很大程度上依赖于语言的优化。可以在 Java 中完成类似的方法，例如使用Java的set操作和其他功能。

public func solution(_ A : inout [Int]) -> Int {
    let positives = A.filter{ $0 > 0}
    let max = positives.count <= 100_000 ? positives.count + 1 : 100_001
    return Set(1...max).subtracting(A).min() ?? -1
}

从源数组中获取所有正数。
基于正计数获得了所有可能的结果。如问题所述将集限制为100k。如果源数组是完整序列，则加1。
排除源数组的值后返回最小正数来自所有可能结果的元素。

注意：函数声明来自Codility，不需要inout。返回整数不允许使用零，因此使用-1。

Answer 30

使用Swift重写接受的答案。 Swift中的Hashset是Set。我认为如果需要索引作为返回值，则尝试使用Dictionary。

以100％的分数通过。

public func solution(_ A: [Int]) -> Int {
    let n = A.count
    var aSet = Set<Int>()
    
    for a in A {
        if a > 0 {
            aSet.insert(a)
        }
    }
    
    for i in 1...n+1 {
        if !aSet.contains(i) {
            return i
        }
    }
    
    return 1
}

Answer 31

首先让我在下面解释一下该算法。如果数组不包含任何元素，则返回1 然后在循环中检查数组的当前元素是否比上一个元素大2，然后找到第一个最小的丢失整数，将其返回。如果当前元素与上一个元素连续，则当前最小缺失整数为当前整数+ 1。

    Array.sort(A);

    if(A.Length == 0) return 1;

    int last = (A[0] < 1) ? 0 : A[0];

    for (int i = 0; i < A.Length; i++)
    {
        if(A[i] > 0){
            if (A[i] - last > 1) return last + 1;
            else last = A[i];
        } 
    }

    return last + 1;

Answer 32

没有排序或多余的内存。时间复杂度：O（N）

  public int solution(int[] A) {
        for (int i = 0; i < A.length; i++) {
            if (A[i] <= 0 || A[i] >= A.length) continue;
            int cur = A[i], point;
            while (cur > 0 && cur <= A.length && A[cur - 1] != cur) {
                point = A[cur - 1];
                A[cur - 1] = cur;
                cur = point;
                if (cur < 0 || cur >= A.length) break;
            }
        }
        for (int i = 0; i < A.length; i++) {
            if (A[i] != i+1) return i+1;
        }
        return A.length + 1;
    }

Answer 33

我的python解决方案的正确性为100％

def solution(A):

  if max(A) < 1:
    return 1

  if len(A) == 1 and A[0] != 1:
    return 1

  s = set()
  for a in A:
    if a > 0:
      s.add(a)
  
  
  for i in range(1, len(A)):
    if i not in s:
      return i

  return len(s) + 1

assert solution([1, 3, 6, 4, 1, 2]) == 5
assert solution([1, 2, 3]) == 4
assert solution([-1, -3]) == 1
assert solution([-3,1,2]) == 3
assert solution([1000]) == 1

Answer 34

这是我在Swift 4中的实现，得分为100％。它应该是Java中非常相似的代码。让我知道你的想法。

public func solution(_ A : inout [Int]) -> Int {
  let B = A.filter({ element in
    element > 0
  }).sorted()

  var result = 1
  for element in B {
    if element == result {
      result = result + 1
    } else if element > result {
      break
    }
  }

  return result
}

Answer 35

C＃解决方案：

    public int solution(int[] A)
    {
        int result = 1;

        // write your code in Java SE 8
        foreach(int num in A)
        {
            if (num == result)
               result++;

            while (A.Contains(result))
                result++;
        }

        return result;
    }

Answer 36

对于Swift 4

func solution(_ A : [Int]) -> Int {
     var positive = A.filter { $0 > 0 }.sorted()
     var x = 1
     for val in positive{
    // if we find a smaller number no need to continue, cause the array is sorted
    if(x < val) {
        return x
    }
    x = val + 1
}
return x

}

Answer 37

有效100％。在上述所有条件下进行测试。

//MissingInteger
    public int missingIntegerSolution(int[] A) {
        Arrays.sort(A);
        long sum = 0;
        for(int i=0; i<=A[A.length-1]; i++) {
            sum += i;
        }


        Set<Integer> mySet = Arrays.stream(A).boxed().collect(Collectors.toSet());
        Integer[] B = mySet.toArray(new Integer[0]);
        if(sum < 0)
            return 1;

        for(int i=0; i<B.length; i++) {
            sum -= B[i];
        }

        if(sum == 0) 
            return A[A.length-1] + 1;
        else
            return Integer.parseInt(""+sum);
    }

int[] j = {1, 3, 6, 4, 1, 2,5};

System.out.println("Missing Integer : "+obj.missingIntegerSolution(j));

输出缺少整数：7

int[] j = {1, 3, 6, 4, 1, 2};
System.out.println("Missing Integer : "+obj.missingIntegerSolution(j));

输出缺少整数：5

Answer 38

此解决方案在c＃中，但以100％的分数完成测试

public int solution(int[] A) {
    // write your code in C# 6.0 with .NET 4.5 (Mono)
    var positives = A.Where(x => x > 0).Distinct().OrderBy(x => x).ToArray();
    if(positives.Count() == 0) return 1;
    int prev = 0;
    for(int i =0; i < positives.Count(); i++){

        if(positives[i] != prev + 1){
            return prev + 1;
        }
         prev = positives[i];
    }
    return positives.Last() + 1;
}

Answer 39

    public int solution(int[] A) {

    int res = 0;
    HashSet<Integer> list = new HashSet<>();

    for (int i : A) list.add(i);
    for (int i = 1; i < 1000000; i++) {
        if(!list.contains(i)){
            res = i;
            break;
        }
    }
    return res;
}

Answer 40

package Consumer;


import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class codility {
public static void main(String a[])
    {
        int[] A = {1,9,8,7,6,4,2,3};
        int B[]= {-7,-5,-9};
        int C[] ={1,-2,3};
        int D[] ={1,2,3};
        int E[] = {-1};
        int F[] = {0};
        int G[] = {-1000000};
        System.out.println(getSmall(F));
    }
    public static int getSmall(int[] A)
    {
        int j=0;
        if(A.length < 1 || A.length > 100000) return -1;
        List<Integer> intList = Arrays.stream(A).boxed().sorted().collect(Collectors.toList());
         if(intList.get(0) < -1000000 || intList.get(intList.size()-1) > 1000000) return -1;
         if(intList.get(intList.size()-1) < 0) return 1;
        int count=0;         
         for(int i=1; i<=intList.size();i++)
         {
             if(!intList.contains(i))return i;
             count++;
         }
         if(count==intList.size()) return ++count;
        return -1;
    } 
}

Answer 41

我的JavaScript解决方案，使用reduce（）方法

function solution(A) {
  // the smallest positive integer = 1
  if (!A.includes(1)) return 1;

  // greater than 1
  return A.reduce((accumulator, current) => {
    if (current <= 0) return accumulator
    const min = current + 1
    return !A.includes(min) && accumulator > min ? min : accumulator;
  }, 1000000)
}

console.log(solution([1, 2, 3])) // 4
console.log(solution([5, 3, 2, 1, -1])) // 4
console.log(solution([-1, -3])) // 1
console.log(solution([2, 3, 4])) // 1

https://codesandbox.io/s/the-smallest-positive-integer-zu4s2

Answer 42

我的Java代码，100％导致Codility

import java.util.*;

class Solution {
   public int solution(int[] arr) {
     int smallestInt = 1; 

    if(arr.length == 0) return smallestInt;

    Arrays.sort(arr);

    if(arr[0] > 1) return smallestInt;
    if(arr[ arr.length - 1] <= 0 ) return smallestInt; 

    for(int i = 0; i < arr.length; i++){
        if(arr[i] == smallestInt){ 
         smallestInt++;}    
    }

    return smallestInt;
}

}

Answer 43

我的解决方案具有100％的性能，因此可以与Swift 4兼容。

func solution(_ A : [Int]) -> Int {
    let positive = A.filter { $0 > 0 }.sorted()
    var x = 1
    for val in positive{
        if(x < val) {
            return x
        }
        x = val + 1
    }
    return x
}

Answer 44

//My recursive solution:

class Solution {
    public int solution(int[] A) {
        return next(1, A);
    }
    public int next(int b, int[] A) {
        for (int a : A){
            if (b==a)
                return next(++b, A);
        }
        return b;
    }
}

Answer 45

如果空间复杂度为O(1)并且可以修改数组，则可能如下：

public int getFirstSmallestPositiveNumber(int[] arr) {
    // set positions of non-positive or out of range elements as free (use 0 as marker)
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] <= 0 || arr[i] > arr.length) {
            arr[i] = 0;
        }
    }

    //iterate through the whole array again mapping elements [1,n] to positions [0, n-1]
    for (int i = 0; i < arr.length; i++) {
        int prev = arr[i];
        // while elements are not on their correct positions keep putting them there
        while (prev > 0 && arr[prev - 1] != prev) {
            int next = arr[prev - 1];
            arr[prev - 1] = prev;
            prev = next;
        }
    }

    // now, the first unmapped position is the smallest element
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] != i + 1) {
            return i + 1;
        }
    }
    return arr.length + 1;
}

@Test
public void testGetFirstSmallestPositiveNumber() {
    int[][] arrays = new int[][]{{1,-1,-5,-3,3,4,2,8},
      {5, 4, 3, 2, 1}, 
      {0, 3, -2, -1, 1}};

    for (int i = 0; i < arrays.length; i++) {
        System.out.println(getFirstSmallestPositiveNumber(arrays[i]));
    }
}

输出：

5

6

2

Answer 46

我找到了另一种解决方案，以增加存储空间

/*
* if A = [-1,2] the solution works fine
* */
public static int solution(int[] A) {

    int N = A.length;

    int[] C = new int[N];

    /*
     * Mark A[i] as visited by making A[A[i] - 1] negative
     * */
    for (int i = 0; i < N; i++) {

        /*
         * we need the absolute value for the duplicates
         * */
        int j = Math.abs(A[i]) - 1;

        if (j >= 0 && j < N && A[j] > 0) {
            C[j] = -A[j];
        }
    }

    for (int i = 0; i < N; i++) {

        if (C[i] == 0) {
            return i + 1;
        }
    }

    return N + 1;
}

Answer 47

无需存储任何内容。无需哈希集。（额外的内存），您可以随心所欲在数组中移动。但是，必须对数组进行排序。而且我们知道最小的最大值是1

import java.util.Arrays;
class Solution {
    public int solution(int[] A) {
        Arrays.sort(A);     
        int min = 1; 
            int cap = A.length; //for efficiency — no need to calculate or access the array object’s length property per iteration 

        for (int i = 0; i < cap; i++){
            if(A[i] == min){
                min++;
            }
        }   
        //min = ( min <= 0 ) ? 1:min; //this means: if (min <= 0 ){min =1}else{min = min} you can also do: if min <1 for better efficiency/less jumps
        return min;    
    }
}

Answer 48

这是我在C ++中的解决方案。它获得了100％的得分（正确率100％，性能100％）（经过多次尝试；）。它基于将其值与其对应的索引进行比较的简单原理（经过一些预处理（例如排序）之后）。我同意您的解决方案做得太多；您不需要四个循环。

我的解决方案的步骤基本上是：

排序并删除所有重复项。这里有两种可能的方法，第一种利用std::sort，std::unique和erase，而第二种利用std::set的优势以及集合自身进行排序的事实并禁止重复
处理很多情况（我最初错过了这些，起初我的分数很低）。三种边缘情况是：
- 原始数组中的所有整数均为负数
- 原始数组中的所有整数均为正且大于1
- 原始数组中只有1个元素
对于每个元素，检查其值！=其索引+1。第一个为真的元素是最小的缺失正整数所在的位置。即如果vec.at(i) != i+1，则vec.at(i-1)+1是丢失的最小正整数。
如果vec.at(i) != i+1对于数组中的所有元素都是false，则数组的序列中没有“间隙”，并且最小的正int就是vec.back（）+ 1（第四个边缘情况为你会的。）

和代码：

int solution(vector<int>& rawVec)
{
    //Sort and remove duplicates: Method 1
    std::sort(rawVec.begin(), rawVec.end());
    rawVec.erase(std::unique(rawVec.begin(), rawVec.end()), rawVec.end());

    //Sort and remove duplicates: Method 2
    // std::set<int> s(rawVec.begin(), rawVec.end());
    // rawVec.assign(s.begin(), s.end());

    //Remove all ints < 1
    vector<int> vec;
    vec.reserve(rawVec.size());
    for(const auto& el : rawVec)
    {
        if(el>0)
            vec.push_back(el);
    }

    //Edge case: All ints were < 1 or all ints were > 1
    if(vec.size()==0 or vec.at(0) != 1)
        return 1;

    //Edge case: vector contains only one element
    if(vec.size()==1)
        return (vec.at(0)!=1 ? 1 : 2);

    for(int i=0; i<vec.size(); ++i)
    {
        if(vec.at(i) != i+1)
            return vec.at(i-1)+1;
    }
    return vec.back()+1;
}

Answer 49

此代码已用Java SE 8编写

import java.util.*;

public class Solution {
    public int solution(int[] A) {        

        int smallestPositiveInt = 1; 

        if(A.length == 0) {
            return smallestPositiveInt;
        }

        Arrays.sort(A);

        if(A[0] > 1) {
            return smallestPositiveInt;
        }

        if(A[A.length - 1] <= 0 ) {
            return smallestPositiveInt;
        }

        for(int x = 0; x < A.length; x++) {
            if(A[x] == smallestPositiveInt) { 
                smallestPositiveInt++;
             }    
        }

        return smallestPositiveInt;
    }
}

Answer 50

public static int solution(int[] A) {
    Arrays.sort(A);
    int minNumber = 1;
    int length = A.length - 1;
    int max = A[length];
    Set < Integer > set = new HashSet < > ();
    for (int i: A) {
        if (i > 0) {
            set.add(i);
        }
    }
    for (int j = 1; j <= max + 1; j++) {
        if (!set.contains(j)) {
            minNumber = j;
            break;
        }
    }
    return minNumber;
}

Answer 51

无排序，100％得分和O（N）运行时的JavaScript解决方案。它会在找到最大值的同时建立一个正数的哈希集。

function solution(A) {
    set = new Set()
    let max = 0
    for (let i=0; i<A.length; i++) {
        if (A[i] > 0) {
            set.add(A[i])
            max = Math.max(max, A[i])
        }
    }

    for (let i=1; i<max; i++) {
        if (!set.has(i)) {
            return i
        }
    }
    return max+1
}

Answer 52

最近加入对话。基于：

https://codereview.stackexchange.com/a/179091/184415

即使输入中包含重复的整数，对于此问题确实存在O（n）复杂度的解决方案：

solution(A)
Filter out non-positive values from A
For each int in filtered
    Let a zero-based index be the absolute value of the int - 1
    If the filtered range can be accessed by that index  and  filtered[index] is not negative
        Make the value in filtered[index] negative

For each index in filtered
    if filtered[index] is positive
        return the index + 1 (to one-based)

If none of the elements in filtered is positive
    return the length of filtered + 1 (to one-based)

So an array A = [1, 2, 3, 5, 6], would have the following transformations:

abs(A[0]) = 1, to_0idx = 0, A[0] = 1, make_negative(A[0]), A = [-1,  2,  3,  5,  6]
abs(A[1]) = 2, to_0idx = 1, A[1] = 2, make_negative(A[1]), A = [-1, -2,  3,  5,  6]
abs(A[2]) = 3, to_0idx = 2, A[2] = 3, make_negative(A[2]), A = [-1, -2, -3,  5,  6]
abs(A[3]) = 5, to_0idx = 4, A[4] = 6, make_negative(A[4]), A = [-1, -2, -3,  5, -6]
abs(A[4]) = 6, to_0idx = 5, A[5] is inaccessible,          A = [-1, -2, -3,  5, -6]

A linear search for the first positive value returns an index of 3. Converting back to a one-based index results in solution(A)=3+1=4

这是建议的算法在C＃中的实现（将其转换为Java语言应该很简单-减少了一些懈怠的习惯）：

public int solution(int[] A)
{
    var positivesOnlySet = A
        .Where(x => x > 0)
        .ToArray();

    if (!positivesOnlySet.Any())
        return 1;

    var totalCount = positivesOnlySet.Length;
    for (var i = 0; i < totalCount; i++) //O(n) complexity
    {
        var abs = Math.Abs(positivesOnlySet[i]) - 1;
        if (abs < totalCount && positivesOnlySet[abs] > 0) //notice the greater than zero check 
            positivesOnlySet[abs] = -positivesOnlySet[abs];
    }

    for (var i = 0; i < totalCount; i++) //O(n) complexity
    {
        if (positivesOnlySet[i] > 0)
            return i + 1;
    }

    return totalCount + 1;
}

Answer 53

kotlin 中使用 set 的解决方案。

空间复杂度：O(N)
时间复杂度：O(N)

fun solutionUsingSet(A: IntArray): Int {
    val set = HashSet<Int>()
    A.forEach {
        if (it > 0) {
            set.add(it)
        }
    }
    // If input array has no positive numbers
    if (set.isEmpty()) {
        return 1
    }
    for (i in 1 until A.size + 1) {
        if (!set.contains(i)) {
            return i
        }
    }
    // If input array has all numbers from 1 to N occurring once
    return A.size + 1
}

Answer 54

以下C ++解决方案得分为100％。代码的理论复杂度是。时间复杂度：O（N）因哈希集而摊销，而O（N）的辅助空间复杂度则归因于在O（1）时间中使用哈希进行查找。

OS

Answer 55

您可以简单地使用它，它是Insertion-Sort的一种变体，不需要Set或对整个数组进行排序。

    public static int solution(int[] A) {
    //we can choose only positive integers to enhance performance
        A = Arrays.stream(A).filter(i -> i > 0).toArray();
        for(int i=1; i<A.length; i++){
            int v1 = A[i];
            int j = i-1;
            while (j > -1 && A[j] > v1) {
                A[j + 1] = A[j];
                j = j - 1;
            }
            A[j + 1] = v1;
            if(A[i] - A[i-1] > 1){
                return A[i] + 1;
            }
        }
        return 1;
    }

Answer 56

解决方案的Python实现。获取数组的集合-这确保我们只有唯一的元素。然后继续检查，直到该值不存在于集合中-打印下一个值作为输出并将其返回。

def solution(A):
# write your code in Python 3.6
    a = set(A)
    i = 1
    while True:
        if i in A:
            i+=1
        else:
            return i
    return i
    pass

Answer 57

我认为使用诸如：set或dict的结构来存储唯一值不是更好的解决方案，因为您要么在循环内寻找导致O（N * N）复杂性的元素，要么使用另一个循环来验证遗漏的值，使您的线性复杂度为O（N），但花费的时间却不止1个循环。

对于存储空间，使用计数器阵列结构都不是最佳选择，因为即使阵列只有一项，您最终仍要分配内存的MaxValue块。

因此，我认为最好的解决方案仅使用一个for循环，避免使用结构，并在不再需要时实施条件以停止迭代：

public int solution(int[] A) {
    // write your code in Java SE 8
    int len = A.length;
    int min=1;

    Arrays.sort(A);

    if(A[len-1]>0)
    for(int i=0; i<len; i++){
        if(A[i]>0){
            if(A[i]==min) min=min+1;
            if(A[i]>min) break;
        }
    }
    return min;
}

这样，您将获得O（N）或O（N * log（N））的复杂度，因此在更好的情况下，您将处于O（N）复杂度下

Answer 58

这可能会对您有所帮助，它应该可以正常工作！

public static int sol(int[] A)
{
    boolean flag =false;
    for(int i=1; i<=1000000;i++ ) {
        for(int j=0;j<A.length;j++) {
            if(A[j]==i) {
                flag = false;
                break;
            }else {
                flag = true;
            }
        }
        if(flag) {
            return i;
        }
    }
    return 1;
}

Answer 59

下面是我的解决方法

int[] A = {1,2,3};
Arrays.sort(A);
Set<Integer> positiveSet = new HashSet<>();
for(int a: A) {
    if(a>0) {
        positiveSet.add(a);
    }
}
for(int a: A) {
    int res = a+1;
    if(!positiveSet.contains(res)) {
        System.out.println("result : "+res);
        break;
    }
}

Answer 60

这是C＃中的解决方案：

using System;
// you can also use other imports, for example:
using System.Collections.Generic;

// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");

class Solution {
public int solution(int[] A) {
    // write your code in C# 6.0 with .NET 4.5 (Mono)
int N = A.Length;
HashSet<int> set =new HashSet<int>();
foreach (int a in A) {
if (a > 0) {
    set.Add(a);
    }
}
for (int i = 1; i <= N + 1; i++) {
if (!set.Contains(i)) {
    return i;
    }
}
return N;
}
}

Answer 61

使用while循环的最简单方法：

fun solution(A: IntArray): Int {
    var value = 1
    var find = false
    while(value < A.size) {
        val iterator = A.iterator()
        while (iterator.hasNext()) {
            if (value == iterator.nextInt()) {
                find = true
                value++
            }
        }
        if (!find) {
            break
        } else {
            find = false
        }
    }
    return value
}

Answer 62

Python 中最短的答案。 100%

def solution(A):
   return min([x for x in range(1,len(A) + 2) if x not in set(sorted([x for x in A if x>0 ]))])

Answer 63

尝试使用此代码对我有用

import java.util.*;
    class Solution {
        public static int solution(int[] A) {
            // write your code in Java SE 8
            int m = Arrays.stream(A).max().getAsInt(); //Storing maximum value 
            if (m < 1) // In case all values in our array are negative 
            { 
                return 1; 
            } 
            if (A.length == 1) { 

                //If it contains only one element 
                if (A[0] == 1) { 
                    return 2; 
                } else { 
                    return 1; 
                } 
            } 
            int min = A[0];
            int max= A[0];
            int sm = 1;

            HashSet<Integer> set = new HashSet<Integer>();

            for(int i=0;i<A.length;i++){
                set.add(A[i]);

                if(A[i]<min){
                    min = A[i];
                }
                if(A[i]>max){
                    max = A[i];
                }
            }

            if(min <= 0){
                min = 1;
            }

            if(max <= 0){
                max = 1;
            }

            boolean fnd = false;
            for(int i=min;i<=max;i++){
                if(i>0 && !set.contains(i)){
                    sm = i;
                    fnd = true;
                    break;
                }
                else continue;

            }
            if(fnd)
                return sm; 
            else return max +1;
        }

              public static void main(String args[]){

               Scanner s=new Scanner(System.in);

            System.out.println("enter number of elements");

            int n=s.nextInt();

            int arr[]=new int[n];

            System.out.println("enter elements");

            for(int i=0;i<n;i++){//for reading array
                arr[i]=s.nextInt();

            }

        int array[] = arr;

        // Calling getMax() method for getting max value
        int max = solution(array);
        System.out.println("Maximum Value is: "+max);

      }
    }

Answer 64

我正在考虑另一种方法（JS、JavaScript）并且由于性能问题得到了 66% 的结果：

    const properSet = A.filter((item) => { return item > 0 });
    let biggestOutsideOfArray = Math.max(...properSet);
    
    if (biggestOutsideOfArray === -Infinity) {
       biggestOutsideOfArray = 1;
    } else {
        biggestOutsideOfArray += 1;
    }
    
   for (let i = 1; i <= biggestOutsideOfArray; i++) {
       if(properSet.includes(i) === false) {
           return i;
       }
   } 
}

Answer 65

只玩循环怎么样。

import java.util.Arrays;
public class SmallestPositiveNumber {

    public int solution(int[] A) {
        Arrays.sort(A);
        int SPI = 1;

        if(A.length <= 1) return SPI;

        for(int i=0; i<A.length-1; i++){

            if((A[i+1] - A[i]) > 1)
            {
                return A[i] + 1;
            }
        }
        return A[A.length-1]+1;
    }
}

Answer 66

此解决方案使用Javascript，但以100％的分数和更少的代码完成测试

function solution(A) {
    let s = A.sort((a, b) => { return a - b })
    let x = s.find(o => !s.includes(o+1) && o>0)
    return ((x<0) || !s.includes(1)) ? 1 : x+1
}

Answer 67

这是我在 Java 上的解决方案：

public int solution(int[] A) {

   int smallestPositiveInteger = 1;
        
   Arrays.sort(A);

   if(A[0] <= 0) return smallestPositiveInteger;

      for( int i = 0; i < A.length; i++){
          if(A[i] == smallestPositiveInteger)
            smallestPositiveInteger++;
      }    

      return smallestPositiveInteger;
}

Answer 68

100% 的 Java 编码准确性

    public int solution(int[] A) {
        // write your code in Java SE 8

     Arrays.sort(A);
    int i=1;
    for (int i1 = 0; i1 < A.length; i1++) {
      if (A[i1] > 0 && i < A[i1]) {
        return i;
      }else if(A[i1]==i){
         ++i;
      }

    }
    return i;
    }

Answer 69

不是最好的C ++，但它的得分为100％https://app.codility.com/demo/results/demoCNNMBE-B5W/

// you can use includes, for example:
#include <algorithm>
#include <iostream>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

template <class T>
bool allneg(const T start, const T end) {
    T it;
    for (it = start; it != end; it++) {
        if (*it >= 0) return false;
    }

    return true;
}

int solution(vector<int> &A) {
    if(A.empty()) throw std::invalid_argument("unexpected empty vector");

    std::sort(A.begin(),A.end());
    /*
    for(size_t i = 0; i < A.size(); i++) {
        std::cout << A[i] << ", ";
    }*/
    if(allneg(A.begin(),A.end())){
        return 1;
    }
    int v = 1;
    auto it = A.begin();
    while(it!=A.end()){
        if(std::binary_search(it,A.end(),v)){
            v++;
        } else {
            return v;
        }
        it++;
    }
    return v;
}

基于Fastest way to find smallest missing integer from list of integers，并且比上述https://app.codility.com/demo/results/demoCJ7MDF-CDD/稍快

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    std::vector<bool> negative(1000000,false);
    std::vector<bool> non_negative(1000000+1,false);
    bool contain_negative = false;
    bool contain_non_negative = false;
    for(int a : A){
        if(a<0) {
            negative[-a] = true;
            contain_negative = true;
        } else {
            non_negative[a] = true;
            contain_non_negative = true;
        }
    }
    int result = 1;
    if(contain_negative && !contain_non_negative){
        return result;
    } else {
        for(size_t i = 1; i < non_negative.size(); i++){
            if(!non_negative[i]){
                result = i;
                break;
            }
        }
    }
    return result;
}

Answer 70

在C＃中，bur需要改进。

    public int solution(int[] A) {
          int retorno = 0;
          for (int i = 0; i < A.Length; i++)
            {
                int ultimovalor = A[i] + 1;
                if (!A.Contains(ultimovalor))
                {
                    retorno = (ultimovalor);
                    if (retorno <= 0) retorno = 1;
                }
            }
            return retorno;
    }

Answer 71

我的解决方案：

  public int solution(int[] A) {
        int N = A.length;
        Set<Integer> set = new HashSet<>();
        for (int a : A) {
            if (a > 0) {
                set.add(a);
            }
        }
        for (int index = 1; index <= N; index++) {
            if (!set.contains(index)) {
                return index;
            }
        }
        return N + 1;
    }

Answer 72

此解决方案以O（N）复杂度运行，并且涵盖了所有极端情况。

   public int solution(int[] A) {
        Arrays.sort(A);
        //find the first positive integer
        int i = 0, len = A.length;
        while (i < len && A[i++] < 1) ;
        --i;

        //Check if minimum value 1 is present
        if (A[i] != 1)
            return 1;

        //Find the missing element
        int j = 1;
        while (i < len - 1) {
            if (j == A[i + 1]) i++;
            else if (++j != A[i + 1])
                return j;
        }

        // If we have reached the end of array, then increment out value
        if (j == A[len - 1])
            j++;
        return j;
    }

Answer 73

这是我使用Java的方法。该答案的时间复杂度为2 * O（N），因为我对数组A进行了两次迭代。

import java.util.HashMap;

public static final Integer solution(int[] A) {
    HashMap<Integer, Integer> map = new HashMap<>(A.length); //O(n) space

    for (int i : A) {
        if (!map.containsKey(i)) {
            map.put(i, i);
        }
    }

    int minorPositive = 100000;
    for (int i : A) {
        if (!map.containsKey(i + 1)) {
            if (i < minorPositive) {
                minorPositive = i + 1;
            }
        }
    }

    if (minorPositive < 0){
        minorPositive = 1;
    }
    return minorPositive;

}

Answer 74

最短的PHP解决方案

function solution($A) {
    // write your code in PHP7.0
    $lastNum = 1;

    while(in_array($lastNum, $A)) {
        $lastNum++;
    }

    return $lastNum;
}

Answer 75

我在Ruby中的答案

def smallest_pos_integer(arr)
  sorted_array = arr.select {|x| x >= 1}.sort
  res = 1

  for i in (0..sorted_array.length - 1)
    if res < sorted_array[i]
      return res
    end
    res = sorted_array[i] + 1
  end
  res
end

Answer 76

我还没有看到使用Linq的C＃解决方案...以下是我认为获得100％通过测试的最简单方法：

using System;
using System.Linq;

class Solution {
    public int solution(int[] A) => Enumerable.Range(1, 100001).Except(A).Min();
}

但是，我应该注意，尽管以上内容很简单，并且可以100％通过测试，但这并不是最有效的。对于更有效的Linq解决方案，以下类似方法会更好地工作：

using System;
using System.Collections.Generic;

public static int solution(int[] A)
{
    var set = new HashSet<int>(A);

    return Enumerable.Range(1, A.Length + 1).First(i => !set.Contains(i));
}

Answer 77

JavaScript解决方案

function solution(A) {
    let smallestInt = 1;

    function existsInArray(val) {
        return A.find((a) => a === val);
    }

    for (let index = smallestInt; index < 1000000; index++) {
        if (existsInArray(index) && !existsInArray(index + 1) &&
            existsInArray(smallestInt)) {
            smallestInt = index + 1
        }
    }
    return smallestInt;
}

Answer 78

<JAVA> Try this code-

private int solution(int[] A) {//Our original array

        int m = Arrays.stream(A).max().getAsInt(); //Storing maximum value
        if (m < 1) // In case all values in our array are negative
        {
            return 1;
        }
        if (A.length == 1) {

            //If it contains only one element
            if (A[0] == 1) {
                return 2;
            } else {
                return 1;
            }
        }
        int i = 0;
        int[] l = new int[m];
        for (i = 0; i < A.length; i++) {
            if (A[i] > 0) {
                if (l[A[i] - 1] != 1) //Changing the value status at the index of our list
                {
                    l[A[i] - 1] = 1;
                }
            }
        }
        for (i = 0; i < l.length; i++) //Encountering first 0, i.e, the element with least value
        {
            if (l[i] == 0) {
                return i + 1;
            }
        }
        //In case all values are filled between 1 and m
        return i+1;
    }
Input: {1,-1,0} , o/p: 2
Input: {1,2,5,4,6}, o/p: 3
Input: {-1,0,-2}, o/p: 1

Answer 79

在PHP中，我可以通过几行代码来实现。

function solution($A) {
  for($i=1; in_array($i,$A); $i++);
  return $i;    
}

Answer 80

使用.reduce()

public func solution(_ A : inout [Int]) -> Int {
    return A.filter { $0 > 0 }.sorted().reduce(1) { $0 < $1 ? $0 : $1 + 1}
}

Answer 81

我在Swift上尝试过，并获得了100％的收益。

public func solution(_ A : inout [Int]) -> Int {
// write your code in Swift 4.2.1 (Linux)
if A.count == 0 {
    return 1
}
A = A.sorted()
if A[A.count - 1] <= 0 {
    return 1
}

var temp = 1

for numb in A {

    if numb > 0 {

        if numb == temp {
            temp += 1
        }else if numb != (temp - 1) {
            return temp
        }
    }
}

return temp

}

Answer 82

对于JavaScript，我会这样做：

function solution(arr)
{
    let minValue = 1;

    arr.sort();

    if (arr[arr.length - 1] > 0)
    {
        for (let i = 0; i < arr.length; i++)
        {
            if (arr[i] === minValue)
            {
                minValue = minValue + 1;
            }
            if (arr[i] > minValue)
            {
                break;
            }
        }
    }

    return minValue;
}

使用以下示例数据对其进行了测试：

console.log(solution([1, 3, 6, 4, 1, 2]));
console.log(solution([1, 2, 3]));
console.log(solution([-1, -3]));

Answer 83

我在Ruby上的解决方案

def solution(a)
  p = {}
  b = 1
  a.each do |n|
    p[n] = n
    b = n if n > b
  end

  nb = b
  (b-1).downto(1) do |n|
    unless p[n]
      nb = n
      break
    end
  end  
  (nb == b) ? b+1 : nb
end

puts solution([1,3,5,4,1,2,6])
puts solution([1,3,6,4,1,2,5])
puts solution([1,2,3])

Answer 84

// Codility Interview Question Solved Using Javascript

const newArray = []; //used in comparison to array with which the solution is required

const solution = (number) => {
  //function with array parameter 'number'
  const largest = number.reduce((num1, num2) => {
    return num1 > num2
      ? num1
      : num2; /*finds the largest number in the array to
                                   be used as benchmark for the new array to
                                   be created*/
  });

  const range = 1 + largest;
  for (
    let x = 1;
    x <= range;
    x++ //loop to populate new array with positive integers
  ) {
    if (x > range) {
      break;
    }
    newArray.push(x);
  }
  console.log("This is the number array: [" + number + "]"); //array passed
  console.log("This is the new array: [" + newArray + "]"); //array formed in relation to array passed
  const newerArray = newArray.filter((elements) => {
    //array formed frome unique values of 'newArray'
    return number.indexOf(elements) == -1;
  });
  console.log(
    "These are numbers not present in the number array: " + newerArray
  );

  const lowestInteger = newerArray.reduce((first, second) => {
    //newerArray reduced to its lowest possible element by finding the least element in the array
    return first < second ? first : second;
  });
  console.log("The lowest positive integer is " + lowestInteger);
};
solution([1, 2, 3, 4, 6]); //solution function to find the lowest possible integer invoked

Answer 85

通过以下Python解决方案，我达到了100％的目标：-

def solution(A):
   a=frozenset(sorted(A))
   m=max(a)
   if m>0:
       for i in range(1,m):
           if i not in a:
              return i
       else:
          return m+1
   else:
       return 1

Answer 86

下面的代码更简单，但我的动机是为JavaScript，ES6用户编写代码：

function solution(A) {

    let s = A.sort();
    let max = s[s.length-1];
    let r = 1;

    for(let i=1; i <= (max + 1); i++) {
        r  = A.includes(i) ? 1 : i ;
        if(r>1) break;
    }

    return r;
}

Answer 87

我的Java解决方案获得了100％的收益。我觉得这很简单，复杂度是O（n）。

public int solution(int[] A) {
    Integer s = 1;
    List<Integer> list = new ArrayList<>();

    for (int i : A) {
        if (i>0) {
            list.add(i);
        }
    }

    Collections.sort(list);

    for (int i : list) {
        if (s < i) {
            return s;
        }
        s = i + 1;
    }

    return s;
}

让我知道我们是否可以进一步改进。

Answer 88

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public int solution(int[] A) {
    int size=A.length;
    int min=A[0];
    for(int i=1;i<=size;i++){
        boolean found=false;
        for(int j=0;j<size;j++){
            if(A[j]<min){min=A[j];}
            if(i==A[j]){
                found=true;
            }
        }
            if(found==false){
                return i;

            }
        }

    if(min<0){return 1;}
        return size+1;



    }
}

Answer 89

完成此任务的简单方法！

public int  findNearestPositive(int array[])
{
    boolean isNegative=false;
    int number=0;
    int value=0;

    if(array[0]<=0 && array[array.length-1]<0)
    {
    return 1;


    }

    for(int i=0;i<array.length;i++)
    {
    value=i+1;
    isNegative=false;

    for(int j=0;j<array.length;j++)
    {
    if(value==array[j])
    {
    isNegative=true;

    }

    }

    if(isNegative!=true)
    {
    if(number==0){

    number=value;
    }else if(value<number){
    number=value;
    }

    }               

    }


    if(number==0)
    {

    number=value+1;
    }

    return number;

}

Answer 90

def solution(A):
A = sorted(filter(lambda x: x >= 0, A))
if A is []:
    return 1
for i in range(1, 100000):
    if i not in A:
        return i

Answer 91

这对于Java非常有效。它使用按位异或和赋值运算符

    public int solution(int[] A) {
        // write your code in Java SE 8
        int sol = 0;
        for(int val:A){
            sol ^= val;
        }
        return sol;
    }
}

查找在给定序列中不出现的最小正整数

91 个答案: