这个解决方案有什么问题？ （Perm-Missing-Elem codility test）

Question

我已经开始玩讽刺并遇到了这个问题：

  

给出了由N个不同整数组成的零索引数组A.   该数组包含[1 ..（N + 1）]范围内的整数，表示   只缺少一个元素。

     

您的目标是找到缺少的元素。

     

写一个函数：

int solution(int A[], int N); 

     

给定零索引数组A，返回缺失的值   元件。

     

例如，给定数组A使得：

     

A [0] = 2 A [1] = 3 A [2] = 1 A [3] = 5

     

该函数应该返回4，因为它是缺少的元素。

     

假设：

    N is an integer within the range [0..100,000];
    the elements of A are all distinct;
    each element of array A is an integer within the range [1..(N + 1)].

     

复杂度：

    expected worst-case time complexity is O(N);
    expected worst-case space complexity is O(1), beyond input storage (not counting the storage required for input arguments).

我已经提交了以下解决方案（在PHP中）：

function solution($A) {
    $nr = count($A);
    $totalSum = (($nr+1)*($nr+2))/2;
    $arrSum = array_sum($A);
    return ($totalSum-$arrSum);
}

这给了我66分的100分，因为它涉及大型数组的测试失败： “large_range范围序列，长度= ~100,000” 结果： RUNTIME ERROR 测试程序意外终止 标准输出： 结果类型无效，预期为int。

我在本地测试了100,000个元素的数组，并且它没有任何问题。那么，我的代码似乎是什么问题以及什么样的测试用例使用codility来返回“无效的结果类型，int expected”？

Answer 1

PermMissingElem的100/100 php解决方案：

function solution($A) {   
    $N   = count($A);
    $sum = ($N + 2) * ($N + 1) / 2;
    for($i = 0; $i < $N; $i++){
        $sum -= $A[$i];
    }
    return intval($sum);
}

Answer 2

其他人已经回答了原来的问题，但我想更深入地了解这个问题并在C ++中分享一个快速的替代解决方案。

当然，解决方案是基于旧的算法技巧来加入大量连续数字，着名的归功于卡尔·弗里德里希·高斯（Carl Friedrich Gauss）在他还是个小男孩时发现它。

由于N> 65,536的乘法超过32位精度，OP遇到整数溢出问题。这是一个小技巧，以避免在给定范围的N = [0..100,000]。 当计算[1..N + 1]中数字的所有整数之和（高斯和）时，我们减去（N + 2）/ 2的偏移量，使其成为零和（或者最多为“偏移”）情况N是奇数）。类似地，我们也从数组中的所有值中减去此偏移量。这样我们就可以将要添加的数字范围移至最多[-50,000 ... + 50,000]。在最坏的情况下，即如果所有正（或负）范围数都是顺序的，则最大的中间和从不超过31位，因此不会发生溢出。对于交错的正数和负数，中间和将更小。

从高斯和中减去数组之和后，我们再次通过添加偏移量来找到缺失的数组元素。

这是C ++中的代码（在编码测试中得分为100％）：

int solution(vector<int> &A) {
    int N;
    int sum;
    int gauss;              // sum of all ints in [1..N+1] using Gauss' trick
    int offset;             // subtract offset from all numbers to make it a zero-sum
    int num_x;


    N = int(A.size());      // convert from size_t to int

    sum = 0;
    offset = (N+2) >> 1;        // make range symmetric between [-N/2..N/2] to avoid integer overflow in Gauss sum for large N

    // "gauss" should nominally be a zero sum, but if N is odd then N/2 is truncated 
    // and offset is off by 1/2 for each of the N elements. This formula compensates for that.
    gauss = (N & 1) * offset;

    for (int i = 0; i < N; i++) {
        sum += (A[i] - offset);     // this is the O(n) part of summing all elements in the array
    }

    num_x = gauss - sum + offset;   // find the missing number

    return num_x;
}

Answer 3

当您执行乘法时，看起来您正在达到PHP变量可以容纳的最大值。我不确定PHP是否允许你使用位，但是这个问题可以使用类似于Java BitSet类的东西轻松解决。

