在Java中找到列表/数组是否实际上是较小数组的好方法

我一直在尝试编写这个reduce方法，但我找不到一个用java实现它的好方法。我用python进行了管理，但它使用了很多python的东西，而将其移植到java似乎真的很痛苦。有没有更适合java的方法

这里有一些测试代码，如果标题不清楚，应该可以说明我的意思

我的python测试代码：

def reduce_(duplicated):
  def get_factors(n):    
    return set(reduce(list.__add__, 
      ([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0)))

  factors = sorted(list(get_factors(len(duplicated))))
  for factor in factors:
    chunks = set([tuple(duplicated[i:i + factor]) for i in xrange(0, len(duplicated), factor)])
    if len(chunks) == 1:
      return list(chunks.pop())
  return duplicated


def verify(expected, duplicated):
  try:
    result = reduce_(duplicated)
    assert (expected == result)
    print expected, "passed"
  except AssertionError:
      print "expected", expected, "!=", duplicated

#should return the same
verify([1, 2, 3], [1,2,3])
verify([1,2], [1,2])
verify([1,1,2], [1,1,2])
verify([5,8,8], [5,8,8])
verify([8], [8])
verify([1,8,1], [1,8,1])
verify([5,2,2,5], [5,2,2,5])
verify([5,5,2,2], [5,5,2,2])

# repeated only once    
verify([1, 2, 3], [1,2,3,1,2,3])
verify([1,2], [1,2,1,2])
verify([1,1,2], [1,1,2,1,1,2])
verify([5,8,8], [5,8,8,5,8,8])
verify([8], [8,8])
verify([1,8,1], [1,8,1,1,8,1])
verify([5,2,2,5], [5,2,2,5,5,2,2,5])
verify([5,5,2,2], [5,5,2,2,5,5,2,2])

# repeated twice  
verify([1, 2, 3], [1,2,3,1,2,3,1,2,3])
verify([1,2], [1,2,1,2,1,2])
verify([1,1,2], [1,1,2,1,1,2,1,1,2])
verify([5,8,8], [5,8,8,5,8,8,5,8,8])
verify([8], [8,8,8])
verify([1,8,1], [1,8,1,1,8,1,1,8,1])
verify([5,2,2,5], [5,2,2,5,5,2,2,5,5,2,2,5])
verify([5,5,2,2], [5,5,2,2,5,5,2,2,5,5,2,2])

您可以在此处运行：

还有一些Java测试代码，可以在这里运行

import java.util.*；
公共类HelloWorld
{
公共静态T[]减少（T[]重复）
{
返回重复；//实现我！
}
//使用此编辑器下面的文本字段传递参数
公共静态void main（字符串[]args）
{
//应该返回相同的
验证（新整数[]{1,2,3}，新整数[]{1,2,3}）；
验证（新整数[]{1,2}，新整数[]{1,2}）；
验证（新整数[]{1,1,2}，新整数[]{1,1,2}）；
验证（新整数[]{5,8,8}，新整数[]{5,8,8}）；
验证（新整数[]{8}，新整数[]{8}）；
验证（新整数[]{1,8,1}，新整数[]{1,8,1}）；
验证（新整数[]{5,2,2,5}，新整数[]{5,2,2,5}）；
验证（新整数[]{5,5,2,2}，新整数[]{5,5,2,2}）；
//只重复一次
验证（新整数[]{1,2,3}，新整数[]{1,2,3,1,2,3}）；
验证（新整数[]{1,2}，新整数[]{1,2,1,2}）；
验证（新整数[]{1,1,2}，新整数[]{1,1,2,1,1,2}）；
验证（新整数[]{5,8,8}，新整数[]{5,8,8,5,8,8}）；
验证（新整数[]{8}，新整数[]{8,8}）；
验证（新整数[]{1,8,1}，新整数[]{1,8,1,1,8,1}）；
验证（新整数[]{5,2,2,5}，新整数[]{5,2,2,5,5,5,2,2,5}）；
验证（新整数[]{5,5,2,2}，新整数[]{5,5,2,2,5,5,2,2}）；
//重复两次
验证（新整数[]{1,2,3}，新整数[]{1,2,3,1,2,3,1,2}）；
验证（新整数[]{1,2}，新整数[]{1,2,1,2,1,2}）；
验证（新整数[]{1,1,2}，新整数[]{1,1,2,1,1,2,1,2}）；
验证（新整数[]{5,8,8}，新整数[]{5,8,8,5,8,8}）；
验证（新整数[]{8}，新整数[]{8,8,8}）；
验证（新整数[]{1,8,1}，新整数[]{1,8,1,1,8,1,1}）；
验证（新整数[]{5,2,2,5}，新整数[]{5,2,2,5,5,5,2,2,5,5}）；
验证（新整数[]{5,5,2,2}，新整数[]{5,5,2,2,5,5,2,2}）；
}
公共静态无效验证（预期最终T[]，最终T[]重复）
{
如果（预期==null | |复制==null）抛出新的ComparisonException（“不能为null”）；
最终T[]结果=减少（重复）；
如果（result==null）抛出新的ComparisonException（“不能为null”）；
if（预期的.length！=结果.length）
{
抛出新的ComparisonException（“长度在“+Arrays.toString（预期）+”和“+Arrays.toString（结果）”中不匹配）；
}
对于（int i=0；i

所以您想测试一个数组是否是一个较小的重复数组-现在根据您的定义，

bigArray.length%smallArray.length！=0

表示它不是重复的较小数组，我可以给您一个解决方案。换句话说：如果较小的数组在较大的数组中不适合偶数次，这是否意味着较小的数组不是重复的？如果这是真的，请尝试以下方法：

public boolean isArrayAnotherArrayRepeated(ArrayType[] bigArray, ArrayType[] smallType) {
    double numberOfTimesSmallFitsInBig = bigArray.length / smallArray.length;
    if (numberOfTimesSmallFitsInBig % 1 == 0)
    {
        //checks the condition mentioned above, i.e. that small doesn't fit into big an even number of times
        return false;
    }
    for (int i = 0; i < (int) numberOfTimesSmallFitsInBig; i++)
    {
        for (int h = 0; h < smallArray.length; h++)
        {
            if (smallArray[h] != bigArray[i+h]) {
                //note that you may have to use .equals here, if you don't want to compare references or primitive data types.
                //that would then look like "if (!smallArray[h].equals(bigArray[i+h]))"
                return false;
            }
        }
    }
    return true;
}

公共布尔值isArrayAnotherArrayRepeated（ArrayType[]bigArray，ArrayType[]smallType）{
double numberOfTimesSmallFitsInBig=bigArray.length/smallArray.length；
如果（numberOfTimesSmallFitsInBig%1==0）
{
//检查上述情况，即小的不适合大的次数为偶数
返回false；
}
对于（int i=0；i<（int）numberoftimesmallfitsinbig；i++）
{
for（int h=0；h

如果这个解决方案不符合您的需要，请评论我的答案，我将尝试想出其他解决方案。不过现在已经很晚了，否则我现在就去^^
（请注意，我从未使用Python做过任何事情，因此我没有费心去理解您的代码）

不确定“nice”，但它可以工作：

public static <T> T[] reduce(T[] duplicated)
{
    int len = duplicated.length;
    for (int i = 1; i <= len / 2; i++) {
        if (len % i == 0) {
            if (checkFactors(i, duplicated)) {
                return Arrays.copyOf(duplicated, i);
            }
        }
    }
    return duplicated;
}

public static <T> boolean checkFactors(int factor, T[] arr) {
    int len = arr.length;
    for (int j = 1; j < len / factor; j++) {
        if (!rangeCompare(j * factor, factor, arr)) {
            return false;
        }
    }
    return true;
}

public static <T> boolean rangeCompare(int off, int len, T[] arr) {
    for (int i = 0; i < len; i++) {
        if (!arr[i].equals(arr[off + i])) {
            return false;
        }
    }
    return true;
}

公共静态T[]减少（T[]重复）
{
int len=重复的长度；
对于（inti=1；i这个如何？返回值是0=不重复，1=相同，2=重复一次，3=重复两次等

public int FindDuplicates(Integer[] a, Integer[] b)
{
    int bigIndex = 0;
    int smallIndex = 0;
    int duplicates = 0;

    if(b.length % a.length == 0)
    while(bigIndex < b.length)
    {
        if(a[smallIndex] == b[bigIndex])
        {
            bigIndex++;
            smallIndex++;
            if(smallIndex == a.length)
            {
                smallIndex = 0;
                duplicates++;
            }
        }
        else
        {
            duplicates = 0;
            break;
        }
    }

    return duplicates;
}

public int findduplices（整数[]a，整数[]b）
{
int-bigIndex=0；
int-smallIndex=0；
重复整数=0；
如果（b.length%a.length==0）
而（bigIndex

这也是O（n），因为我们只需要通过最大的
public int FindDuplicates(Integer[] a, Integer[] b)
{
    int bigIndex = 0;
    int smallIndex = 0;
    int duplicates = 0;

    if(b.length % a.length == 0)
    while(bigIndex < b.length)
    {
        if(a[smallIndex] == b[bigIndex])
        {
            bigIndex++;
            smallIndex++;
            if(smallIndex == a.length)
            {
                smallIndex = 0;
                duplicates++;
            }
        }
        else
        {
            duplicates = 0;
            break;
        }
    }

    return duplicates;
}