In this Kata, you will remove the left-most duplicates from a list of integers and return the result.

```python
# Remove the 3's at indices 0 and 3
# followed by removing a 4 at index 1
solve([3, 4, 4, 3, 6, 3]) # => [4, 6, 3]
```

More examples can be found in the test cases. 

Good luck!

Difficulty: introductory

Starter code:

def solve(arr):
	

Solutions:
def solve(arr): 
    re = []
    for i in arr[::-1]:
        if i not in re:
            re.append(i)
    return re[::-1]

def solve(arr): 
    return list(dict.fromkeys(arr[::-1]))[::-1]

def solve(arr): 
    return [a for i,a in enumerate(arr) if a not in arr[i+1:]]

def solve(arr): 
    list = arr.copy()
    for i in arr:
        if list.count(i) > 1:
            list.remove(i)
    return list

def solve(arr): 
    seen = set()
    return [seen.add(a) or a for a in reversed(arr) if a not in seen][::-1]

def solve(l): 
    return sorted(set(l), key=l[::-1].index)[::-1]

# Python >= 3.6.0 only
solve=lambda a: list(dict.fromkeys(reversed(a)))[::-1]

def solve(arr): 
    return sorted(set(arr), key=lambda n: -arr[::-1].index(n))


def solve(arr): 
    return sorted(set(arr), key=arr[::-1].index)[::-1]

def solve(arr): 
    return list(reversed(list(dict.fromkeys(reversed(arr)))))

def solve(arr): 
    d = {x: i for i, x in enumerate(arr)}
    return sorted(d, key=d.get)

solve=lambda arr:[e for i,e in enumerate(arr) if e not in arr[i+1:]]

def solve(arr): 
    final = []
    for number in arr[::-1]:
        if number not in final:
            final.insert(0,number)
    return final

def solve(arr): 
    return [arr[el] for el in range(len(arr)) if arr[el] not in arr[el+1:]]

from collections import OrderedDict
from typing import List


def solve(arr: List[int]) -> List[int]:
    d = OrderedDict()
    for a in arr:
        try:
            d.move_to_end(a)
        except KeyError:
            d[a] = None

    return list(d.keys())


def solve(array):
    return [*dict.fromkeys(array[::-1]).keys()][::-1]

def solve(a): 
    return list(dict.fromkeys(a[::-1]))[::-1]

def solve(lst): 
    return sorted(set(lst), key=lst[::-1].index)[::-1]

def solve(arr): 
    uniques = set(arr)
    output = []
    for n in arr[::-1]:
        if n in uniques:
            output = [n] + output
            uniques.remove(n)
        if len(uniques) == 0:
            return output
    return output

def solve(arr): 
    unique = set (arr)
    for num in unique:
        for i in range (arr.count(num) - 1):
            arr.pop((arr.index(num)))
    return arr

def solve(arr): return [v for i, v in enumerate(arr) if v not in arr[i + 1:]]


def solve(l): 
    for i in range(3):
        [l.pop(l.index(i)) for i in l if l.count(i) > 1]
    return l

def solve(arr):
    for i in range(max(arr)+1):
        while arr.count(i)>1:
            arr.remove(i)
    return arr

def solve(arr):
    arr2=[]
    for i in range(0,len(arr)):
        f=0
        for j in range(i+1,len(arr)):
            if arr[j] == arr[i]:
                f=f+1
        if f == 0:
            arr2.append(arr[i])
    return arr2

def solve(seq):
    set1 = set()
    seq = list(reversed(seq))
    set_add = set1.add
    return list(reversed([x for x in seq if not (x in set1 or set_add(x))]))

def solve(arr):
    n = len(arr)
    ans = []
    while n > 0:
        if arr[n-1] not in ans:
            ans.append(arr[n-1])
        n -= 1
    return ans[::-1]

def solve(arr):
    # Copy the list
    new_arr = arr.copy()
    # iterate by every item in old list
    for digit in arr:
        # get list of indexes of duplicates in new list by enumarating them
        index_list_of_duplicates = [i for i, x in enumerate(new_arr) if x == digit]
        # if count of the duplicates list is higher than 1 it deletes the first duplicate by index value from the new list
        if len(index_list_of_duplicates) > 1:
            del new_arr[index_list_of_duplicates[0]]
    return new_arr

def solve(arr): 
    newArr = []
    for i in range(len(arr) - 1, -1, -1):
        if arr[i] not in newArr: newArr.append(arr[i])
    newArr.reverse()
    return newArr

solve=lambda a:[j for i,j in enumerate(a) if a[i:].count(j)==1]

def solve(arr):
    num = 0
    while num < len(arr):
        counter = 0
        for elem in arr:
            if arr[num] == elem:
                counter += 1
        if counter > 1:
            del arr[num]
        else:
            num += 1
    return(arr)


def solve(arr): 
    arr2=[]
    for i in range(len(arr)):
        if arr[i] not in arr[i+1:]:
            arr2.append(arr[i])
    return arr2


def solve(arr):
    l = []
    for num in arr[::-1]:
        if num not in l:
            l.append(num)
    return l[::-1]

    


def solve(arr):
    array = []
    for item in arr:
        if item in array:
            array.remove(item)
            array.append(item)
        else:
            array.append(item)
    return array

def solve(l, i=[]):
    for x in l[::-1]:
        i=[x]*(x not in i)+i
    return i

def solve(A,Z=[]):
    for x in A[::-1]:Z=[x]*(x not in Z)+Z
    return Z

def solve(arr):
    d = {}
    for i, e in enumerate(arr): d[e] = i
    return sorted(set(arr), key=d.get)


def solve(arr): 
    ans = []
    arr.reverse()
    for i in arr:
        if i not in ans:
            ans.append(i)
    return ans[::-1]

def solve(arr): 
    removed = []
    for i in arr[::-1]:
        if not i in removed:
            removed.append(i)
    return removed[::-1]

def solve(arr):
    n = len(arr)
    res = []
    for i in range(n-1,-1,-1):
        if(arr[i] not in res):
            res.append(arr[i])
    res.reverse()
    return res

def solve(arr):
    solution = []
    for i in reversed(arr):
        if i not in solution:
            solution.append(i)
    solution.reverse()
    return solution

def solve(arr): 
    res = []
    [res.append(c) for c in arr[::-1] if c not in res]
    return res[::-1]

def solve(arr):
    x = list(set(arr))
    res = []
    indices = []
    result = []
    for num in x:
        index = last_index(arr,num)
        indices.append(index)
        res.append(arr[index])
    while len(indices) > 0:
        loc = indices.index(min(indices))    
        result.append(res[loc])
        indices.pop(loc)
        res.pop(loc)
    return result

def last_index(pepe,n):
    return [i for i in range(len(pepe)) if pepe[i] == n][::-1][0]

def solve(arr): 
    output = []
    
    for x in arr[::-1]:
        if x in output:
            continue
        else:
            output.append(x)
    return output[::-1]

def solve(arr):
    res = []
    for number in arr[::-1]:
        if number not in res:
            res.append(number)
        else:
            pass
    return res[::-1]
            
            


def solve(arr): 
    r = []
    for i in reversed(arr):
        if i not in r:
            r.append(i)
    
    return r[::-1]

def solve(arr):
    arr1 = arr[::-1]
    arr2 = list(dict.fromkeys(arr1))
    return arr2[::-1]


from collections import Counter
def solve(arr): 
    result = []
    dic = Counter(arr)
    for value in arr:
        if dic[value]==1:
            result.append(value)
        else:
            dic[value]-=1
    return result
            


def solve(arr): 
    tmp = {}
    s = set(arr)
    for n in s:
        tmp[n] = [idx for idx, num in enumerate(arr) if num == n]
    ides = [value[-1] for value in tmp.values()]
    return [arr[idx] for idx in sorted(ides)]

def solve(arr): 
    
# =============================================================================
#     This function removes the left-most duplicates from a list of integers and
#     returns the result.
# 
#     Example:
#         Remove the 3's at indices 0 and 3
#         followed by removing a 4 at index 1
#         solve([3, 4, 4, 3, 6, 3]) # => [4, 6, 3]
# =============================================================================
    
    print(arr)    
    
    arr.reverse()
    
    print (arr)
    
    result = []
    
    for item in arr:
        if item not in result:
            result.append(item)
            
    result.reverse()
    
    return result

def solve(arr): 
    return [i for index, i in enumerate(arr) if i not in arr[index+1:]]

def solve(arr): 
    arr2 = []
    for i in arr[::-1]:
        if i not in arr2:
            arr2.insert(0, i)
    return arr2

def solve(arr): 
    output = []
    for i in arr[::-1]:
        if i not in output:
            output.append(i)
        else:
            pass
    return output[::-1]

def solve(arr):
    for j in reversed(arr):
        if arr.count(j)!=1:
            arr.remove(j)
    return arr

def solve(arr):    
    unique = []
    arr.reverse()
    for n in arr:
        if n not in unique:
            unique.insert(0, n)
    
    return unique

def solve(arr): 
    ll = []
    for i in reversed(arr):
        if i not in ll:
            ll.insert(0, i)
            
    return ll

def solve(arr): 
    ls = []
    for x in arr[::-1]:
        if ls.count(x) == 0:
            ls.append(x)
    return [i for i in ls[::-1]]

def solve(arr):
    res = []
    for i, v in enumerate(arr):
        if arr[i:].count(v) == 1:
            res.append(v)

    return res

def solve(arr):
    ds = []
    for x in arr:
        if arr.count(x) > 1:
            if x not in ds:
                ds.append(x)
            else:
                pass
        else:
            pass
    for x in ds:
        while arr.count(x) > 1:
            arr.remove(x)
    
    return arr

def solve(arr): 
    # functional style
    def unique_recursive(src_arr, trg_arr):
        if len(src_arr) == 0:
            return trg_arr
        else:
            head, *tail = src_arr
            if head not in tail:
                trg_arr.append(head)
            return unique_recursive(tail, trg_arr)
    return unique_recursive(arr, [])

def solve(arr): 
    a = []
    for i in arr[::-1]:
        if (i in a)== False: a.append(i)
    return a[::-1]

def solve(arr): 
    result=[]
    for i in range(len(arr)):
        if arr[i] in arr[i+1:len(arr)]:
            pass
        else:
            result.append(arr[i])
    return result

def solve(arr):
    res = []
    for v in arr[-1::-1]:
        if v not in res:
            res.append(v)
    return res[-1::-1]

def solve(arr):
    x = []
    for element in arr:
        if element in x:
            x.remove(element)
            x.append(element)
        else:
            x.append(element)
    return x

def solve(arr):
    remove = list(set(arr))
    print(remove)
    duplicates = []
    print(arr)
    for k in range(len(remove)):
        print("K>", remove[k])
        for i, j in enumerate(arr):
            if j == remove[k]:
                duplicates.append(i)
                print(duplicates)
        if len(duplicates) > 1:
            for n in range(0, len(duplicates) - 1):
                arr[duplicates[n]] = ""
            duplicates = []
        else:
            duplicates = []
    while '' in arr:
        arr.remove('')
    print(arr)
    return arr

def solve(arr): 
    arr = arr[::-1]
    a = []
    for i in arr:
        if i not in  a:
            a.append(i)
    return a[::-1]

def solve(arr): 
    ans = []
    for i in arr[::-1]:
        if i not in ans:
            ans = [i]+ans
    return ans

def solve(arr): 
    result = []
    for number in arr[::-1]:
        if number not in result:
            result.append(number)
    return result[::-1]


def solve(arr):
    seen = []
    for i in arr:
        if i in seen:
            seen.remove(i)
        seen.append(i)        
    return seen

def solve(arr):
    seen = []
    for i in arr:
        if i in seen:
            seen.remove(i)
            seen.append(i)
        else:
            seen.append(i)
            
    return seen

def solve(arr): 
    result = []
    for i in range(len(arr)):
        try:
            if arr[i] not in arr[i+1:]:
                result.append(arr[i])
        except IndexError:
            pass
    return result


from collections import Counter
def solve(arr): 
    return [k for k in Counter(arr[::-1]).keys()][::-1]

def solve(a):
    return list(dict.fromkeys(a[::-1]).keys())[::-1]


def solve(a):
    n = len(a)
    for i in range(n-1):
        if a[i] in a[i+1:]: a[i] = 'a'
    while True:
        if 'a' in a: a.remove('a')
        else     : break
    return a


def solve(arr): 
    seen = []
    return_list = []
    for number in arr[::-1]:
        if number not in seen:
            seen.append(number)
            return_list.append(number)
    return return_list[::-1]


def solve(arr): 
    res = []
    
    for i in range(len(arr)):
        if arr[i] not in arr[i+1:]:
            res.append(arr[i])
            
    return res

def solve(arr): 
    out=[]
    for x in arr[::-1]:
        if x in out : continue
        out.append(x)
    return out[::-1]

def solve(arr): 
    nums = set()
    out = []
    for elem in reversed(arr):
        if elem not in nums:
            out.append(elem)
            nums.add(elem)

    return out[::-1]

def solve(arr): 
    temp=arr[::-1]
    out=[]
    for i in range(len(temp)):
        if temp[i] in out:
            continue
        out.append(temp[i])
    return out[::-1]

def solve(arr): 
    s = []
    for k,v in enumerate(arr):
        if arr[k+1:].count(v) == 0:
            s.append(arr[k])
    return s            

def solve(arr):
    k = 0
    while k < len(arr):
        while arr.count(arr[k]) > 1:
            del arr[k]
            k = 0
        else:
            k += 1

    return arr

def solve(arr):
    i, k = 0, len(arr) 
    while k > i:
        if arr.count(arr[i]) != 1:
            del arr[i]
            k -= 1
        else:
            i += 1
    return arr

def solve(arr): 
    b = reversed(arr)
    new =[]
    for i in b:
        if i not in new:
            new.append(i)
    arr=new
    arr.reverse()
    return arr
    pass

def solve(arr): 

    holder, result = {}, []
    index = len(arr) - 1
    while (0 <= index):
        if (arr[index] not in holder):
            result.insert(0,
                          arr[index])
            holder[arr[index]] = True
        index -= 1

    return result


def solve(arr):
    t = []
    for i in range(len(arr)):
        if arr[i:].count(arr[i]) == 1:
            t.append(arr[i])
    return t

def solve(arr):
    res = []
    for i in arr[::-1]:
        if i in res:
            continue
        else:
            res.insert(0, i)
    return res

def solve(arr): 
    for i in range(len(arr)):
        while i+1 < len(arr)+1 and arr[i] in arr[i+1:]:
            arr.pop(i)
    return arr

def solve(arr):
    temp = {}
    answer = []
    for single in set(arr):
        temp[single] = [i for i, x in enumerate(arr) if x == single][-1]
    for k, v in sorted(temp.items(), key=lambda x: x[1]):
        answer.append(k)
    return answer

def solve(arr): 
    return sorted(set(arr[::-1]), key =arr[::-1].index)[::-1]

def solve(arr): 
    return [j for i, j in enumerate(arr) if j not in arr[i+1:]]

def solve(arr): 
    arrr=arr[::-1]
    ans =[]
    for i in arrr:
        if i not in ans:
            ans.append(i)
    return ans[::-1]
        


def solve(arr):
    answer=[]
    while len(arr)>0:
        poppedElement= arr.pop()
        if poppedElement not in answer:
            answer.append(poppedElement) 
    answer.reverse()
    return answer
print((solve([3,4,4,3,6,3]))) 


from collections import OrderedDict

def solve (arr):
    arr = arr[::-1]
    arr = list(OrderedDict.fromkeys(arr))[::-1]
    return arr

from collections import OrderedDict

arr = [3, 4, 4, 3, 6, 3]
def solve (arr):
    arr = arr[::-1]
    arr = list(OrderedDict.fromkeys(arr))[::-1]
    return arr

def solve(arr):
    for i in list(arr):
        if arr.count(i)>1:
            arr.remove(i)
    return list(arr)


def solve(arr): 
    result = []
    arr = arr[::-1]
    for i in arr:
        if i not in result:
            result.append(i)
    return result[::-1]

def solve(arr): 
    returnedarray = []
    for item in arr[::-1]:
        if item not in returnedarray:
            returnedarray.insert(0, item)
    return returnedarray

def solve(arr): 
    i=0
    while i < len(arr):
        if arr.count(arr[i]) > 1:
            arr.remove(arr[i])
            i = 0
        else:
            i+=1
    return arr

def solve(arr):
    a2 = []
    for e, a in enumerate(arr):
        if a not in arr[e+1:]:
            a2.append(a)
    return a2

def solve(arr): 
    ret = []
    for el in list(reversed(arr)):
        if el not in ret:
            ret.append(el)
    return list(reversed(ret))
    


def solve(arr):
    dist = {}
    l = len(arr)
    for i in range(l):
        if arr[l-i-1] in dist.keys():
            arr.pop(l-i-1)
        else:
            dist[arr[l-i-1]] = 1
    return arr