There are 32 letters in the Polish alphabet: 9 vowels and 23 consonants. 
 
Your task is to change the letters with diacritics:

```
ą -> a,
ć -> c,
ę -> e,
ł -> l,
ń -> n,
ó -> o,
ś -> s,
ź -> z,
ż -> z
```
and print out the string without the use of the Polish letters.


For example:
```
"Jędrzej Błądziński"  -->  "Jedrzej Bladzinski"
```

Difficulty: introductory

Starter code:

def correct_polish_letters(st):
	

Solutions:
def correct_polish_letters(s):
    return s.translate(str.maketrans("ąćęłńóśźż", "acelnoszz"))

def correct_polish_letters(st):
    l = "ąćęłńóśźż"
    lt = "acelnoszz"
    for i in range(len(l)):
        st = st.replace(l[i], lt[i])
    return st

def correct_polish_letters(st): 
    d={'ą':'a',
    'ć':'c',
    'ę':'e',
    'ł':'l',
    'ń':'n',
    'ó':'o',
    'ś':'s',
    'ź':'z',
    'ż':'z'}
    return "".join(d[c] if c in d else c for c in st)

correct_polish_letters = lambda st: st.translate(str.maketrans('ąćęłńóśźż', 'acelnoszz'))

def correct_polish_letters(st): 
    rules = {
        'ą': 'a',
        'ć': 'c',
        'ę': 'e',
        'ł': 'l',
        'ń': 'n',
        'ó': 'o',
        'ś': 's',
        'ź': 'z',
        'ż': 'z'
        }
    return ''.join(map(lambda c: rules[c] if c in rules else c, st))

def correct_polish_letters(stg): 
    return stg.translate(str.maketrans("ąćęłńóśźż", "acelnoszz"))

def correct_polish_letters(st): 
    return st.translate(st.maketrans("ąćęłńóśźż", "acelnoszz"))


def correct_polish_letters(st): 
    alphabet = {'ą':'a', 'ć':'c', 'ę':'e', 'ł':'l', 'ń':'n',
                'ó':'o', 'ś':'s', 'ź':'z', 'ż':'z'}
    
    result = ''
    for i in st:
        if i in alphabet:
            result += alphabet[i]
        else:
            result += i
            
    return result

def correct_polish_letters(st): 
    return st.translate(str.maketrans("ąćęłńóśźż", "acelnoszz"))


intab = 'ąćęłńóśźż'
outtab = 'acelnoszz'
polish = str.maketrans(intab, outtab)

def correct_polish_letters(st): 
    return st.translate(polish)

def correct_polish_letters(st): 
    new_str =''
    for i in range(0,len(st)):
    
        # print(st)
        if st[i] == 'ą': new_str+='a'
        elif st[i] == 'ę' :new_str+='e'
        elif st[i] == 'ć': new_str+='c'
        elif st[i] == 'ł': new_str+='l'
        elif st[i] == 'ń' : new_str+= 'n'
        elif st[i] == 'ó': new_str+='o'
        elif st[i] == 'ś': new_str+='s'
        elif st[i] == 'ź' : new_str+='z'
        elif st[i] == 'ż' : new_str+='z'

        else :  new_str+= st[i]
    return new_str



def correct_polish_letters(s):
  pol_to_eng = {
    "ą": "a",
    "ć": "c",
    "ę": "e",
    "ł": "l",
    "ń": "n",
    "ó": "o",
    "ś": "s",
    "ź": "z",
    "ż": "z",
  }
  return "".join(pol_to_eng.get(c) or c for c in s)

import re

def correct_polish_letters(s):
    pol_to_eng = {
      "ą": "a",
      "ć": "c",
      "ę": "e",
      "ł": "l",
      "ń": "n",
      "ó": "o",
      "ś": "s",
      "ź": "z",
      "ż": "z",
    }
    return re.sub(
        r"[ąćęłńóśźż]",
        lambda matchobj: pol_to_eng[matchobj.group()],
        s
    )

def correct_polish_letters(str_: str) -> str:
    """ Change the letters with diacritics. """
    return str_.translate(
        str.maketrans(
            {
                "ą": "a",
                "ć": "c",
                "ę": "e",
                "ł": "l",
                "ń": "n",
                "ó": "o",
                "ś": "s",
                "ź": "z",
                "ż": "z"
            }
        )
    )

import unicodedata

def correct_polish_letters(st): 
    mapper = {"ą": "a", "ć": "c", "ę": "e", "ł": "l", "ń": "n", "ó": "o", "ś": "s", "ź": "z", "ż": "z"}

    return ''.join([mapper[c] if c in mapper else c for c in st])

correct_polish_letters = lambda s: ''.join({'ą': 'a', 'ć': 'c', 'ę': 'e',
                                            'ł': 'l', 'ń': 'n', 'ó': 'o',
                                            'ś': 's', 'ź': 'z', 'ż': 'z'}.get(c, c) for c in s)

