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):
m=["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=input()
ans=[]
for i in range(len(s)):
    index=m.index(s[i])
    if index+N>=26:
        ans.append(m[index+N-26])
    else:
        ans.append(m[index+N])
print(*ans, sep='')

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

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

rot = []
for i in s:
  c = b.find(i)
  d = int(c) + n
  if d >= 26:
    d -= 26
  rot.append(b[d])
r = ''.join(rot)
print(r)

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

for i in range(len(s)):
  tmp=ord(s[i])
  tmp+=n

  if tmp>90:
    tmp=(tmp%90)+64
  print(chr(tmp),end="")

print()

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


alpha = ["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 index_i, i in enumerate(S):
    for index_j, j in enumerate(alpha):
        if i == j:
            if index_j + N > len(alpha) - 1:
                index_j = index_j + N - (len(alpha) - 1)
                index_j = index_j - 1
                S[index_i] = alpha[index_j]
            else:
                S[index_i] = alpha[index_j+N]
        else:continue

print("".join(S))

Solution (Python):
n = int(input())
s = str(input())
alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
rot = []
for i in s:
  pos = alphabet.find(i)
  pos = int(pos) + n
  if pos >= 26:
    pos = int(pos) - 26
  rot.append(alphabet[pos])
strout = "".join(rot)
print(strout)

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

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

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


w = ''

for a in S:
    uni = ord(a) + N
    if uni > 90:
        uni -= 26
    w += chr(uni)

print(w)

Solution (Python):
n = int(input())
s = input()
t = ''
for i in range(len(s)):
    num = ord(s[i]) + n
    if num > 90: t += chr(num-26)
    else: t += chr(num)

print(t)

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)):
    k= a.index(s[i])
    s[i] = a[(k + n) % 26]
for k in s:
    print(k,end = "")

Solution (Python):
n = int(input())
s = input()
alp = [chr(ord('A') + i) for i in range(26)]
res = ''
for si in s:
    index = 0
    for i in range(len(alp)):
        if si == alp[i]:
            index = i
    res += alp[(index + n) % len(alp)]
print(res)

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

for i in range(len(S)):
  S[i] = ord(S[i])+N

  if S[i] > 90:
    S[i] = S[i] - 26
    S[i] = chr(S[i])
  else:
    S[i] = chr(S[i])
  
  
ans = ''.join(S)
print(ans)

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

data = input()

result = ""

for i in data: result+=chr(65+(ord(i)-65+nim)%26)
print(result)

Solution (Python):
a = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
N = int(input())
S = input()
 
for i in S:
    b = a.index(i) + N
    if b <= 25:
        print(a[b], end="")
    else:
        print(a[b-26], end="")

Solution (Python):
a = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
N = int(input())
S = input()
 
for i in S:
    b = a.index(i) + N
    if b <= 25:
        print(a[b], end="")
    else:
        print(a[b-26], end="")

Solution (Python):
n = int(input())
res = []
for i in input():
    a = ord(i) + n
    if a > 90:
        res.append(chr(a % 90 + 64))
    else:
        res.append(chr(a))
print("".join(res))

Solution (Python):
N = int(input())
S = input()
ans = str()
for i in S:
	m = (ord(i) - ord('A') + N) % 26
	ans += chr(m + ord('A'))
print(ans)

Solution (Python):
import math

def makelist(n, m):
    return [[0 for _ in range(m)] for _ in range(n)]

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

ans = []
for c in S:
    hoge = ((ord(c) - ord("A") + N) % 26) + ord("A")
    ans.append(chr(hoge))

print("".join(ans))

Solution (Python):
N=int(input())
S=input()
abc_list="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
L=len(abc_list)
ans= " "
for i in S:
  ans += abc_list[(abc_list.index(i)+N) % L]
print(ans)

Solution (Python):
l="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
N=int(input())
S=list(input())
c=N%26

Sdash=[]
for e in S:
    if l.index(e)+c>=26:
        Sdash.append(l[c-(26-l.index(e))])
    else:
        Sdash.append(l[l.index(e)+c])
print("".join(Sdash))

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