解决方案的要点是，因为我们知道数字将介于1和n之间，所以在索引为输入数组元素的变量中将这些位设置为1。现在有另一个变量，其所有位都设置在位置，1到并包括n。对这些变量进行异或将为您提供缺失数字的位置。

这是一个实现上述逻辑的java代码（也是Codility上的100/100）

public int solution(int[] A) {
    long result = 0L;

    BitSet all_elements = new BitSet();
    BitSet given_elements = new BitSet();

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

    for (int i = 1; i <= A.length + 1; i++) {
        all_elements.set(i);
    }

    all_elements.xor(given_elements);

    for (int i = 0; i < all_elements.length(); ++i) {
        if(all_elements.get(i)) {
            result = i;
            break;
        }
    }

    return (int)result;
}

Answer 4

我是stackoverflow的新手，试图以格式化的方式。这是我在java中的答案，100/100得分.......具有O（n）复杂度。如果您愿意，可以通过以下链接查看.... http://codility.com/demo/results/demoJJERZ4-E7Z/

public int solution(int[] A) {
        int len = A.length;
    int result = 0;
         int[] B;
         B = new int[len+1];
         for(int i=0; i<= B.length-1; i++)
         {
            B[i] = i+1;
         }
              // int n = len +1;
                int i, sum1 = 0, sum2 = 0;
                for (i = 0; i <= A.length-1; i++) {
                        sum1 = sum1 + A[i];
                }
                for (i = 0; i <= B.length-1; i++) {
                        sum2 = sum2 + B[i];
                }
               result = sum2 - sum1;

                return result;
    }

Answer 5

在Ruby中考虑这个100/100解决方案：

# Algorithm:
#
# * Compute theoretical sum based on array size.
# * Compute actual sum.
# * Subtract one from the other and you get the missing element.
def solution(ar)
  # Trivial case.
  return 1 if ar.empty?

  size = ar.size + 1
  full_sum = (size*(size + 1))/2
  actual_sum = ar.inject(:+)

  # Result.
  full_sum - actual_sum
end

#--------------------------------------- Tests

def test
  sets = []
  sets << ["empty", 1, []]
  sets << ["12", 3, [1, 2]]
  sets << ["13", 2, [1, 3]]
  sets << ["sample", 4, [2, 3, 1, 5]]

  sets.each do |name, expected, ar|
    out = solution(ar)
    raise "FAILURE at test #{name.inspect}: #{out.inspect} != #{expected.inspect}" if out != expected
  end

  puts "SUCCESS: All tests passed"
end

Answer 6

Python中的100/100解决方案。只有3行，易于理解。

def solution(A):
    sum1 = sum(range(1,len(A)+2))
    sum2 = sum(A)
    return sum1-sum2

对于大型阵列，上述解决方案效率不高，有时可能无效。所提出的改进解决方案适用于所有极端情况。请注意，在这种情况下，我们只迭代数组一次。因此，该解决方案针对空间和时间复杂性进行了优化。

def solution(A):
    size = 0
    array_sum = 0
    for item in A:
        size += 1
        array_sum += item
    expected_sum = (size+1)*(size+2)/2
    return expected_sum - array_sum

Answer 7

PHP代码：我得到了（100％）

功能解决方案（$ A）{

$arraySum=0;

$totalSum=0;

$res = 0;

for($i=0;$i<count($A);$i++)
{
    $arraySum += $A[$i];
    $totalSum += $i+1 ;
}
$totalSum += $i+1 ;
return abs((int)($totalSum - $arraySum)) ; 

}

Answer 8

我在O（N）或O（N * log（N））PHP中的100/100解决方案

function solution($A) {

    $right = 0;

    $count = count($A);

    $left = 0;


    for ($i = 0; $i < $count; $i++) {
        $right += $A[$i];
        $left += ($i + 1);
    }

    $left += $count;
    return (int)(abs(($right - $left))+1);

}

Answer 9

这是一个数学问题。使用系列的总和，得出最后一项的总和

 Sn = n /2 * (a + l) 

where a is the first term i.e. 1, n = the last number i.e. (array length + 1)

实际总和与计算得出的数组总和之差是缺少的元素。

