如何检查存储在数组中的两个循环序列是否相等（Java）？

Question

在我的课堂上，我的任务是用 Java 编写一个程序，告诉你存储在一个数组中的 2 个长度为 8 的 DNA 序列是否相同。然而，序列可以是循环的。比如这两个是一样的：

A T G C G T A T

A T A T G C G T

我编写的代码检查索引 0 处的两个数组是否相同，如果它们相同，则转到检查数组方法，如果不是，则将 1 添加到第二个数组的索引并重新开始。但是我很困惑，因为我不确定如何输入检查方法通过两个数组的新索引，或者如何循环索引（即从 7 回到 0）。

对不起，如果代码是垃圾，我是一个初学者，发现这个问题很混乱。 在此先感谢:)

/* checking whether the two arrays are equal at a certain index

for (x=0;x<8;) {
            for (y=0;y<8;) {
                if (DNAarray1[x] == DNAarray2[y]) {
                    isEqual(ADNarray1, ADNarray2);
                } else y++;
            }
        }

/* isEqual method - my issue is with how I can take x and y from above and carry them into this method.
And also how to loop this back round so the index of y goes from 7 back to 0.

static boolean isEqual(int[] ADN1, int[] ADN2) {
        for (int c = 1; c < 8; c++) {
            if (ADN1[x + c] == ADN2[y + c]) {
                return true;
            } else return false;
        }
    }

Answer 1

要让 x 和 y 进入方法，只需添加同名参数 要在 7 之后返回 0，请使用模运算符 %。

您的代码包含必要的更改和一些修复：

static boolean isCyclicEqual(int[] DNA1, int[] DNA2) {
    for (x=0;x<8;x++) {
        for (y=0;y<8;y++) {
            if (isEqual(DNAarray1, x, DNAarray2, y)) {
                return true;
            }
        }
    }
    return false;
}

static boolean isEqual(int[] DNA1, int x, int[] DNA2, int y) {
    for (int c = 0; c < 8; c++) {
        if (DNA1[(x + c) % 8] != DNA2[(y + c) % 8]) {
            return false;
        }
    }
    return true;
}

Answer 2

如果数组中只有 8 元素，那么性能对于解决方案来说并不重要。那么它可能是这样的：

public static boolean isEqualCycle(char[] one, char[] two) {
    String strOne = new String(one);
    String strTwo = new String(two);

    for (int i = 0; i < one.length; i++) {
        if (strOne.equalsIgnoreCase(strTwo))
            return true;
        strTwo = strTwo.charAt(strTwo.length() - 1) + strTwo.substring(0, strTwo.length() - 1);
    }

    return false;
}

---

另一个灵魂是使用额外的数组：

public static boolean isEqualCycle(char[] one, char[] two) {
    char[] tmp = Arrays.copyOf(two, two.length);

    for (int i = 0; i < one.length - 1; i++) {
        if (isEqual(one, tmp))
            return true;
        rotateRight(tmp);
    }

    return false;
}

private static boolean isEqual(char[] one, char[] tmp) {
    for (int i = 0; i < one.length; i++)
        if (one[i] != tmp[i])
            return false;
    return true;
}

private static void rotateRight(char[] arr) {
    for (int i = 0, j = arr.length - 1; i < j; i++, j--)
        swap(arr, i, j);
    for (int i = 1, j = arr.length - 1; i < j; i++, j--)
        swap(arr, i, j);
}

private static void swap(char[] arr, int i, int j) {
    char tmp = arr[i];
    arr[i] = arr[j];
    arr[j] = tmp;
}

Answer 3

如果将DNA序列表示为字符串/字符串数组，可以方便地使用Collections.rotate方法进行循环移位：

static boolean isEqual(String[] one, String[] two) {
    if (one.length != two.length) return false; // verify the length
    
    List<String> sec = Arrays.asList(two);
    
    for (int i = 0; i < one.length; i++) {
        if (Arrays.equals(one, two)) {
            System.out.println("equal at position=" + i);
            return true;
        }
        Collections.rotate(sec, -1); // contents of `two` is rotated as well
    }
    System.out.println("non-equal");
    return false;
}

测试：

isEqual("ATGCGTAT".split(""), "ATATGCGT".split(""));
isEqual("ATGCGTAT".split(""), "TATGGCTA".split(""));

输出：

equal at position=2
non-equal