Javascript 如何判断一个数组中的每个数字是否在另一个数组中都是平方的？

给定两个数组a和b，编写函数compa，b compSamea，b 在Clojure中，检查两个数组是否具有相同的 元素，具有相同的多重性。同样的意思是，在这里 b中的元素是a平方中的元素，无论顺序如何

例子

有效数组

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

compa，b返回true，因为b121是1114641的平方 是12120736的平方，是144361的平方，是19的平方， 25921平方161，依此类推

首先，我只想检查每个项目，并测试平方版本是否存在于另一个数组中。这是我的代码：

函数比较1，数组2{ 返回数组2.everyitem=>{ 设a=array1.indexOfitem**2； ifa>=0{ 返回true； }否则{ 返回false； } } } console.logcomp[121,144,19,161,19,144,19,11]，[121,14641,207361,25921,361,207361] 您可以为array2选择一个，然后检查array1的每个产品

函数比较1，数组2{ const set2=新Setarray2； 返回array1.everyv=>set2.hasv*v； } console.logcomp[121,144,19,161,19,144,19,11]，[121,14641,207361,25921,361,207361] 您可以为array2选择一个，然后检查array1的每个产品

函数比较1，数组2{ const set2=新Setarray2； 返回array1.everyv=>set2.hasv*v； } console.logcomp[121,144,19,161,19,144,19,11]，[121,14641,207361,25921,361,207361] 使用each和includes，可以用简单的一行书写：

常数a=[121,144,19,161,19,144,19,11] 常数b=[121146411207361259213611907361] 常量comp=a，b=>a.length==b.length&&a.everyvalue=>b.includevalue**2 console.logcompa，b使用each和includes，可以用简单的一行代码编写：

常数a=[121,144,19,161,19,144,19,11] 常数b=[121146411207361259213611907361] 常量comp=a，b=>a.length==b.length&&a.everyvalue=>b.includevalue**2

---

console.logcompa，b使用each和a set删除重复项

a=[121144,19161,19144,19,11] b=[12114641207363612592136120736361] 功能比较a，b{ a=[…新Seta] b=新立根 返回a.everyx=>b.hasx*x }

---

console.logcomparea，b使用every和a set删除重复项

a=[121144,19161,19144,19,11] b=[12114641207363612592136120736361] 功能比较a，b{ a=[…新Seta] b=新立根 返回a.everyx=>b.hasx*x }

---

logcomparea，b您的代码对于测试用例来说几乎是好的。您只需在内部交换阵列：

function comp(array1, array2){
  return array1.every((item)=>{
    let a = array2.indexOf((item ** 2));
    if(a >=0){
      return true;
    } else{
      return false;
    }
  })
}

尽管如果我理解正确，即使数组具有不同的长度，或者如果第二个数组中的元素不是第一个数组中的元素的重数，只要第一个数组在第二个数组中具有一些重数，这将返回true：

console.log(comp([2,4,4,2], [4,16]));
// -> true
console.log(comp([2,4], [4,16, 536]));
// -> true

因此，忠实于前提，更有效地避免索引或包括：

function comp2(A, B){
  if(A.length != B.lengt) return false;
  
  A.sort((a, b) => a-b);
  B.sort((a, b) => a-b);
  
  return A.every((a, i)=>{
    const b = B[i];
    if(a ** 2 == b){
      return true;
    } else{
      return false;
    }
  })
}

console.log(comp2([2,4,4,2], [4,16]));
// -> false
console.log(comp2([2,4], [4,16, 536]));
// -> false

---

操场：

您的代码对于测试用例来说几乎是好的。您只需在内部交换阵列：

function comp(array1, array2){
  return array1.every((item)=>{
    let a = array2.indexOf((item ** 2));
    if(a >=0){
      return true;
    } else{
      return false;
    }
  })
}

尽管如果我理解正确，即使数组具有不同的长度，或者如果第二个数组中的元素不是第一个数组中的元素的重数，只要第一个数组在第二个数组中具有一些重数，这将返回true：

console.log(comp([2,4,4,2], [4,16]));
// -> true
console.log(comp([2,4], [4,16, 536]));
// -> true

因此，忠实于前提，更有效地避免索引或包括：

function comp2(A, B){
  if(A.length != B.lengt) return false;
  
  A.sort((a, b) => a-b);
  B.sort((a, b) => a-b);
  
  return A.every((a, i)=>{
    const b = B[i];
    if(a ** 2 == b){
      return true;
    } else{
      return false;
    }
  })
}

console.log(comp2([2,4,4,2], [4,16]));
// -> false
console.log(comp2([2,4], [4,16, 536]));
// -> false

---

游乐场：

includes在^2上运行。includes在^2上运行。a=[11,11]，b=[121]的答案应该是什么？我想它应该是假的，因为它确实有121个，但它只出现一次。a=[11,11]，b=[121]的答案应该是什么？我认为它应该是假的，因为它确实有121个，但它只出现一次。这个问题要求相同的多重性。集合丢失此信息。问题要求相同的多重性。Set将丢失此信息。