# Task
 Given string `s`, which contains only letters from `a to z` in lowercase.

 A set of alphabet is given by `abcdefghijklmnopqrstuvwxyz`.
 
 2 sets of alphabets mean 2 or more alphabets.
 
 Your task is to find the missing letter(s). You may need to output them by the order a-z. It is possible that there is more than one missing letter from more than one set of alphabet.

 If the string contains all of the letters in the alphabet, return an empty string `""`

# Example

 For `s='abcdefghijklmnopqrstuvwxy'`

 The result should be `'z'`

 For `s='aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyy'`
 
 The result should be `'zz'`

 For `s='abbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxy'`
 
 The result should be `'ayzz'`

 For `s='codewars'`
 
 The result should be `'bfghijklmnpqtuvxyz'`

# Input/Output


 - `[input]` string `s`

  Given string(s) contains one or more set of alphabets in lowercase.


 - `[output]` a string

  Find the letters contained in each alphabet but not in the string(s). Output them by the order `a-z`. If missing alphabet is repeated, please repeat them like `"bbccdd"`, not `"bcdbcd"`

Difficulty: introductory

Starter code:

def missing_alphabets(s):
	

Solutions:
from collections import Counter
from string import ascii_lowercase

def missing_alphabets(s):
    c = Counter(s)
    m = max(c.values())
    return ''.join(letter * (m - c[letter]) for letter in ascii_lowercase)

from collections import Counter
from string import ascii_lowercase as alphabet

def missing_alphabets(s):
    counts = Counter(s)
    max_count = max(counts.values())
    return ''.join(c * (max_count - counts[c]) for c in alphabet)

def missing_alphabets(s):
  return ''.join(sorted(c * (max(s.count(x) for x in s) - s.count(c)) for c in 'abcdefghijklmnopqrstuvwxyz'))

from collections import Counter
def missing_alphabets(s):
    c, a = Counter(s), Counter(map(chr, range(97, 123)))
    return ''.join(sorted((sum([a] * max(c.values()), Counter()) - c).elements()))

from collections import Counter

def missing_alphabets(s):
    a, C = [], []
    count = Counter(s)
    
    for i in range(1,max(count.values()) + 1):
        a.append([k for k,v in list(count.items()) if v >= i ])
    

    A = "abcdefghijklmnopqrstuvwxyz"
    B = [I for I in A if I not in s]
    

    for i in range(0 ,len(a)):
        C.append([I for I in A if I not in a[i]])

    return ''.join(sorted([j for i in C for j in i])) 


import string
from collections import Counter
def missing_alphabets(s):
    my_dict = Counter(s)
    set = max(my_dict.values())
    return "".join([letter*(set-my_dict[letter]) for letter in string.ascii_lowercase])

from string import ascii_lowercase
from collections import Counter

def missing_alphabets(str_in):
    counts = Counter(str_in)
    most = counts.most_common()[0][1]
    return ''.join(letter * (most - counts[letter]) for letter in ascii_lowercase)

def missing_alphabets(s):
    alphabet = "abcdefghijklmnopqrstuvwxyz"
    c = []
    for letter in alphabet:
        c.append(s.count(letter))
    sets = max(c)
    result = []
    for letter in alphabet:
        if s.count(letter) != sets:
            result.append(letter*(sets-s.count(letter)))
    return(''.join(result))

def missing_alphabets(s):
    alphabet = {chr(x):0 for x in range(ord('a'), ord('z')+1)}
    results = []
    for letter in s:
        if letter in alphabet:
            alphabet[letter] += 1
    l_count = max(alphabet.values())
    for key in alphabet:
        if alphabet[key] < l_count:
            results.append(key*(l_count - alphabet[key]))

    return ''.join(results)

from string import ascii_lowercase
from collections import Counter

def missing_alphabets(s):
    C = Counter(s)
    x = C.most_common(1)[0][1]
    return ''.join(c*(x-C[c]) for c in ascii_lowercase)