def correct_polish_letters(st):
    letters = {"ą":"a",
              "ć":"c",
              "ę":"e",
              "ł":"l",
              "ń":"n",
              "ó":"o",
              "ś":"s",
              "ź":"z",
              "ż":"z"}
    result = ""
    for s in st:
        if s in letters:
            result = result + letters.get(s)
        else:
            result = result + s
    return result

correct_polish_letters = lambda s: s.translate(str.maketrans("ąćęłńóśźż", "acelnoszz")) 

def correct_polish_letters(st): 
    replace = {
        'ą': 'a',
        'ć': 'c',
        'ę': 'e',
        'ł': 'l',
        'ń': 'n',
        'ó': 'o',
        'ś': 's',
        'ź': 'z',
        'ż': 'z'
    }
    return ''.join(replace.get(letter, letter) for letter in st)

def correct_polish_letters(st): 

    if 'ą' in st:
        st = st.replace('ą','a')
    if 'ć' in st:
        st = st.replace('ć','c')
    if 'ę' in st:
        st = st.replace('ę','e')
    if 'ł' in st:
        st = st.replace('ł','l')
    if 'ń' in st:
        st = st.replace('ń','n')
    if 'ó' in st:
        st = st.replace('ó','o')
    if 'ś' in st:
        st = st.replace('ś','s')
    if 'ź' in st:
        st = st.replace('ź','z')
    if 'ż' in st:
        st = st.replace('ż','z')
        
    return st
        


dic = {
  "ą" : "a",
  "ć" : "c",
  "ę" : "e",
  "ł" : "l",
  "ń" : "n",
  "ó" : "o",
  "ś" : "s",
  "ź" : "z",
  "ż" : "z"
}

def correct_polish_letters(st): 
    for key, val in list(dic.items()):
        if key in st:
            st = st.replace(key, val)
    return st


db = {
'ą': 'a',
'ć': 'c',
'ę': 'e',
'ł': 'l',
'ń': 'n',
'ó': 'o',
'ś': 's',
'ź': 'z',
'ż': 'z',    
}
def correct_polish_letters(st): 
    return ''.join((db.get(i, i) for i in st))


def correct_polish_letters(st): 
    map = {
     'ą': 'a',
     'ć': 'c',
     'ę': 'e',
     'ł': 'l',
     'ń': 'n',
     'ó': 'o',
     'ś': 's',
     'ź': 'z',
     'ż': 'z',
    }
    for key in map.keys():
        st = st.replace(key, map[key])
    return st

def correct_polish_letters(st): 
    dict = {"ą": "a", "ć": "c", "ę": "e", "ł": "l", "ń": "n", "ó": "o", "ś": "s", "ź": "z", "ż": "z"}
    output = ""
    
    for x in st:
        if x in dict:
            output += dict[x]
        else:
            output += x
            
    return output        

def correct_polish_letters(st): 
    polish = ['ą', 'ć', 'ę', 'ł', 'ń', 'ó', 'ś', 'ź', 'ż']
    changeTo = ['a', 'c', 'e', 'l', 'n', 'o', 's', 'z', 'z']
    converted = []
    for letter in st:
        if letter in polish:
            i = polish.index(letter)
            converted.append(changeTo[i])
        else:
            converted.append(letter)
    return ''.join(converted)


def correct_polish_letters(st):
    trans = {"ą": "a", "ć": "c", "ę": "e", "ł": "l", "ń": "n", 
             "ó": "o", "ś": "s", "ź": "z", "ż": "z"}
    return "".join(trans.get(s, s) for s in st)

def correct_polish_letters(st): 
    st2=''
    arr=[]
    for i in st:
        arr.append(i)
    letters=[['ą', 'ć', 'ę', 'ł', 'ń', 'ó', 'ś', 'ź', 'ż'], ['a', 'c', 'e', 'l', 'n', 'o', 's', 'z', 'z']]
    for i in range(len(arr)):
        for j in range(len(letters[0])):
            if arr[i]==letters[0][j]:
                arr[i]=letters[1][j]
    for i in arr:
        st2+=i
    return st2

def correct_polish_letters(st): 
    letters_dict = {'ą': 'a', 'ć': 'c', 'ę': 'e', 'ł': 'l', 'ń': 'n', 'ó': 'o', 'ś': 's', 'ź': 'z', 'ż': 'z'}
    eng_string = ''
    for letter in st:
        if letter in letters_dict.keys():
            eng_string += letters_dict[letter]
        else:
            eng_string += letter
    return eng_string

def correct_polish_letters(st): 
    dict = {
        'ą' : 'a',
        'ć' : 'c',
        'ę' : 'e',
        'ł' : 'l',
        'ń' : 'n',
        'ó' : 'o',
        'ś' : 's',
        'ź' : 'z',
        'ż' : 'z'
    }
    return ''.join(dict.get(c, c) for c in st)

