C++ 如何计算向量中相等的相邻元素？

假设我有一个

向量{1,1,2,3,3,1,1}

，我想把它转换成一个

向量{{1,2}，{2,1}，{3,3}，{1,2}

，表示“相邻元素计数”：

---

我可能会在向量上迭代，使用一个标志指示新“邻接集”的开始，并使用一个计数器计算连续元素的数量。我只是想知道STL中是否还没有一个更抽象、更优雅的解决方案，因为这似乎是一个非常常见的用例。像独特的、邻接的、找到的或相等的范围的算法看起来与我所寻找的非常接近，但不完全正确，而且从我自己从头开始执行它可能没有任何好处。

< p>据我所知，没有这样的C++库会自动完成你所要求的。 无论如何，实现这一点非常简单。这里有一个方法：

#include <iostream>
#include <vector>

using namespace std;

void count_equal_elements(vector<int>& vec, vector<pair<int,int> >& result){
    if (vec.empty())
        return;
    int curr = vec[0];
    int count = 1;
    for (vector<int>::iterator it = vec.begin()+1; it != vec.end(); ++it){
        if (curr == *it){
            count++;
        }
        else{
            result.push_back(make_pair(curr,count));
            curr = *it;
            count = 1;
        }
    }
    result.push_back(make_pair(curr,count));
}

#包括
#包括
使用名称空间std；
无效计数等于元素（向量和向量、向量和结果）{
if（vec.empty（））
返回；
int curr=vec[0]；
整数计数=1；
for（vector:：iterator it=vec.begin（）+1；it！=vec.end（）；+it）{
如果（当前==*it）{
计数++；
}
否则{
结果。推回（生成一对（curr，count））；
curr=*it；
计数=1；
}
}
结果。推回（生成一对（curr，count））；
}

---

<>参见.< /P> < P>。据我所知，没有这样的C++库，它会自动完成你所要求的。 无论如何，实现这一点非常简单。这里有一个方法：

#include <iostream>
#include <vector>

using namespace std;

void count_equal_elements(vector<int>& vec, vector<pair<int,int> >& result){
    if (vec.empty())
        return;
    int curr = vec[0];
    int count = 1;
    for (vector<int>::iterator it = vec.begin()+1; it != vec.end(); ++it){
        if (curr == *it){
            count++;
        }
        else{
            result.push_back(make_pair(curr,count));
            curr = *it;
            count = 1;
        }
    }
    result.push_back(make_pair(curr,count));
}

#包括
#包括
使用名称空间std；
无效计数等于元素（向量和向量、向量和结果）{
if（vec.empty（））
返回；
int curr=vec[0]；
整数计数=1；
for（vector:：iterator it=vec.begin（）+1；it！=vec.end（）；+it）{
如果（当前==*it）{
计数++；
}
否则{
结果。推回（生成一对（curr，count））；
curr=*it；
计数=1；
}
}
结果。推回（生成一对（curr，count））；
}

请参见。

，其中有一个

group\u by

，非常类似于，并根据需要对连续的等效元素进行分组

要对向量进行分组，请从

const vector<int> l{ 1, 1, 2, 3, 3, 3, 1, 1 };
auto x = l | view::group_by(std::equal_to<int>());

---

示例

#include <vector>
#include <iostream>
#include <range/v3/all.hpp>

int main(int argc, char **argv) { 
    const std::vector<int> l{ 1, 1, 2, 3, 3, 3, 1, 1 };
    auto x = l | ranges::view::group_by(std::equal_to<int>());

    for (auto i = x.begin();i != x.end(); ++i) 
        std::cout <<  *((*i).begin()) << " " << ranges::to_vector(*i).size() << std::endl;
}

，它有一个非常类似于的

group_by

，并根据需要对连续的等效元素进行分组

要对向量进行分组，请从

const vector<int> l{ 1, 1, 2, 3, 3, 3, 1, 1 };
auto x = l | view::group_by(std::equal_to<int>());

---

示例

#include <vector>
#include <iostream>
#include <range/v3/all.hpp>

int main(int argc, char **argv) { 
    const std::vector<int> l{ 1, 1, 2, 3, 3, 3, 1, 1 };
    auto x = l | ranges::view::group_by(std::equal_to<int>());

    for (auto i = x.begin();i != x.end(); ++i) 
        std::cout <<  *((*i).begin()) << " " << ranges::to_vector(*i).size() << std::endl;
}

---

从算法的角度来看，最接近的事情是我会说。我不认为有现成的算法可以做到这一点，但代码应该很简单：

std::vector<std::pair<int, int>> out; 
for (int i: in)
{
     if (out.empty() || out.back().first != i)
     {
         out.emplace_back(i, 1);
     }
     else
     {
         ++out.back().second;
     }
}

std:：向量输出；
for（int i:in）
{
if（out.empty（）| out.back（）.first！=i）
{
向外。向后安置（i，1）；
}
其他的
{
++out.back（）秒；
}
}

---

从算法的角度来看，最接近的事情是我要说的。我不认为有现成的算法可以做到这一点，但代码应该很简单：

std::vector<std::pair<int, int>> out; 
for (int i: in)
{
     if (out.empty() || out.back().first != i)
     {
         out.emplace_back(i, 1);
     }
     else
     {
         ++out.back().second;
     }
}

std:：向量输出；
for（int i:in）
{
if（out.empty（）| out.back（）.first！=i）
{
向外。向后安置（i，1）；
}
其他的
{
++out.back（）秒；
}
}

---

使用

std

，您可以执行以下操作：

template <typename T>
std::vector<std::pair<T, std::size_t>>
adjacent_count(const std::vector<T>& v)
{
    std::vector<std::pair<T, std::size_t>> res;

    for (auto it = v.begin(), e = v.end(); it != e; /*Empty*/) {
        auto it2 = std::adjacent_find(it, e, std::not_equal_to<>{});
        if (it2 != e) {
            ++it2;
        }
        res.emplace_back(*it, std::distance(it, it2));
        it = it2;
    }
    return res;
}

模板
向量
相邻_计数（常数std:：vector&v）
{
std：：向量res；
对于（auto it=v.begin（），e=v.end（）；it！=e；/*Empty*/）{
auto it2=std：：相邻查找（it，e，std：：不等于{}）；
如果（it2！=e）{
++it2；
}
res.emplace_back（*it，标准：：距离（it，it2））；
it=it2；
}
返回res；
}

或

模板
向量
相邻_计数（常数std:：vector&v）
{
std：：向量res；
对于（auto it=v.begin（），e=v.end（）；it！=e；/*Empty*/）{
const auto it2=std:：find_if（it，e，[&]（const auto&x）{return x！=*it；}）；
res.emplace_back（*it，标准：：距离（it，it2））；
it=it2；
}
返回res；
}

---

使用

std

，您可以执行以下操作：

template <typename T>
std::vector<std::pair<T, std::size_t>>
adjacent_count(const std::vector<T>& v)
{
    std::vector<std::pair<T, std::size_t>> res;

    for (auto it = v.begin(), e = v.end(); it != e; /*Empty*/) {
        auto it2 = std::adjacent_find(it, e, std::not_equal_to<>{});
        if (it2 != e) {
            ++it2;
        }
        res.emplace_back(*it, std::distance(it, it2));
        it = it2;
    }
    return res;
}

模板
向量
相邻_计数（常数std:：vector&v）
{
std：：向量res；
对于（auto it=v.begin（），e=v.end（）；it！=e；/*Empty*/）{
auto it2=std：：相邻查找（it，e，std：：不等于{}）；
如果（it2！=e）{
++it2；
}
res.emplace_back（*it，标准：：距离（it，it2））；
it=it2；
}
返回res；
}

或

模板
向量
相邻_计数（常数std:：vector&v）
{
std：：向量res；
对于（auto it=v.begin（），e=v.end（）；it！=e；/*Empty*/）{
const auto it2=std:：find_if（it，e，[&]（const auto&x）{return x！=*it；}）；
res.emplace_back（*it，标准：：距离（it，it2））；
it=it2；
}
返回res；
}

---

“我只是想知道STL中是否还没有一个更抽象、更优雅的解决方案，因为这似乎是向量的一个非常常见的用例？”？也许是一张地图，而“普通”是一种延伸。C++库中没有构建任何类似于此的构建算法。由你来实施它。听起来你已经很好地掌握了这个算法，所以等待一个答案是没有意义的，这个答案是不会从互联网上的人那里得到的。向量中的相邻元素是什么？至少有两种解释。是什么阻碍了你简单地通过向量进行交互？@AmiTavory正确，我这边的输入错误。我只是想知道STL中是否还没有一个更抽象、更优雅的解决方案，因为这似乎是向量的一个非常常见的用例？也许是一张地图，而“普通”是一种延伸。C++库中没有构建任何类似于此的构建算法。由你来实施它。听起来你已经很好地掌握了这个算法，所以等待一个答案是没有意义的，这个答案不会从互联网上的人那里得到