C++ 找出一个共度的解决方案？

给出了一个由N个不同整数组成的零索引数组。数组包含范围

[1..（N+1）]

内的整数，这意味着只缺少一个元素

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

编写一个函数：

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

给定零索引数组

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).

这不适用于有两个要素的情况

int solution(vector<int> &A) {

    sort(A.begin(), A.end());
    int missingIndex = 0;

    for (int i = 0; i < A.size(); i++)
    {
        if ( i != A[i]-1)
        {
            missingIndex = i+1;
        }

    }
    return missingIndex;
}

int解决方案（向量&A）{
排序（A.begin（），A.end（））；
int missingIndex=0；
对于（int i=0；i

由于数组的索引为零，且数字从1到N+1，因此语句应为：

if ( i != A[i]-1)

此外，您应该在更新missingIndex后立即从for循环中跳出，因为丢失元素之外的所有条目都应该具有（i！=A[i]-1）

此外，由于排序，您的解决方案是O（NlogN），而不是O（N）

---

相反，您可以对数组中的所有元素求和（使用无符号long long int）并检查其与

N（N+1）/2的差异

您可以使用简单的数学公式计算从1到N+1的所有数的和。然后对所有给定的数字进行迭代并计算该和。缺少的元素将是两个和之间的差

int solution(std::vector<int> &a) {
    uint64_t sum = (a.size() +1 ) * (a.size() + 2) / 2;
    uint64_t actual = 0;
    for(int element : a) {
        actual += element;
    }
    return static_cast<int>(sum - actual);
}

int解决方案（std:：vector&a）{
uint64总和=（a.大小（）+1）*（a.大小（）+2）/2；
uint64_t实际值=0；
for（int元素：a）{
实际+=元素；
}
返回静态_cast（总和-实际值）；
}

此解决方案使用值的符号作为标志。最坏的情况下，它需要两次通过元素。N（N+1）/2解决方案只需要一次过程

int solution(vector<int> &a) {
    int n = (int)a.size();
    for(auto k : a)
    {
        int i = abs(k) - 1;
        if (i != n)
            a[i] = -a[i];
    }

    for (int i = 0; i < n; ++i)
        if (a[i]>0)
            return i+1;
    return n+1;
}

int解决方案（向量&a）{
int n=（int）a.size（）；
用于（自动k:a）
{
int i=abs（k）-1；
如果（i！=n）
a[i]=-a[i]；
}
对于（int i=0；i0）
返回i+1；
返回n+1；
}

使用STL的所有功能：

#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>());
}

#包括
#包括
整数解（向量&A）{
返回std:：accumulate（A.begin（），A.end（），（A.size（）+1）*（A.size（）+2）/2，std:：minus（））；
}

我用这种方式解决了这个问题，并想把它贴在这里，供我自己和其他人参考：）

#包括
#包括
整数解（向量&A）{
uint64总和=（A.大小（）+1）*（A.大小（）+2）/2；
uint64_t sumA=std:：累加（A.begin（），A.end（），0）；
返回sumAll-sumA；
}

我用这个解决方案解决它，也许有更好的方法，但我用不同的值测试它，发现它工作正常，而其他解决方案给我奇怪的结果。 例如：

std::vector<int> A = { 12,13,11,14,16 };
std::vector<int> A2 = { 112,113,111,114,116 };


int  Solution(std::vector<int> &A)
{
int temp;
for (int i = 0; i < A.size(); ++i)
{
    for (int j = i+1;j< A.size();++j )  
{
    if (A[i] > A[j])
        {
            temp = A[i];
            A[i] = A[j];
            A[j] = temp;
        }
    }
}

for (int i = 0; i < A.size()-1;++i)
{
    if ((A[i] + 1 != A[i + 1]))
    {
    return (A[i] + 1);
    }
    if(i+1 == A.size() - 1)
    return (A[i+1] + 1);

}}

std:：vector A={12,13,11,14,16}；
向量A2={112113111114116}；
int解决方案（std:：vector&A）
{
内部温度；
对于（int i=0；iA[j]）
{
温度=A[i]；
A[i]=A[j]；
A[j]=温度；
}
}
}
对于（int i=0；i

---

现在一切都很好，但是如果我使用上面的数组和下面的方法，我会得到错误的值，除了小数值仍然没有通过测试用例，对于单个元素和数组中的两个元素，检查它与N（N+1）/2的差异非常棒！这仍然是错误的，如果（i！=A[i]-1{missingIndex=i+1；break；}int解决方案（vector&A）{sort（A.begin（），A.end（））；int missingIndex=0；for（int i=0；iO（N）复杂性。由于得到的值范围有限，因此它适用于计数排序。真正的限制是

O（1）

space limit:）@fjardon确实，在这种情况下，您可以使用足够有效的排序算法。此外，Raistmaj发现了一个更简单/更智能的解决方案。很好。我能和你取得联系吗？我也是住在奥地利的移民：）？

std::vector<int> A = { 12,13,11,14,16 };
std::vector<int> A2 = { 112,113,111,114,116 };


int  Solution(std::vector<int> &A)
{
int temp;
for (int i = 0; i < A.size(); ++i)
{
    for (int j = i+1;j< A.size();++j )  
{
    if (A[i] > A[j])
        {
            temp = A[i];
            A[i] = A[j];
            A[j] = temp;
        }
    }
}

for (int i = 0; i < A.size()-1;++i)
{
    if ((A[i] + 1 != A[i + 1]))
    {
    return (A[i] + 1);
    }
    if(i+1 == A.size() - 1)
    return (A[i+1] + 1);

}}

 std::vector<int> A = { 12,13,11,14,16 };
 int Solution_2(std::vector<int> &A) 
{
unsigned int n = A.size() + 1;
long long int estimated = n * (n + 1) / 2;
long long int total = 0;
for (unsigned int i = 0; i < n - 1; i++) total += A[i];
return estimated - total;
}

std::vector<int> A = { 12,13,11,14,16 };
int Solution_3(std::vector<int> &A) 
{
 uint64_t sumAll = (A.size() + 1) * (A.size() + 2) / 2;
 uint64_t sumA = std::accumulate(A.begin(), A.end(), 0);
 return sumAll - sumA;
}