How can you tell an extrovert from an
introvert at NSA? Va gur ryringbef,
gur rkgebireg ybbxf ng gur BGURE thl'f fubrf.

I found this joke on USENET, but the punchline is scrambled. Maybe you can decipher it?
According to Wikipedia, ROT13 (http://en.wikipedia.org/wiki/ROT13) is frequently used to obfuscate jokes on USENET.

Hint: For this task you're only supposed to substitue characters. Not spaces, punctuation, numbers etc.
Test examples:
```
rot13("EBG13 rknzcyr.") == "ROT13 example.";
rot13("This is my first ROT13 excercise!" == "Guvf vf zl svefg EBG13 rkprepvfr!"
```

Difficulty: introductory

Starter code:

def rot13(message):
	

Solutions:
def rot13(message):
    def decode(c):
        if 'a' <= c <= 'z':
            base = 'a'
        elif 'A' <= c <= 'Z':
            base = 'A'
        else:
            return c
        return chr((ord(c) - ord(base) + 13) % 26 + ord(base))
    return "".join(decode(c) for c in message)

def rot13(message):
    PAIRS = dict(zip("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
        "nopqrstuvwxyzabcdefghijklmNOPQRSTUVWXYZABCDEFGHIJKLM"))
    return "".join(PAIRS.get(c, c) for c in message)

def rot13(message):
    import codecs
    return codecs.encode(message, 'rot_13')

from string import ascii_lowercase as abc
from string import ascii_uppercase as ABC

def rot13(message):
    abc_message = abc + ABC
    abc_cipher = abc[13:] + abc[:13] + ABC[13:] + ABC[:13]
    return message.translate(str.maketrans(abc_message, abc_cipher))

def rot13(message):
    root13in = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
    root13out = 'NOPQRSTUVWXYZABCDEFGHIJKLMnopqrstuvwxyzabcdefghijklm'
    root13map = dict(zip(root13in, root13out))
    
    res = ''.join([root13map.get(s, s) for s in message])
    
    return res

from string import ascii_letters, ascii_lowercase, ascii_uppercase

def shift(s, n):
    return s[n:] + s[:n]

table = str.maketrans(
    ascii_letters,
    shift(ascii_lowercase, 13) + shift(ascii_uppercase, 13))

def rot13(message):
    return message.translate(table)


import re

def rot13(message):
    pattern1 = re.compile(r'[A-Ma-m]') 
    pattern2 = re.compile(r'[N-Zn-z]')   
    deciphered = []
    for s in message:
        if pattern1.match(s):
            deciphered.append(chr(ord(s) + 13))
        elif pattern2.match(s):
            deciphered.append(chr(ord(s) - 13))
        else:
            deciphered.append(s)
    return ''.join(deciphered)

def rot13(message):
    abc = "a b c d e f g h i j k l m n o p q r s t u v w x y z".split()*2
    abc_upper = "a b c d e f g h i j k l m n o p q r s t u v w x y z".upper().split()*2
    res = ""
    for i in message:
        if i in abc_upper:
            res += abc_upper[abc_upper.index(i)+13]
        elif i in abc:
            res += abc[abc.index(i)+13]
        else:
            res += i

    return res


def rot13c(c):
    if c.islower(): a = 'a'
    elif c.isupper(): a = 'A'
    else: return c
    return chr(ord(c)+13) if ord(c) < ord(a)+13 else chr(ord(c)-13)
def rot13(message): return ''.join(rot13c(c) for c in message)


def rot13(message):
    return ''.join(map(lambda c: chr(ord(c)+13) if c.isalpha() and c.lower() <= 'm' else
                                 chr(ord(c)-13) if c.isalpha() else c, message))

import codecs
def rot13(message):
    #your code here  
    code = codecs.encode(message, 'rot_13')
    return(code)
        
                
            


def rot13(message):
    source = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    target = "nopqrstuvwxyzabcdefghijklmNOPQRSTUVWXYZABCDEFGHIJKLM"
    code = {k:v for k,v in zip(source, target)}
    
    result = ""
    
    for c in message:
        # use non-code characters as-is 
        if c not in code:
            result += c
            continue
        
        result += code[c]
        
    return result

import string
def rot13(message):
    q = ""
    p = list(string.ascii_lowercase)
    for i in message:
        if i.isalpha()== True:
            a = p.index(i.lower())+ 13
            if i.isupper()== True:
                if a > 25:
                    a -= 26
                q += (p[a]).upper()
            else:
                if a > 25:
                    a -= 26
                q += (p[a]).lower()
        else:
            q += i  
    return q
    


def rot13(message):
    index = {}
    az=[chr(i) for i in range(ord("a"),ord("z")+1)]
    AZ=[chr(i) for i in range(ord("A"),ord("Z")+1)]
    azT = az[13:]+az[0:13]
    AZT = AZ[13:]+AZ[0:13]
    t={a:b for a,b in zip(az+AZ,azT+AZT)}
    
    return "".join([t.get(i,i) for  i in message])