def correct_polish_letters(st): 
    change = str.maketrans('ąćęłńóśźżz', 'acelnoszzz')
    return st.translate(change)

def correct_polish_letters(st): 
    let = {
        "ą":"a",
        "ć":"c",
        "ę":"e",
        "ł":"l",
        "ń":"n",
        "ó":"o",
        "ś":"s",
        "ź":"z",
        "ż":"z"
    }
    new = ""
    for i in st:
        if i in let:
            new += let[i]
        else:
            new += i
    
    return new

def correct_polish_letters(text): 
    x = {'ą': 'a', 'ć': 'c', 'ę': 'e', 'ł': 'l', 'ń': 'n', 'ó': 'o', 'ś': 's', 'ź': 'z', 'ż': 'z'}
    
    for key in list(x.keys()):
        text = text.replace(key, str(x[key]))
    return text
  


def correct_polish_letters(st): 
    polish = {
        'ą':'a',
        'ć':'c',
        'ę':'e',
        'ł':'l',
        'ń':'n',
        'ó':'o',
        'ś':'s',
        'ź':'z',
        'ż':'z'
    }    
    return "".join([polish.get(char, char) for char in st])


def correct_polish_letters(st): 
    d = {'ą':'a', 'ć':'c', 'ę':'e', 'ł':'l', 'ń':'n',
                'ó':'o', 'ś':'s', 'ź':'z', 'ż':'z'}
    ans = ''
    for char in st:
        if char in d:
            ans += d[char]
        else:
            ans += char
    return ans

import unicodedata

NON_NFKD_MAP = {'\u0181': 'B', '\u1d81': 'd', '\u1d85': 'l', '\u1d89': 'r', '\u028b': 'v', '\u1d8d': 'x', '\u1d83': 'g', '\u0191': 'F', '\u0199': 'k', '\u019d': 'N', '\u0220': 'N', '\u01a5': 'p', '\u0224': 'Z', '\u0126': 'H', '\u01ad': 't', '\u01b5': 'Z', '\u0234': 'l', '\u023c': 'c', '\u0240': 'z', '\u0142': 'l', '\u0244': 'U', '\u2c60': 'L', '\u0248': 'J', '\ua74a': 'O', '\u024c': 'R', '\ua752': 'P', '\ua756': 'Q', '\ua75a': 'R', '\ua75e': 'V', '\u0260': 'g', '\u01e5': 'g', '\u2c64': 'R', '\u0166': 'T', '\u0268': 'i', '\u2c66': 't', '\u026c': 'l', '\u1d6e': 'f', '\u1d87': 'n', '\u1d72': 'r', '\u2c74': 'v', '\u1d76': 'z', '\u2c78': 'e', '\u027c': 'r', '\u1eff': 'y', '\ua741': 'k', '\u0182': 'B', '\u1d86': 'm', '\u0288': 't', '\u018a': 'D', '\u1d8e': 'z', '\u0111': 'd', '\u0290': 'z', '\u0192': 'f', '\u1d96': 'i', '\u019a': 'l', '\u019e': 'n', '\u1d88': 'p', '\u02a0': 'q', '\u01ae': 'T', '\u01b2': 'V', '\u01b6': 'z', '\u023b': 'C', '\u023f': 's', '\u0141': 'L', '\u0243': 'B', '\ua745': 'k', '\u0247': 'e', '\ua749': 'l', '\u024b': 'q', '\ua74d': 'o', '\u024f': 'y', '\ua751': 'p', '\u0253': 'b', '\ua755': 'p', '\u0257': 'd', '\ua759': 'q', '\xd8': 'O', '\u2c63': 'P', '\u2c67': 'H', '\u026b': 'l', '\u1d6d': 'd', '\u1d71': 'p', '\u0273': 'n', '\u1d75': 't', '\u1d91': 'd', '\xf8': 'o', '\u2c7e': 'S', '\u1d7d': 'p', '\u2c7f': 'Z', '\u0183': 'b', '\u0187': 'C', '\u1d80': 'b', '\u0289': 'u', '\u018b': 'D', '\u1d8f': 'a', '\u0291': 'z', '\u0110': 'D', '\u0193': 'G', '\u1d82': 'f', '\u0197': 'I', '\u029d': 'j', '\u019f': 'O', '\u2c6c': 'z', '\u01ab': 't', '\u01b3': 'Y', '\u0236': 't', '\u023a': 'A', '\u023e': 'T', '\ua740': 'K', '\u1d8a': 's', '\ua744': 'K', '\u0246': 'E', '\ua748': 'L', '\ua74c': 'O', '\u024e': 'Y', '\ua750': 'P', '\ua754': 'P', '\u0256': 'd', '\ua758': 'Q', '\u2c62': 'L', '\u0266': 'h', '\u2c73': 'w', '\u2c6a': 'k', '\u1d6c': 'b', '\u2c6e': 'M', '\u1d70': 'n', '\u0272': 'n', '\u1d92': 'e', '\u1d74': 's', '\u2c7a': 'o', '\u2c6b': 'Z', '\u027e': 'r', '\u0180': 'b', '\u0282': 's', '\u1d84': 'k', '\u0188': 'c', '\u018c': 'd', '\ua742': 'K', '\u1d99': 'u', '\u0198': 'K', '\u1d8c': 'v', '\u0221': 'd', '\u2c71': 'v', '\u0225': 'z', '\u01a4': 'P', '\u0127': 'h', '\u01ac': 'T', '\u0235': 'n', '\u01b4': 'y', '\u2c72': 'W', '\u023d': 'L', '\ua743': 'k', '\u0249': 'j', '\ua74b': 'o', '\u024d': 'r', '\ua753': 'p', '\u0255': 'c', '\ua757': 'q', '\u2c68': 'h', '\ua75b': 'r', '\ua75f': 'v', '\u2c61': 'l', '\u2c65': 'a', '\u01e4': 'G', '\u0167': 't', '\u2c69': 'K', '\u026d': 'l', '\u1d6f': 'm', '\u0271': 'm', '\u1d73': 'r', '\u027d': 'r', '\u1efe': 'Y'}

