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: EASY
Tags: String algorithms

Game theory

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(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