You have to rebuild a string from an enumerated list.
For this task, you have to check if input is correct beforehand.

* Input must be a list of tuples
* Each tuple has two elements.
* Second element is an alphanumeric character.
* First element is the index of this character into the reconstructed string.
* Indexes start at 0 and have to match with output indexing: no gap is allowed.
* Finally tuples aren't necessarily ordered by index.

If any condition is invalid, the function should return `False`.

Input example: 
```python 
[(4,'y'),(1,'o'),(3,'t'),(0,'m'),(2,'n')]
```
Returns

```python
'monty'
```

Difficulty: EASY
Tags: Fundamentals

Sorting
Skill types: Sorting

Starter code:
def denumerate(enum_list):
	

Solutions:
def denumerate(enum_list):
	try:
		nums = dict(enum_list)
		maximum = max(nums) + 1
		result = ''.join((nums[a] for a in range(maximum)))
		if result.isalnum() and len(result) == maximum:
			return result
	except (KeyError, TypeError, ValueError):
		pass
	return False


def denumerate(enum_list):
	try:
		(l, d) = (len(enum_list), dict(enum_list))
		ret = ''.join(map(d.get, range(l)))
		assert ret.isalnum() and len(ret) == l
		return ret
	except:
		return False


def denumerate(enum_list):
	try:
		for t in enum_list:
			if len(t) != 2 or not t[1].isalnum() or len(t[1]) != 1:
				return False
		(a, b) = zip(*sorted(enum_list))
		if list(a) == list(range(len(a))):
			return ''.join(b)
		else:
			return False
	except:
		return False


from re import findall

def denumerate(enum):
	enum = sorted(enum) if isinstance(enum, list) else ''
	if findall("(?<=\\[)(\\(\\d,\\s'[a-zA-Z\\d]'\\)[,\\s]*)*(?=\\])", str(enum)):
		(a, b) = zip(*enum)
		if all((a[i] == i for i in range(len(a)))):
			return ''.join(b)
	return False


is_list = lambda L: type(L) == list
is_index = lambda I, size: type(I) == int and 0 <= I < size
is_char = lambda C: type(C) == str and len(C) == 1 and C.isalnum()
is_tuple = lambda size: lambda T: type(T) == tuple and len(T) == 2 and is_index(T[0], size) and is_char(T[1])

def denumerate(enum_list):
	return is_list(enum_list) and all(map(is_tuple(len(enum_list)), enum_list)) and ''.join((t[1] for t in sorted(enum_list)))


def denumerate(e):
	if type(e) != list or any((type(i) != tuple for i in e)) or sorted([i[0] for i in e]) != list(range(0, len(e))):
		return False
	li = ''.join([i[1] for i in sorted(e) if len(i[1]) == 1 and i[1].isalnum() and (len(i) == 2)])
	return li if len(li) == len(e) else False


def denumerate(enum_list):
	try:
		return bool(enum_list) and ''.join((c for (cnt, (idx, c)) in enumerate(sorted(enum_list)) if cnt == idx and len(c) == 1 and c.isalnum() or 1 / 0))
	except:
		return False


def denumerate(enum_list):
	try:
		string = ''
		enum_list = sorted(enum_list, key=lambda i: i[0])
		for (i, j) in enumerate(enum_list):
			if len(j) == 2 and len(j[1]) == 1 and j[1].isalnum() and (i == j[0]):
				string += j[1]
			else:
				return False
		return string
	except:
		return False


def denumerate(enum_list):
	if not isinstance(enum_list, list):
		return False
	for el in enum_list:
		if not isinstance(el, tuple):
			return False
		if len(el) != 2:
			return False
		if not isinstance(el[1], str):
			return False
		if len(el[1]) != 1:
			return False
		if not el[1].isalnum():
			return False
		if not 0 <= el[0] <= len(enum_list) - 1:
			return False
	return ''.join((tup[1] for tup in sorted(enum_list)))


def denumerate(enum_list):
	if type(enum_list) is list:
		tmp = [None] * len(enum_list)
		for (index, item) in enumerate(enum_list):
			if type(item) is not tuple or len(item) != 2 or (not str(item[1]).isalnum()) or (len(str(item[1])) != 1) or (type(item[0]) is not int):
				return False
			try:
				tmp[item[0]] = item[1]
			except:
				return False
		tmp = list(filter(None, tmp))
		if len(tmp) != len(enum_list):
			return False
		return ''.join(tmp)
	return False