Write a function that takes one or more arrays and returns a new array of unique values in the order of the original provided arrays.

In other words, all values present from all arrays should be included in their original order, but with no duplicates in the final array.

The unique numbers should be sorted by their original order, but the final array should not be sorted in numerical order.

Check the assertion tests for examples.

*Courtesy of [FreeCodeCamp](https://www.freecodecamp.com/challenges/sorted-union), a great place to learn web-dev; plus, its founder Quincy Larson is pretty cool and amicable. I made the original one slightly more tricky ;)*

Difficulty: introductory

Starter code:

def unite_unique(*args):
	

Solutions:
def unite_unique(*arg):
    res = []
    for arr in arg:
        for val in arr:
            if not val in res: res.append(val)
    return res

from itertools import chain

def unite_unique(*args):
    return list(dict.fromkeys(chain.from_iterable(args)))

from itertools import chain

def unite_unique(*arrs):
    r = list ()
    
    for item in chain (*arrs):
        if item not in r:
            r.append (item)

    return r


def unite_unique(*arrays):
    output = []
    for arr in arrays:
        for i in arr:
            if i not in output: output.append(i)
    return output


from itertools import chain

def unite_unique(*lists):
    cache = set()
    result = list()
    for elem in chain(*lists):
        if elem not in cache:
            result.append(elem)
        cache.add(elem)
    return result

def unite_unique(*args):
    a = []
    for e in args:
        for x in e:
            if x not in a:
                a.append(x)
    return a

from collections import OrderedDict


def unite_unique(*xss):
    return list(OrderedDict.fromkeys(x for xs in xss for x in xs))

from collections import OrderedDict
def unite_unique(*args):
    return list(OrderedDict.fromkeys(sum([a for a in args], [])))

def unite_unique(*args):
    result = []
    for e in sum(args, []):
        if e not in result:
            result.append(e)
    return result

def unite_unique(*args):
    result = []
    [[result.append(nr) for nr in arg if nr not in result] for arg in args]
    return result


"""
go through each array,
keep track of duplicate elements using a hash
if it doesn exist store it in final array.
"""
def unite_unique(*arrays):
    final = []
    table = {}
    
    for array in arrays:
        for elem in array:
            if elem not in final:
                final.append(elem)
    
    return final

def unite_unique(*args):
    result = []
    for a in args:
        for b in a:
            if b not in result:
                result.append(b)
    return result


def unite_unique(*array):
  return [y for x, y in enumerate(sum(array, [])) if y not in sum(array, [])[:x]]

def unite_unique(*lists):
    l = [item for lst in lists for item in lst]
    s = set(l)
    return sorted(s, key=l.index)

def unite_unique(*arrs):
    seen = set()
    return [i for a in arrs for i in a if not (i in seen or seen.add(i))]

from collections import OrderedDict
def unite_unique(*lists):
    
    return list(OrderedDict.fromkeys(sum(lists,[])))

from collections import OrderedDict
def unite_unique(*arrs):
    arrs = [x for arr in arrs for x in arr]
    return [x for i, x in enumerate(arrs) if i == arrs.index(x)]