Problem:
 Score : 200 points    Problem Statement We have a string S consisting of uppercase English letters. Additionally, an integer N will be given.  Shift each character of S by N in alphabetical order (see below), and print the resulting string.  We assume that A follows Z . For example, shifting A by 2 results in C ( A  \to  B  \to  C ), and shifting Y by 3 results in B ( Y  \to  Z  \to  A  \to  B ).      Constraints  0 \leq N \leq 26  1 \leq |S| \leq 10^4  S consists of uppercase English letters.         Input Input is given from Standard Input in the following format:  N  S       Output Print the string resulting from shifting each character of S by N in alphabetical order.        Sample Input 1 2
ABCXYZ      Sample Output 1 CDEZAB  Note that A follows Z .       Sample Input 2 0
ABCXYZ      Sample Output 2 ABCXYZ       Sample Input 3 13
ABCDEFGHIJKLMNOPQRSTUVWXYZ      Sample Output 3 NOPQRSTUVWXYZABCDEFGHIJKLM

Solution (Python):
n = int(input())
s = input()

ans = ''
for c in s:
    nc_ord = ord(c) + n
    while nc_ord > ord('Z'):
        nc_ord -= 26
    ans += chr(nc_ord)
print(ans)

Solution (Python):
N = int(input())
S = list(input())
for i in range(len(S)):
    S[i] = chr((ord(S[i]) - ord('A') + N) % 26 + ord('A'))
print(''.join(S))

Solution (Python):
n = int(input())
s = input()

m = map(
  lambda x: chr((ord(x) - ord('A') + n) % 26 + ord('A')), list(s))
print(''.join(list(m)))

Solution (Python):
N = int(input())
S = input()
for s in S:
    asc = ord(s) + N
    if asc > 90: asc -= 26
    print(chr(asc), end='')

Solution (Python):
from functools import partial

N = int(input())
S = input()
lst = [chr(ord("A")+i) for i in range(26)]

def convert(x,n,l):
  id = ord(x) - ord("A")
  return l[(id+n)%26]

ans = "".join(map(partial(convert,n=N,l=lst),S))
print(ans)

Solution (Python):
from functools import partial

N = int(input())
S = input()

lst = [chr(ord("A")+i) for i in range(26)]

def convert(x,n):
  id = ord(x) - ord("A")
  return lst[(id+n)%26]

convert1 = partial(convert,n=N)

ans = "".join(map(convert1,S))
print(ans)

Solution (Python):
N = int(input())
S = input()

output = ""
for s in S:
  trans_s = chr((ord(s) - ord("A") + N) % 26 + ord("A"))
  output += trans_s

print(output)

Solution (Python):
N = int(input())
S = list(input())
for i in range(len(S)):
  if ord(S[i])+N <= 90:
    S[i] = chr(ord(S[i])+N)
  else:
    S[i] = chr(ord(S[i])+N-26)
for j in S:
  print(j,end = "")

Solution (Python):
N = int(input())
s = input()
a = [chr(i) for i in range(65, 65+26)]
ls = []
for x in a:
  ls.append(x)
for x in a:
  ls.append(x)
ans = []
for x in s:
  ans.append(ls[ls.index(x)+N])
print(''.join(ans))

Solution (Python):
import sys 
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N = int(readline())
S = readline().decode().rstrip()
ans = ''
A = ord('A')
for i in range(len(S)):
    char = chr(A + (ord(S[i])+N-A)%26)
    ans += char
print(ans)

Solution (Python):
n = int(input())
s = input()

ls = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'*2

ans = ''
for c in s:
    ans += ls[ls.index(c) + n]
print(ans)

Solution (Python):
n = int(input())
s = input()
l = []

for i in s:
    l.append(chr((ord(i) - 65 + n) % 26 + 65))
print(*l, sep="")

Solution (Python):
N = int(input())
S = input()

ans = ''
for i in S:
    n = ord(i) + N
    if n > 90:
        n -= 26
    ans += chr(n)
print(ans)

Solution (Python):
N = int(input())
S = list(input())
alp = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
S_a = ""
for s in S:
    n = alp.index(s)+N 
    if(alp.index(s)+N>=26):
        n -= 26
    S_a += alp[n]
print(S_a)

Solution (Python):
n = int(input())
s = input()

ret = ""
for c in s:
	temp = ord(c) + n
	if (temp > 90): temp -= 26
	ret += chr(temp)

print(ret)

Solution (Python):
n = int(input())
s = input()
ans = ""
for i in range(len(s)):
    num = ord(s[i])
    if num + n > 90:
        num1 = (num+n)-90+64
    if num + n <= 90:
        num1 = num + n
    ans += chr(num1)