alphabet = ["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 items in s:
    if alphabet.index(items) + n >= len(alphabet):
        items = alphabet[alphabet.index(items) + n - 26]
        print(items,end = "")
    else:
        items = alphabet[alphabet.index(items) + n]
        print(items,end = "")
print()

Solution (Python):
import itertools

n = int(input())
s = list(input())
t =[]
u = []
for i in range(len(s)):

    t.append(ord(s[i])+n)

for j in range(len(t)):
    if t[j] > 90:
        t[j] = t[j]%90+64


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

Solution (Python):
import sys
input=sys.stdin.readline
n=int(input())
s=input().rstrip()
for i in s:
    x=ord(i)
    y=x+n
    if y>90:
        y-=26
    z=chr(y)
    print(z,end='')

Solution (Python):
N=int(input())
S=input()
abc_list="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
L=len(abc_list)
ans= " "
for i in S:
  ans += abc_list[(abc_list.index(i)+N) % L]
print(ans)

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

alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
alpha_num = len(alphabet)

ans = ''
for i in s:
    ans += alphabet[(alphabet.index(i)+n) % alpha_num]

print(ans)

Solution (Python):
ab = 'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ'
n = int(input())
s = input()
l = ''

for S in s:
  i = 0
  for w in ab:
    if S == w:
      l += ab[i+n]
      break
    i += 1

print(l)

Solution (Python):
N=int(input())
S=str(input())
letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
ans = ""
for i in range(len(S)):
  ans = ans + letters[(letters.index(S[i])+N)%26]
print(ans)

Solution (Python):
import sys


def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI1(): return map(int1, sys.stdin.readline().split())

def LI(): return list(map(int, sys.stdin.readline().split()))

def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SR(): return sys.stdin.readline().rstrip()

ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
ascii_uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ascii_uppercase2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ'


p2D = lambda x: print(*x, sep="\n")
p2E = lambda x: print(''.join(x))


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

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

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

alpha = ord('Z') - ord('A') + 1
result = []
for s in S:
    x = ord(s) + N
    if x > ord('Z'):
        x -= alpha
    result.append(chr(x))
print(''.join(result))

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

for str in s:
    if ord(str)+n > ord("Z"):
        print(chr(ord(str)+n-26), end="")
    else:
        print(chr(ord(str)+n), end ="")

Solution (Python):
def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**7)
    from collections import Counter, deque
    
    from itertools import combinations, permutations, accumulate, groupby
    
    from bisect import bisect_left,bisect_right
    from heapq import heapify, heappop, heappush
    from math import floor, ceil
    

    
    

    n = int(input())
    s = input().rstrip()
    alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 
    
    res = []
    for i in s:
        res.append(alphabet[(alphabet.index(i)+n)%26])
    print(''.join(map(str, res)))

if __name__ == '__main__':
    main()

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

ans = ''
for i in s:
    c = i
    for j in range(n):
        if c == 'Z':
            c = 'A'
        else:
            c = chr(ord(c) + 1)
    ans = ans + c

print(ans)

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

Solution (Python):
alpha = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
n = int(input())
s = input()
ans = ''
for x in s:
    ans += alpha[(alpha.find(x) + n) % 26]
print(ans)

Solution (Python):
def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**7)
    from collections import Counter, deque
    
    from itertools import combinations, permutations, accumulate, groupby
    
    from bisect import bisect_left,bisect_right
    from heapq import heapify, heappop, heappush
    from math import floor, ceil
    

    
    

    alphabet = 'abcdefghijklmnopqrstuvwxyz' 
    n = int(input())
    s = input().rstrip()
    a = alphabet.upper()
    
    res = []
    for i in s:
        res.append(a.index(i))
    a = a*2
    ans = ''
    for i in res:
        ans += a[i+n]
    print(ans)




if __name__ == '__main__':
    main()

Solution (Python):
import math
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)


def get_nums_l():
    return [ int(s) for s in input().split(" ")]


def get_nums_n(n):
    return [ int(input()) for _ in range(n)]


def get_all_int():
    return map(int, open(0).read().split())

def log(*args):
    print("DEBUG:", *args, file=sys.stderr)

n = int(input())
s = input()
ord_a = ord("A")
ans = ""
for c in s:
    i = (ord(c) - ord_a + n)%26
    ans += chr(ord_a + i)

print(ans)

Solution (Python):
A = "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ"
n = int(input())
S = input()

ANS = []*n
for i in range(len(S)):
    x = A.index(S[i])
    ANS.append(A[n+x])
