You have to create a function,named `insertMissingLetters`, that takes in a `string` and outputs the same string processed in a particular way.

The function should insert **only after the first occurrence** of each character of the input string, all the **alphabet letters** that:

-**are NOT** in the original string  
-**come after** the letter of the string you are processing  

Each added letter should be in `uppercase`, the letters of the original string will always be in `lowercase`.


Example:  


`input`: "holly"  

`missing letters`: "a,b,c,d,e,f,g,i,j,k,m,n,p,q,r,s,t,u,v,w,x,z"  

`output`: "hIJKMNPQRSTUVWXZoPQRSTUVWXZlMNPQRSTUVWXZlyZ"  


You don't need to validate input, the input string will always contain a certain amount of lowercase letters  (min 1 / max 50).

Difficulty: introductory

Starter code:

def insert_missing_letters(st):
	

Solutions:
def insert_missing_letters(s):
    s, lst, found, inside = s.lower(), [], set(), set(s.upper())
    for a in s:
        lst.append(a if a in found else
                   a + ''.join(c for c in map(chr, range(ord(a)-31,91)) if c not in inside) )
        found.add(a)
        
    return ''.join(lst)

from string import ascii_uppercase
from itertools import dropwhile

def insert_missing_letters(st):
    missing = [m for m in ascii_uppercase if m.lower() not in st]
    dict = { c:list(dropwhile(lambda m: m < c.upper(), missing)) for c in set(st) }
    return ''.join(c + ''.join(dict.pop(c)) if c in dict else c for c in st)

from string import ascii_lowercase as a
import re
def insert_missing_letters(s):    
    t = ""
    c = set()
    for i in s:
        if i not in c:
            t = t + i + re.sub("|".join(s),"",a[a.index(i)+1:]).upper()
            c.add(i)
        else:
            t += i
    return t

abc = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

def insert_missing_letters(st):
  return ''.join(c + ''.join(x for x in abc[abc.index(c.upper())+1:] if x.lower() not in st) if st.index(c) == i else c for i, c in enumerate(st))

def insert_missing_letters(word):
    alphabet = 'abcdefghijklmnopqrstuvwxyz'
    new = ''
    used = ''

    for letter in set(word):
        alphabet = alphabet.replace(letter,"")

    for letter in word:
        if letter not in used:
            new += letter + "".join([x.upper() for x in alphabet if ord(x) > ord(letter)])
        else: new += letter

        used += letter
        
    return new

import string

def insert_missing_letters(st):
    tbl = dict.fromkeys(map(ord, st.upper()))
    result = []
    seen = set()
    for c in st:
        if c not in seen:
            seen.add(c)
            c += string.ascii_uppercase[string.ascii_lowercase.find(c) + 1:].translate(tbl)
        result.append(c)
    return ''.join(result)

def insert_missing_letters(s):
    alph = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; res = ""; memo = {}
    for char in s:
        if char not in memo: memo[char] = 1
        else: memo[char] += 1
        if memo[char] == 1:
            res += char + "".join(sorted(list(set(alph[alph.index(char.upper())+1:])-set(s.upper()))))
        else: res += char
    return res
     


def insert_missing_letters(s):
    found, inside = set(), set(s.upper())
    return ''.join(a if a in found else found.add(a) or a+''.join(c for c in map(chr, range(ord(a)-31,91)) if c not in inside) for a in s)

def insert_missing_letters(st):
    az=[ chr(a) for a in  (list(range( ord('a'), ord('z')+1)) )]
    return ''.join([st[i]+''.join([ a.upper() for a in az[az.index(st[i])+1:] if a not in st ]) if st[i] not in st[:i] else st[i] for i in range(len(st))])


import string 
def insert_missing_letters(st):
    has_seen = []
    alphabet = string.ascii_lowercase
    retstr = ""
    i = 0
    while i < len(st):
        retstr = retstr + st[i]
        index = alphabet.index(st[i])
        if st[i] not in has_seen:
            while index < len(alphabet):
                if alphabet[index] not in st:
                   retstr = retstr + alphabet[index].upper()
                index = index + 1
        has_seen.append(st[i])
        i = i + 1
    return retstr