print(ans)

Solution (Python):
N = int(input())
S = list(input())
for i in range(len(S)):
    S[i] = chr((((ord(S[i])-65+ N) % 26) + 65))
print(''.join(S))

Solution (Python):
N = int(input())
S = input()

for s in S:
  print(chr(65+(ord(s)+N-65)%26),end="")

Solution (Python):
N = int(input())

result = []

for c in input():
    r = ord(c) + N

    
    if r > 90:
        r = 65 + r % 90 - 1

    result.append(chr(r))

print(''.join(result))

Solution (Python):
N=int(input())
S=input()
a=ord("A")
z=ord("Z")
result=""
for i in range(len(S)):
    word=ord(S[i])+N
    if word>z:
        word=word-z-1+a
    x=chr(word)
    result+=x
print(result)

Solution (Python):
n = int(input())
s = input()

print("".join(chr((ord(c)-ord("A")+n)%26+ord("A")) for c in s))

Solution (Python):
N = int(input())
S = input()
ans = []

for i in range(len(S)):
    if ord(S[i])+N <= 90:
        ans.append(chr(ord(S[i])+N))
    else:
        ans.append(chr(ord(S[i])+N-26))

print("".join(ans))

Solution (Python):
import string

n = int(input())
s = input()
ALPHABET = string.ascii_uppercase

ans = ''
for s_ in s:
    idx = ALPHABET.index(s_)
    idx_ = idx + n if idx + n < 26 else idx + n - 26
    ans += ALPHABET[idx_]
print(ans)

Solution (Python):
N = int(input())
S = input()
char = ''

for i in range(len(S)):
    char += chr((ord(S[i]) + N - 65) % 26 + 65)

print(char)

Solution (Python):
N, S = [input() for _ in range(2)]
X = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
Y = ""
for s in S:
  Y += X[(X.index(s)+int(N))%26]
print(Y)

Solution (Python):
a = int(input())
b = input()
for i in range(0, len(b)):
    c = ord(b[i])
    d = int(c+a)
    if d>90:
        d -= 26
    e = chr(d)
    print(e, end="")

Solution (Python):
n=int(input())
s=input()
S=[]
for i in s:
    if ord(i)+n > 90:
        S.append(chr(ord(i)+n-26))
    else:
        S.append(chr(ord(i)+n))
print(''.join(S))

Solution (Python):
alphabet = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ')
N = int(input())
S = input()

print(*[alphabet[(alphabet.index(s) + N) % 26] for s in S], sep='')

Solution (Python):
n = int(input())
s = input()
s = list(s)

for i in range(len(s)):
    if ord(s[i])+n > 90:
        s[i] = chr(ord(s[i])+n-26)
    else:
        s[i] = chr(ord(s[i])+n)
print("".join(s))

Solution (Python):
n = int(input())
s = input()
ans = [chr(ord(s_)+n) if (ord(s_)+n)<91 else chr((ord(s_)+n)-26) for s_ in s ]
print(''.join(ans))

Solution (Python):
n = int(input())
s = input()
for i in s:
    i = ord(i) + n
    if (i > 90):
        d = i - 90
        print(chr(64+d),end = '')
    else:
        print(chr(i),end = '')

Solution (Python):
n = int(input())
s = input()

def rot(c, r):
    base = 65
    return chr((ord(c)-base+r)%26+base)

print(''.join([rot(i, n) for i in s]))

Solution (Python):
roma = [chr(ord('A') + i) for i in range(26)] + [chr(ord('A') + i) for i in range(26)]
n = int(input())
s = list(input())
for j in s:
  print(roma[roma.index(j) + n], end="")

Solution (Python):
n = int(input())
s = input()
 
def ROTN(tmp, n):
    tmp = ord(tmp) + n
    if tmp > 0x5a:
        tmp -= 26
    return chr(tmp)
 
 
ans = []
for i in range(len(s)):
    tmp = s[i]
    ans.append(ROTN(tmp, n))
 
for i in range(len(ans)):
    print(ans[i], end="")

Solution (Python):
n = int(input())
s = input()

def ROTN(tmp, n):
    tmp = ord(tmp) + n
    if tmp > 0x5a:
        tmp -= 26
    return chr(tmp)


ans = []
for i in range(len(s)):
    tmp = s[i]
    ans.append(ROTN(tmp, n))

for i in range(len(ans)):
    print(ans[i], end="")

Solution (Python):
N = int(input())
S = input()
ret = ''
for s in S:
    o = ord(s) - ord('A') + N
    ret += chr(ord('A') + o % 26)
