Java 扫描数组以查找可被3整除的最长子数组的长度

我正在编写一个程序，扫描一个数组，并生成最长子数组的长度，其中包含的元素的和可以被3整除。我使用了另一个问题中的概念，使用前缀和概念——扫描modolu 3给出0,1,2的第一个和最后一个总和，计算每个集合之间的差值，并返回三个集合中最大的一个

我决定用随机数组生成器来测试它。90%的情况下，它是有效的，但在其他情况下，它会因为几个数字而错过正确答案。 知道怎么了吗

我已经包括了一个测试人员，其中包括一个做同样事情的非有效方法。图片包括：

输出：

84 | 4 | 94 | 27 | 85 | 10 | 87 | 11 | 66 | 34 | 66 | 42 | 26 | 65 | 12 | 93 | 14|

阵列大小为：17

坏什么：15

我的什么：13

代码：

导入静态java.lang.Math.*；
导入java.util.Random；
公开课Q1{
公共静态void main（字符串参数[]）{
Random rand=新的Random（）；
int[]a=新int[rand.nextInt（100）]；
for（int i=0；i结果）
结果=++firstZero；
返回结果；
}
公共静态int negMod（int a）
{
如果（a一个明显的错误是，不是
sumlefit+=negMod（a[i]%3）；
而是
sumlefit+=negMod（a[i]）%3；

您的算法中似乎有很多问题。首先，在
sumrright
中，您应该包含从第一个元素到当前元素的总和，但您包含的是从当前元素到最后一个元素的总和。因此，您的解决方案在一些测试中起到了作用，这真是一个好运气

第二，你应该找到第一个具有特定模的子数组和最后一个。因此，一旦找到它，你不需要覆盖它

这应该起作用：

public static int what(int[] a) {
    if (a.length == 0) {
        return 0;
    }

    int sumLeft = 0, sumRight = 0;
    for (int el : a) {
        sumRight += el % 3;
    }
    sumRight = negMod(sumRight % 3);

    int firstZero = a.length, firstOne = a.length, firstTwo = a.length,
            lastZero = -1, lastOne = -1, lastTwo = -1;
    for (int i = 0; i < a.length + 1; i++) {
        if (sumLeft % 3 == 0 && firstZero == a.length)
            firstZero = i;
        if (sumRight % 3 == 0 && lastZero == -1)
            lastZero = a.length - 1 - i;
        if (sumLeft % 3 == 1 && firstOne == a.length)
            firstOne = i;
        if (sumRight % 3 == 1 && lastOne == -1)
            lastOne = a.length - 1 - i;
        if (sumLeft % 3 == 2 && firstTwo == a.length)
            firstTwo = i;
        if (sumRight % 3 == 2 && lastTwo == -1)
            lastTwo = a.length - 1 - i;
        sumLeft += negMod(a[min(i, a.length - 1)] % 3);
        sumRight = negMod(sumRight - a[max(a.length - 1 - i, 0)] % 3);
    }
    int zero = lastZero - firstZero + 1;
    int one = lastOne - firstOne + 1;
    int two = lastTwo - firstTwo + 1;
    Integer[] options = new Integer[]{zero, one, two, 0};
    return Collections.max(Arrays.asList(options));
}

公共静态int-what（int[]a）{
如果（a.length==0）{
返回0；
}
int sumlight=0，sumlight=0；
对于（整数el:a）{
sumRight+=el%3；
}
sumRight=negMod（sumRight%3）；
int firstZero=a.length，firstOne=a.length，firstTwo=a.length，
lastZero=-1，lastOne=-1，lastTwo=-1；
对于（int i=0；i
“90%的情况下它能工作，但在其他情况下，它会因为几个数字而错过正确答案”-发布示例输入/输出/预期输出元组。感谢反馈，我已经编辑了帖子。你有什么理由将它们作为截图而不是实际代码包含吗？有人如何将截图插入到他们的代码中，并找出你的代码行为不正常的原因？我已经将输出包含在文本中，没有必要生气，这是我第一次在这里问问题。@Jamaico：除非有人在这里使用攻击性的词语，否则不要过多地解读人们的语气。如果它跨过了一条线，你可以将其标记为版主，但要记住，高代表性的用户不断看到相同的帖子问题，他们（我们）希望通过帮助人们在第一次编辑时合理地正确/回答问题来提高堆栈溢出的效率。非常感谢。这减少了错误的数量，但仍然存在问题。非常感谢，我发现我的主要问题不是为模（1,2,0）的概念做准备只能出现一次或根本不能出现。你就是那个人！@A.Yurchenko当你输入一个不能被3整除的单元素数组时，有一个问题，即58 |数组大小是：1坏什么：0我的什么：1@Jamaico-我编辑了我的答案，再次检查。选择的初始值有问题添加if（（a.length==1）和&（a[0]%3！=0））{返回0；}
public static int what(int[] a) {
    if (a.length == 0) {
        return 0;
    }

    int sumLeft = 0, sumRight = 0;
    for (int el : a) {
        sumRight += el % 3;
    }
    sumRight = negMod(sumRight % 3);

    int firstZero = a.length, firstOne = a.length, firstTwo = a.length,
            lastZero = -1, lastOne = -1, lastTwo = -1;
    for (int i = 0; i < a.length + 1; i++) {
        if (sumLeft % 3 == 0 && firstZero == a.length)
            firstZero = i;
        if (sumRight % 3 == 0 && lastZero == -1)
            lastZero = a.length - 1 - i;
        if (sumLeft % 3 == 1 && firstOne == a.length)
            firstOne = i;
        if (sumRight % 3 == 1 && lastOne == -1)
            lastOne = a.length - 1 - i;
        if (sumLeft % 3 == 2 && firstTwo == a.length)
            firstTwo = i;
        if (sumRight % 3 == 2 && lastTwo == -1)
            lastTwo = a.length - 1 - i;
        sumLeft += negMod(a[min(i, a.length - 1)] % 3);
        sumRight = negMod(sumRight - a[max(a.length - 1 - i, 0)] % 3);
    }
    int zero = lastZero - firstZero + 1;
    int one = lastOne - firstOne + 1;
    int two = lastTwo - firstTwo + 1;
    Integer[] options = new Integer[]{zero, one, two, 0};
    return Collections.max(Arrays.asList(options));
}