def correct_polish_letters(st):

    if not isinstance(st, str):
        st = str(st)

    return ''.join(NON_NFKD_MAP[c] if c in NON_NFKD_MAP else c \
                   for part in unicodedata.normalize('NFKD', st) for c in part
                   if unicodedata.category(part) != 'Mn')



def correct_polish_letters(st): 
    result = ""
    alphabet = { "ą": "a",
     "ć": "c",
     "ę": "e",
     "ł": "l",
     "ń": "n",
     "ó": "o",
     "ś": "s",
     "ź": "z",
     "ż": "z"}
    
    for n in st:
        if n in alphabet:
            result += alphabet[n]
        else:
            result += n
    
    return result
    
    


def correct_polish_letters(st): 
    polish = 'ąćęłńóśźż'
    english = 'acelnoszz'
    for i in range(9):
        st = st.replace(polish[i], english[i])
    return st

def correct_polish_letters(st): 
    polish, latin = 'ąćęłńóśźż', 'acelnoszz'
    for i in polish:
        st = st.replace(i, latin[polish.find(i)])
    return st

letter_corr = {
    "ą": "a",
    "ć": "c",
    "ę": "e",
    "ł": "l",
    "ń": "n",
    "ó": "o",
    "ś": "s",
    "ź": "z",
    "ż": "z" 
}


def correct_polish_letters(st):
    l = []
    for i in st:
        l.append(letter_corr.get(i, i))
    return ''.join(l)

def correct_polish_letters(st): 
    PolishDict = {
        "ą" : "a",
        "ć" : "c",
        "ę" : "e",
        "ł" : "l",
        "ń" : "n",
        "ó" : "o",
        "ś" : "s",
        "ź" : "z",
        "ż" : "z"
    }
    newStr = ""
    for i in range(len(st)):
        if st[i] in PolishDict:
            newStr += PolishDict[st[i]]
        else:
            newStr += st[i]
    return newStr

def correct_polish_letters(st): 
    dict = {
    'ą': 'a',
    'ą': 'a',
    'ć': 'c',
    'ę': 'e',
    'ł': 'l',
    'ń': 'n',
    'ó': 'o',
    'ś': 's',
    'ź': 'z',
    'ż': 'z'
    }
    str = ''
    for letter in st:
        if letter in dict:
            str += dict[letter]
        else:
            str += letter
    return str

correct_polish_letters = lambda st: ''.join([{'ą':'a','ć':'c','ę':'e','ł':'l','ń':'n','ó':'o','ś':'s','ź':'z','ż':'z'}.get(i,i) for i in st])

def correct_polish_letters(st): 
    polish_alphabet = {
        'ą' : 'a',
        'ć' : 'c',
        'ę' : 'e',
        'ł' : 'l',
        'ń' : 'n',
        'ó' : 'o',
        'ś' : 's',
        'ź' : 'z',
        'ż' : 'z'
    }
    return ''.join([polish_alphabet.get(i) if i in polish_alphabet else i for i in st])

def correct_polish_letters(st): 
    polish={'ą':'a','ć':'c','ę':'e','ł':'l','ń':'n','ó':'o','ś':'s','ź':'z','ż':'z'}
    new_string=""
    for i in st:
        if i in polish:
            new_string+=(polish[i])
        else:
            new_string+=i
    return new_string


def correct_polish_letters(st): 
    new_string = ""
    eng = "acelnoszz"
    pol = "ąćęłńóśźż"
    
    for i in range(len(st)):
        if st[i] in pol:
            new_string += eng[pol.index(st[i])]
        else:
            new_string += st[i]
            
    return new_string