print(ret)

Solution (Python):
a = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
n = int(input())
ss = input()
print(''.join([a[(a.index(s) + n) % 26] for s in ss]))

Solution (Python):
import os, sys, re, math, string

N = int(input())
S = input()

a = string.ascii_uppercase * 2
print(''.join([a[a.index(s) + (N % 26)] for s in S]))

Solution (Python):
n = int(input())
s = input()
t = 'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ'
print(''.join([t[t.index(c) + n] for c in s ]))

Solution (Python):
n=int(input())
s=input()
ans=""
for i in range(len(s)):
    tmp=ord(s[i])+n
    if tmp>90:
        tmp-=26
    ans+=chr(tmp)
print(ans)

Solution (Python):
N = int(input())
S_ord = [ord(i) for i in input()]
S_ord_change = [65 + (i + N - 65) % 26 for i in S_ord]
S_change = [chr(i) for i in S_ord_change]
result = ''.join(S_change)
print(result)

Solution (Python):
n = int(input())
s = input()
ans = ""
for str in s:
  ords = ord(str)
  if ords + n > 90:
    ords -= 26
  ans += chr(ords + n)
print(ans)

Solution (Python):
n = (int)(input())
s = input()

ret = ""
retc = ''
for i in range(len(s)):
    c = ord(s[i])
    if c + n > ord('Z'):
        retc = c + n - ord('Z') + ord('A') - 1
    else:
        retc = c + n
    ret += chr(retc)

print("{}".format(ret))

Solution (Python):
N = int(input())
S = input()

ans = ''
for c in S:
    i = ord(c) - ord('A')
    i = (i+N)%26
    ans += chr(i + ord('A'))
print(ans)

Solution (Python):
def main():
    n = int(input())
    s = input()
    for i in s:
        mod = (ord(i) - ord('A') + n) % 26
        ans = chr(ord('A') + mod)
        print(ans, end='')
        
if __name__ == '__main__':
    main()

Solution (Python):
N = int(input())
S_ord = [ord(i) for i in input()]
S_ord_change = []
for i in S_ord:
    i += N
    if i >= 91:
        i = i - 26
    S_ord_change.append(i)

S_change_chr = [chr(i) for i in S_ord_change]
result = ''.join(S_change_chr)
print(result)

Solution (Python):
import sys
input = sys.stdin.readline
from string import ascii_uppercase

letters = ascii_uppercase + ascii_uppercase
shift = int(input())
s = input()[:-1]
for char in s: print(letters[letters.index(char) + shift], end = '')
print()

Solution (Python):
N = int(input())
S_list = list(input())

ans = ""



for i in S_list:
    if 90 < ord(i) + N:
        ans += chr(ord(i) + N - 26)
    else:
        ans += chr(ord(i) + N)

print(ans)

Solution (Python):

n = int(input())
s = input()
print(*[chr((ord(i) + n - 65) % 26 + 65)for i in s], sep="")

Solution (Python):
n=int(input())
s=list(input())

for i in s:
  x=ord(i)
  y=x+n
  if y>90:
    z=chr(y-26)
  else:
    z=chr(y)
  print(z,end='')

Solution (Python):
import sys
from string import ascii_uppercase

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    N = int(readline())
    S = readline().strip()

    ans = [0] * len(S)
    for i, c in enumerate(S):
        ans[i] = ascii_uppercase[(ascii_uppercase.index(c) + N) % 26]

    print(''.join(ans))
    return


if __name__ == '__main__':
    main()

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    N = int(readline())
    S = readline().strip()

    ans = [0] * len(S)
    for i, c in enumerate(S):
        ans[i] = chr((ord(c) - 65 + N) % 26 + 65)

    print(''.join(ans))
    return


if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
S = input()

for s in S:
    seq = (ord(s) - ord("A") + n) % 26
    print(chr(ord("A")+seq), end="")

Solution (Python):

import numpy as np







def main():
    N = int(input())
    S = input()
    S_new =""
    for i in range(len(S)):
         S_new +=chr((ord(S[i])+N-ord("A"))%26+ord("A"))
    print(S_new)
if __name__ == "__main__":
    main()

Solution (Python):
n = int(input())
s = input()
ans = []

for i in range(len(s)):
    temp = ord(s[i]) +n
    if temp > 0x5a:
        temp -= 26
    ans.append(chr(temp))
    
for k in range(len(ans)):
    print(ans[k], end = "")

Solution (Python):
N = int(input())
S = list(str(input()))

l = [chr(ord('A')+i) for i in range(26)]
p = []
for t in range(len(S)):
    for i in range(26):
        if S[t] == l[i]:
            k = (i+N)%26
            p.append(l[k])