JavaScript版本：100％得分

function solution(A) {    
    //approach question using series
    //find the sum to the last term
    let lastNumb = A.length + 1;
    let sumOfSeries = ((1 + lastNumb) * lastNumb) / 2;
    
    //sum the numbers in the array
    let arraySum = A.reduce((accum,val)=>accum+val,0);

    //the missing number is the difference between
    //the array sum and the expected sum
    return sumOfSeries - arraySum;
}

Answer 10

稍微短一点线PHP解决方案100/100 PermMissingElem：

function solution($a) {
    return array_sum(range(1, count($a)+1)) - array_sum($a);
}

Answer 11

我的PHP解决方案：100/100得分

function solution($a) {   
$c   = count($a); // counting the elements
$sum = ($c + 2) * ($c + 1) / 2; // getting the elements sum
$s = array_sum($A); // taking the sum of actual array elements
return intval($sum - $s ); //returning the difference
}//end of solution

致以最诚挚的问候，希望这有帮助

Answer 12

PHP中的100/100以及第n个三角形数字的可读性更强

function solution($a)
{
   $array_count = count($a) + 1;
   $sum = (($array_count + 1) * $array_count) / 2;
   $result = $sum - array_sum($a);
   return $result;
}

Answer 13

int solution(int []A){
    //missing number is sum of all possible entries ([1..N+1]) minus
    //sum of all items in A that are with the constrain [1..N+1] 
    int N = A.length;
    long sum = 0L;
    for(int i=1;i<=N+1;i++){
        sum += i;
    }

    long sumPossible= 0L;
    for(int i=0; i<N;i++){
        int x = A[i];
        boolean outOfRange = x<1 || x>N+1;
        if(!outOfRange) {
            sumPossible += x;
        }
    }
    return (int)(sum-sumPossible);
}

Answer 14

C ++单行100/100解决方案：

#include <algorithm>
#include <functional>

int solution(vector<int> &A) {
    return std::accumulate(A.begin(), A.end(), (A.size()+1) * (A.size()+2) / 2, std::minus<int>());
}

Answer 15

叹了口气，我得承认这很有趣...... N + 1个整数之和=（N + 1）（N + 2）/ 2 = N [（N + 2）/ 2] +（N + 2）/ 2 = N *因子+因子，其中因子=（N 2）/ 2。

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

int solution(int A[], int N) {    
    int factor = N+2;
    int total = factor;             
    for (int i=0;i<N;i++){        
        total += (factor - (A[i]<<1));                
    }    
    return (total>>1)+(total&1);
}

Answer 16

这是我的PHP解决方案：

function solution($A) {   
    $n = count($A) + 1;
    return (($n * ($n + 1)) / 2) - (array_sum($A));
}

Answer 17

最快的方式：

function solution($A){
   $arr2 = range(1, max($A));
   $missing = array_diff($arr2, $A);
}

Answer 18

我找到了一种使用binarySearch在 java 中得分为100/100的解决方案。

代码如下：

import java.util.*;

class Solution {
    public int solution(int[] A) {
        Arrays.sort(A);
        int i = 1;
        while (i <= A.length) {
            int res = Arrays.binarySearch(A, i); 
            if (res < 0) {
                return i;
            }
            i++;
        }
        return i;
    }
}

Answer 19

function solution($A) {
    $sum = array_sum($A);
    $sum2 = 0;
    for ($i = 1; $i <= count($A)+1; $i++) {
        $sum2 += $i;
    }
    return $sum2-$sum;
}

php 100/100解决方案

Answer 20

简短的C ++答案，测试成绩100％

#include<numeric>

int solution(vector<int> &A) {

    // compute sum of all elements, needs <numeric>
    long long sum = std::accumulate(A.begin(), A.end(), 0);

    // number of elements as 64-bit int to avoid overflow for large arrays
    long long N =  static_cast<long long>(A.size());

    // missing element is sum of elems 1 to N+1 minus sum, cast to int
    return static_cast<int>( ((N+1)*(N+2))/2 - sum );
}

Answer 21

哇，这里有一些非常好的答案......

JavaScript 的初始 100％不符合测试要求的 O（1）空间复杂度：

