Question

我想知道整数数组是否交替。在JAVA。

例如：

a[]={1,-1,1,-1,1,-1}  --> true
a[]={-1,1,-1,1,-1}    --> true
a[]={1,-4,1-6,1}      --> true
a[]={1,1,1,14,5,3,2}  --> false

我已经开始编写一些使用标志的代码。例如，如果current_is_positive=0和else = 1，但我没有到达任何地方。实现这种效果的好方法是什么？

Answer 1

我认为你的意思是交替出现符号，即正数，负数，正数等？您可以使用以下策略：

略过第一个元素。

对于其他每个元素，将其符号与前一个元素的符号进行比较：

如果它们不同，那么序列现在仍然是交替的 - 你应该继续。
如果它们是相同的符号，则序列不是交替的。此时您可以停止处理。

由于这听起来像是家庭作业，我会留给你用Java编写适当的代码。

Answer 2

这是我的解决方案：

这检查元素n + 1是元素n的倒数。

    public static void main(String[] args) {
        int[] ints = {1, -1, 2, -1};
        System.out.println(new Example().isArrayAlternating(ints));
    }

    public boolean isArrayAlternating(int[] ints) {
        if (ints == null || ints.length % 2 != 0) {
            return false;
        }
        for (int i = 0; i < ints.length - 1; i++) {
            if (ints[i] != ints[i + 1]*(-1)) {
                return false;
            }
        }
        return true;
    }

如果您只想检查正数，负数... n次，而不注意值：

public static void main(String[] args) {
    int[] ints = {1, -1, 2, -1};
    System.out.println(new Example().isArrayAlternating(ints));
}

public boolean isArrayAlternating(int[] ints) {
    if (ints == null || ints.length % 2 != 0) {
        return false;
    }
    for (int i = 0; i < ints.length - 1; i++) {
        if (ints[i] >= 0 && ints[i + 1] >= 0 || ints[i] <= 0 && ints[i + 1] <= 0) {
            return false;
        }
    }
    return true;
}

Answer 3

您可以简单地检查所有项目是否与两步后面的项目相同。我不知道你使用的语言是什么，但是例如使用C＃你可以这样做：

bool alternating = a.Skip(2).Where((n, i) => a[i] == n).Count() == a.Length - 2;

编辑：

所以你想检查值的符号是否是交替的，而不是值？

然后只需检查上一项的标志：

bool alternating = a.Skip(1).Where((n,i) => Math.Sign(n) == -Math.Sign(a[i])).Count() == a.Length-1;

Answer 4

boolean prevPositive = arr[0] > 0, error = false;
for (int i = 1; i < arr.length; ++i) {
    boolean current = arr[i] > 0;
    if (current != prevPositive) {
        current = prevPositive;
    } else {
        error = true;
        break;
    }
}
if (error)
   System.out.println("No");
else
   System.out.println("Yes");

Answer 5

运行循环，从第一个索引到最大可能，步长为2，以检查相同的符号。
然后再循环一次，从第二个索引到最大可能，步长为2，检查相反的符号，但都是相同的。
所以，从索引循环 - 0, 2, 4, 6, ...
然后从索引循环 - 1, 3, 5, 7, ...

然后检查两次循环中每个数字的乘以该迭代中的第一个数字是否为正。

int a[]={1,-1,1,-1,1,-1};

boolean alternating = true;

for (int i = 0; i < a.length; i = i + 2) {
    if (a[i] * a[0] > 0) {
    } else {
        alternating = false;
    }
}
for (int i = 1; i < a.length; i = i + 2) {
    if (a[i] * a[1] > 0) {
    } else {
        alternating = false;
    }
}

if (alternating) {
    System.out.println("Array is alternating");
} else 
    System.out.println("Array is not alternating");
}

Answer 6

private enum SIGN {
    POSITIVE, NEGATIVE
};

public static boolean isAlternating(int... ints) {
    SIGN last = null;
    for (int i : ints) {
        if (i >= 0) {
            if (last == null) {
                last = SIGN.POSITIVE;
            } else {
                if (last == SIGN.POSITIVE) {
                    return false;
                } else {
                    last = SIGN.POSITIVE;
                }
            }
        } else {
            if (last == null) {
                last = SIGN.NEGATIVE;
            } else {
                if (last == SIGN.NEGATIVE) {
                    return false;
                } else {
                    last = SIGN.NEGATIVE;
                }
            }
        }
    }
    return true;
}

Answer 7

从索引1直到结束运行数组。

在每个索引处，评估(a[i] > 0) == (a[i-1] > 0)。如果这是真的，那么你的数组不会交替。

如果直到结束而没有结束它不是交替的，那么它是交替的：）

Answer 8

For i = 2 to n

   check whether A[i-1] && A[i] are with diff sign..
   in C++; return  ((A[i-1] ^  A[i]) < 0).

同样在此解释：http://www.youtube.com/watch?v=Z59REm2YKX0

修改

如果整数为负，则高位为1.否则为0.您可以通过将它们一起进行异或来检查两个整数是否具有不同的符号。如果符号不同，则结果的高位为1.如果它们相同，则高位为0.因此，

XOR B＆lt; 0相当于“A和B有不同的符号”

Peter Ruderman

如何判断整数数组是否为交替数组？

8 个答案:

编辑：