C++ 选择向量中的右元素

我尽可能清楚地解释了我的问题： 我有两个向量prova1和prova2。在prova1内部有一组整数，即

prova1={0;1;2;4;6;7,8;9;10;11;12;13};

prova2是prova1的子集，即

prova2={2;4;6;8;10;12;13};

我的目标是在第三个向量（称为“prova”）中只复制prova2中prova1和contigous中的元素序列。 对于上述关于条件的向量，我有两个序列： {2；4；6}和{12；13}，实际上这两个序列在prova1中没有分离元素

下面是我处理此问题的代码：

std::vector<int> prova1 = {0, 1, 2, 4, 6, 7, 8, 9, 10, 11, 12, 13};
std::vector<int> prova2 = {2, 4, 6, 8, 10, 12, 13};
std::vector<int> prova;

for (int i=1;i<=prova1.size()-1;i++) {
    for (int j=1;j<=prova2.size()-1;j++) {
        if (prova2[j]==prova1[i]) {
            int variabile=prova2[j-1];
            if (prova1[i-1]==variabile) {
                prova.push_back(prova2[j]);
            }
        }
    }
}

std:：vector prova1={0,1,2,4,6,7,8,9,10,11,12,13}；
向量prova2={2,4,6,8,10,12,13}；
std：：向量prova；
对于（int i=1；i你可以简单地使用复制函数来复制范围。你不需要自己迭代向量就可以做到这一点。看看std算法并使用它，你可以很容易地做到这一点。
我找到了这个简单的解决方案：

#include <iostream>
#include <vector>

int main()
{
    std::vector<int> sequenceA = {0, 1, 2, 4, 6, 7, 8, 9, 10, 11, 12, 13};
    std::vector<int> sequenceB = {2, 4, 6, 8, 10, 12, 13};
    std::vector<int> result;

    std::stable_sort(sequenceA.begin(), sequenceA.end());
    std::stable_sort(sequenceB.begin(), sequenceB.end());

    int indexA = 0;
    int indexB = 0;
    while (indexA < sequenceA.size() && indexB < sequenceB.size()) {
        const int valueA = sequenceA[indexA];
        const int valueB = sequenceB[indexB];
        if (valueA == valueB) {
            result.push_back(valueA);
            ++indexA;
            ++indexB;
        } else if (valueA < valueB) {
            ++indexA;
        } else {
            ++indexB;
        }
    }

    for (int value : result) {
        std::cout << value << ", ";
    }

    return 0;
}

