Question

有一个1和0的向量：

int[] vec = new int[6]{0,1,0,0,1,0};

我需要计算＆＃34; 0＆＃34;的总数。＆＃34; 1＆＃34;之间的位置位置。例如，如果<0,1,0,0,1,0>则答案为2.但是，问题是向量可能包含以下值：

int[] vec = new int[6]{0,1,0,0,0,0};  // the answer is 0

或

int[] vec = new int[6]{1,0,0,1,0,1};  / the answer is 3

到目前为止，我只为第一种情况（<0,1,0,0,1,0>）制作了一个简单的算法。

    int start = 0, end = 0;
    for (int i=0; i<vec.length; i++)
    {
        if (vec[i] == 1 && start == 0)
            start = i;

        if (vec[i] == 1 && start != 0)
            end = i;
    }
    int result = end - start - 1;

我需要一些帮助来开发能够处理所有上述情况的更通用的算法。

Answer 1

您可以从两端迭代数组以查找第一个和最后一个1。然后，如果您找到了两者，请计算它们之间的0。

int start = -1;
int end = vec.length;
int i = 0;
int j = vec.length-1;
while (i < j) {
    if (vec[i] == 1 && start < 0)
        start = i;
    i++;
    if (vec[j] == 1 && end >= vec.length)
        end = j;
    j--;
    if (start >= 0 && end < vec.length)
        break;
} 
int count = 0;
if (start >= 0 && end < vec.length) {
    for (i = start + 1; i < end; i++) {
        if (vec[i] == 0)
            count++;
    }
}

它可以优化为单个循环。

Answer 2

抱歉，最初我以为你想要计算段数而不是实际的零数。

您可以计算第一个之后的所有零（n），跟踪自上次看到的零（m）以来的零数。然后，当您到达向量的末尾时，n的计数为m的值过高。

int count = 0;
int zeroesSinceLastOne = 0;
bool firstOneSeen = false;

for(int i = 0, n = vector.size(); i < n; ++i)
{
    while(!firstOneSeen && vector[i] == 0)
    {
        continue;
    }
    firstOneSeen = true;

    if(vector[i] == 0)
    {
        ++count; 
        ++zeroesSinceLastOne;
    }
    else
    {
        zeroesSinceLast = 0;
    }
}

return count - zeroesSinceLastOnce;

免责声明：未经测试。可能会给出错误的号码或杀死你的猫。

Answer 3

试试这个算法：

startIndex = -1;
endIndex = -1;
for i from 1 to vec.length():
   if( 1 == vec[i])
       startIndex = i
       break;
for i from vec.length() to 1:
   if( 1 == vec[i])
       endIndex = i
       break;
ans = endIndex - startIndex - no_of_ones_in_between

计算总数＆＃34; 0＆＃34; ＆＃34; 1＆＃34;之间的位置向量int []中的位置

3 个答案: