Question

我有一个作业，应该检查两个带有整数的数组（未排序），看是否

它们的长度相同
第一个元素包含整数，第二个元素具有相同的平方值，以任意顺序排列

例如：

function test(arr1, arr2){
  // sort arrays
  const arr1Sort = arr1.sort(),
        arr2Sort = arr2.sort();

  // compare length and then compare values
  if(arr1Sort.length === arr2Sort.length) {
    for(let i = 0; i < arr1Sort.length; i++) {
      if(arr1Sort[i] === arr2Sort[i]) {
        return true;
      } else {
        return false;
      }
    }
  }
}

console.log(test([1,2,3], [1,5,4])); returns true but the array values are different?!

到目前为止，我首先对两个输入数组进行了排序，然后比较了长度。一旦确认长度相同，我们将遍历每个值以确保它们相等。请记住，我还没有将这些值与其平方对应值进行比较，因为我的循环并没有给我预期的结果。这是代码：

div

Answer 1

在for内，无论是否满足if或else，该函数都会在第一次迭代时立即返回true或false-它永远不会超过索引0。首先，return true仅在循环结束后结束，并且return false是否为arr1Sort[i] ** 2 !== arr2Sort[i]（检查第一个平方是否等于第二个平方）。

另外，在排序时，请确保使用回调函数比较每个项目的差异，因为否则，.sort将按字母顺序对进行排序（例如{ {1}}）：

[1, 11, 2]

您可以通过将function comp(arr1, arr2){ // sort arrays const sortCb = (a, b) => a - b; const arr1Sort = arr1.sort(sortCb), arr2Sort = arr2.sort(sortCb); // compare length and then compare values if(arr1Sort.length !== arr2Sort.length) { return false; } for(let i = 0; i < arr1Sort.length; i++) { if(arr1Sort[i] ** 2 !== arr2Sort[i]) { return false; } } return true; } console.log(comp([1,2,3], [1,5,4])); console.log(comp([5,4,1], [1,16,25]));变成预先由平方数索引的对象，将计算复杂度降低到O(N)而不是O(N log N)：

arr2

（如果不允许重复，则使用function comp(arr1, arr2){ if (arr1.length !== arr2.length) { return false; } const arr2Obj = arr2.reduce((a, num) => { a[num] = (a[num] || 0) + 1; return a; }, {}); for (let i = 0; i < arr1.length; i++) { const sq = arr1[i] ** 2; if (!arr2Obj[sq]) { return false; } arr2Obj[sq]--; } return true; } console.log(comp([1,2,3], [1,5,4])); console.log(comp([5,4,1], [1,16,25]));会容易得多，但不幸的是，它们很容易实现）

Answer 2

这应该有效，没有要比较的数据：

function similar(needle, haystack, exact){
  if(needle === haystack){
    return true;
  }
  if(needle instanceof Date && haystack instanceof Date){
    return needle.getTime() === haystack.getTime();
  }
  if(!needle || !haystack || (typeof needle !== 'object' && typeof haystack !== 'object')){
    return needle === haystack;
  }
  if(needle === null || needle === undefined || haystack === null || haystack === undefined || needle.prototype !== haystack.prototype){
    return false;
  }
  var keys = Object.keys(needle);
  if(exact && keys.length !== Object.keys(haystack).length){
    return false;
  }
  return keys.every(function(k){
    return similar(needle[k], haystack[k]);
  });
}
console.log(similar(['a', {cool:'stuff', yes:1}, 7], ['a', {cool:'stuff', yes:1}, 7], true));
// not exact
console.log(similar(['a', {cool:'stuff', yes:1}, 7], ['a', {cool:'stuff', stuff:'more', yes:1}, 7, 'more stuff only at the end for numeric array']));

比较两个数组中元素的相等性

2 个答案: