比较两个数组

Question

我有两个数组，例如A = {1,2,3,4,5}和B = {5,6,3,4,5}。我想比较这两个数组，并告诉A中有多少元素比B少，反之亦然，也可能是元素位置较小。我可以使用嵌套循环来做到这一点，但在C++中有没有一种有效的方法来做到这一点？

在这个例子中， A = {1,2,3,4,5} B = {5,6,3,4,5}

因此，我希望的答案是“B是大于A“，只是因为它满足了两个元素中它更大的条件。或者如果它是

A = {1,2,3,4,5}和B = {1,2,3,0,4}，A更大。

我只需要比较数量大小的元素，而不是本身的值。

对不起，我的含糊不清。

Answer 1

你想比较A和B的相应元素并计算有多少A'小于匹配的B？这可以用STD来完成:: inner_product这样的：

int A[] = { 1,2,3,4,5 }; 
int B[] = { 5,6,3,4,5 }; 

int count = std::inner_product(A, A+5, B, 0, std::plus<int>(), std::less<int>()); 

std::cout << count << "\n"; 

当然，这只是一个为O​​（n）的STL数字算法内部循环。

Answer 2

目前尚不清楚你的意思。你的意思是比较元素明智吗？

vector<int> indexesForA; 
vector<int> indexesForB; 
for(int i = 0; i < length; i++) { 
    if(A[i] < B[i]) { 
     indexesForA.push_back(i); 
    } 
    else if(B[i] < A[i]) { 
     indexesForB.push_back(i); 
    } 
} 

// now indexesForA.size() is the count of indexes i where A[i] < B[i] 
// and indexesForA contains the indexes 
// similarly for indexesForB 

请发表一个澄清，我们可以引导你。

Answer 3

int A[5] = {1,2,3,4,5}; 
int B[5] = {5,6,3,2,4}; 

std::vector<int> vectA(A); 
std::vector<int> vectB(B); 

并使用标准<algorithm>在两个向量上完成作业或部分作业。

例如： count_if返回范围内满足条件（函数模板）元素的个数

Answer 4

你是什么意思？你的意思是A [i] < B [i]还是你的意思是B中有多少元素少于A [i]？要么你会有一个循环，你要比较每个数组的第i个元素，或者你将有一个嵌套循环，在这里你将A的第i个元素和B的第j个元素进行比较。因为我没有知道你想要哪一个，我不能告诉你正确的答案。

Answer 5

我认为最有效的方法是首先对数组进行排序，然后检查哪个索引是数组B的第一个元素大于其A对应元素。由于顺序是可传递的，所以您甚至可以为同一遍中的所有元素执行此操作。

Answer 6

这是我的例子。也许它可能会使用更先进的STL技术，但我认为这足够了。

class Examiner 
{ 
    template <class Pred> 
    struct CompareToZero: std::unary_function<const int&, bool> { 
     Pred comparator; 
     bool operator() (const int& value) const { 
      return comparator(value, 0); 
     } 
    }; 
    template<class T> 
    std::vector<size_t> getComparedIndices(const CompareToZero<T>& comparator, const std::vector<int>& vint) const { 
     std::vector<size_t> retval; 
     for (size_t i = 0; i < vint.size(); i++) { 
      if (comparator(vint[i])) 
       retval.push_back(i); 
     } 
     return retval; 
    } 
    const std::vector<int>& _results; 

public: 
    Examiner(const std::vector<int>& results) 
     : _results(results) { 
    } 

    std::vector<size_t> getLessIndices() const {   
     return getComparedIndices(CompareToZero<std::less<int> >(), _results); 
    } 
    std::vector<size_t> getGreaterIndices() const { 
     return getComparedIndices(CompareToZero<std::greater<int> >(), _results); 
    } 
    std::vector<size_t> getEqualIndices() const { 
     return getComparedIndices(CompareToZero<std::equal_to<int> >(), _results); 
    } 
    size_t getLessCount() const { 
     return getLessIndices().size(); 
    } 
    size_t getGreaterCount() const { 
     return getGreaterIndices().size(); 
    } 
    size_t getEqualCount() const { 
     return getEqualIndices().size(); 
    } 
}; 


void arrcomp() 
{ 
    int A[5] = {1,2,3,4,5}; 
    int B[5] = {5,6,3,2,4}; 

    std::vector<int> results(sizeof(A)/sizeof(A[0])); 
    for (size_t i = 0; i < results.size(); ++i) { 
     results[i] = 
      (A[i] < B[i])? -1: 
       (A[i] > B[i])? 0: 
        1;    
    } 
    Examiner examiner(results); 

    std::cout << "less count : " << examiner.getLessCount() << std::endl; 
    std::cout << "greater count: " << examiner.getGreaterCount() << std::endl; 
    std::cout << "equal count : " << examiner.getEqualCount() << std::endl;  
}