You are on page 1of 2

/*

* PermMissingElem: Find the missing element in a given permutation.


Find the missing element in a given permutation.
A zero-indexed array A consisting of N different integers is given. The array co
ntains integers in the range [1..(N + 1)], which means that exactly one element
is missing.
Your goal is to find that missing element.
Write a function:
int solution(vector<int> &A);
that, given a zero-indexed array A, returns the value of the missing element.
For example, given array A such that:
A[0] = 2
A[1] = 3
A[2] = 1
A[3] = 5
the function should return 4, as it is the missing element.
Assume that:
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)].
Complexity:
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).
Elements of input arrays can be modified.
*/
#include <algorithm>
#include <vector>
#include <iostream>
/* Correctness 80%, Performance 60% Task score 70% */
int solutionF(std::vector<int> &A)
{
const int size = A.size();

if ((0 == size) || (size > 100000)) return -1;

const long sumOfArray = std::accumulate(A.begin(), A.end(), 0);
const long sumOfSequence = (size + 1) * (size + 2) / 2;
int missingElement = static_cast<int>(sumOfSequence - sumOfArray);
return missingElement;
}
/* Detected time complexity: O(N) or O(N * log(N)). Correctness 100%, Performanc
e 100% Task score 100% */
int solution(std::vector<int> &A)
{
const int size = A.size();
if ((size > 100000)) return -1;
const int offset = (size + 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 truncat
ed
// and offset is off by 1/2 for each of the N elements. This formula compensat
es for that.
const int gauss = (size & 1) * offset;
long long sum = 0;
for (int i = 0; i < size; ++i) {
sum += (A[i] - offset); // this is the O(n) part of summing all elemen
ts in the array
}
const int misingNumber = gauss - sum + offset; // find the missing number
return misingNumber;
}
int _tmain()
{
std::vector<int> A;
A.push_back(1);
A.push_back(2);
A.push_back(3);
A.push_back(5);
A.push_back(4);
std::cout << "Result: " << solution(A) << std::endl;
_getch();
return 0;
}