向量中连续数字的计数答案

【问题标题】：Count of consecutive numbers in a vector向量中连续数字的计数
【发布时间】：2015-09-29 06:37:16
【问题描述】：

假设我有以下排序的向量作为输入：

[22]
[22, 23]
[22, 46]
[22, 46, 47]
[22,23,33,44,45,46,55,56]

我想要以下输出，它显示每个向量中连续数字的计数：

1 //edgecase: if there's 1 number it's consecutive)
2 //22, 23 are 2 consecutive numbers
0 //22, 46 not consecutive
2 //46, 47 are 2 consecutive numbers
7 //22,23 (2) 44,45,46 (3) 55,56(2) 7 consecutive numbers

我的向量不会有重复项。

到目前为止我所拥有的是：

vector<int> numbers;
int consecCount=0;
if (numbers.size()==1)
        consecCount++;
else{
    for (size_t k=1; k<numbers.size(); k++) {
        if (numbers[k]==numbers[k-1]+1) {
            consecCount +=2;
        }
}

当然这个方法不适用于最后一个数组。解决方案似乎真的错了。

我的实际向量非常大，所以更喜欢任何不涉及使用另一个向量的想法

【问题讨论】：

你能解释一下输出数字是什么意思吗？
向量总是排序的吗？
所以你的输入是vector<vector<int>>?
问题编辑与输出的含义。是的，向量总是排序的。
为什么不存储一个布尔标志，如“连续两个以上”或类似的东西？

标签： c++ vector

【解决方案1】：

这样的？

size_t conseccount(const vector<int> &v)
{
    size_t s = v.size();
    size_t ret = 0;
    bool seqstart = true;
    if(s < 2) return 0;
    for(size_t i = 1; i < s; i++)
    {
        if(v[i - 1] + 1 == v[i])
        {
            if(seqstart) ret++;
            seqstart = false;
            ret++;
        }
        else seqstart = true;
    }
    return ret;
}

【讨论】：

好一个，但如果重复值，它将返回错误的输出
谢谢，这正是我想要的！我无法弄清楚我的解决方案有什么问题。我今天真的很慢:(
@KiranChoudhary 引用问题：“我的向量不会有重复项。”
@kami 别担心，每个人都会遇到 :)

【解决方案2】：

预期输出

vector    question  why      my query
1         1         22       Is it 1 or 0.  // I don't understand why 
2         2         22,23   
3         0              
4         2        46,47 
5         7       22,23 44,45,46  55,56

计算属于序列一部分的条目数，使得 a[i] = a[i+1]

这样做的关键是确保您单独计数，但在序列末尾添加一个。

你需要检查你是否在一个序列bool bInSequence，最初是false。转换为序列时，将其设置为 true。

然后当你离开一个序列或循环时，你添加一个。

vector<int> numbers;
int consecCount=0;
if (numbers.size()==1)
   consecCount++;
else{
    bool inSequence = false;
    for (size_t k=1; k<numbers.size(); k++) {
        if (numbers[k]==numbers[k-1]+1) {
            consecCount +=1;
            inSequence = true;
        } else if ( inSequence ) {
            inSequence = false;
            consecCount ++;
        }
    }
    if( inSequence == true ) {
        // inSequence = false; //not needed, but logically correct
        consecCount ++;
    }
}

【讨论】：

【解决方案3】：

使用std::adjacent_find，您可以执行以下操作：

std::size_t count_consecutive_sequence(const std::vector<int> &v)
{
    if (v.size() <= 1) {
        return v.size();
    }

    std::size_t res = 0;
    for (auto it = v.begin(); it != v.end(); ) {
        auto e = std::adjacent_find(it, v.end(),
                                    [](int lhs, int rhs) { return lhs + 1 != rhs; });

        if (it == e || it + 1 == v.end()) {
            ++it;
        } else {
            if (e != v.end()) {
                ++e;
            }
            res += distance(it, e);
            it = e;
        }
    }
    return res;
}

Demo

【讨论】：