var ll = A.length, lookup = {};

for (i=0; i<ll; i++)
   lookup[A[i]] = true;

for (i=0; i<ll; i++)
   if (!lookup[i+1]) return i+1;

来到这里看到优秀的帖子后，我选择了 Daniel Caballero 的代码，通过 vaxquis 进行了简化，转换为Javascript并粘贴到此处以供将来享受：

var N = A.length, sum = 2*N + 1, i; 

for (i = N-1; i >= 0; i--) 
   sum += (i-A[i]); 

return sum; 

Answer 22

这个简单的解决方案得分为100％：

int solution(int A[], int N) {
  // write your code in C90
  double sum = N/2.;
  int i;
  double sumA=0;
  for(i=0; i<N; ++i) {
    sumA += A[i] - N/2.;
  }
  sumA -= N+1;
  return sum - sumA;
}

Answer 23

虽然我只有80岁:(但它有效

int solution(int A[], int N) {

    int ret, nsum, i, sum = 0;

    nsum=(N * (N + 1)) / 2;

    for(i = 0; i < N; i++){
       sum = sum + A[i];
    }
    sum = (sum - (N + 1));
    ret = sum - nsum;
    return ret;
}

Answer 24

100％得分：Perm缺少Codility

function solution($A){
    return intval(intval(((count($A)+1) * ((count($A)+1) + 1)) / 2) - intval(array_sum($A)));
}

Answer 25

这是我的解决方案。它基本上遍历数组，将各个元素设置为零。一旦处理了数组，非零元素的索引就表示缺失值。

void f( vector<int> &A, int i )
{
    if( i != A.size()+1 &&  i != 0 )
    {
        int j = A[i-1];
        A[i-1] = 0;
        f(A, j);
    }
}

int solution(vector<int> &A) 
{   
    for ( int i = 0; i < A.size(); i++)
    {
        f(A, A[i]);
    }
    for( int i = 0; i < A.size(); i++)
   {
       if(A[i] != 0)
        return i+1;
   } 
   return A.size()+1;
}

Answer 26

有史以来第一次贡献（交叉手指使其正确！）。我的C ++解决方案如下：

int solution(int A[], int N)
{
    int sum = 0;
    for(int i=0; i<N; i++)
    {
        sum+= (i+1) - A[i];
    }
    sum+=(N+1);

    return(sum);
}

无需包含其他库;-)。希望它能帮助每个人！

Answer 27

PermMissingElem的另一个C解决方案（在Codility上得分100/100）：

#include <math.h>
int solution(int A[], int N) {

double sum = (pow(N, 2) + 3 * N + 2) / 2;
int i;

for (i = 0; i < N; i++) {
    sum -= A[i];
}
return (int)sum;
}

Answer 28

PermMissingElem的100/100 Objective C解决方案：

int solution(NSMutableArray *A) {

    unsigned long length = [A count] + 1;
    unsigned long sum1 = 0;
    unsigned long sum2 = 0;

    for (int i=0; i < [A count]; i++) {
        sum1 += [[A objectAtIndex:i] longValue];
    }

    sum2 = ((((length+1)*length)/2) - sum1);

    return sum2;

}

Answer 29

请查看我的解决方案，我的时间复杂度为O（N），时间复杂度为O（N），得分为100。

int solution(int A[], int N) {
int * p = (int *)malloc((N + 1)*sizeof(int));
memset(p, 0, (N + 1)*sizeof(int));

int i;
int ret = 0;

for (i = 0; i < N; i++)
{
    A[i] = A[i] - 1;
}

for (i = 0; i < N; i++)
{
    p[A[i]] = 1;    
}

for (i = 0; i <= N; i++)
{
    if(p[i] == 0)
    {
        ret = i + 1;
        break;
    }
}

free(p);
return ret;

}

Answer 30

public static int solution(int[] A)
    {
        int Min = A.Min();
        int Max = A.Max();
        for (int i = Min; i < Max; i++)
        {
            if (A.Where(t => t == Min+i).ToArray().Length == 0)
            {
                return Min+i;
            }

        }
        return Min-1;
    }