Question

今天下午，我尝试解决Codility的演示测试。在考虑了很多如何提高性能（并进行了一些搜索）之后，我创建了以下代码：

function solution(A) {
    let array = [...Array(1000001).keys()];

    const onlyPositives = A.filter(n => n>0);
    if(onlyPositives.length == 0) return 1

    onlyPositives.forEach(a => {
        if(array[a] != null)
            array[a] = null;
    });
    array[0] = null;

   return array.findIndex(e => e != null);
}

有人有另一个主意吗？

Answer 1

O（n）解决方案javascript。使用两个循环。第一个循环将所有大于零的元素放入地图/对象第二循环检查值是否存在于地图中。

function solution(A) {
    let obj = {};
    let min = 1;

   //iterate over all items in the array and store the value in a object;
    for (let i = 0, len=A.length; i < len; i++) {
        const num = A[i];
        if (num > 0) {
            obj[num] = true;
        }
    }
    //start with min===1 check if it's in the object
    // if it is if it's in the object then increment min and repeat until min not in object.
    while (obj[min]) {
        min++;
    }
    //this will return the smallest value not in array bigger or equal to 1
    return min;
}

Answer 2

function solution(A) {
    const numbers = []

    for (let i = 0; i < A.length; i++) {
        numbers[A[i]] = true
    }

    if (numbers.length === 0) {
        return 1   
    }

    for (let i = 1; i < numbers.length; i++) {
        if(numbers[i] === undefined) {
            return i
        }
    }

    return numbers.length
}

Answer 3

还有，您可以使用相同的代码而无需过滤，但在某些情况下有效的代码较少。

function solution(A) {
    let array = [...Array(1000001).keys()];

    A.forEach(a => {
        if(array[a] != null)
            array[a] = null;
    });
    array[0] = null;

   return array.findIndex(e => e != null);
}

Answer 4

另一种方法可能是对数组进行排序并搜索第一个空位：

function solution(arr) {
  arr.sort((a, b) => a - b);
  for(var i = 1; i < arr.length; i++) {
    if(arr[i] >= 0 && arr[i] - arr[i - 1] <= 1) 
       return arr[i - 1] + 1;
  }
  return arr[i - 1] + 1;
}

Answer 5

问题

编写函数：int solution（NSMutableArray * A）;

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

例如

Given A = [1, 3, 6, 4, 1, 2], the function should return 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]范围内的整数。

目标C解决方案O（N）

Codility提供的结果

任务得分：100％
正确性：100％
效果：100％

时间复杂度

最差的时间复杂度是O（N）或O（N * log（N））

Xcode Solution Here

+(int)solution:(NSMutableArray*)array {

    /******** Algorithm Explanation  ********/
    // STEP 1
    //       Check for edge cases - when the array is empty [], we should return 1
    // STEP 2
    //       Generate NSSet from the Array in oder to eliminate possible duplicates
    // STEP 3
    //      Implement a loop taking in consideration:
    //          N always starts from 1 and so on (1,2,3...n)
    //          There is always one missing element in the array
    //          So, in the Array we sould have N => (1,2,3...n+1)
    //
    // STEP 4
    //      Look for the current element in the SET
    //      If the element does't exist, that means we have found the smallest one missing element.
    //      Break the loop.


    // STEP 1
    int smallestCandidate = 0;
    int n = (int)[array count];
    if (n==0) {
        smallestCandidate = 1;
    }
    else {
        // STEP 2
        NSSet *elements = [NSSet setWithArray:array];

        // STEP 3
        for (int i=1; i<=(n+1); i++) {
            BOOL exist = [elements containsObject:@(i)];
            if(!exist) {
                // STEP 4
                smallestCandidate = i;
                return smallestCandidate;
            }
        }
    }
    return smallestCandidate;
}

Answer 6

另一种处理积极事物的方法。我的JS解决方案获得了100个全面支持。基本上，我会生成一个新数组，其键将是原始数组的值，并将每个值设置为真实值。这有两件事：将负值带出新数组的迭代循环，还允许您从最小值开始循环并返回给您未定义的第一个索引。

function solution(A) {
    orderedArr = [];
    for (let i = 0; i < A.length; i++) {
        if (!orderedArr[A[i]]) {
            orderedArr[A[i]] = true;
         }
    }
    if (orderedArr.length === 0) return 1;
    for (let i = 1; i < orderedArr.length; i++) {
        if (!orderedArr[i]) {
            return i;
        }
    }
    return orderedArr.length;
}

Answer 7

这是解决方案的Java 8版本，提交后结果为100％。我使用HashSet消除了重复元素。

import java.util.*;

类解决方案{

public int solution（int [] A）{

    // sort the array
    Arrays.sort(A);
    int len = A.length;

    int result = 1;

    if (len == 0) {
        result = 1;
    }else {
        // populate hashset from the array to eliminate duplicate
        HashSet<Integer> aSet = new HashSet<Integer>();
        for(int i=0; i<len; i++) {
            aSet.add(A[i]);
        }

        // now loop through from 1 to len in the array and check if index exists
        for(int j=1; j<len+1;j++) {
            boolean exists = aSet.contains(j);
            if(!exists) {
                result = j;
                break;
            }else {
                if(j>0) {
                    result = j+1;
                }
            }
        }
    }

    return result;

}

}

Answer 8

这是我的 100% 高性能解决方案

function solution(A) {
    let missingInteger = 1;
    A = A.sort((a, b) => a - b);
    for(let i = 0; i < A.length; i++){
        if(A[i] == missingInteger ) missingInteger++;
        if(A[i] > missingInteger) return missingInteger;
    }
    return missingInteger;
}

Codility MissingInteger Javascript解决方案（建议）

8 个答案: