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: introductory

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:
        # tuple validation
        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(r"(?<=\[)(\(\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