Are they the "same"?

Instructions:

Given two arrays a and b write a function comp(a, b) (orcompSame(a, b)) that checks whether the two arrays have the "same" elements, with the same multiplicities (the multiplicity of a member is the number of times it appears). "Same" means, here, that the elements in b are the elements in a squared, regardless of the order.

Examples
Valid arrays
a = [121, 144, 19, 161, 19, 144, 19, 11]

b = [121, 14641, 20736, 361, 25921, 361, 20736, 361]
comp(a, b) returns true because in b 121 is the square of 11, 14641 is the square of 121, 20736 the square of 144, 361 the square of 19, 25921 the square of 161, and so on. It gets obvious if we write b's elements in terms of squares:

a = [121, 144, 19, 161, 19, 144, 19, 11]
b = [11*11, 121*121, 144*144, 19*19, 161*161, 19*19, 144*144, 19*19]
Invalid arrays
If, for example, we change the first number to something else, comp is not returning true anymore:

a = [121, 144, 19, 161, 19, 144, 19, 11]

b = [132, 14641, 20736, 361, 25921, 361, 20736, 361]
comp(a,b) returns false because in b 132 is not the square of any number of a.

a = [121, 144, 19, 161, 19, 144, 19, 11]

b = [121, 14641, 20736, 36100, 25921, 361, 20736, 361]
comp(a,b) returns false because in b 36100 is not the square of any number of a.

Remarks
a or b might be [] or {} (all languages except R, Shell).
a or b might be nil or null or None or nothing (except in C++, COBOL, Crystal, D, Dart, Elixir, Fortran, F#, Haskell, Nim, OCaml, Pascal, Perl, PowerShell, Prolog, PureScript, R, Racket, Rust, Shell, Swift).
If a or b are nil (or null or None, depending on the language), the problem doesn't make sense so return false.

Thoughts 1:

Initially, I approached the problem by checking if each number from the first array, when squared, exists in the second array. However, during submission, I encountered errors that made me realise the importance of accounting for multiplicity. Specifically, after matching a squared value from the first array in the second array, I need to remove it from the second array to prevent it from being matched again incorrectly.

Solution 1:

function comp(array1, array2) {
  const arrValue = array2.includes(Math.pow(a,2));
  if (compare.includes(false)) console.log(false);
  else console.log(true);
}

Thoughts 2:

1. In this solution, I started by checking if either input array is null, as the problem specifies that in such cases we should return false.
2. Then, for each element in array1, I calculated its square, checked if the square exists in array2 and if it does, I removed that specific squared value from array2 using splice to ensure proper handling of duplicate values (i.e., correct multiplicity).
3. I collected the result of each comparison in a new array called compare. If any element from array1 did not have a matching square in array2, the final result is false. Otherwise, if all elements matched correctly, I return true.
4. This logic ensures that:
   • The multiplicities are respected.
   • The order of elements doesn’t matter.
   • Only valid matches are considered, with used elements removed to avoid false positives.

Solution 2:

function comp(array1, array2){
 if( array1 === null || array2 ===null) return false;
 const compare = array1.map(a =>{  
  function removeIndex(){
    var index = array2.indexOf(Math.pow(a,2));
    if (index !== -1) array2.splice(index, 1);
  }
  const arrValue = array2.includes(Math.pow(a,2));
  if(arrValue === true) removeIndex();
  return arrValue;
  });
  if(compare.includes(false)) return false;
  else return true;
}

This is a CodeWars Challenge of 6kyu Rank