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

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