检查两个数组是否相似的Java代码

我在一个网站上遇到了这个编码问题。问题如下:

如果通过交换其中一个数组中最多一对元素可以从另一个数组中获得一个数组，则称这两个数组为相似数组

给定两个数组，检查它们是否相似

范例

对于A=[1,2,3]和B=[1,2,3]，输出应该是 A相似（A，B）=真

数组是相等的，不需要交换任何元素

对于A=[1,2,3]和B=[2,1,3]，输出应该是 A相似（A，B）=真

我们可以通过交换B中的2和1从A获得B

对于A=[1,2,2]和B=[2,1,1]，输出应该是 A相似（A，B）=假

A或B中任意两个元素的任何交换都不会使A和B相等

这就是我给出的解决方案：

boolean areSimilar(int[] A, int[] B) {
    if(A.length != B.length) return false;

    int[] copyA = A, copyB = B;
    Arrays.sort(copyA); Arrays.sort(copyB); 
    int countSwap = 0;

    if(!Arrays.equals(copyA, copyB)) return false;

    for(int i = 0; i < A.length; i++) {
        if(A[i] != B[i]) countSwap++;
    }

    return (countSwap == 2 || countSwap == 0);
}

布尔相似（int[]A，int[]B）{
如果（A.length！=B.length）返回false；
int[]copyA=A，copyB=B；
Arrays.sort（copyA）；Arrays.sort（copyB）；
int countSwap=0；
如果（！array.equals（copyA，copyB））返回false；
for（int i=0；i

此代码为以下阵列提供了正确的结果：

答：[1,2,3]
B:[1,2,3]

答：[1,2,3]
B:[2,1,3]

答：[1,2,2]
B:[2,1,1]

答：[1,1,4]
B:[1,2,3]

答：[1,2,3]
B:[1,10,2]

答：[2,3,1]
B:[1,3,2]

---

但每次我试图提交代码时，网站仍然显示“不正确”。它未能通过六个隐藏测试中的两个，我也不知道为什么。这是正确的代码吗？还有其他更简单的方法吗？

您的代码无法工作，因为您在此处对原始数组进行了排序

copyA = A, copyB = B;
Arrays.sort(copyA); Arrays.sort(copyB);

然后比较排序的数组而不是原始数组，以检查它们是否可以仅使用一次交换进行转换

你应该这样做

boolean areSimilar(int[] A, int[] B) {
    if(A.length != B.length) return false;

    int countSwap = 0;
    int[] copyA = Arrays.copyOf(A, A.length);
    int[] copyB = Arrays.copyOf(B, B.length);

    // checking both contain the same elements...
    Arrays.sort(copyA); Arrays.sort(copyB); 
    if(!Arrays.equals(copyA, copyB)) return false; 

    // checking for min 2 swaps using original arrays...
    for(int i = 0; i < A.length; i++) {
        if(A[i] != B[i]) countSwap++;
    }

    return (countSwap == 2 || countSwap == 0);
}

布尔相似（int[]A，int[]B）{
如果（A.length！=B.length）返回false；
int countSwap=0；
int[]copyA=Arrays.copyOf（A，A.length）；
int[]copyB=Arrays.copyOf（B，B.length）；
//正在检查两者是否包含相同的元素。。。
Arrays.sort（copyA）；Arrays.sort（copyB）；
如果（！array.equals（copyA，copyB））返回false；
//正在使用原始阵列检查至少2次交换。。。
for（int i=0；i

更有效的解决方案

boolean areSimilar(int[] A, int[] B) {
  ArrayList<Integer> ids = new ArrayList<>();
  for (int i = 0; i < A.length; i++) {
    if ( A[i] != B[i] ) {
      ids.add(i);
    }
  }
  if (ids.size() == 0) {
    return true;
  }
  if (ids.size() != 2) {
    return false;
  }
  int id1 = ids.get(0);
  int id2 = ids.get(1);
  if (A[id1] == B[id2] && A[id2] == B[id1]) {
    return true;
  }
  return false;
}

布尔相似（int[]A，int[]B）{
ArrayList ID=新的ArrayList（）；
for（int i=0；i

程序中的问题 您没有创建和排序数组的副本，而是使用赋值

copyA = A

这意味着

copyA

仍然是对原始数组的引用，因此，当您尝试计算交换时，原始数组将被排序

这意味着，当您尝试检查两个具有相同元素但有许多交换的数组时，当您应该得到

false

时，您将得到

true

应通过以下方式复制阵列：

• A.clone（）

• Arrays.copyOf（A，A.length）

• 或

  copyA=newint[A.length]；System.arrayCopy（A，0，copyA，0，A.length）

集合而不是排序 您可以使用集合，而不是复制数组、排序和比较。进行排序的原因是检查两个数组是否具有完全相同的元素。在这种情况下，您可以将元素放入集合并比较集合，而无需排序

Set<Integer> setA = new HashSet<>(Arrays.asList(A));
Set<Integer> setB = new HashSet<>(Arrays.asList(B));
if ( ! setA.equals(setB) ) {
    return false;
}

Set setA=newhashset（Arrays.asList（A））；
Set setB=新的HashSet（Arrays.asList（B））；
如果（！setA.equals（setB））{
返回false；
}

集合的

equals

方法返回

true

当且仅当两个集合包含完全相同的元素时（在集合中顺序无关紧要）

只有在保证数组不具有重复值的情况下，set方法才会起作用。频率图可以用于重复的阵列，但坦率地说，它是不可读的

线性方法 除了线性内存之外，由于排序的原因，您的方法需要O（n logn）。事实上，目前的问题可以在线性时间和恒定内存中解决

• 检查长度是否相等。如果不是，则返回false
• 设

  ind

  为两个元素的数组，用于存在差异的位置的索引
• 循环数组（如您现在所做的）计算差异
• 如果遇到差异，如果

  countSwap

  <2，将

  i

  放入

  ind[countSwap]

  ，然后递增

  countSwap

• 在循环结束时，如果

  countSwap

  为0，则返回true
• 如果

  countSwap

  为1或大于2，则返回false
• 如果

  countSwap

  为2，请检查保留的索引项。如果

  A[ind[0]==B[ind[1]]

  和

  A[ind[1]]==B[ind[0]]

  ，则返回

  true

  ，否则返回

  false

解释

如果两个数组之间存在1或3个及以上的差异，那么它们当然不是“相似的”

但是如果你有两个不同点，这可能是因为在这两个地方有完全不同的值，或者是因为有交换

因此，您可以检查这两个差异是否是由于交换造成的

不需要排序。您进行排序的唯一原因是查看

def areSimilar(a, b):
    n = 0
    if len(a)!=len(b):
        return False
    else:
        for i in range(len(a)):
            if a[i]!=b[i]:
                n+=1
                if n>2:
                    return False
            if a[i] not in b:
                return False
        print(n)
        return True