Question

一个代码问题要求在零索引数组A中找到由N个不同整数组成的缺失数字。

E.g。

  Arr[0] = 2
  Arr[1] = 3
  Arr[2] = 1
  Arr[3] = 4
  Arr[4] = 6

我之前提交了一个解决方案，首先对数组进行排序，然后执行forEach函数返回值+1，其中元素之间的数组差异大于1，但这不会得到100分。

有没有办法改善这个？

Answer 1

使用此功能获得100的正确性和性能

function solution(A) {
    // write your code in JavaScript (Node.js 4.0.0)
    var size = A.length;
    var sum = (size + 1) * (size + 2) / 2;
    for (i = 0; i < size; i++) {
        sum -= A[i];
    }
    return sum;
}

Answer 2

如果您使用高斯公式计算前N个连续数字的总和，则很容易：


    function solution(A) {
        var np1, perfectSum, sum;

        if (!A || A.length == 0) {
            return 1;
        }

        np1 = A.length + 1;

        // Gauss formula
        perfectSum = np1 * (1 + np1) / 2;

        // Sum the numbers we have
        sum = A.reduce((prev, current) => prev + current);

        return perfectSum - sum;
    }

Answer 3

没有高斯公式，只有简单且简单的 for 循环，给出 O(N) 或 O(N * log(N)) 和 100% 分数：

function solution(A) {

    if(!A.length){
        return 1; //Just because if empty this is the only one missing.
    }

    let fullSum = 0;
    let sum = 0;

    for(let i = 0; i <= A.length; i++){
        fullSum += i+1;
    }

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

    return fullSum - sum;

}

Answer 4

尝试使用Math.min，Math.max，while循环

var Arr = [];

Arr[0] = 2
Arr[1] = 3
Arr[2] = 1
Arr[3] = 4
Arr[4] = 6

var min = Math.min.apply(Math, Arr),
  max = Math.max.apply(Math, Arr),
  n = max - 1;

while (n > min) {

  if (Arr.indexOf(n) === -1) {
    console.log(n);
    break;
  } 

  --n;

}

Answer 5

这是100％的javascript解决方案：

function solution(A) {
    if (!A.length) return 1;
    let n = A.length + 1;
    return (n + (n * n - n) / 2) - A.reduce((a, b) => a + b);
}

如果给定数组为空，则返回1，这是空数组中缺少的元素。

接下来，假设序列中的第一个元素始终为1，我们将计算“常规”序列之和。然后，找到给定数组与完整序列之间的差，然后将其返回。这是缺少的元素。

我在这里使用的数学函数是序列和，以及最后一个元素：

S _n =（n / 2）*（a ₁ + a _n）
a _n = a ₁ +（n-1）* d

Answer 6

根据第一个自然数公式的总和

现在，由于任务中对我们来说N项是（N + 1），因此我们将n替换为n + 1并得到

使用上面的公式，我们可以计算1到n + 1之间的数字总和，因为在这些数字之间有缺失的数字，现在我们可以做的是开始遍历给定数组A并减去数组项从数字的总和。期末和是数组中缺少的项目。因此：

function solution(A) {

    var n = A.length;

    // using formula of first natural numbers 
    var sum = (n + 1) * (n + 2) / 2;

    for (var i = 0; i < n; i++) {
        sum -= A[i];
    }

    return sum;
}

Answer 7

这应该很好：

function solution(A) {

      // Size of the A array
      const size = A.length;

      // sum of the current values
      const arrSum = A.reduce((a, b) => a + b, 0);

      // sum of all values including the missing number
      const sum = (size + 1) * (size + 2) / 2;

      // return substruction of all - current
      return (sum - arrSum);

    }

Answer 8

这让我100％

function solution(A) {
if (A.length === 0 || !A) {
    return 1;
}

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

}

Answer 9

我得到了另一种没有高斯公式的100％正确性/性能解决方案，而是先对数组进行排序：

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

Answer 10

我的代码遇到了同样的问题：

function solution(A) {
    var i, next;

    A.sort();

    next = 1;
    for (i=0; i<A.length; i++){
        if (A[i] != next) return next;
        next++;
    }

    return next;
}

尽管它的正确性得分为100％，但它在所有性能测试中都给出了错误答案。

C中的相同代码在两者上都获得100％：

int cmpfunc (const void * a, const void * b){
   return ( *(int*)a - *(int*)b );
}

int solution(int a[], int n) {
    int i, next;

    qsort(a, n, sizeof(int), cmpfunc);

    next = 1;
    for (i=0; i<n; i++){
        if (a[i] != next) return next;
        next++;
    }

    return next;
}

Javascript中的Codility“PermMissingElem”解决方案

11 个答案: