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!

Source: codewars | Difficulty: EASY
Tags: Fundamentals

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]


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):
	new_arr = arr.copy()
	for digit in arr:
		index_list_of_duplicates = [i for (i, x) in enumerate(new_arr) if x == digit]
		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):
	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):

	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):
	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):
	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):
	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):
	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 [j for (i, j) in enumerate(arr) if j not in arr[i + 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):
	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