def correct_polish_letters(st): 
    stt=st.replace("ą", "a").replace("ć", "c").replace("ę", "e").replace("ł", "l").replace("ń", "n").replace("ó", "o").replace("ś", "s").replace("ź", "z").replace("ż", "z")
    return stt

def correct_polish_letters(st): 
    dict = {
        'ą': 'a',
        'ć': 'c',
        'ę': 'e',
        'ł': 'l',
        'ń': 'n',
        'ó': 'o',
        'ś': 's',
        'ź': 'z',
        'ż': 'z'
    }
    for c in st:
        if c in dict:
            st = st.replace(c, dict[c])
    return st

def correct_polish_letters(st):
    diacritic = {'ą' : 'a',
                'ć' : 'c',
                'ę' : 'e',
                'ł' : 'l',
                'ń' : 'n',
                'ó' : 'o',
                'ś' : 's',
                'ź' : 'z',
                'ż' : 'z'}
    return ''.join([char.replace(char, diacritic[char]) if char in diacritic.keys() else char for char in st])

def correct_polish_letters(st): 
    alp = {'ą': 'a', 'ć': 'c', 'ę': 'e', 'ł': 'l', 'ń': 'n', 'ó': 'o', 'ś': 's', 'ź': 'z', 'ż': 'z'}
    for key in alp.keys():
        st = st.replace(key, alp[key])
    return st

def correct_polish_letters(st): 
    for p,e in {"ą":"a","ć":"c","ę":"e","ł":"l","ń":"n","ó":"o","ś":"s","ź":"z","ż":"z"}.items():
        st=st.replace(p,e)
    return st

def correct_polish_letters(st): 
    check = {"ą" : "a",
            "ć" : "c",
            "ę" : "e",
            "ł" : "l",
            "ń" : "n",
            "ó" : "o",
            "ś" : "s",
            "ź" : "z",
            "ż" : "z"}
    str = ""
    for i in range(len(st)):
        if st[i] in check.keys():
            str += check.get(st[i])
        else:
            str += st[i]
    return str

def correct_polish_letters(st):
    d = {
        'ą': 'a', 'ć': 'c', 'ę': 'e',
        'ł': 'l', 'ń': 'n', 'ó': 'o',
        'ś': 's', 'ź': 'z', 'ż': 'z'
    }
    for k in d:
        st = st.replace(k, d[k])
    return st

def correct_polish_letters(st): 
    alp = "ąćęłńóśźż"
    alpc = "acelnoszz"
    return st.translate(st.maketrans(alp, alpc))

def correct_polish_letters(st): 
    base = {'ą':'a',
            'ć':'c',
            'ę':'e',
            'ł':'l',
            'ń':'n',
            'ó':'o',
            'ś':'s',
            'ź':'z',
            'ż':'z'}
    
    return ''.join([base[i] if i in base else i for i in st])

def correct_polish_letters(st):
    diacritics = {
        "ą": "a",
        "ć": "c",
        "ę": "e",
        "ł": "l",
        "ń": "n",
        "ó": "o",
        "ś": "s",
        "ź": "z",
        "ż": "z"
    }
    return "".join([diacritics.get(c) if diacritics.get(c) else c for c in st])

def correct_polish_letters(st): 
    letters = {
        "ą": "a",
        "ć": "c",
        "ę": "e",
        "ł": "l",
        "ń": "n",
        "ó": "o",
        "ś": "s", 
        "ź": "z",
        "ż": "z"
    }
    result = ""
    for i in st:
        if i in letters:
            result += letters[i]
        else:
            result += i
    return result

def correct_polish_letters(st): 
    Polish_alphabet = {'ą': 'a', 'ć': 'c', 'ę': 'e', 'ł': 'l', 'ń': 'n', 'ó': 'o', 'ś': 's', 'ź': 'z', 'ż': 'z'}
    result = ''
    for el in st:
        result += Polish_alphabet.get(el, el)
    return result

trans = {'ą':'a','ć':'c','ę':'e','ł':'l','ń':'n','ó':'o','ś':'s','ź':'z','ż':'z'}

def correct_polish_letters(st): 
    empty = []
    for char in st:
        if char not in trans:
            empty.append(char)
        elif char in trans:
            empty.append(trans[char])
            
    return ''.join(empty)

def correct_polish_letters(st): 
    answer = ""
    d= {
        "ą":"a",
        "ć":"c",
        "ę":"e",
        "ł":"l",
        "ń":"n",
        "ó":"o",
        "ś":"s",
        "ź":"z",
        "ż":"z"
    }
    lst = ["ą","ć","ę","ł","ń","ó","ś","ź","ż"]
    
    for c in st:
        if c in lst:
            answer += d.get(c)
        else: 
            answer += c
    return answer

