为什么我的代码在比较两个数组时只返回一次true

Question

我正试图解决一个代码战争问题，但我似乎无法让我的代码正常工作。

a1 = [121, 144, 19, 161, 19, 144, 19, 11];
a2 = [11*11, 121*121, 144*144, 19*19, 161*161, 19*19, 144*144, 19*19];
Test.assertEquals(comp(a1, a2), true);
function comp(array1, array2){
let newArray1Squared = [];
let newArray1 = a1.sort(function(a, b){
return a - b;
});
newArray1.map(function(num){
newArray1Squared.push(num*num);
});
let newArray2 = a2.sort(function(a, b){
return a - b;
});
for (let i = 0; i<newArray1Squared.length; i++){
if (newArray1Squared[i] === newArray2[i]){
return true;
} else {
return false;
}
}
}

到目前为止，这是我的代码。问题是：

给定两个数组a和b，编写一个函数comp(a，b((Clojure中的compSame(a，b((，检查这两个数组是否具有"相同"的元素，具有相同的乘法。这里，"相同"的意思是，b中的元素是正方形中的元素，而不考虑顺序。

示例有效数组

a = [121, 144, 19, 161, 19, 144, 19, 11]  
b = [121, 14641, 20736, 361, 25921, 361, 20736, 361]

comp(a，b(返回true，因为在b中，121是11的平方，14641是121的平方，20736是144的平方，361是1925921的平方，161的平方，依此类推

Answer 1

在for循环中，您当前只比较排序数组中的第一项。除最低项之外的任何项目都不会被考虑，因为一旦比较了两个最低项，函数将是return true或return false。

排序后，使用every检查一个数组中的每个元素是否与另一个匹配：

const a1 = [121, 144, 19, 161, 19, 144, 19, 11];
const a2 = [11 * 11, 121 * 121, 144 * 144, 19 * 19, 161 * 161, 19 * 19, 144 * 144, 19 * 19];
console.log(comp(a1, a2));
function comp(array1, array2) {
if (array1.length !== array2.length) {
return false;
}
const arr1Sq = array1
.map(num => num ** 2)
.sort((a, b) => a - b);
array2.sort((a, b) => a - b);
return arr1Sq.every((num, i) => array2[i] === num);
}

然而，.sort具有O(n log n)的复杂性。对于较大的输入，最好使用对象或Map来收集出现次数，因为O(n):的总体复杂性

const a1 = [121, 144, 19, 161, 19, 144, 19, 11];
const a2 = [11 * 11, 121 * 121, 144 * 144, 19 * 19, 161 * 161, 19 * 19, 144 * 144, 19 * 19];
console.log(comp(a1, a2));
function comp(array1, array2) {
if (array1.length !== array2.length) {
return false;
}
const counts = {};
for (const item of array1) {
const squared = item ** 2;
counts[squared] = (counts[squared] || 0) + 1;
}
for (const item of array2) {
counts[item]--;
if (counts[item] === -1 || Number.isNaN(counts[item])) {
return false;
}
}
return true;
}

Answer 2

函数只被调用一次，在使用return语句时结束。您只检查数组的第一个值。

您需要重构函数以在外部使用for循环，并在每个循环中运行测试。

我认为这是可行的：

a1 = [121, 144, 19, 161, 19, 144, 19, 11];
a2 = [11*11, 121*121, 144*144, 19*19, 161*161, 19*19, 144*144, 19*19];
let newArray1 = a1.sort(function(a, b){
return a - b;
});
let newArray2 = a2.sort(function(a, b){
return a - b;
});
for (let i = 0; i<newArray1.length; i++){  
console.log(comp(newArray1[i], newArray2[i])); //Run the test for every value in the array
}
function comp(value1, value2){
let squareValue1 = value1*value1; 
return squareValue1 === value2;
}

Answer 3

您可以通过使用对象存储数组1中每个值的出现次数，然后遍历数组2并递减对象中的出现次数来解决此问题，最后遍历对象以查看是否所有值都为0。

检查以下内容：

var a1 = [121, 144, 19, 161, 19, 144, 19, 11];
var a2 = [11*11, 121*121, 144*144, 19*19, 161*161, 19*19, 144*144, 19*19];
function comp(array1, array2) {
var temp = {};
if(array1.length != array2.length)
return false;
for(let a of array1) {
if(temp[a]) {
temp[a]++;
} else {
temp[a] = 1;
}
}
for(let a of array2) {
let sqrt = Math.sqrt(a);
if(temp[sqrt] && temp[sqrt] > 0) {
temp[sqrt]--;
} else {
return false;
}
}
var keys = Object.keys(temp);
for(let key of keys) {
if(temp[key] != 0)
return false;
}
return true;
}
console.log(comp(a1, a2));