for i in range(len(ANS)):
    print(ANS[i], end = "")

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

m = len(s)

for i in range(m):
	if ord(s[i])+n-65<26:
		s[i]=chr(ord(s[i])+n)
	else:
		s[i]=chr(ord(s[i])+n-26)
"".join(s)
print("".join(s))

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

Solution (Python):
N = int(input())
S = list(input())
chars = map(lambda c: chr((ord(c) - ord('A') + N) % 26 + ord('A')), S)
print(''.join(chars))

Solution (Python):
N=int(input())
S=str(input())
s=len(S)
A=[chr(i) for i in range(65, 65+26)]
ans=''

for i in range(s):
    ind=A.index(S[i])
    ans+=A[(ind+N)%26]

print(ans)

Solution (Python):
n=int(input())
s=input()
alphabet=list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
ans=[]
for i in s:
    new=(alphabet.index(i)+n)%26
    ans.append(alphabet[new])
print("".join(ans))

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

ans = []
for ch in s:
  if ord(ch)+n > ord('Z'):
    ans.append(chr(ord(ch)+n-26))
  else:
    ans.append(chr(ord(ch)+n))
    
ans = ''.join(ans)
print(ans)

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

anc = []
for i in s:
    print(chr((ord(i)-ord('A')+n)%26+ord('A')), end='')

Solution (Python):
bet = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ')
n = int(input())
s = list(input())
new = ''

for name in s:
  x = bet.index(name)
  new += bet[x+n] if x+n < 26 else bet[x+n-26]

print(new)

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

result = ''

for i in range(len(S)):
    char = S[i]
    ord_char = ord(char)
    ord_char += N
    if ord_char > 90:
        ord_char -= 26
    chr_char = chr(ord_char)
    result = result + chr_char

print(result)

Solution (Python):
N=int(input())
S=input()
print(bytes((s-65+N)%26+65 for s in S.encode()).decode())

Solution (Python):
n=int(input())
S=input()
ALPHABETS=[chr(i) for i in range(ord("A"),ord("A")+26)]
ans=""
for s in S:
  t=ALPHABETS.index(s)
  ans+=ALPHABETS[(t+n)%26]
print(ans)

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

Solution (Python):
n = int(input())
s = input()
t = "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ"
u = [0] * len(s)
for i in range(len(s)):
    idx = 0
    for j in range(26):
        if s[i] == t[j]:
            idx = j
            break
    u[i] = t[j + n]
print(*u, sep="")

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

Solution (Python):

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


ascii_uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ascii_uppercase_2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ'


kotae =""
for i in S:
    x = ascii_uppercase_2.index(i)
    kotae +=ascii_uppercase_2[x+N]
print(kotae)

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

a = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

ans = ''
for l in s:
    ans += a[a.find(l) + n - 26]

print(ans)

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

ans = [""]*len(s)
for i in range(len(s)):
    x = ord(s[i]) + n
    if x > 90:
        x = x - 90 + 64
    ans[i] = chr(x)

print("".join(ans))