def correct_polish_letters(st): 
    dict = { "ą" : "a",
"ć" : "c",
"ę" : "e",
"ł" : "l",
"ń" : "n",
"ó" : "o",
"ś" : "s",
"ź" : "z",
"ż" : "z" }
    st2= ""
    for ch in st:
        if ch in dict:
            st2= st2+(dict[ch])
        else:
            st2= st2+(ch)
    
    
    return st2


def correct_polish_letters(st): 
    result = ""
    for letter in st:
        if letter == "ą":
            result += "a"
        elif letter == "ć":
            result += "c"
        elif letter == "ę":
            result += "e"
        elif letter == "ł":
            result += "l"
        elif letter == "ń":
            result += "n"
        elif letter == "ó":
            result += "o"
        elif letter == "ś":
            result += "s"
        elif letter == "ź":
            result += "z"
        elif letter == "ż":
            result += "z"  
        else:
            result += letter
    return result
            
    # your code here
    pass

def correct_polish_letters(st): 
    alphabet = {
            "ą": "a",
    "ć": "c",
    "ę": "e",
    "ł": "l",
    "ń": "n",
    "ó": "o",
    "ś": "s",
    "ź": "z",
    "ż": "z",
    }
    new_str = ''
    for c in list(st):
        if c in alphabet:
            new_str += alphabet[c]
        else:
            new_str += c
    return new_str

def correct_polish_letters(st): 
    letters = {
        'ą': 'a',
        'ć': 'c',
        'ę': 'e',
        'ł': 'l',
        'ń': 'n',
        'ó': 'o',
        'ś': 's',
        'ź': 'z',
        'ż': 'z'
        }
    
    for l in st:
        if l in letters:
            st = st.replace(l, letters[l])
    return st

X = {
    "ą": "a",
    "ć": "c",
    "ę": "e",
    "ł": "l",
    "ń": "n",
    "ó": "o",
    "ś": "s",
    "ź": "z",
    "ż": "z"
}
def correct_polish_letters(st):
    for x in X: st = st.replace(x, X[x])
    return st

def correct_polish_letters(st): 
    letters_dict = {
        'ą': 'a',
        'ć': 'c',
        'ę': 'e',
        'ł': 'l',
        'ń': 'n',
        'ó': 'o',
        'ś': 's',
        'ź': 'z',
        'ż': 'z'
    }
    result = ''
    for letter in st:
        if letter in letters_dict.keys():
            result += letters_dict[letter]
        else:
            result += letter
    return result

polish_letter = {"ą": "a",
"ć": "c",
"ę": "e",
"ł": "l",
"ń": "n",
"ó": "o",
"ś": "s",
"ź": "z",
"ż": "z"}

def correct_polish_letters(st):
    new_list = []
    for letter in st:
        if letter in polish_letter:
            letter = polish_letter[letter]
        new_list.append(letter)
    return "".join(new_list)


def correct_polish_letters(st): 
    s,p,n="",["ą","ć","ę","ł","ń","ó","ś","ź","ż"],["a","c","e","l","n","o","s","z","z"]
    for i in list(st):
        if i in p: 
            s+=n[p.index(i)]
        else: s+=i
    return s

ALPHABET = {"ą": "a",
            "ć": "c",
            "ę": "e",
            "ł": "l",
            "ń": "n",
            "ó": "o",
            "ś": "s",
            "ź": "z",
            "ż": "z"}


def correct_polish_letters(st): 

    result = ""
    for char in st:
        if (char in ALPHABET):
            result += ALPHABET[char]
        else:
            result += char

    return result


def correct_polish_letters(st): 
    new = ''
    for x in st:
        if x == 'ą':
            new += 'a'
        elif x == 'ć':
            new += 'c'
        elif x == 'ę':
            new += 'e'
        elif x == 'ł':
            new += 'l'
        elif x == 'ń':
            new += 'n'   
        elif x == 'ó':
            new += 'o'   
        elif x == 'ś':
            new += 's' 
        elif x == 'ź':
            new += 'z'
        elif x == 'ż':
            new += 'z'   
        else:
            new += x
    return new

          
            


import re
polist_letters = {
    'ą': 'a',
    'ć': 'c',
    'ę': 'e',
    'ł': 'l',
    'ń': 'n',
    'ó': 'o',
    'ś': 's',
    'ź': 'z',
    'ż': 'z'
}

def correct_polish_letters(st): 
    my_st = st
    for l in polist_letters:
        my_st = re.sub(l, polist_letters.get(l), my_st)
    return my_st


def correct_polish_letters(st):
    # your code here
    d = {'ą': 'a', 'ć': 'c', 'ę': 'e', 'ł': 'l', 'ń': 'n', 'ó': 'o', 'ś': 's', 'ź': 'z', 'ż': 'z'}
    return ''.join(map(lambda x: x.replace(x, d.get(x, x)), st))

