C++ 访谈-在数组中查找偶和对

给定一个数组，如何返回求和为偶数的对数

例如：

a[] = { 2 , -6 , 1, 3, 5 }

在此数组中，与偶数和配对的数为 （2，-6）、（1,3）、（1,5）、（3,5）

函数应该返回4，因为有4对，如果没有，则返回-1

预期时间复杂度-O（N）最坏情况 预期空间复杂度-O（N）最坏情况

方法1： 蛮力

Start with the first number
  Start with second number
      assign the sum to a temp variable
      check if the temp is even
          If it is increment evenPair count
      else
          increment the second index

这里的时间复杂度是O（N2）

int奇数=0，偶数=0；
对于（int i=0；i

int奇数=0，偶数=0；
对于（int i=0；i

如果要使用标准算法，则代码可以按以下方式查看

#include <iostream>
#include <utility>
#include <numeric>
#include <iterator>

int main() 
{
    int a[] = { 2 , -6 , 1, 3, 5 };

    typedef size_t Odd, Even;
    auto p = std::accumulate( std::begin( a ), std::end( a ), 
                              std::pair<Odd, Even>( 0, 0 ),
                              []( std::pair<Odd, Even> &acc, int x )
                              {
                                return x & 1 ? ++acc.first : ++acc.second, acc;
                              } );

    std::cout << "There are " 
              << ( p.first * ( p.first - 1 ) + p.second * ( p.second - 1 ) ) / 2
              << " even sums" << std::endl;

    return 0;
}

考虑到

n！/（2！*（n-2）！

相当于

（n-1）*n/2

使用标准算法的优点是可以使用序列的任何子范围。您还可以使用标准流输入，因为

std:：acculate

使用输入迭代器

此外，如果在赋值的描述中，如果数组元素之间没有偶数和，则函数应返回0而不是-1，则会更好

---

在面试中展示这段代码并不丢脸，尽管我建议不要在面试中做任何作业。面试不是考试。

如果要使用标准算法，那么代码可以如下所示

#include <iostream>
#include <utility>
#include <numeric>
#include <iterator>

int main() 
{
    int a[] = { 2 , -6 , 1, 3, 5 };

    typedef size_t Odd, Even;
    auto p = std::accumulate( std::begin( a ), std::end( a ), 
                              std::pair<Odd, Even>( 0, 0 ),
                              []( std::pair<Odd, Even> &acc, int x )
                              {
                                return x & 1 ? ++acc.first : ++acc.second, acc;
                              } );

    std::cout << "There are " 
              << ( p.first * ( p.first - 1 ) + p.second * ( p.second - 1 ) ) / 2
              << " even sums" << std::endl;

    return 0;
}

考虑到

n！/（2！*（n-2）！

相当于

（n-1）*n/2

使用标准算法的优点是可以使用序列的任何子范围。您还可以使用标准流输入，因为

std:：acculate

使用输入迭代器

此外，如果在赋值的描述中，如果数组元素之间没有偶数和，则函数应返回0而不是-1，则会更好

---

在面试中展示这段代码并不丢脸，尽管我建议不要在面试中做任何作业。面试不是考试。

如果a和b是偶数，a+b是偶数。
如果它们是奇数，a+b也是偶数。
如果一个是奇数，一个是偶数，a+b是奇数

这意味着我们不需要执行任何加法，只需要知道每种类型有多少个数字。
找出这一点需要线性时间

如果有k个数字，则有k-1对包括第一个数字，k-2包括第二个数字，依此类推。
使用熟悉的求和公式，

sum（1..n）=（n*（n+1））/2

让

那么

该计算在恒定时间内运行，因此时间复杂度仍然是线性的

我们只需要一个恒定的额外空间，这比要求的要好

---

可能值得思考的后续面试问题：

如果：

• 重复项只计数一次，即

  {1,1,1,2}

  只有两个这样的对
• 我们不考虑顺序，即

  （1,2）

  和

  （2,1）

  是“同一”对吗

---

如果a和b是偶数，则a+b是偶数。
如果它们是奇数，a+b也是偶数。
如果一个是奇数，一个是偶数，a+b是奇数

这意味着我们不需要执行任何加法，只需要知道每种类型有多少个数字。
找出这一点需要线性时间

如果有k个数字，则有k-1对包括第一个数字，k-2包括第二个数字，依此类推。
使用熟悉的求和公式，

sum（1..n）=（n*（n+1））/2

让

那么

该计算在恒定时间内运行，因此时间复杂度仍然是线性的

我们只需要一个恒定的额外空间，这比要求的要好

---

可能值得思考的后续面试问题：

如果：

• 重复项只计数一次，即

  {1,1,1,2}

  只有两个这样的对
• 我们不考虑顺序，即

  （1,2）

  和

  （2,1）

  是“同一”对吗

---

另一种方法是通过偶数和赔率计算总和的数量，然后求和，然后求和

int sumO = 0 , sumE = 0 , numO = 0 , numE = 0;
for (int i=0; i < 5; i++)
{
    if (a[i] % 2 == 0)
    {
        sumE += numE;
        numE ++;
    }
    else
    {
        sumO += numO;
        numO ++;
    }
}

printf ("Total: %d\n", sumO + sumE);

intsumo=0，sumE=0，numO=0，numE=0；
对于（int i=0；i<5；i++）
{
如果（a[i]%2==0）
{
sumE+=numE；
numE++；
}
其他的
{
相扑+=numO；
numO++；
}
}
printf（“总计：%d\n”，相扑+相扑）；

另一种方法是通过偶数和赔率计算总和的数量，然后求和，然后求和

int sumO = 0 , sumE = 0 , numO = 0 , numE = 0;
for (int i=0; i < 5; i++)
{
    if (a[i] % 2 == 0)
    {
        sumE += numE;
        numE ++;
    }
    else
    {
        sumO += numO;
        numO ++;
    }
}

printf ("Total: %d\n", sumO + sumE);

intsumo=0，sumE=0，numO=0，numE=0；
对于（int i=0；i<5；i++）
{
如果（a[i]%2==0）
{
sumE+=numE；
numE++；
}
其他的
{
相扑+=numO；
numO++；
}
}
printf（“总计：%d\n”，相扑+相扑）；

我从一次采访中得到了这个问题。 无需将偶数和奇数之和分开

public static int evenTotalPairs(int[] A) {
int size = A.length;
int evens = 0;
for(int i = 0; i < size; i++ ){
    if(A[i] % 2 == 0){
        evens++;
    }
}
return evens*(evens-1)/2 + (size-evens)*(size-evens-1)/2;

publicstaticinteventotalPairs（int[]A）{
int size=A.length；
int-evens=0；
对于（int i=0；i

---

}我从一次采访中得到了这个问题。 无需将偶数和奇数之和分开

public static int evenTotalPairs(int[] A) {
int size = A.length;
int evens = 0;
for(int i = 0; i < size; i++ ){
    if(A[i] % 2 == 0){
        evens++;
    }
}
return evens*(evens-1)/2 + (size-evens)*(size-evens-1)/2;

publicstaticinteventotalPairs（int[]A）{
int size=A.length；
int-evens=0；
对于（int i=0；i

---

}

如果两个数字中的任何一个都是eve，则两个数字的总和将为偶数

public static int evenTotalPairs(int[] A) {
int size = A.length;
int evens = 0;
for(int i = 0; i < size; i++ ){
    if(A[i] % 2 == 0){
        evens++;
    }
}
return evens*(evens-1)/2 + (size-evens)*(size-evens-1)/2;