print(''.join(map(str,p)))

Solution (Python):
n=int(input())
s=list(input())
for i in range(len(s)):
  if ord(s[i])+n<=90:
    s[i]=chr(ord(s[i])+n)
  else:
    s[i]=chr(ord(s[i])+n-26)
print("".join(s))

Solution (Python):
N = int(input())
S = input()
for i in range(len(S)):
    a = ord(S[i])+N
    if a > ord('Z'):
        a -= 26
    print(chr(a),end ='')

Solution (Python):
alphabet = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
N = int(input())
S = input()
for i in S:
  print(alphabet[(alphabet.index(i)+N) % 26], end='')

Solution (Python):
n = int(input())
s = list(input())
ans = []
for i in range(len(s)):
    a = ord(s[i])
    moji = a + n if a + n <= 90 else a + n -26
    ans += [chr(moji)]
print("".join(ans))

Solution (Python):
N = int(input())

S = input()

def alpha2num(alpha):
    num=0
    for index, item in enumerate(list(alpha)):
        num += pow(26,len(alpha)-index-1)*(ord(item)-ord('A')+1)
    return num


def num2alpha(num):
    if num<=26:
        return chr(64+num)
    elif num%26==0:
        return num2alpha(num//26-1)+chr(90)
    else:
        return num2alpha(num//26)+chr(64+num%26)

li = []

for s in S:
    num = alpha2num(s)
    num += N
    num %= 26
    if num==0:
        num = 26
    ap = num2alpha(num)
    li.append(ap)


print("".join(li))

Solution (Python):
n = int(input())
s = input()

sl = list(s)

answer = ""
for i in s:
  t = ord(i)+n
  if t <= 90:
    answer += chr(t)
  else :
    answer += chr(ord("A") + abs(t-90)-1)

print(answer)

Solution (Python):
n = int(input())
s = input()
ans = ''
for c in s:
  ans += chr((ord(c) - ord("A") + n) % 26 + ord("A"))
print(ans)

Solution (Python):
n = int(input())
a = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
s = input()
l = []

for i in range(len(s)):
    j = a.index(s[i])
    j = (j + n) % 26
    l.append(a[j])

print(''.join(l))

Solution (Python):
n = int(input())
s = input()
ans = ""
for i in s:
  t = ord(i)+n
  if t <= 90:
    ans += chr(t)
  elif t > 90:
    ans += chr(ord("A")+(abs(90-t))-1)
print(ans)

Solution (Python):
n = int(input())
s = input()
l = 'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ'
ans = ''
for t in s:
  ans += l[l.index(t)+n]
print(ans)

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)

N = int(input())
S = list(str(input()))
ans = []
for s in S:
    i = ord(s)
    if i+N>90:
        i -= 26
    ans.append(chr(i+N))

print(''.join(ans))

Solution (Python):
N = int(input())
S = list(input())
ans = ''
for i in S:
    text = ord(i)+N
    if(text>(ord('Z'))):
        text=text-26
    ans+=chr(text)
print(ans)

Solution (Python):
n = int(input())
s = input()
d = 0
ans = ''
for i in range(len(s)):
    if ord('Z') < ord(s[i]) + n:
        d = ord(s[i])+n-26
    else:
        d = ord(s[i])+n
    ans = ans + chr(d)

print(ans)

Solution (Python):
def main():
    n = int(input())
    s = input()
    ans = ""
    for si in s:
        t = ord(si)+n
        t = t if t<=ord('Z') else ord('A')-1+t-ord('Z')
        ans += chr(t)
    print(ans)

main()

Solution (Python):
n = int(input())
ans = ""
for c in input():
    if ord(c)+n > 90:
        ans += chr(ord('A')+(abs(90-(ord(c)+n))-1))
    else:
        ans += chr(ord(c)+n)
print(ans)

Solution (Python):
N = int(input())
S = input()
alfa = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
lis = []
for s in S:
    for i in range(26):
        if s == alfa[i]:
            lis.append((i+N)%26)
            break
for i in range(len(S)):
    print(alfa[lis[i]],end = '')

Solution (Python):
N=int(input())
S=input()
ans=""

for i in S:
    m=(ord(i)-ord("A")+N)%26
    ans += chr(m+ord("A"))
print(ans)

Solution (Python):
i_n = int(input())
i_str = input()
alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
lastIndex = 26
resStr = ''

for i in i_str:
  targetIndex = alphabet.index(i)
  if targetIndex + i_n >= lastIndex:
    resStrIndex = targetIndex + i_n - lastIndex
  else:
    resStrIndex = targetIndex + i_n

  resStr += alphabet[resStrIndex]

print(resStr)

Solution (Python):
i_n = int(input())
i_str = input()
res_str = ""
for i in i_str:
  if ord(i)+i_n>90:
    res_str+=chr(ord(i)+i_n-26)
  else:
    res_str+=chr(ord(i)+i_n)
print(res_str)

Solution (Python):
import sys
sys.setrecursionlimit(4100000)
import math
INF = 10**9

def main():
    n = int(input())
    S = input()

    base = ord('A')
    ans = ''
    for i in range(len(S)):
        ans += chr((ord(S[i])-base+n)%26+base)
    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):
