Write a method that takes a string as an argument and groups the number of time each character appears in the string as a hash sorted by the highest number of occurrences.

The characters should be sorted alphabetically e.g:

```python
get_char_count("cba") == {1: ["a", "b", "c"]}
```

You should ignore spaces, special characters and count uppercase letters as lowercase ones.

For example: 
```python
get_char_count("Mississippi")           ==  {4: ["i", "s"], 2: ["p"], 1: ["m"]}
get_char_count("Hello. Hello? HELLO!")  ==  {6: ["l"], 3: ["e", "h", "o"]}
get_char_count("aaa...bb...c!")         ==  {3: ["a"], 2: ["b"], 1: ["c"]}
get_char_count("abc123")                ==  {1: ["1", "2", "3", "a", "b", "c"]}
get_char_count("aaabbbccc")             ==  {3: ["a", "b", "c"]}
```

Difficulty: EASY
Starter code: def get_char_count(s):
	

Solutions:
def get_char_count(s):
	counts = {}
	for c in (c.lower() for c in s if c.isalnum()):
		counts[c] = counts[c] + 1 if c in counts else 1
	m = {}
	for (k, v) in counts.items():
		m[v] = sorted(m[v] + [k]) if v in m else [k]
	return m


from collections import Counter, defaultdict
from bisect import insort

def get_char_count(s):
	D = defaultdict(list)
	for (k, v) in Counter(map(str.lower, filter(str.isalnum, s))).items():
		insort(D[v], k)
	return D


from collections import Counter, defaultdict

def get_char_count(s):
	d = defaultdict(list)
	c = Counter(sorted(s.lower()))
	for (i, j) in c.items():
		if i.isalnum():
			d[j].append(i)
	return dict(sorted(d.items())[::-1])


from collections import Counter

def get_char_count(s):
	con = Counter([e for e in s.lower() if any((e.isalpha(), e.isdigit()))])
	return {v: sorted([e for e in con.keys() if con[e] == v]) for v in sorted(con.values(), reverse=1)}


def get_char_count(s):
	lst = filter(lambda x: x.isalnum(), s.lower())
	result = {}
	for i in set(lst):
		result[s.lower().count(i)] = sorted(result.get(s.lower().count(i), []) + [i])
	return result


def get_char_count(s):
	print(s)
	ls = []
	ls2 = []
	d = {}
	nd = {}
	s = s.lower()
	for i in s:
		if i.isalpha() or i.isnumeric():
			ls.append(i)
	st = set(ls)
	for i in st:
		ls2.append((s.count(i), i))
	for i in st:
		d[s.count(i)] = []
	x = 0
	for i in ls2:
		d[ls2[x][0]].append(ls2[x][1])
		x += 1
	for i in sorted(d, reverse=True):
		nd[i] = sorted(d[i])
	return nd


from itertools import groupby
from collections import defaultdict

def get_char_count(s):
	d = defaultdict(list)
	for (k, g) in groupby(filter(str.isalnum, sorted(s.lower()))):
		d[len(list(g))].append(k)
	return d


from collections import Counter
from itertools import groupby

def get_char_count(s):
	cnt = Counter((c for c in s.lower() if c.isalnum())).most_common()
	return {k: sorted(map(lambda x: x[0], vs)) for (k, vs) in groupby(cnt, key=lambda x: x[1])}


from collections import Counter

def get_char_count(stg):
	result = {}
	for (char, count) in Counter(sorted((c for c in stg.lower() if c.isalnum()))).items():
		result.setdefault(count, []).append(char)
	return result


def get_char_count(s):
	newDict = {}
	s = s.lower()
	s = ''.join(sorted(s))
	for element in s:
		if element.isalnum():
			newDict.setdefault(element, 0)
			newDict[element] += 1
	inverse = {}
	for key in newDict:
		value = newDict[key]
		inverse.setdefault(value, []).append(key)
	return inverse