#包括
#包括
int main（）
{
向量序列a={0,1,2,4,6,7,8,9,10,11,12,13}；
std:：vector sequenceB={2,4,6,8,10,12,13}；
std：：向量结果；
std:：stable_sort（sequenceA.begin（），sequenceA.end（））；
std:：stable_sort（sequenceB.begin（），sequenceB.end（））；
int indexA=0；
int indexB=0；
而（indexAstd：：cout这是一个高效且易于理解的解决方案-当它运行在
v1
中的每个元素时，它跟踪它是否不在正在运行的匹配中，是否只看到可能是多元素子序列匹配的第一个元素，或者肯定在这样的匹配中，以及
推回
s元素

enum { unmatched, once, many } state = unmatched;
for (int i = 0, j = 0; i < v1.size() && j < v2.size(); ++i)
    if (v1[i] == v2[j])
        if (state == unmatched)
        {
            ++j;
            state = once;
        }
        else if (state == once)
        {
            v.push_back(v2[j - 1]);
            v.push_back(v2[j++]);
            state = many;
        }
        else
            v.push_back(v2[j++]);
    else
        state = unmatched;


更新：以下是如何包含哨兵来分隔子序列：

const int sentinel = -1;  // or std::numeric_limit<int>::min or whatever else...

enum { unmatched, once, many } state = unmatched;
for (int i = 0, j = 0; i < v1.size() && j < v2.size(); ++i)
    if (v1[i] == v2[j])
        if (state == unmatched)
        {
            ++j;
            state = once;
        }
        else if (state == once)
        {
            v.push_back(sentinel);
            v.push_back(v2[j - 1]);
            v.push_back(v2[j++]);
            state = many;
        }
        else
            v.push_back(v2[j++]);
    else
        state = unmatched;

const int sentinel=-1；//或std:：numeric\u limit:：min或其他任何内容。。。
枚举{不匹配，一次，多次}状态=不匹配；
对于（inti=0，j=0；i

然后，当您迭代时：

for (int i = 0; i < v.size(); ++i)
    if (v[i] == sentinel)
        std::cout << "starting new subsequence!\n";
    else
        std::cout << v[i] << '\n';

for（int i=0；istd：：向量是否已排序和/或仅包含不同的数字？@csgillespie抱歉，我添加了此标记，因为stack建议这样做tag@Jarod42是的，它们被分类了。序列长度有限制吗？一个含有1个元素的序列是有效序列吗？@Flovdis否。向量长度没有限制。一个含有1个元素的序列是一种f序列，但这不是我的情况。我有排序和不同元素的序列。我知道有可能使用函数copy…但我更喜欢使用上面的代码来组合正确序列的副本请给我几分钟时间来测试这个示例否…这个示例无法解决我的目标。因为在输出中你可以在SequenceA中找到像8-10这样不符合“连续”条件的单个元素。你可以看到它正在运行-输出是
2,4,6,8,10,12,13，
-不完全是程序中提到的“{2；4；6}和{12；13}”子序列。抱歉，但是你必须澄清你的问题。我将结果视为[2,4,6]，[8] ，[10]，[12,13]。你告诉我有1个元素的序列是有效的。因此，我认为这个结果是有效的。请在你的问题中提供一些例子，并更详细地解释你的目标。我还有一个问题要问你：是否可以识别或分离算法发现的每个序列？在本例中是{2；4:6}和{12；13}这是两个不同的序列，我想对它们进行一些细化。@CecchinoSMI是的，当然-例如，如果你有
std:：vector v；
，那么对于
state==once
do
v.push_back（std:：vector（））；
创建一个额外的序列容器，然后
v.back（）.push_back（v2[j-1）；
和
v2类似[j++]
（对于两个
状态
）。然后，您可以使用两个
for
循环在
v
上迭代。另一种更简单的方法是
推回一个不同的哨兵值（您知道数据不会有任何值）在推送序列数据之前，在
state==once
中，您可以稍后使用它来了解序列的起始位置。我想使用第二种方法……在这种情况下，确定任何序列的起始索引，我需要在sentinel vector的push_back函数中放入什么？@CecchinoSMI：我在answ中编辑了一些代码呃，如果你在努力，你应该考虑抽点时间来学习C++——很难得到任何真正的程序。-好吧，也许我的问题不清楚。我知道你可以使用一个像你的例子那样的哨兵，但是在我的例子中，哨兵需要包含一个序列是STA的正确索引。这是我的难题：）
for (int i = 0; i < v.size(); ++i)
    if (v[i] == sentinel)
        std::cout << "starting new subsequence!\n";
    else
        std::cout << v[i] << '\n';

enum { unmatched, once, many } state = unmatched;
int j;
for (int i = j = 0; i < v1.size() && j < v2.size(); ++i)
    if (v1[i] == v2[j])
        if (state == unmatched)
        {
            ++j;
            state = once;
        }
        else if (state == once)
        {
            starts_at.push_back(j - 1);
            v.push_back(v2[j - 1]);
            v.push_back(v2[j++]);
            state = many;
        }
        else
            v.push_back(v2[j++]);
    else
    {
        if (state == many)
            finishes_at.push_back(j - 1);
        state = unmatched;
    }
if (state == many)
    finishes_at.push_back(j - 1);