def correct_polish_letters(st): 
    polish_letters = "ąćęłńóśźż"
    english_letters = "acelnoszz"
    table = st.maketrans(polish_letters, english_letters) 
    return st.translate(table)

def correct_polish_letters(st): 
    table = st.maketrans("ąćęłńóśźż","acelnoszz")
    st = st.translate(table)
    return st

def correct_polish_letters(st): 
    translation = { 'ą' : 'a',
                    'ć' : 'c',
                    'ę' : 'e',
                    'ł' : 'l',
                    'ń' : 'n',
                    'ó' : 'o',
                    'ś' : 's',
                    'ź' : 'z',
                    'ż' : 'z' }
    output = ''
    for x in st:
        if x in translation:
            output += translation.get(x)
        else:
            output += x
    return output

def correct_polish_letters(st):
    dict = {'ą' : 'a', 'ć' : 'c','ę' : 'e', 'ł' : 'l', 'ń' : 'n', 'ó' : 'o', 'ś' : 's', 'ź' : 'z', 'ż' : 'z'}
    return ''.join([dict[x] if x in dict.keys() else x for x in st])

def correct_polish_letters(string):
    dic = {"ą": "a",
           "ć": "c",
           "ę": "e",
           "ł": "l",
           "ń": "n",
           "ó": "o",
           "ś": "s",
           "ź": "z",
           "ż": "z"}
    return "".join(dic.get(l, l) for l in string)

def correct_polish_letters(st): 
    dict = {
        'ą': 'a',
        'ć': 'c',
        'ę': 'e',
        'ł': 'l',
        'ń': 'n',
        'ó': 'o',
        'ś': 's',
        'ź': 'z',
        'ż': 'z' 
    }
    for key in dict.keys():
        st = st.replace(key, str(dict[key]))
            
    return st

def correct_polish_letters(st): 
    res = ""
    
    letters = { "ą": "a", "ć":  "c", "ę":  "e", "ł":  "l", "ń":  "n", 
                "ó":  "o", "ś":  "s", "ź":  "z", "ż": "z" }
    
    for elem in st:
        for letter in elem:
            if letter in letters:
                res += letters[letter]
            else:
                res += elem
    
    return res               

def correct_polish_letters(st): 
    d= {
        'ą' : 'a',
        'ć' : 'c',
        'ę' : 'e',
        'ł' : 'l',
        'ń' : 'n',
        'ó' : 'o',
        'ś' : 's',
        'ź' : 'z',
        'ż' : 'z'
    }
    output=""
    for i in st:
        output += d.get(i,i)
    return output

def correct_polish_letters(st): 
    list=[]
    dict={"ą":"a",
        "ć":"c",
        "ę":"e",
        "ł":"l",
        "ń":"n",
        "ó":"o",
        "ś":"s",
        "ź":"z",
        "ż":"z"}
    for i in st:
        if i in dict.keys():
            list.append(dict[i])
        elif st.isspace():
            list.append(" ")
        else:
            list.append(i)
    return "".join(list)

def correct_polish_letters(st): 
    # your code here
    alf={' ':' ','ą':'a','ć':'c','ę':'e','ł':'l','ń':'n','ó':'o','ś':'s','ź':'z','ż':'z'}
    return ''.join(alf[i] if i in alf else i for i in st)

def correct_polish_letters(st): 
    d = {'ą': 'a', 'ć': 'c', 'ę': 'e', 'ł': 'l', 'ń': 'n', 'ó': 'o', 'ś': 's', 'ź': 'z', 'ż': 'z'}
    r = ''
    for letter in st:
        if letter in d:
            r += d[letter]
        else:
            r += letter
    return r

def correct_polish_letters(st): 
    dict={'ą':'a','ć':'c','ę':'e','ł':'l','ń':'n','ó':'o','ś':'s','ź':'z','ż':'z'}
    return ''.join(dict.get(char,char) for char in st)


def correct_polish_letters(st): 
    dict={'ą':'a','ć':'c','ę':'e','ł':'l','ń':'n','ó':'o','ś':'s','ź':'z','ż':'z'}
    return ''.join(list(dict.get(char,char) for char in st))



def correct_polish_letters(st): 
    pol = {'ą': 'a',
           'ć': 'c',
           'ę': 'e',
           'ł': 'l',
           'ń': 'n',
           'ó': 'o',
           'ś': 's',
           'ź': 'z',
           'ż': 'z'}
    
    st2 = ""
    
    for c in st:
        if c in pol:
            st2 += pol[c]
        
        else:
            st2 += c
    
    return st2

def correct_polish_letters(st): 
    dict = {"ą" : "a",
            "ć" : "c",
            "ę": "e",
            "ł" :"l",
            "ń" : "n",
            "ó" : "o",
            "ś" : "s",
            "ź" : "z",
            "ż" : "z"
    }
    word =""
    for i in st:
        if i.isupper()==True:
            word+=i
        else:
            word+= dict.get(i,i)
    return word