n=int(input())
s=input()

sll=[((ord(s[i])+n-65)%26)+65 for i in range(len(s))]
sln=[chr(j) for j in sll]

ans="".join(sln)
print(ans)

Solution (Python):
n = int(input())
s = input()
res = ''
for i in s:
  ap = ord(i) + n
  if ap > ord('Z'):
    ap -= 26
  res += chr(ap)
print(res)

Solution (Python):
def main():
    n = int(input())
    s = input()
    ans = ""
    for i in range(len(s)):
        suuji = ord(s[i])
        tsugi = suuji + n
        if tsugi > 65+25:
            tsugi -= 26
        ans += chr(tsugi)
    print(ans)


    
    
if __name__ == "__main__":
    main()

Solution (Python):
n = int(input())

def push(chara, dig):
  if ord(chara) + dig > 90: return chr(64 + dig + ord(chara) -90)
  else: return chr(dig + ord(chara))
  
string = input()
e = ""
for i in range(0, len(string)):
  e = e + push(string[i], n)
  
print(e)

Solution (Python):
N = int(input())
S = input()
for c in S:
    print(chr(ord(c) + N) if ord(c) + N <= 90 else chr(ord(c) + N - 26), end='')
print()

Solution (Python):
import sys

def I(): return int(sys.stdin.readline().rstrip())
def LS2(): return list(sys.stdin.readline().rstrip())  

N = I()
S = LS2()
for i in range(len(S)):
    a = ord(S[i]) + N
    if a <= 90:
        S[i] = chr(a)
    else:
        S[i] = chr(a-26)

print(''.join(S))

Solution (Python):
n = int(input())
def split(para):
    return [char for char in para]
inp = split(para=input())
alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
for i in range(len(inp)):
    inp[i] = alpha[(alpha.index(inp[i])+n)%26]
joiner=""
print(joiner.join(inp))

Solution (Python):


n = int(input())
s = input()
ans = ""

for i in s:
    val = ord(i)
    if val + n > 90:
        ex = (val + n) - 90
        new = 64 + ex
        ans += chr(new)
    else:
        ans += chr(val + n)

print(ans)

Solution (Python):
n = int(input())
s = list(input())
a = ['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']
for i in range(len(s)):
  c = (a.index(s[i])+n)%26
  s[i] = a[c]
print("".join(s))

Solution (Python):
n=int(input())
s=input()
ans=""
for i in range(len(s)):
    str=s[i]
    num=ord(str)
    num+=n
    if(num>=91):
        num-=26
    ans+=chr(num)
print(ans)

Solution (Python):
n = int(input())
s = input()

dic = {'A':0,'B':1,'C':2,'D':3,'E':4,'F':5,'G':6,'H':7,'I':8,'J':9,'K':10,'L':11,'M':12,\
       'N':13,'O':14,'P':15,'Q':16,'R':17,'S':18,'T':19,'U':20,'V':21,'W':22,'X':23,'Y':24,'Z':25}
dic_items = {0:'A',1:'B',2:'C',3:'D',4:'E',5:'F',6:'G',7:'H',8:'I',9:'J',10:'K'\
             ,11:'L',12:'M',13:'N',14:'O',15:'P',16:'Q',17:'R',18:'S'
             ,19:'T',20:'U',21:'V',22:'W',23:'X',24:'Y',25:'Z'}
ans =""
for i in range(len(s)):
  ans += dic_items[(dic[s[i]]+n)%26]
print(ans)

Solution (Python):
n=int(input())
a=input()
ans=''
for i in a:
    p=ord(i)+n
    if p>ord('Z'):
        p-=26
    ans+=chr(p)
print(ans)

Solution (Python):
alp=["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","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"]

n=int(input())
s=list(input())

for i in range(len(s)):
    s[i]=alp[alp.index(s[i])+n]

print(("".join(s)).upper())

