You are given a secret message you need to decipher. Here are the things you need to know to decipher it:

For each word:
- the second and the last letter is switched (e.g. `Hello` becomes `Holle`)
- the first letter is replaced by its character code (e.g. `H` becomes `72`)

Note: there are no special characters used, only letters and spaces

Examples
```
decipherThis('72olle 103doo 100ya'); // 'Hello good day'
decipherThis('82yade 115te 103o'); // 'Ready set go'
```

Difficulty: introductory

Starter code:

def decipher_this(string):
	

Solutions:
def decipher_word(word):
    i = sum(map(str.isdigit, word))
    decoded = chr(int(word[:i]))
    if len(word) > i + 1:
        decoded += word[-1]
    if len(word) > i:
        decoded += word[i+1:-1] + word[i:i+1]
    return decoded

def decipher_this(string):
    return ' '.join(map(decipher_word, string.split()))

def decipher_this(string):
    words = string.split()
    res = []
    #check if there is a part only consisting digts
    for x in words:
        if x.isdigit():
            res.append(chr(int(x)))
    #if not then seperate the numbers and the string charakters in seperate variables
        elif len(x) >= 3:
            sum = ""
            new_str = ""
            for i in x:    
                if i.isdigit():
                    sum += i
                else:
                    new_str += i
            #transverse the digit to the she specific letter and add the old string to it
            sum = chr(int(sum)) + new_str
            #ckeck if the string length has changed due to the transversation and switch the letter position 
            if len(sum) > 2:
                x = (sum[0::len(sum) - 1] + sum[2:len(sum) -1 ] + sum[1])
                res.append(x)
            else:
                res.append(sum)
    return " ".join(res)


def decipher_this(string):
    words = []
    for word in string.split():
        code = ''.join(char for char in word if char.isdigit())
        new_word = chr(int(code))+''.join(char for char in word if not char.isdigit())
        words.append(new_word[:1]+new_word[-1]+new_word[2:-1]+new_word[1] if len(new_word)>2 else new_word)
    return ' '.join(words)

import re

def decipher_this(stg):
    return re.sub(r"(\d+)(\w?)(\w*)", decipher_word, stg)

def decipher_word(match):
    o, cl, cr = match.groups()
    return f"{chr(int(o))}{cr[-1:]}{cr[:-1]}{cl}"

def decipher_this(string):
    translated = []
    for word in string.split():
        digits = ''
        for c in word:
            if c.isdigit():
                digits += c
        word = word.replace(digits, chr(int(digits)))    
        if len(word) > 2:
            translated.append(''.join([word[0], word[-1], word[2:-1], word[1]]))
        else:
            translated.append(word)
    return ' '.join(translated)

import string as Str

def decipher_this(string):
    
    allLetters = Str.ascii_letters
    allNumbers = Str.digits
    
    sentence = string.split(" ")
    
    decodedSentence = ""
    
    for word in sentence:
        ascii_code = word.strip(allLetters)
        ascii_letters = word.strip(allNumbers)
        
        first_letter = chr(int(ascii_code))
        
        if len(ascii_letters) > 1:
            ascii_letters = ascii_letters[-1:] + ascii_letters[1:-1] + ascii_letters[:1]
        
        decodedSentence = decodedSentence + first_letter + ascii_letters + " "
    
    return decodedSentence[:-1]
    


import re
def decipher_this(string):
    #list to save decrypted words
    decrypted = []
    for word in string.split():
        #get number in string
        re_ord = re.match(r'\d+', word).group()
        #replace number by ascii letter and transform word in a list
        new_word = list(re.sub(re_ord, chr(int(re_ord)), word))
        #swap second and last letter in the word list
        if len(new_word) > 2:
            new_word[1], new_word[-1] = new_word[-1], new_word[1]
        #save the word in the string list
        decrypted.append(''.join(new_word))
    #return the decrypted words list as a string
    return ' '.join(decrypted)

import re
def decipher_this(text):
    return re.sub(r'\b(\d{2,3})(\w?)(\w*?)(\w?)\b', lambda m: '{}'.format(chr(int(m.group(1))) + m.group(4) + m.group(3) + m.group(2)), text)

import re

REGEX = re.compile(r'(\d+)([a-zA-Z]*)$')


def decipher_this(s):
    result = []
    for word in s.split():
        m = REGEX.match(word)
        digits, chars = m.groups()
        tmp = [chr(int(digits))]
        if len(chars) < 2:
            tmp.append(chars)
        else:
            tmp.append('{}{}{}'.format(chars[-1], chars[1:-1], chars[0]))
        result.append(''.join(tmp))
    return ' '.join(result)


import re
def decipher_this(str):
    return re.sub(r"(\d+)(\w*)", lambda m : chr(int(m.group(1))) + ( m.group(2)[-1] + m.group(2)[1:-1] + m.group(2)[0] if len(m.group(2))>1 else m.group(2)), str)