Are-they-the-same.js

/*
  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.
*/

// Answer:

// given 2 arrays or objects a and b, a with not squared number, b with squared, we need to check are numbers is
// same in both e.g. 11 in a = 121 in b, return true or false,

// if any of parameters is null return false;
// create object which is going to store number and its squared number
// loop through first array and fill object where key is squared number and value is amount this number appears
// loop through second array and check each number does it exist in our object and does its appears amount > 0
// final loop through object to check is all values is 0, which means that all object are same

function comp(array1, array2){
  if (!array1 || !array2) return false;
  
  let object = {};
  for (let number of array1) {
    object[number ** 2] ? object[number ** 2]++ : object[number ** 2] = 1
  }
  for (let number of array2) {
    if (!object[number] || object[number] < 1) return false;
    object[number]--;
  }
  for (let key in object) {
    if (object[key] !== 0) return false;
  }
  return true;
}
// BigO: O(n)