# Task
 You have two sorted arrays `a` and `b`, merge them to form new array of unique items.

 If an item is present in both arrays, it should be part of the resulting array if and only if it appears in both arrays the same number of times.

# Example

  For `a = [1, 3, 40, 40, 50, 60, 60, 60]` and `b = [2, 40, 40, 50, 50, 65]`, the result should be `[1, 2, 3, 40, 60, 65]`.
```
Number 40 appears 2 times in both arrays, 
thus it is in the resulting array.
Number 50 appears once in array a and twice in array b, 
therefore it is not part of the resulting array.```

# Input/Output


 - `[input]` integer array `a`

 A sorted array.
 
 1 ≤ a.length ≤ 500000
 
 
 - `[input]` integer array `b`

 A sorted array.
 
 `1 ≤ b.length ≤ 500000`
 

- `[output]` an integer array

  The resulting sorted array.

Difficulty: introductory

Starter code:

def merge_arrays(a, b):
	

Solutions:
def merge_arrays(a, b):
    out = []
    for n in a+b:
        if n in a and n in b:
            if a.count(n) == b.count(n):
                out.append(n)
        else:
            out.append(n)
    return sorted(set(out))

from collections import Counter

def merge_arrays(a, b):
    ca, cb = Counter(a), Counter(b)
    return [ k for k in sorted(ca.keys() | cb.keys()) if (k in ca)+(k in cb) == 1 or ca[k] == cb[k] ]

merge_arrays=lambda a,b:sorted([x for x in set(a+b) if a.count(x)==b.count(x) or a.count(x)*b.count(x)==0])

def merge_arrays(a, b):
  return sorted(n for n in set(a+b) if (n in a) != (n in b) or a.count(n) == b.count(n))

def merge_arrays(a, b):
    list =[]
    for i in a+b :
        if (a.count(i)==b.count(i) or b.count(i)==0 or a.count(i)==0) and i not in list:
            list.append(i)
    return sorted(list)

def merge_arrays(a, b):
  result = []
  currA = 0
  currB = 0
  while currA < len(a) and currB < len(b):
    if a[currA] < b[currB]:
        # Check that we are not adding a duplicate
        if not result or result[-1] != a[currA]:
          result.append(a[currA])
        currA += 1
    elif b[currB] < a[currA]:
        # Check that we are not adding a duplicate
        if not result or result[-1] != b[currB]:
          result.append(b[currB])
        currB += 1
    else:
        val = a[currA]
        # Count how many times the value occurs in a and b
        countA = 0
        while currA < len(a):
            if a[currA] == val:
                countA += 1
                currA += 1
            else:
                break
        countB = 0
        while currB < len(b):
            if b[currB] == val:
                countB += 1
                currB += 1
            else:
                break
        if countA == countB:
            result.append(val)
  # We've exhausted either a or b    
  while currA < len(a):
    if not result or result[-1] != a[currA]:
      result.append(a[currA])
    currA += 1
  while currB < len(b):
    if not result or result[-1] != b[currB]:
      result.append(b[currB])
    currB += 1
  return result

from collections import Counter

def merge_arrays(a, b):
    C1, C2 = Counter(a), Counter(b)
    return sorted((C1.keys() ^ C2.keys()) | {k for k in (C1.keys() & C2.keys()) if C1[k] == C2[k]})

from collections import Counter

def merge_arrays(a, b):
    c = Counter(a)
    d = Counter(b)
    return sorted(x for x in set(a) | set(b) if c[x] == d[x] or not c[x] or not d[x])

from collections import Counter
def merge_arrays(a, b):
    li = set()
    c1,c2 = Counter(a), Counter(b)
    for i in set(a + b):
        if i in c1 and i in c2:
            if c1[i] == c2[i] : li.add(i)
        else : li.add(i)
    return sorted(li)

from collections import Counter

def merge_arrays(a, b):
    ca = Counter(a)
    cb = Counter(b)
    return [x for x in sorted(set(ca).union(cb)) if ca[x] == cb[x] or ca[x] * cb[x] == 0]