C 相等操作要检查数组中的四个值是否相等，这些值必须紧随其后

此函数应返回第一个值等于下一个值的k值，以此类推。 函数当前将0作为输出

int function(double array1[])
{
    int k = 0, count = 0;

    for( k = 0; k < 720; k++ )
    {
        if( ( (array1[k]   != 0) && 
              (array1[k+1] != 0)) && 
            ( (array1[k+2] != 0) && 
              (array1[k+3] != 0) ) )
        {
            if( ( (array1[k]) == 
                  (array1[k+1]) ) == 
                ( (array1[k+2]) ==
                  (array1[k+3]) ) )
            {
                count++ ;
            }
        }
    }

    return count;
}

int函数（双数组1[]
{
int k=0，count=0；
对于（k=0；k<720；k++）
{
如果（（数组1[k]！=0）和
（数组1[k+1]！=0））&
（（数组1[k+2]！=0）和
（数组1[k+3]！=0）））
{
如果（（数组1[k]）==
（数组1[k+1]）==
（（阵列1[k+2]）==
（阵列1[k+3]））
{
计数++；
}
}
}
返回计数；
}

相等操作，检查数组中的四个值是否相等

OP的代码发现数组[k]与下一个数组相等。然后找到数组[k+2]与其下一个数组的相等性。最后，对这两个等式（均为0或1）进行比较

这不是“检查数组中的四个值是否相等”

---

检查第一个是否等于第二个，如果是，那么如果第一个等于第三个，以此类推。避免赤裸裸的幻数<代码>O（尺寸+n）

---

更高级的版本将利用连续的匹配<代码>O（尺寸）

大小连续匹配（常量双数组1[]，大小大小，大小n）{
//病理病例
if（n0）返回大小；
返回0；
}
大小\u t计数=0；
尺寸匹配长度=1；
对于（大小k=1；k

首先，您需要为代码提供一些结构，这是一个示例

int compare(const int *const array, size_t k, size_t size)
{
    for (int j = k + 1; ((j < k + 4) && (j < size)); ++j) {
        // If a signle value is not equal to
        // `array[k]' we immediately return
        // false. 
        if (array[k] != array[j]) {
            return 0;
        }
    }
    return 1;    
}

int function(const int *const array, size_t size)
{
    int count = 0;
    for (int k = 1; k < size; k++) {
        // If array[k - 1] == 0, then it doesn't matter if the following
        // three values are equal to it, so we skip this one
        if (array[k - 1] == 0) {
            continue;
        }

        // Check that all the following three values are equal to
        // `array[k - 1]'
        if (compare(array, k - 1, size) != 0) {
            count += 1;
        }
    }
    // Now this could be the expected value
    return count;
}

---

与前一个相比，它没有多大改进，但它使一个参数可调，因此该函数更通用，因此更“可重用”。

您的逻辑有缺陷且过于复杂。要确定四个连续值是否等于零：

    double a = array1[k] ;
    double b = array1[k + 1] ;
    double c = array1[k + 2] ;
    double d = array1[k + 3] ;

    if( a != 0 &&
        a == b &&
        a == c &&
        a == d )
    {
        ...
    }

但是，对于测试连续相等性，以下方法更有效，并允许更容易地扩展连续计数：

double previous = array1[0] ;
for( k = 1, count = 0; count < MIN_CONSECUTIVE && k < ARRAY1_LEN; k++ )
{    
    next = array1[k] ;
    if( next != 0 && previous == next )
    {
        count++ ;
    }
}

return count == MIN_CONSECUTIVE ? k : -1 ;

double-previous=array1[0]；
对于（k=1，count=0；count

但是，比较浮点值是否精确相等存在问题，最好：

if( fabs(next) < MIN_EQUALITY && 
    fabs(previous - next) < MIN_EQUALITY )

if（fabs（next）

或者在第一种情况下：

    if( fabs(a) < MIN_EQUALITY &&
        fabs(a - b) <  MIN_EQUALITY &&
        fabs(a - c) <  MIN_EQUALITY &&
        fabs(a - d) <  MIN_EQUALITY )
    {
        ...
    }

if（fabs（a）

---

其中

MIN_EQUALITY

是可接受误差或差异的某个小值。例如，如果说等于小数点后6位就足够了，那么不要编写这样的代码！从未！您应该注意运算符的优先级，并请在逻辑上分别使用HiteSpace和what't should。那么您有什么建议？@mellow如果数组确实有720个元素，则函数具有未定义的行为。使用像720这样的幻数是个坏主意。清楚地定义函数的用途。例如，您说它应该返回一个索引，但您返回的是完全不同的

count

。比较浮点值是否相等是有问题的-数组中的值是以任何方式计算的，名义上相等的值在二进制表示中可能并不完全相等。相等测试操作（运算符

==

）的值是1或0，这取决于操作数实际上是否相等。因此，您正在执行的链接

==

操作没有您希望的效果。

int compare(const int *const array, size_t size, size_t width)
{
    for (const int *next = array + 1; next < array + width; ++next) {
        // If a signle value is not equal to
        // `array[0]' we immediately return
        // false. 
        if (array[0] != next[0]) {
            return 0;
        }
    }
    return 1;    
}

int function(const int *const array, size_t size, size_t width)
{
    int count = 0;
    for (int k = 1; k < size; k++) {
        // If array[k - 1] == 0, then it doesn't matter if the 
        // following three values are equal to it, so we skip this
        // one
        if (array[k - 1] == 0) {
            continue;
        }    
        // Check that all the following three values are equal to
        // `array[k - 1]'
        if (compare(&array[k - 1], size, width) != 0) {
            count += 1;
        }
    }
    return count;
}

    double a = array1[k] ;
    double b = array1[k + 1] ;
    double c = array1[k + 2] ;
    double d = array1[k + 3] ;

    if( a != 0 &&
        a == b &&
        a == c &&
        a == d )
    {
        ...
    }

double previous = array1[0] ;
for( k = 1, count = 0; count < MIN_CONSECUTIVE && k < ARRAY1_LEN; k++ )
{    
    next = array1[k] ;
    if( next != 0 && previous == next )
    {
        count++ ;
    }
}

return count == MIN_CONSECUTIVE ? k : -1 ;

if( fabs(next) < MIN_EQUALITY && 
    fabs(previous - next) < MIN_EQUALITY )

    if( fabs(a) < MIN_EQUALITY &&
        fabs(a - b) <  MIN_EQUALITY &&
        fabs(a - c) <  MIN_EQUALITY &&
        fabs(a - d) <  MIN_EQUALITY )
    {
        ...
    }