Solution (Python):
n = int(input())
s = input()
ans = ""
for i in s:
    if (ord(i)+n) <= 90:
        ans += chr(ord(i)+n)
    else:
        ans += chr(ord(i) + n - 26)
print(ans)

Solution (Python):
A=['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']
N=int(input())
x=input()
X=[j for j in x]
for i in range(0,len(X)):
  n=(A.index(X[i])+N)%26
  X[i]=A[n]
Y=''
for i in X:
  Y+=i
print(Y)

Solution (Python):
N = int(input())
S = input()
ans=""
for i in range(len(S)):
  ord_S=ord(S[i])
  if(ord_S+N<=90):
    ans+=chr(ord_S+N)
  else:
    ans+=chr(ord_S+N-26)
print(ans)

Solution (Python):
N=int(input())
S=list(input())
x=N-((N//26)*26)
empty=[]
for i in S:
    if ord(i)+x>90:
        a=chr(ord(i)+x-26)
        empty.append(a)
    else:
        a=chr(ord(i)+x)
        empty.append(a)
y=''.join(empty)
print(y)

Solution (Python):
N = int(input())
S = list(ord(x) for x in input())
for T in range(0,len(S)):
    if S[T]+N>90:
        S[T] = chr(S[T]+N-26)
    else:
        S[T] = chr(S[T]+N)
print(''.join(S))

Solution (Python):
N = int(input())
S = input()
alpha = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

new_S = list()
for word in S:
    num = alpha.index(word)+N
    if num > 25:
        num -= 26
    new_S.append(alpha[num])
print(''.join(new_S))

Solution (Python):
n=int(input())
s=input()
t=''
for i in s:
  x=chr((ord(i)-65+n)%26+65)
  t+=x
print(t)

Solution (Python):
n=int(input())
s=input()
ans=""
for i in range(len(s)):
    str=s[i]
    num=ord(str)
    num+=n
    if(num>=91):
        num-=26
    ans+=chr(num)
print(ans)

Solution (Python):
n = int(input())
s = input()
ls = list(s)
alphabet = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ')
for i in range(len(s)):
    index = alphabet.index(ls[i])
    if index + n < 26:
        ls[i] = alphabet[index + n]
    else:
        ls[i] = alphabet[index + n - 26]
print(''.join(ls))

Solution (Python):
a = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
new = ""
n = int(input())
s = input()

for i in s:
    new+= a[(a.index(i)+n)%26]
print(new)

Solution (Python):
N=int(input())
S=input()
s=list()
for i in S:
  temp=ord(i)+N
  if temp<=ord("Z"):
    s.append(chr(temp))
  else:
    s.append(chr(temp-(ord("Z")-ord("A"))-1))
for i in s:
  print(i,end="")

Solution (Python):
n=int(input())
s=input()
ss=""
for m in s:
  l=((ord(m)+n)-65)%26+65
  ss+=chr(l)
print(ss)

Solution (Python):
N = int(input())
S = list(input())
T = ['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']
t = len(T)
n = len(S)
S2 = []
for i in range(n):
  for j in range(t):
    if S[i] == T[j]:
      a = T[(j+N)%t]
      S2.append(a)
      break
k = S2[0]
for i in range(1,n):
  k += S2[i]
print(k)

Solution (Python):
N=int(input())
S=input()

a=['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','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']
anslist=[]

for i in range(len(S)):
    b=a.index(S[i])
    anslist.append(a[b+N])

ans="".join(anslist)
print(ans)

Solution (Python):
N = int(input())
S = list(input())
65 - 90
A = []
for i in range (65, 91):
  A.append(chr(i))
A *= 2
for j in range (len(S)):
  k = A.index(S[j])
  S[j] = A[k+N]
L = ''
for m in S:
  L += m
print(L)

Solution (Python):
Alp =["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"]*2
N = int(input())
S = list(input())
for i in range(len(S)):
	Anum = Alp.index(S[i])
	S[i] = Alp[Anum+N]
print("".join(S))

Solution (Python):
n=int(input())
s=input()
k=len(s)
x='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
l=[]
y=0
for i in range(k):
    y=x.index(s[i])
    if y+n<25:
        l.append(x[y+n])
    else:
        l.append(x[y+n-26])
l=''.join(l)
print(l)

Solution (Python):
n=int(input())
s=input()
b=""
a=["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"]
for i in range(len(s)):
   for j in range(26):
       if s[i]==a[j]:
           b+=a[j+n-26]
print(b)

Solution (Python):
N = int(input())
S = input()

ans = ''
for i in S:
    if ord(i) + N <= 90:
        ans += chr(ord(i)+N)
    else:
        ans += chr(-90 + ord(i) +N +64)

print(ans)

Solution (Python):
arb='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
N = int(input())
S = input()
ans =''
for i in range(len(S)):
    if arb.index(S[i]) + N +1 <= len(arb):
        ans += arb[arb.index(S[i])+N]
    else:
        ans += arb[-len(arb) + arb.index(S[i]) + N]
print(ans)

Solution (Python):
import sys
input = lambda: sys.stdin.readline().rstrip()

def main():
    n = int(input())
    s = list(input())
    string = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ'*2)
    for i in range(len(s)):
        s[i] = string[string.index(s[i])+n]
    print(*s, sep='')
    
if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
s = list(input())

d = ""
for i in range(len(s)):
  a = ord(s[i])+n
  if a <= ord("Z"):
    d = d + chr(a)
  else:
    d = d + chr(a - (ord("Z")-ord("A"))-1)
    
print(d)

Solution (Python):
def solve():
    n = int(input())
    s = input()
    reps = ''
    for c in s:
        asc = (ord(c) + n - 65) % 26 + 65
        reps += chr(asc)
    print(reps)


if __name__ == '__main__':
    solve()

Solution (Python):
def solve():
    n = int(input())
    s = input()
    reps = ''
    for c in s:
        asc = ord(c) + n
        if asc > 90:
            reps += chr(64 + asc - 90)
        else:
            reps += chr(asc)
    print(reps)


if __name__ == '__main__':
    solve()

Solution (Python):
def change_n(s,n) :
    ans = ""
    for i in s :
        ans +=chr( ord("A") + ((ord(i) - ord("A") + n) %26) )
    
    return ans


N = int(input())
S = list(input())
print(change_n(S,N))

Solution (Python):
N = int(input())
S = input()
a = [chr((ord(s) - 65 + N)%26 + 65) for s in S]
S = "".join(a)

print(S)

Solution (Python):
N = int(input())
S = input()
a = [chr((ord(s) - 65 + N)%26 + 65) for s in S]
S = "".join(a)

print(S)

Solution (Python):
CONST='ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ'
n=int(input())
s=list(input())
news=''
for si in s:
  news += CONST[CONST.index(si)+n]
print(news)

Solution (Python):
N = int(input())
S = str(input())

ans = ''
for i in S:
  chatonum = lambda i: ord(i) - ord('A') + 1
  num = chatonum(i)
  num += N
  if 26 < num:
    num -= 26
  numtocha = lambda num: chr(num+64)
  cha = numtocha(num)
  ans += cha
  
print(ans)

Solution (Python):
n = int(input())
s = input()
ans = ''
for i in s:
    if ord(i) + n >= 91:
        ans += chr(ord(i) + n - 26)
    else:
        ans += chr(ord(i) + n)

print(ans)

Solution (Python):
n = int(input())
s = input()
t = ""
for i in s:
    t += chr(ord('A')+(ord(i)-ord("A")+n)%26)
    

print(t)

Solution (Python):
N = int(input())
S = input()
for s in S:
    ans = chr((ord(s) - ord("A") + N) % 26 + ord("A"))
    print(ans,end="")

Solution (Python):
n = int(input())
st = ["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"]
s = input()
for i in range(len(s)):
    a = (st.index(s[i]) + n) % 26
    print(st[a],end="")

Solution (Python):
n = int(input())
s = input()

plain = ""
for char in list(s):
    ASCII = ord(char)
    num = ASCII -65
    num = (num + n) % 26
    ASCII = num + 65
    plain += chr(ASCII)
print(plain)

Solution (Python):
n = int(input())
s = input()
x = []
for i in s:
    m = ((ord(i) - ord('A') + n) % 26)
    x += (chr(m+ ord('A')))
print(''.join(x))

Solution (Python):
N = int(input())
S = input()

ans = [chr((ord(s) - ord('A') + N) % 26 + ord('A')) for s in S]
print(''.join(ans))

Solution (Python):
N = int(input())
S = input()

out = ''

for s in S:
    if ord(s) + N > 90:
        out = out + chr(64 + (ord(s) + N - 90))
    else:
        out = out + chr(ord(s) + N)

print(out)

Solution (Python):
import numpy as np
n = int(input())
s = input()

alp = [chr(i) for i in range(65,65+26)]
ind = np.arange(len(alp))

dic = dict(zip(alp, ind))

st = ''
for m in s:
    idx = dic[m]
    idx = (idx+n) % 26
    st += alp[idx]

print(st)

Solution (Python):
n = int(input())
s = input()

ans = ''
for char in s:
    ans += chr(ord(char) + n if ord(char) + n < 91 else 65 + (ord(char) + n - 91))
print(ans)

Solution (Python):
import bisect,collections,copy,heapq,itertools,math,string
import sys
def S(): return sys.stdin.readline().rstrip()
def M(): return map(int,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
N = I()
s = S()
AZ = string.ascii_uppercase
ans = []
for c in s:
    i = (AZ.index(c) + N)%26
    ans += AZ[i]
print(''.join(ans))

Solution (Python):

from string import ascii_uppercase

char_idx = {char:i for i, char in enumerate(ascii_uppercase)}

n = int(input())
s = input().rstrip()
res = "".join(ascii_uppercase[(char_idx[char] + n) % 26] for char in s)
print(res)

Solution (Python):
n = int(input())
s = input()
al = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ans = ''
for i in range(len(s)):
    ans += (al[al.index(s[i]) - 26 + n])
 
print(ans)

Solution (Python):

N = int(input())
S = list(input())

ans = list(map(ord, S))
for i in range(len(ans)):
    ans[i] = ans[i] + N
    if ans[i] > ord("Z"):
        ans[i] = ans[i] - 26

for ans in ans:
    print("".join(chr(ans)), end="")

Solution (Python):
n=int(input())
s=input()
ans=''
for t in s:
        ord_t=ord(t)
        ord_t+=n
        if(ord_t>ord('Z')):
                ord_t-=26
        ans+=chr(ord_t)
print(ans)

Solution (Python):
N = int(input())
S = list(input())

for i in range(len(S)):
    a = ord(S[i]) + N
    if a > 90:
        S[i] = chr(64 + a % 90)
    else:
        S[i] = chr(a)
print(''.join(S))

Solution (Python):
n = int(input())
s = input()
for i in s:
    k = ord(i)+n
    print(chr(k-(k>ord("Z"))*26),end= "")

Solution (Python):
n = int(input())
s = input()
al = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ans = ''
for i in range(len(s)):
    ans += (al[al.index(s[i]) - 26 + n])

print(ans)

Solution (Python):
n = int(input())
S = list(input())

p = ord("Z") - ord("A")
for i in range(len(S)):
  k = ord(S[i]) + n
  if k > ord("Z"):
    S[i] = chr(ord(S[i])+n-p-1)
  else:
    S[i] = chr(ord(S[i])+n)
    
print("".join(S))

Solution (Python):
N=int(input())
S=input()
S_num=[ord(S[i]) for i in range(len(S))]
S_str=''
for i in range(len(S)):
  S_num[i]=int(S_num[i])+N
  if S_num[i]>=91:
    S_num[i]=S_num[i]-26
  S_str+=chr(S_num[i])
print(S_str)

Solution (Python):
n = int(input())
S = input()

ordA = ord('A')

ans = ''
for s in S:
  s = ord(s) - ordA
  ans += chr(ordA + (s + n) % 26)

print(ans)

Solution (Python):
n = int(input())
s = input()
a = []
for i in range(len(s)):
    hoge = ord(s[i]) + n
    if hoge > 90:
        a.append(chr(hoge - 26))
    else:
        a.append(chr(hoge))
ans = ''.join(a)
print(ans)

Solution (Python):
import sys

def main():
    input = sys.stdin.readline
    n = int(input())
    s = input().rstrip()
    first = ord("A") - 1
    last = ord("Z")
    increment = lambda x: chr(ord(x)+n) if ord(x)+n <= last else chr(first + (ord(x)+n - last))
    new_s = "".join(map(increment, s))
    print(new_s, end="")
    


if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
s = input()
for i in range(len(s)):
    print(chr( (ord(s[i])+n-65)%26 + 65 ),end="")

Solution (Python):
N = int(input())
S = input()
LS = list(S)
L = len(S)

alpha2num = lambda x: ord(x) - ord('A') + 1
num2alpha = lambda x: chr(x+64)

for i in range(L):
    num = alpha2num(LS[i]) + N
    if num <= 26:
        LS[i] = num2alpha(num)
    else:
        LS[i] = num2alpha(num-26)

print(''.join(LS))

Solution (Python):
n=int(input())
s=input()
k=len(s)
alp='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
a=''
for i in s:
  a+=alp[(alp.index(i)+n)%26]
print(a)

Solution (Python):
n = int(input())
s = input()
ans = [chr(ord(s_)+n) if (ord(s_)+n)<91 else chr((ord(s_)+n)-26) for s_ in s ]
print(''.join(ans))

Solution (Python):
N = int(input())
S = input()


print(''.join(chr((ord(c) - ord('A') + N) % 26 + ord('A')) for c in S))