Given two arrays `a` and `b` write a function `comp(a, b)` (`compSame(a, b)` in Clojure) that checks whether the two arrays have the "same" elements, with the same multiplicities. "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 we change the first number to something else, `comp` may not return 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 `[]` (all languages except R, Shell).
- `a` or `b` might be `nil` or `null` or `None` or `nothing` (except in Haskell, Elixir, C++, Rust, R, Shell, PureScript). 

If `a` or `b` are `nil` (or `null` or `None`), the problem doesn't make sense so return false.

#### Note for C
The two arrays have the same size `(> 0)` given as parameter in function `comp`.

Difficulty: introductory

Starter code:

def comp(array1, array2):
	

Solutions:
def comp(array1, array2):
    try:
        return sorted([i ** 2 for i in array1]) == sorted(array2)
    except:
        return False

def comp(a1, a2):
    return None not in (a1,a2) and [i*i for i in sorted(a1)]==sorted(a2)

def comp(array1, array2):
    if array1 and array2:
        return sorted([x*x for x in array1]) == sorted(array2)
    return array1 == array2 == []

def comp(a1, a2):
    return isinstance(a1, list) and isinstance(a2, list) and sorted(x*x for x in a1) == sorted(a2)

from collections import Counter as c
def comp(a1, a2):
    return a1 != None and a2 != None and c(a2) == c( elt**2 for elt in a1 )

def comp(xs, ys):
    if xs is None or ys is None:
        return False
    return sorted(x * x for x in xs) == sorted(ys)

def comp(a, b):
    try:
        return sorted(i*i for i in a) == sorted(b)
    except:
        return False

def comp(array1, array2):
    if (array1 == None) or (array2 == None):
        return False
    tmp = sorted([s*s for s in array1])
    return tmp == sorted(array2) 

def comp(array1, array2):
    return None not in (array1, array2) and sum([i*i for i in array1]) == sum(array2)