POLSKA_STRONG = {
    'ą': 'a',
    'ć': 'c',
    'ę': 'e',
    'ł': 'l',
    'ń': 'n',
    'ó': 'o',
    'ś': 's',
    'ź': 'z',
    'ż': 'z'
}
def correct_polish_letters(st):
    return ''.join(POLSKA_STRONG.get(i, i) for i in st)


pol = {'ą': 'a', 'ć': 'c', 'ę': 'e', 'ł': 'l','ń': 'n',\
       'ó': 'o', 'ś': 's','ź':'z', 'ż': 'z'}

def correct_polish_letters(st): 
    for char in st: 
        if char in pol.keys():
            st = st.replace(char, pol.get(char))
    return st

def correct_polish_letters(s):
    return s.translate(str.maketrans({"ą": "a", "ć": "c", "ę": "e", "ł": "l", "ń": "n", "ó": "o", "ś": "s", "ź": "z", "ż": "z"}))


def correct_polish_letters(st): 
    ls = {"ą": "a", "ć": "c", "ę": "e", "ł": "l", "ń": "n", "ó": "o", "ś": "s", "ź": "z", "ż": "z"}
    return ''.join(ls[l] if l in ls else l for l in st)


def correct_polish_letters(st): 
    dic = {
        'ą':'a',
        'ć':'c',
        'ę':'e',
        'ł':'l',
        'ń':'n',
        'ó':'o',
        'ś':'s',
        'ź':'z',
        'ż':'z'
    }
    res = "".join(dic[i] if i in dic else i for i in st)
    return res

def correct_polish_letters(st):
    dict_ = {'ą': 'a', 'ć': 'c', 'ę': 'e', 'ł': 'l', 'ń': 'n', 'ó': 'o', 'ś': 's', 'ź': 'z', 'ż': 'z'}
    return ''.join(dict_[i] if i in dict_ else i for i in st)

def correct_polish_letters(st):
    translationTable = str.maketrans("ąćęłńóśźż", "acelnoszz")
    return st.translate(translationTable)


def correct_polish_letters(st): 
    # your code here
    polish = {
        'ą': 'a',
        'ć': 'c',
        'ę': 'e',
        'ł': 'l',
        'ń': 'n',
        'ó': 'o',
        'ś': 's',
        'ź': 'z',
        'ż': 'z'
    }
    
    res = ''
    for i in st:
        if i in polish:
            q = st.index(i)
            res += st[q].replace(st[q], polish.get(st[q]))
        else:
            res += i


    return res

p = {'ą':'a','ć':'c','ę':'e','ł':'l','ń':'n','ó':'o','ś':'s','ź':'z','ż':'z'}

def correct_polish_letters(st): 
    return ''.join([p.get(c, c) for c in st])

def correct_polish_letters(st): 
    char = ['a','c','e','l','n','o','s','z','z']
    mod = ['ą','ć','ę','ł','ń','ó','ś','ź','ż']
    for x in st:
        if x in mod:
            st = st.replace(x, char[mod.index(x)])
    return st

def correct_polish_letters(st):

    str = ""

    for x in st:
        if x == "ą":
            str += "a"
        elif x == "ć":
            str += "c"
        elif x == "ę":
            str += "e"
        elif x == "ł":
            str += "l"
        elif x == "ń":
            str += "n"
        elif x == "ó":
            str += "o"
        elif x == "ś":
            str += "s"
        elif x == "ź":
            str += "z"
        elif x == "ż":
            str += "z"
        else:
            str += x
    return (str)

def correct_polish_letters(st): 
    polish_letters = {'ą': 'a', 
                      'ć': 'c', 
                      'ę': 'e', 
                      'ł': 'l', 
                      'ń': 'n', 
                      'ó': 'o', 
                      'ś': 's', 
                      'ź': 'z', 
                      'ż': 'z'}
    ret = ''
    for i in st:
        if i in polish_letters.keys():
            ret += polish_letters[i]
        else:
            ret += i
    return ret

import ast
def correct_polish_letters(st): 
    letters="""ą -> a,
ć -> c,
ę -> e,
ł -> l,
ń -> n,
ó -> o,
ś -> s,
ź -> z,
ż -> z"""
    letters="{'"+letters.replace(" -> ","':'").replace(",","',").replace("\n","'")+"'}"
    letters=ast.literal_eval(letters)
    st2=""
    for i in range(len(st)):
        if st[i] not in letters:
            st2+=st[i]
        else:
            st2+=letters.get(st[i])
    return st2


def correct_polish_letters(st): 
    dic = {
        "ą":'a',
        "ć":'c',
        "ę":'e',
        "ł":'l',
        'ń':'n',
        'ó':'o',
        'ś':'s',
        'ź':'z',
        'ż': 'z'
    }
    for i in dic:
        st = st.replace(i,dic[i])
    return st