Solution (Python):
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}
gyak={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"}

N=int(input())
S=input()
M=""
for i in range(len(S)):
  M+=gyak[(dic[S[i]]+N)%26]
print(M)

Solution (Python):
ls = ["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"]
dic = {"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":26}

n = int(input())
s = input()
ans = ""
for i in range(len(s)):
  ans += ls[(dic[s[i]]+n-1) % 26]
print(ans)

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

Solution (Python):
N = int(input())
S = input()
A = 'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ'
ans = ''
for i in range(len(S)):
    for j in range(len(A)):
        if S[i] == A[j]:
            ans += A[j+N]
            break
print(ans)

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

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

print(ans)

Solution (Python):
N = int(input())
S = list(input())
z = ord("Z")
for i in range(len(S)):
    if ord(S[i])+ N > z:
        S[i] = chr(ord(S[i])+N-26)
    else:
        S[i] = chr(ord(S[i])+N)
print("".join(S))

Solution (Python):


import sys
import math
import collections
import itertools
INF = 10 ** 10
MOD = 10 ** 9 + 7
def input() : return sys.stdin.readline().strip()
def gcd(x, y) : return y if x % y == 0 else gcd(y, x % y)
def lcm(x, y) : return (x * y) // gcd(x, y)
def I() : return int(input())
def LI() : return [int(x) for x in input().split()]
def RI(N) : return [int(input()) for _ in range(N)]
def LRI(N) : return [[int(x) for x in input().split()] for _ in range(N)]
def PL(L) : print(*L, sep="\n")

N = I()
S = input()

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

Solution (Python):
N = int(input())
S = input()
word = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ans = ''
for i in S:
    k = word.index(i)
    if k+N > 25:
        ans+=word[k+N-26]
    else:
        ans+=word[k+N]
print(ans)

Solution (Python):
n = int(input())
s = list(input())
alp = [chr(ord('A') + i) for i in range(26)]
ans = []
for a in s:
    i = (alp.index(a) + n) % 26
    ans.append(alp[i])
print(''.join(ans))

Solution (Python):
ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
N, S = int(input()), input()
newline = ""
for s in S:
  idx = (ALPHABET.index(s) + N) % 26
  newline += ALPHABET[idx]
print(newline)

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

ans = ''

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

print(ans)

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

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

print(*[chr(((ord(s) - ord('A')) + N) % 26 + ord('A')) for s in S], sep='')

Solution (Python):
n = int(input())
s = input().rstrip()
cs = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ans = ''
for c in s:
    ans += cs[(cs.index(c) + n) % 26]
print(ans)

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

def foo(alphabet, n):
    NUM_OF_ALPHABETS = 26
    diff = ord(alphabet) - ord('A')
    index = (diff + n) % NUM_OF_ALPHABETS
    result = chr(ord('A') + index)

    return result


def calculate(str, n):
    calculated = ''.join([foo(alphabet, n) for alphabet in str])

    return calculated

answer = calculate(S, N)

print(answer)

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

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

    
print("".join(map(str,S)))

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

Solution (Python):
N = int(input())
S = input()
L = [chr(i) for i in range(65, 65+26)]
H = ""
for i in range(len(S)):
  x = S[i]
  for j in range(26):
    if x == L[j]:
      H = H + L[(j+N)%26]
      break
print(H)

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

Solution (Python):
N=int(input())
S=list(input())
AruFa=['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']
ans=[]
for i in S:
	ans.append(AruFa[AruFa.index(i)+N])
print(''.join(ans))

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

Solution (Python):
a = int(input())
b = input()
chr_a = 0
ans = ''
for i in range(len(b)):
    if ord(b[i]) + a <= 90:
        chr_a = ord(b[i]) + a
    else:
        chr_a = ord(b[i]) + a -26
    ans += chr(chr_a)
print(ans)

Solution (Python):
import sys
input = sys.stdin.readline
from collections import Counter, deque

import numpy as np


INF = float('inf')


def ctoi(char):
    return ord(char) - ord('A')


def itoc(number):
    return chr(number + ord('A'))


def main():
    N = int(input())
    S = list(input().rstrip())
    S_list = np.array([ctoi(c) for c in S])
    S_list += N
    ans = [itoc(num % 26) for num in S_list]
    print(''.join(ans))


if __name__ == '__main__':
    main()

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

ans = []
for i in S:
    s = int(ord(i)) + N
    if s > 90:
        ans.append(chr(s % 91 + 65))
    else:
        ans.append(chr(s % 65 + 65))

print(''.join(ans))

Solution (Python):










"""def kiri(n,m):
  r_ = n / m
  if (r_ - (n // m)) > 0:
    return (n//m) + 1
  else:
    return (n//m)"""
  
def main():
  n = int(input())
  s = input()
  slen = len(s)
  new = ""
  for i in range(slen): 
    if 65 <= ord(s[i]) + n <= 90:
      new += chr(ord(s[i])+n)
    else:
      new += chr(ord(s[i]) + n - 26)
  print(*new,sep="")
if __name__ == '__main__':
  main()

Solution (Python):



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

sli = [ord(c) for c in S]
sli_mod = [n + N for n in sli]

for i, s in enumerate(sli_mod):
    if s > ord('Z'):
        sli_mod[i] -= 26


final = [chr(c) for c in sli_mod]
out = "".join(final)
print(out)

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

n = int(readline())
s = input()
ans = ['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']
memo = ''
for i in range(len(s)):
    memo += ans[ans.index(s[i]) + n]
print(memo)

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

Solution (Python):


import sys














def main():
    mod = 10000007                  
    inf = float('inf')
    input = sys.stdin.readline      
    sys.setrecursionlimit(10**6)    
    def ii():  return int(input())
    def mi():  return map(int, input().rstrip().split())
    def lmi(): return list(map(int, input().rstrip().split()))
    def li():  return list(input().rstrip())
    
    
    n = ii()
    s = input().rstrip()
    print("".join(list(map(chr, map(lambda x: x+n if x+n<=ord('Z') else ord('A')+(n-1)-(ord('Z')-x), (map(ord, s)))))))

if __name__ == "__main__":
    main()

Solution (Python):
N=int(input())
S=list(input())
i=0
ans=''
while i<len(S):
    ans+=chr([ord(S[i])+N,ord(S[i])+N-26][ord(S[i])+N>90])
    i+=1
print(ans)

Solution (Python):
n = int(input())
ls = list(map(str,input()))
r = len(ls)
for i in range(r):
    if ord(ls[i]) + n <= 90:
        ls[i] = chr(ord(ls[i]) + n)
    else:
        ls[i] = chr((ord(ls[i]) + n)%90+64)
a = "".join(ls)
print(a)

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

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

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

s_out = ""
for i in range(len(s)):
    s_out += a[(a.index(s[i]) + n) % len(a)]

print(s_out)

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

for i in range(len(S)):
  A.append(chr((ord(S[i])-65+N)%26+65))
print("".join(A))

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

Solution (Python):
a=int(input())
b=list(input())
s=[]
for i in range(len(b)):
  c=(ord(b[i])-ord("A")+a)%26+ord("A")
  s.append(chr(c))
print("".join(s))

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

alphabet = ["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 = []
for i in range(len(s)):
    for j in range(26):
        if s[i] == alphabet[j]:
            a.append(alphabet[(j+n)%26])
print("".join(a))

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

for i in S:
    tmp = ord(i)
    tmp += N
    if tmp > 90:
        tmp -= 90 - 64
    list_ans.append(chr(tmp))

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

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

cip = ''
for i in range(len(s)):
    ASCII = ord(s[i])
    ASCII += n
    if ord('A') + 25 < ASCII:
        ASCII -= 26
    cip = cip + chr(ASCII)

print(cip)

Solution (Python):
N = int(input())
ans = []
for s in input():
  ans.append(chr((ord(s) - ord('A') + N) % 26 + ord('A')))
print(''.join(ans))

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

Solution (Python):
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    alp=list('ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ')
    n=INT()
    s=STR()
    ans=[]
    for i in s:
        ans.append(alp[alp.index(i)+n])
    print(*ans,sep='')
    
if __name__ == '__main__':
    do()

Solution (Python):
def ii():return int(input())
def iim():return map(int,input().split())
def iil():return list(map(int,input().split()))
def ism():return map(str,input().split())
def isl():return list(map(str,input().split()))

n = ii()
s = list(input())
ans = []
alpha = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ')

for i in s:
    ans.append(alpha[(alpha.index(i)+n)%26])
print(''.join(ans))

Solution (Python):

n = int(input())
s = input()
alphabet = [chr(i) for i in range(65,65+26)]
s_list = []
for i in s:
    s_list.append(i)

for j in range(len(s_list)):
    s_list[j] = alphabet[(alphabet.index(s_list[j])+ n) % 26]
print("".join(s_list))

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

A=""
c=0
for i in range(L):
  if ord(S[i])+N <91:
    A=A+ chr(ord(S[i])+N)
  else:
    A=A+ chr(ord(S[i])-26+N)
  
print(A)

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

ans=''

for i in S:
    af = ord(i) + N
    if af - 91 >= 0:
        af = af - 91 + 65
    
    ans = ans + chr(af)

print(ans)

Solution (Python):
n = int(input())
s = list(input().encode("ascii"))

for i in range(len(s)):
    if s[i] + n <= 90:
        s[i] += n
    else:
        s[i] += n - 26
    s[i] = chr(s[i])    

print(''.join(s))

Solution (Python):
dic = list('abcdefghijklmnopqrstuvwxyz'.upper())
n = int(input())
s = input()

ans = ''
for s_ in s:
  ans += dic[(dic.index(s_) + n) % 26]
print(ans)

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

Solution (Python):
import sys
import numpy as np

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

N = ir()
S = list(sr())
base = ord('A')
for i in range(len(S)):
    s = S[i]
    S[i] = chr(base + (ord(s) + N - base) % 26)

print(*S, sep='')

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

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

bs = S.encode('us-ascii')
print(bytes((b - 65 + N) % 26 + 65 for b in bs).decode('us-ascii'))

Solution (Python):
N = int(input())
S = input()
ans = []
for c in S:
    nc = chr(ord("A") + (ord(c) - ord("A") + N) % 26)
    ans.append(nc)
print("".join(ans))

Solution (Python):
n = int(input())
s = input()
new_s = (chr((ord(c) + n - 65) % 26 + 65) for c in s)
print(''.join(new_s))

Solution (Python):
import string
A=string.ascii_uppercase
N=int(input())
S=list(input())
ans=S
for i in range(len(S)):
    a=A.index(S[i])
    a+=N
    if a>=26:a-=26
    ans[i]=A[a]
print("".join(ans))

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

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

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"]
s_ans = ""

for i in range(nl):
    newnumber = alp.index(s[i])+n
    if newnumber > 25:
        newnumber = newnumber - 26
    newi = alp[newnumber]
    s_ans += newi

print(s_ans)

Solution (Python):
N = int(input())
S = list(input())
numZ = ord('Z')

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

ans = ''
for i in range(len(S)):
    ans += S[i]

print(ans)

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

alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

ans = ''
for i in range(len(S)):
    ans += alphabet[(alphabet.index(S[i]) + N)%26]

print(ans)

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

for i in range(len(s)):
    tmp = ord(s[i]) + n
    if tmp > 90:
        tmp -= 26
    s[i] = chr(tmp)

print("".join(s))

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

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


out = []

for i in S:
  
  num = ord(i)
  num = num + N
  if num > 90:
    num = num - 26
  
  out.append(chr(num))


out = "".join(out)
print(out)

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

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

Solution (Python):
def ABC146B(a):
    if a > 90:
        return a - 26
    else:
        return a
n = int(input())
s = input()
p = ''
for i in s:
    p += chr(ABC146B(ord(i)+n))
print(p)

Solution (Python):
N = int(input())
S = input()
out = ''
for ch in S:
  num = (ord(ch) - ord('A') + N) % 26 + ord('A')
  out += chr(num)
print(out)

Solution (Python):
n = int(input())
 
s = input()
 
alphabet = ["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"]
 
ans = ""
for i in range(len(s)):
    num = (alphabet.index(s[i]) + n) % len(alphabet)
    ans += alphabet[num]
    
print(ans)

Solution (Python):
n = int(input())
 
s = input()
 
alphabet = ["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"]
 
ans = ""
for i in range(len(s)):
    num = (alphabet.index(s[i]) + n) % len(alphabet)
    ans += alphabet[num]
    
print(ans)

Solution (Python):
import sys
class alphabet: 
    def __init__(self, capitalize):
        self.num = dict()
        self.index = dict()
        self.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"]
        if capitalize: 
            for i in range(26): self.abc[i] = self.abc[i].upper()
        for i, a in enumerate(self.abc):
            self.num[a] = i
            self.index[i] = a

def solve():
    input = sys.stdin.readline
    N = int(input())
    S = input().strip("\n")
    AB = alphabet(True)
    Ans = [None] * len(S)
    for i in range(len(S)):
        Ans[i] = AB.index[(AB.num[S[i]] + N) % 26]
    print("".join(map(str, Ans)))
    

    return 0

if __name__ == "__main__":
    solve()

Solution (Python):
n = int(input())
s = input()
x = 0
ans = ""
c = ""

for i in s:
  x = ord(i) + n
  if x > 90:
      x = x - 26
  c = chr((x))
  ans = ans + c

print(ans)

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

Solution (Python):
from string import ascii_uppercase as upper

n = int(input())
s = input()
t = ''
for i in range(len(s)):
    t += upper[(upper.find(s[i]) + n) % 26]
print(t)

Solution (Python):
def main():
    n = int(input())
    n = n % 26
    s = input()
    s_list = [d for d in s]
    new_s = ""
    new_ord_base = 64
    for i in s_list:
        new_ord = ord(i) + n
        if new_ord > 90:
            new_ord = new_ord % 90 + new_ord_base
        new_s += chr(new_ord)

    print(new_s)


if __name__ == "__main__":
    main()