使用 Javascript 验证第二个数组中的值是否对应于第一个数组的平方值的函数

Question

我对if-else语句有问题，而且拼接似乎不起作用。

function same(arr1, arr2) {
if (arr1.length !== arr2.length) {
return false;
}
for (let i = 0; i < arr1.length; i++) {
for (let j = 0; j < arr2.length; j++) {
let correctIndex = arr1[i] * 2;
if (correctIndex !== arr2[j]) {
return false;
}
}
console.log(arr2);
arr2.splice(correctIndex, 1)
}
return true;
}
same([1, 2, 3, 2], [9, 1, 4, 4]);

Answer 1

试试这个：

const sortNumber = numArray => numArray.sort((a, b) => a - b);
const same = (_arr1, _arr2) => { 
const arr2 = sortNumber(_arr2);
return sortNumber(_arr1).every((res,i)=>arr2[i]===res**2);
}
console.log(same([1, 2, 3, 2], [9, 1, 4, 4]))

Answer 2

您需要遍历第一个数组，引用第二个数组中的相应索引。一旦找到不是正方形的条目，就可以返回 false。

function same(arr1, arr2){
if(arr1.length !== arr2.length) return false;
arr1.sort();
arr2.sort();
// visit each item in arr1 exactly once
for(let i=0; i<arr1.length; i++){
// if entry at arr2 isn't the square of that entry in arr1, return false immediately
if(arr1[i] * arr1[i] !== arr2[i]) return false;
}
// we've checked each item, return true
return true;
}

这里不需要使用splice()，因为你只需要返回 true 或 false，而不需要修改任何一个数组。此外，您不需要使用 nested for 循环，因为您可以直接访问每个数组。

Answer 3

您还可以使用频率计数器的方法检查O(n)复杂度。

function same(arr1, arr2) {
if (arr1.length !== arr2.length) {
return false;
}
let fc1 = {};
let fc2 = {};
for (let val of arr1) {
fc1[val] = (fc1[val] || 0) + 1;
}

for (let val of arr2) {
fc2[val] = (fc2[val] || 0) + 1;
}
for (let key in fc1) {
if (!(key ** 2 in fc2)) {
return false;
}
if (fc1[key] !== fc2[key ** 2]) {
return false;
}
}

return true;
}

Answer 4

function areSquaredValues(arr1, arr2) {
if (arr1.length !== arr2.length) {
return false;
}

const obj = {};

for (let num of arr1) {
obj[num * num] = obj[num * num] ? obj[num * num] + 1 : 1;
}

for (let num of arr2) {
if (!obj[num] || obj[num] === 0) {
return false;
} else {
obj[num] -= 1;
}
}

return true;
}
console.log(areSquaredValues([1, 2, 3, 2], [9, 1, 4, 4]))

该函数的工作原理如下：

首先，它检查两个数组的长度是否相同。如果不是，它会立即返回 false。 然后，它创建一个空对象 obj 来存储第一个数组的平方值。 然后，该函数遍历第一个数组，并将每个平方值作为 obj 中的一个键添加，该值是平方值在数组中出现的次数。这是通过检查对象中是否已存在键并增加其值来完成的，如果存在，则将其值设置为 1(如果不存在)。 接下来，该函数遍历第二个数组，并检查每个值是否是 obj 中的一个键。如果不是，或者如果它的值为 0(这意味着它已经与第二个数组中的值匹配)，则该函数将立即返回 false。否则，它会递减 obj 中相应键的值。 最后，如果函数在两次迭代中都未返回 false，则返回 true，因为第二个数组中的所有值都对应于第一个数组的平方值。

Answer 5

你不需要嵌套循环。这是一个带有单个 for 循环的单通道算法

function same(arrOne, arrTwo) {
if (arrOne.length === arrTwo.length) {
let totalOne = 0;
let totalTwo = 0;
for (let x = 0; x < arrOne.length; x++) {
totalOne += arrOne[x] ** 2;
totalTwo += arrTwo[x];
}
if (totalOne === totalTwo) {
return true;
} else return false;
}
return false;
}
console.log(same([-1, -2, -3], [4, 1, 9]));
console.log(same([1, 2, 3], [1, 9]));
console.log(same([4, 5, 6], [16, 25, 36]));
console.log(same([1, 2, 3, 2], [9, 1, 4, 4]));

这甚至可以处理第二个数组中的项不按顺序排列的情况。