0

所以我有一个 N 大小的数组。我想首先检查数组是否是交替序列（我们假设数字是正数并且值是 1 或 0）

101010 would return true
110101 would return false

在我检查这个之后，我想知道我需要改变多少这些数字才能使它成为一个交替序列，例如：

1,1,0,1,1会return 2因为你可以颠倒第一个和第五个索引来实现0,1,0,1,0

目前我正在检查交替序列，如下所示：

#include <stdio.h>   // For I/O operations
#include <stdbool.h> // for 'true' and 'false'

int isArrayAlternating(int ints[], size_t N) {
    if (ints == NULL || sizeof(ints) % 2 != 0)
        return false;

    for (int i = 0; i < sizeof(ints) - 1; i++)
        if (ints[i] != ints[i + 1] * (-1))
            return false;

    return true;
}

int main(void) {
    int ints[] = {1, 0, 1, 0};
    size_t N = sizeof(ints) / sizeof(ints[0]);

    isArrayAlternating(ints);

    return 0;
}
4

3 回答 3

3
  • 你不能sizeof用来确定传递数组的大小，所以你必须传递它。（有关更多信息，请参阅传递数组的 C 大小 - 代码日志）
  • 乘法-1将1变成-1和。0_ 0它不能在 和 之间切换1，0所以条件错误。
  • 你isArrayAlternating有 2 个参数，但你调用它时只传递了一个。

应用了这些要点的代码：

int isArrayAlternating(int ints[], int N) {
    if (ints == NULL || N % 2 != 0) {
        return false;

    }
    for (int i = 0; i < N - 1; i++) {
        if (ints[i] != 1 - ints[i + 1]) {
            return false;
        }
    }
    return true;
}

int main() {

    int ints[] = {1, 0, 1, 0};
    isArrayAlternating(ints, sizeof(ints) / sizeof(*ints));
}

下一步可能是添加一些代码来打印结果。

于 2020-10-05T14:22:59.903 回答
0

对于初学者来说，第一个函数参数应该有限定符 const，因为传递的数组在函数中没有改变。此外，使用数组名称的标识符也不是一个好主意，ints 因为它会降低函数的可读性。并且不要对全部由大写字母组成的变量使用标识符。

函数声明可能看起来像

int isArrayAlternating( const int a[], size_t n ) {

其次，您没有在函数体内使用第二个参数。而且您忘记提供相应的参数。而不是它，你正在使用表达式

sizeof(ints)

这给出了指针的大小，因为具有数组类型的函数参数由编译器 tp 指针隐式转换为数组元素类型。也就是这两个函数声明

int isArrayAlternating( const int a[], size_t n );

和

int isArrayAlternating( const int *a, size_t n );

声明相同的一个函数。

在函数中，您不应检查传递的指针是否等于 NULL 或元素数是否为偶数。例如，在您的问题中，您使用的是奇数个元素的数组

1,1,0,1,1

以及 if 语句中的条件

if (ints[i] != ints[i + 1] * (-1))

没有意义。

函数定义看起来像

int isArrayAlternating( const int a[], size_t n ) 
{
    size_t i = 0;

    if ( n )
    {
        int value = a[0];

        for ( ; i < n && a[i] == value; i++ )
        {
            value ^= 1;
        }
    }

    return i == n;
}

该函数可以像这样调用

int alternative = isArrayAlternating(ints, N );
于 2020-10-05T14:43:12.430 回答
0

这是一个有趣的问题，可以转化为 Ada：

with Ada.Text_IO; use Ada.Text_IO;

procedure Main is
   type Bit_Array is array (Positive range <>) of Boolean with
      Pack;
   function Is_Alternating (Item : Bit_Array) return Boolean with
      Pre => Item'Length >= 2
   is
      Value : Boolean  := True;
      I     : Positive := Item'First;
   begin
      loop
         Value := Item (I) xor Item (I + 1);
         exit when Value = False or I = Item'Last - 1;
         I := I + 1;
      end loop;
      return I = Item'Last - 1 and Value = True;
   end Is_Alternating;

   A : Bit_Array := (True, False, True, False, True, False);
   B : Bit_Array := (False, True, False, True, False, True, False, True);
   C : Bit_Array := (True, True, False, True, True);
begin
   Put_Line ("A : " & Boolean'Image (Is_Alternating (A)));
   Put_Line ("B : " & Boolean'Image (Is_Alternating (B)));
   Put_Line ("C : " & Boolean'Image (Is_Alternating (C)));
end Main;

这个程序的输出是：

A : TRUE
B : TRUE
C : FALSE

此解决方案创建一个打包的布尔值数组。一个打包的布尔数组会产生一个位数组，每个位代表一个布尔值。数组类型不受约束，允许 Bit_Array 的每个实例具有不同的长度。因此，标记为 A、B 和 C 的实例具有不同的长度。

于 2020-10-05T15:25:40.327 回答