TnT/Multi_CodeNet4Repair huggingface dataset:
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
from collections import deque
from typing import List


def main():
    h, w = map(int, input().split())
    g = [input() for _ in range(h)]
    print(mm(h, w, g))


def mm(h: int, w: int, g: List[List[str]]) -> int:
    ret = 0
    for i in range(h):
        for j in range(w):
            if (g[i][j] == '#'):
                continue
            cnt = 0
            q = deque([(i, j, cnt)])
            v = set()
            while q:
                ii, jj, cnt = q.popleft()
                v.add((ii, jj))
                ret = max(ret, cnt)
                
                if ii < h - 1 and g[ii + 1][jj] == '.' and (ii + 1, jj) not in v:
                    q.append((ii + 1, jj, cnt + 1))
                
                if jj < w - 1 and g[ii][jj + 1] == '.' and (ii, jj + 1) not in v:
                    q.append((ii, jj + 1, cnt + 1))
                
                if ii > 0 and g[ii - 1][jj] == '.' and (ii - 1, jj) not in v:
                    q.append((ii - 1, jj, cnt + 1))
                
                if jj > 0 and g[ii][jj - 1] == '.' and (ii, jj - 1) not in v:
                    q.append((ii, jj - 1, cnt + 1))
    return ret


if __name__ == '__main__':
    main()


c = input()
print(chr(ord(c) + 1))

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
C = int(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']
ans2 = int(ans.index(C)) + 1
print(ans[ans2])

C = 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']
ans2 = int(ans.index(C)) + 1
print(ans[ans2])

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
import numpy as np
from collections import deque

h, w = map(int, input().split())
s = [list(input()) for _ in range(h)]
#s = np.array(s)
#s = (s == ".") * 1
def neext(a):
    l, m = a[0], a[1]
    return [(l, m+1), (l, m-1), (l+1, m), (l-1, m)]
def solve(i, j):
    if s[i][j] == '#':
        return 0
    else:
        pre = 0
        p = np.full((h, w), -1)
        check = deque([((i, j), 0)])#(from,now, dist)
        while check:
            now, d = check.popleft()
            p[now[0]][now[1]] = d
            pre = max(pre, d)
            for b, c in neext((now[0], now[1])):
                if b < 0 or c < 0 or b >= h or c >= w:
                    continue 
                if p[b][c] != -1 or s[b][c] == '#':
                    continue
                else:
                    check.append(((b, c), d + 1))
        return pre
ans = 0
for H in range(len(s)):
    for W in range(len(s[0])):
        ans = max(ans, solve(H, W))
print(ans)

N, M=map(int,input().split())
if M==0:
	print("0 0")
else:
	A=[]
	for i in range(M):
		a=list(map(str,input().split()))
		A.append(a)
	ch=[]
	ac=0
	pe=0
	for i in range(M):
		if A[i][0] in ch:
			continue
		elif A[i][1]=="AC":
			ch.append(A[i][0])
			ac+=1
		else:
			pe+=1
	print(ac,pe)

C=input()
print(chr(ord(C)+1))

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
s = int(input())

print(chr(ord('s')+1))

C = str(input())

print(chr(ord(C)+1))

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
a = str(input())
s = ['z','x','c','v','b','n','m','a','s','d','f','g','h','j','k','l','q','w','e','r','t','y','u','i','o','p']
e = append(a)
w = sorted(e)
print(w[a+1])



a = str(input())
s = ['z','x','c','v','b','n','m','a','s','d','f','g','h','j','k','l','q','w','e','r','t','y','u','i','o','p']
s.append(a)
s.sort()
Q = s.index(a)
e = Q + 2
print(s[int(e)])



Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
print(1)

s=input()
order=list("abcdefghijklmnopqrstuvwxyz")
i=order.index(s)
print(order[i+1])

Verdicts: Wrong Answer

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
c=input()
print(char(ord(c)+1)

c=input()
print(chr(ord(c)+1))

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
print(chr(ord(input()+1)

c=input()
print(chr(ord(c)+1))

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
C = str(input())

alph = ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u

for i, j in enumerate(alph):
  if C == j:
    print(alph[i+1])


C = str(input())

alph = ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u

for i, j in enumerate(alph):
  if C == j:
    print(alph[i+1])


C = str(input())

alph = ['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, j in enumerate(alph):
  if C == j:
    print(alph[i+1])

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
N, M = map(int, input().split())
ac = [0] * N
wa = [0] * N

ac = 0
wa = 0

for i in range(M):
    p, S = input().split()
    p = int(p)

    if S == "AC":
        if ac[p-1] == 0:
            ac += 1
            
    else:
        if ac[N-1] == 0:
            wa += 1

print(ac, wa)


C = input()
alphabet = "abcdefghijklmnopqrltuvwxyz"

for i in range(len(alphabet)):
    if alphabet[i] == C:
        print(alphabet[i+1])
        exit()

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
C = input()

print(char(ord(C)+1))

C = input()
 
print(chr(ord(C)+1))

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
C = input()
r = chr(ord(C))

print(r)

C = input()
r = chr(ord(C)+1)
print(r)

Verdicts: Wrong Answer

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
a = input()
next = (chr(ord(a)+1))

print("'"+a+"'"+"の次は"+"'"+next+"'"+"です。")

a = input()
next = (chr(ord(a)+1))

print("'"+a+"'"+"の次は"+"'"+next+"'"+"です")

a = input()
next = (chr(ord(a)+1))

print("'"+a+"'"+"の次は"+"'"+next+"'"+"です")

a = input()
print(chr(ord(a)+1))

Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):

def main():
    C = input().rstrip()
    ans = chr(ord(C) + 1)
    print(C)


if __name__ == "__main__":
    main()



def main():
    C = input().rstrip()
    ans = chr(ord(C) + 1)
    print(ans)


if __name__ == "__main__":
    main()


Verdicts: Wrong Answer

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
print(chr(ord((input())+1))

print(chr(ord(input())+1))

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
a = input()
b = chr(ord(a))
print(b)

a = input()
b = chr(ord(a) + 1)
print(b)

Verdicts: Wrong Answer

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
a = ord(input())+1
print(a)


print(chr(ord(input()+1))

N,K,M = map(int,input().split())

A = list(map(int,input().split()))

if N * M - sum(A) > K:
	print(-1)
else:
  	print(max(N*M -sum(A) , 0))


a = chr(ord(input())+1)
print(a)


Verdicts: Wrong Answer

Runtime Error

Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
print(char(ord(input())+1))

print(chr(ord(input())+1))


Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
print(chr(ord(input()+1)))

print(chr(ord(input())+1))

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
c=input()
alp="abcdefghijklmnopqrstuvwxyz"
for i in range(25):
  if c==alp[i]:
    print(alh[i+1])
    break
              

c=input()
alp="abcdefghijklmnopqrstuvwxyz"
for i in range(25):
  if c==alp[i]:
    print(alp[i+1])
    break
              


Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
n=int(input())
diez=10*n+10
if(1<=n<=10000):
    if(n!=10):
        print(diez-n)
    else:
        print(n+99)


a=input()

b=chr(a)
c=chr(b)
d=chr(c)

print(chr(ord(d)+1))

a=input()

b=a
c=b
d=c
e=d
f=e

print(chr(ord(f)+1))

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
inp = input().split()
n,k = int(inp[0]),int(inp[1])
a = [int(x) for x in input().split()]
a.sort()
ans =0
for ini in range(0,n-k+1):
  for end in range(ini+k-1,n):
    m = end-ini-1
    r = k-2
    combi = math.factorial(m) // (math.factorial(m - r) * math.factorial(r))
    ans += (a[end]-a[ini])*combi

ans = ans % (10**9+7)
print(ans)

import math
inp = input().split()
n,k = int(inp[0]),int(inp[1])
a = [int(x) for x in input().split()]
a.sort()
ans =0
for ini in range(0,n-k+1):
  for end in range(ini+k-1,n):
    m = end-ini-1
    r = k-2
    combi = math.factorial(m) // (math.factorial(m - r) * math.factorial(r))
    ans += (a[end]-a[ini])*combi

ans = ans % (10**9+7)
print(ans)

abc='abcdefghijklmnopqrstuvwxyz'
x=input()
print(abc[abc.index(x)+1])

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
import sys
import string
input = sys.stdin.readline

C = input()
if C == 'z': print('a')
else: print(string.ascii_lowercase[string.ascii_lowercase.index(C)+1])

alpha = 'abcdefghijklmnopqrstuvwxyz'
C = input().split()
print(alpha[alpha.index(C)+1])

import sys
import string
input = sys.stdin.readline

C = input()
print(string.ascii_lowercase[string.ascii_lowercase.index(C)+1])


alpha = 'abcdefghijklmnopqrstuvwxyz'
C = input()
print(alpha[alpha.index(C)+1])

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
C = str(input())
Z='abcdefghijklmnopqrtuvwxyz'
alpha = list(Z)
l_in = [alpha[i+1] for i in range(len(alpha)-1) if C in alpha[i]]
print(l_in)

N,K,M=map(int,input().split())
point = list(map(int,input().split()))
full = N*K
tar = M*N
all_p = sum(point)

if full- all_p >full-K:
    print(-1)
else:
    print(full-K-sum(point))

C = str(input())
Z='abcdefghijklmnopqrtuvwxyz'
alpha = list(Z)
l_in = [alpha[i+1] for i in range(len(alpha)-1) if C in alpha[i]]
print(l_in[0])

Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
c = input()
print(str(c+1))

c = input()
print(char(c + 1))

c = input()
print(chr(ord(c) + 1))

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
N,K,M =  map(int,input().split())
A =  list(map(int,input().split()))

result = N*M - sum(A) 
if result > K:
    print("-1")
elif result <=0:
    print("0")
else:
    print(result)

C = input()
print(chr(ord(C) + 1))

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
a=input()
s="abcdefghijklmnopqrstuvwxyz"
for i in range(len(s)-1)
  if s[i]==a:
	print(s[i+1])

a=input()
s="abcdefghijklmnopqrstuvwxyz"
for i in range(len(s)-1):
	if s[i]==a:
		print(s[i+1])


Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
from collections import defaultdict

def solve():
    N = input()
    d = defaultdict(str)
    d['a'] = 'b'
    d['b'] = 'c'
    d['c'] = 'd'
    d['d'] = 'e'
    d['e'] = 'f'
    d['f'] = 'g'
    d['g'] = 'h'
    d['h'] = 'i'
    d['i'] = 'j'
    d['j'] = 'k'
    d['k'] = 'l'
    d['l'] = 'm'
    d['m'] = 'n'
    d['n'] = 'o'
    d['o'] = 'p'
    d['p'] = 'q'
    d['q'] = 'r'
    d['r'] = 's'
    d['s'] = 't'
    d['t'] = 'u'
    d['u'] = 'v'
    d['v'] = 'w'
    d['w'] = 'x'
    d['x'] = 'y'
    d['y'] = 'z'
    return d[N]

def solve():
    N = input()
    return chr(ord(N)+1)

print(solve())

Verdicts: Wrong Answer

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
N, M = map(int, input().split())

P = list()
for m in range(M):
    n, rst = input().split()
    n = int(n)
    P.append( (n, rst) )


ck = [False for _ in range(N+1)]

ret_cor, ret_pen = 0, 0

for n, rst in P:
    if rst == 'AC':
        if not ck[n]:
            ck[n] = True
            ret_cor += 1

    else: # rst == 'WA'
        if not ck[n]:
            ret_pen += 1

print(ret_cor, ret_pen)


l = input()

print(chr(ord(l)+1))


Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
from collections import deque
H, W = map(int, input().split())
X = [input() for _ in range(H)]
maxloc = -10

def bfs(sx, sy, gx, gy):
  if(X[sx-1][sy-1] == '#' or X[gx-1][gy-1] == '#'):
    return -1
  else:
    dist = [[-1]*W for _ in range(H)]
    dist[sx-1][sy-1] = 0
    q = deque([(sx-1, sy-1)])
    while q:
      u, v = q.popleft()
      for i, j in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
        if not(0 <= u+i < H and 0 <= v+j < W):
          continue
    
        if(dist[u+i][v+j] >= 0 or X[u+i][v+j] == "#"):
          continue

        dist[u+i][v+j] = dist[u][v]+1
        q.append((u+i, v+j))

    return dist[gx-1][gy-1]

for i in range(H):
  for j in range(W):
    sx = i
    sy = j
    for k in range(i+1, H):
      for l in range(j+1, W):
        gx = k
        gy = l
        if(bfs(i+1, j+1, k+1, l+1) > maxloc):
          maxloc = bfs(i+1, j+1, k+1, l+1)
          
print(maxloc)


s = "abcdefghijklmnopqrstuvwxyz"
C = input()
for i in range(len(s)):
  if(s[i] == C):
    print(s[i+1])

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
a=input()
n=[chr(i) for i in range(97, 97+26)]

print(n[1+n.count(a)]


a=input()
n=[chr(i) for i in range(97, 97+26)]

print(n[1+n.index(a)])


Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
C = input()

if x == "a":
    print("b")
elif x == "b":
    print("c")
elif x == "c":
    print("d")
elif x == "d":
    print("e")
elif x == "e":
    print("f")
elif x == "f":
    print("g")
elif x == "g":
    print("h")
elif x == "h":
    print("i")
elif x == "i":
    print("j")
elif x == "j":
    print("k")
elif x == "k":
    print("l")
elif x == "l":
    print("m")
elif x == "m":
    print("n")
elif x == "n":
    print("o")
elif x == "o":
    print("p")
elif x == "p":
    print("q")
elif x == "q":
    print("r")
elif x == "r":
    print("s")
elif x == "s":
    print("t")
elif x == "t":
    print("u")
elif x == "u":
    print("v")
elif x == "v":
    print("w")
elif x == "w":
    print("x")
elif x == "x":
    print("y")
elif x == "y":
    print("z")
else:
    print("era-")

C = input()
 
if C == "a":
    print("b")
elif C == "b":
    print("c")
elif C == "c":
    print("d")
elif C == "d":
    print("e")
elif C == "e":
    print("f")
elif C == "f":
    print("g")
elif C == "g":
    print("h")
elif C == "h":
    print("i")
elif C == "i":
    print("j")
elif C == "j":
    print("k")
elif C == "k":
    print("l")
elif C == "l":
    print("m")
elif C == "m":
    print("n")
elif C == "n":
    print("o")
elif C == "o":
    print("p")
elif C == "p":
    print("q")
elif C == "q":
    print("r")
elif C == "r":
    print("s")
elif C == "s":
    print("t")
elif C == "t":
    print("u")
elif C == "u":
    print("v")
elif C == "v":
    print("w")
elif C == "w":
    print("x")
elif C == "x":
    print("y")
elif C == "y":
    print("z")
else:
    print("era-")

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
imp = imput()
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']
print(alp[alp.index(str(imp)) + 2])

imp = imput()
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']
print(alp[alp.index(imp) + 2])

imp = input()
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']
print(alp[alp.index(imp) + 1])

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
s=str(input())

s+=1
print(s)

s=str(input())

s+=1
print(s)

alp=input()
ask=ord(alp)
print(chr(ask+1))

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
c = input()
print(str(ord(c)+1))

c = input()
print(chr(ord(c)+1))

Verdicts: Wrong Answer

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
n, k, m = map(int, input().split())
l = list(map(int, input().split()))

A = n*m - sum(l)

print(max(0, A) if A <= k else -1)

n, m = map(int, input().split())

lac = [0] * n
lwa = [0] * n

for i in range(m):
    p, s = input().split()
    p = int(p) - 1
    if lac[p] == 0:
        if s == 'WA':
            lwa[p] += 1
        if s == 'AC':
            lac[p] = 1

print(sum(lac), sum(x * y for x, y in zip(lac, lwa)))

print(chr(ord(input())+1))

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
C = str(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 len(a):
    if a[i] == C:
        print(a[i+1])

C = str(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(a)):
    if a[i] == C:
        print(a[i+1])

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
n, m = [int(i) for i in input().split(' ')]
wa = [0] * n
ac = [0] * n
for _ in range(m):
    problem, status = input().split(' ')
    problem = int(problem) - 1
    if status == 'WA':
        if ac[problem] == 0:
            wa[problem] += 1
        continue
    ac[problem] = 1

print(chr(ord(input() + 1)))

n, m = [int(i) for i in input().split(' ')]
wa = [0] * n
ac = [0] * n
for _ in range(m):
    problem, status = input().split(' ')
    problem = int(problem) - 1
    if status == 'WA':
        if ac[problem] == 0:
            wa[problem] += 1
        continue
    ac[problem] = 1

no_ac = sum(ac)
no_wa = sum(wa)

print(str(no_ac) + ' ' + str(no_wa))

print(chr(ord(input()) + 1))

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
n,m = map(int,input().split())
ans = [input().split() for _ in range(m)]
ac = []
wn = []
acn,wan = 0,0
for i in ans:
  for j in range(len(ac)):
    if i[0] != ac[j]:
      if i[1] == 'AC' :
        wan += wn.count(i[0])
        ac += [i[0]]
        acn += 1
      else :
        wn += [i[0]]
print(acn,wan)

print(chr(ord(input())+1))

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
x=input()
list=[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(26):
  if list[i] = x:
    print(list[i+i])

x = input()
list = ['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(26):
    if list[i] == x:
        print(list[i + 1])

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
letter=input()
alphabet="abcdefghijklmnopqrstuvwxyz"
for i in range(len(alphabet)):
  if alphabet[i]=letter:
    print(alphabet[i+1])

letter=input()
alphabet="abcdefghijklmnopqrstuvwxyz"
alphabet[i]=letter
print(alphabet[i+1])

letter=input()
alphabet="abcdefghijklmnopqrstuvwxyz"
for i in range(len(alphabet)):
  if alphabet[i]=＝letter:
    print(alphabet[i+1])

letter=input()
alphabet="abcdefghijklmnopqrstuvwxyz"
for i in range(len(alphabet)):
  if alphabet[i]==letter:
    print(alphabet[i+1])

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):

n,m=map(int,input().split())

WA=[0]*n
AC=[0]*n

for i in range(m):
    problem,status=input().split()
    problem=int(problem)

    if status=='WA' and AC[problem-1]==0:
        WA[problem-1]+=1
    elif status=='AC':
        AC[problem-1]=1
print(sum(WA),sum(AC))


n,m=map(int,input().split())
 
WA=[0]*n
AC=[0]*n
 
for i in range(m):
    problem,status=input().split()
    problem=int(problem)
 
    if status=='WA':
        if AC[problem-1]==1:
            continue
        else:
            WA[problem-1]+=1
    elif status=='AC':
        AC[problem-1]=1

for i in range(n):
    if AC[i]==0:
        WA[i]=0
print(sum(AC),sum(WA))


character=input()


print(chr(ord(character)+1))


Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
a,b,c=map(int,input().split())
d=0
e=[int(x) for x in input().split()]
g=0
for i in range(a-1):
    d+=int(e[i])
for i in range(b):
    if (d+i)/a>=c:
        print(i)
        g=1
        break
if g==0:
    print(-1)

print(chr(ord(input())+1))

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
# -*- coding: utf-8 -*-

a = str(input())



print chr(ord(a) + 1)

# -*- coding: utf-8 -*-

a = str(input())

 

print(chr(ord(a) + 1))

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
s = input()
tmp = ord(s)
ans = tmp += 1
print(chr(ans))

s = input()
tmp = ord(s)
ans = tmp + 1
print(chr(ans))

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
import string
s = input()
x = string.ascii_letters
for i in range(len(x)):
    if x[i] == s:
        print(x[i;1])
        break

import string
s = input()
x = string.ascii_letters
for i in range(len(x)):
    if x[i] == s:
        print(x[i+1])
        break

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
c = input()
A = [chr(ord('a') + i) for i in range(26)]
z = A.index("c")
print(A[z+1])

c = input()
A = [chr(ord('a') + i) for i in range(26)]
z = A.index(c)
print(A[z+1])

Verdicts: Wrong Answer

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
C = str(input())
print chr(ord(C) + 1)

C = str(input())
print(chr(ord(C) + 1))

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
c = ord(input())
print(chr(c))

c = ord(input())
print(chr(c+1))

Verdicts: Wrong Answer

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
print(chr(ord(input())))

print(chr(ord(input())+1))

Verdicts: Wrong Answer

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
C = input()
print(chr(ord(c)+1))

print(chr(ord(input())+1))

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
print(str(ord(input())+1))

s = "abcdefghijklmnopqrstuvwxyz"
C = str(input())
print(s[(s.index(C)+1)%26])

Verdicts: Wrong Answer

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
C =str(input())

alph = "abcdefghijklmnopqrstuvwxyz"

alphabet_list = list(alph)

print(alphabet[alphabet_list.index(C)+1])

C =str(input())

alph = "abcdefghijklmnopqrstuvwxyz"

alphabet_list = list(alph)
print(alphabet_list)

print(alphabet[alphabet_list.index(C)+1])

C = input()

alphabet = "abcdefghijklmnopqrstuvwxyz"

alphabet_list = list[alphabet]

print(alphabet_list[alphabet_list.index[C]+1])

C =str(input())

alph = "abcdefghijklmnopqrstuvwxyz"

alphabet_list = list(alph)

print(alphabet_list[alphabet_list.index(C)+1])

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
C = input()

next = ord('C') + 1
print(chr(next))

C = input()

next = ord(C) + 1 
print(chr(next))

Verdicts: Wrong Answer

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
c = input()
print(shr(ord(c)+1))

c = input()
print(chr(ord(c)+1))

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
n,m = map(int,input().split())
ACcount = 0
WAcount = 0
WA = []
AC = []
for i in range(n):
  WA.append(0)
  AC.append(1)
for i in range(m):
  p,s = input().split()
  p = int(p)
  if s == "WA":
    if WA[p-1] >= 0:
      WA[p-1] += 1
  if s == "AC":
    ACcount += AC[p-1]
    AC[p-1] = 0
    if WA[p-1] >= 0:
       WAcount += WA[p-1]
       WA[p-1] = -1
print(ACcount,WAcount)

l = [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(25):
  if s == l[i]:
    print(l[i+1])

l = [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(25):
  if s = l[i]:
    print(l[i+1])

l = ["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(25):
  if s == l[i]:
    print(l[i+1])

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
k,x = map(int,input().split())
a = 500*k
if a >= x:
    print('Yes')
else:
    print('No')


c = input()
ans = chr(ord(c)+1)
print(ans)


Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
N,K, M = map(int,input().split())
A = list(map(int,input().split()))

ans = M*N-sum(A)

if ans > K:
    print(-1)
elif ans < 0:
    print(0)
else:
    print(ans)



a = input()
b = chr(ord(a)+1)
print(b)

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
a = "abcdefghijklmnopqrstuvwyz"

s = input()
print(a.index[a.index(s)+1])

a = "abcdefghijklmnopqrstuvwyz"

s = input()
print(a[a.index(s)+1])

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
s = input()
print(chr(ord('s') + 1))

s = input()
print(chr(ord('s') + 1))

s = input()
print chr(ord(s) + 1)

s = input()
print(chr(ord(s) + 1))

Verdicts: Wrong Answer

Wrong Answer

Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
import itertools

N,K = map(int,input().split())
A = sorted(list(map(int,input().split())))

def fun(a):
    return max(a)-min(a)
def fun1(a):
    return sum(a) % (1000000007)
_1 = [fun(i) for i in itertools.combinations([int(i) for i in A], K)]    
print(fun1(_1))

mod = 10**9 + 7
 
def nCr(n,r):
  if n < r:
    return 0
  if n < 0 or r < 0:
    return 0
  return (fac[n] * facinv[r] * facinv[n - r]) % mod

asc = 'abcdefghijklmnopqrstuvwxyz'
t=input()
for i in range(25):
    if t == asc[i]:
        print(asc[i+1])


Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
print(chr(ord(input())+1)

import time

# success

# https://blogarithms.github.io/articles/2019-01/fermats-theorem


MOD =  1000000007
MOD2 = 1000000005
MAX = 100001

# facs = [1 for _ in range(MAX)]






def get_facs(n, k):
	if k<n-k:
		k = n-k
	r = 1
	for i in range(k+1, n+1):
		r *= i
	for i in range(2, n-k+1):
		r /= i
	return r

def choose(n, k):

	if k==0 or n==k:
		return 1
	if n==0:
		return 0
	if k>n:
		return 0
	return get_facs(n, k)



def main():
	N, K = map(int, input().split())
	numbers = sorted(map(int, input().split()))
	if K==1:
		return 0
	if K==N:
		return abs(numbers[0] - numbers[-1])

	score = 0
	for i, x in enumerate(numbers):
		score += ((choose(i, K-1) - choose(N-1-i, K-1)) * x)

	return int(score%MOD)
	
	
print(main())


print(chr(1+ord(input())))

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
a = input()
ascii_a = ord(a)

next_ascii_a = ascii_a +1
chr(next_ascii_a)

a = input()
ascii_a = ord(a)

next_ascii_a = ascii_a +1
print(chr(next_ascii_a))


Verdicts: Wrong Answer

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
a="b"
b="c"
c="d"
d="e"
e="f"
f="g"
g="h"
h="i"
i="j"
j="k"
k="l"
l="m"
m="n"
n="o"
o="p"
p="q"
q="r"
r="s"
s="t"
t="u"
u="v"
v="w"
w="x"
x="y"
y="z"
z="a"



AA=input()

if AA == "a":
	print("b")
elif AA == "b":
	print("c")
elif AA == "c":
	print("d")
elif AA == "d":
	print("e")
elif AA == "e":
	print("f")
elif AA == "f":
	print("g")
elif AA == "g":
	print("h")
elif AA == "h":
	print("i")
elif AA == "i":
	print("j")
elif AA == "j":
	print("k")
elif AA == "k":
	print("l")
elif AA == "l":
	print("m")
elif AA == "m":
	print("n")
elif AA == "n":
	print("o")
elif AA == "o":
	print("p")
elif AA == "p":
	print("q")
elif AA == "q":
	print("r")
elif AA == "r":
	print("s")
elif AA == "s":
	print("t")
elif AA == "t":
	print("u")
elif AA == "u":
	print("v")
elif AA == "v":
	print("w")
elif AA == "w":
	print("x")
elif AA == "x":
	print("y")
elif AA == "y":
	print("z")
else:
	print("a")


Verdicts: Wrong Answer

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
h,w=map(int,input().split())
l=[]
for i in range(h):
    l.append(list(input()))
for i in range(h):
    for j in range(w):
        if l[i][j]=='.':
            s=[i,j]
v=[[0 for i in range(w)] for j in range(h)]       
v[s[0]][s[1]]=1
mc=0
ms=s
q=[[s,0]]
while q:
    p=q.pop(0)
    x=p[0][0]
    y=p[0][1]
    c=p[1]
    k=[[0,1],[0,-1],[1,0],[-1,0]]
    for j in k:
        nx=x+j[0]
        ny=y+j[1]
        if 0<=nx<h and 0<=ny<w and l[nx][ny]=='.' and v[nx][ny]==0:
            v[nx][ny]=1
            q.append([[nx,ny],c+1])
            if mc<c+1:
                mc=c+1
                ms=[nx,ny]
v=[[0 for i in range(w)] for j in range(h)]       
v[ms[0]][ms[1]]=1
ans=0
q=[[ms,0]]
while q:
    p=q.pop(0)
    x=p[0][0]
    y=p[0][1]
    c=p[1]
    k=[[0,1],[0,-1],[1,0],[-1,0]]
    for j in k:
        nx=x+j[0]
        ny=y+j[1]
        if 0<=nx<h and 0<=ny<w and l[nx][ny]=='.' and v[nx][ny]==0:
            v[nx][ny]=1
            q.append([[nx,ny],c+1])
            ans=max(ans,c+1)
                #ms=[nx,ny]
print(ans)

al=list('abcdefghijklmnopqrstuvwxyz')
a=input()
print(al[al.index(a)+1])

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
a=input()
t=chr(ord(a)+1)
print(t

try:
  n=input()
  c=chr(ord(n)+1)
  print(c)
except:
  pass

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
print(str(ord(input())+1))

print(chr(ord(input())+1))

Verdicts: Wrong Answer

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
a = input()
print chr(ord(a) + 1)

a = input()
b = chr(ord(a) + 1)
print(b)

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
s = input()
a = 'abcdefghijklmnopqrstuvwxyz'
ans = 0
for i in range(len(a)):
  if a[i]=='s':
    ans=i
    break
print(a[ans])

s = input()
a = 'abcdefghijklmnopqrstuvwxyz'
ans = 0
for i in range(len(a)):
  if a[i]=='s':
    ans=i+1
    break
print(a[ans])

s = input()
a = 'abcdefghijklmnopqrstuvwxyz'
ans = 0
for i in range(len(a)-1):
  if a[i]==s:
    ans=i+1
    break
print(a[ans])

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
a = input()
print(chr(ord(a)+1)

a = input()
print(chr(ord(a)+1))

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
list_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']
c=input()
print(l[l.index(c)+1])

list_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']
c=input()
print(list_a[list_a.index(c)+1])

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
c = input()
abc = 'abcdefghijklmnopqrstuvwxyz'
for i in range(26) :
    if abc[i] == c
        print(abc[i+1])
        break

c=int(input())
if c == a :
    print("b")
elif c == b :
    print("c")
elif c == c :
    print("d")
elif c == d :
    print("e")
elif c == e :
    print ("f")
elif c == f :
    print("g")
elif c == g :
    print("h")
elif c == h :
    print("i")
elif c == i :
    print("j")
elif c == j :
    print("k")
elif c == k :
    print("l")
elif c == l :
    print("m")
elif c == m :
    print("n")
elif c == n :
    print("o")
elif c == o :
    print("p")
elif c == p :
    print("q")
elif c == q :
    print("r")
elif c== r :
    print("s")
elif c == s :
    print("t")
elif c == t :
    print("u")
elif c == u :
    print("v")
elif c == v :
    print("w")
elif c == w :
    print("x")
elif c == x :
    print("y")
elif c == y :
    print("z")

c=input()
if c == a :
    print("b")
elif c == b :
    print("c")
elif c == c :
    print("d")
elif c == d :
    print("e")
elif c == e :
    print ("f")
elif c == f :
    print("g")
elif c == g :
    print("h")
elif c == h :
    print("i")
elif c == i :
    print("j")
elif c == j :
    print("k")
elif c == k :
    print("l")
elif c == l :
    print("m")
elif c == m :
    print("n")
elif c == n :
    print("o")
elif c == o :
    print("p")
elif c == p :
    print("q")
elif c == q :
    print("r")
elif c== r :
    print("s")
elif c == s :
    print("t")
elif c == t :
    print("u")
elif c == u :
    print("v")
elif c == v :
    print("w")
elif c == w :
    print("x")
elif c == x :
    print("y")
elif c == y :
    print("z")

c=input()
print(c+1)

c=str(input())
print(c+1)

c=str()
print(c+1)

c=int(input())
print(c+1)

c=int(input())
if c == a :
    print("b")
elif c == b :
    print("c")
elif c == c :
    print("d")
elif c == d :
    print("e")
elif c == e :
    print ("f")
elif c == f :
    print("g")
elif c == g :
    print("h")
elif c == h :
    print("i")
elif c == i :
    print("j")
elif c == j :
    print("k")
elif c == k :
    print("l")
elif c == l :
    print("m")
elif c == m :
    print("n")
elif c == n :
    print("o")
elif c == o :
    print("p")
elif c == p :
    print("q")
elif c == q :
    print("r")
elif c== r :
    print("s")
elif c == s :
    print("t")
elif c == t :
    print("u")
elif c == u :
    print("v")
elif c == v :
    print("w")
elif c == w :
    print("x")
elif c == x :
    print("y")
elif c == y :
    print("z")


c = input()
abc = 'abcdefghijklmnopqrstuvwxyz'
for i in range(26) :
    if abc[i] == c :
        print(abc[i+1])
        break

Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
n,k,m = map(int,input().split())
a = list(map(int,input().split()))
x = 0
for i in range(n-1):
    x+=a[i]
if n*m - x <= k:
    print(n*m-x)
else:
    print(-1)

c = input()
print(chr(ord(c) + 1))

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
print(chir(ord(input())+1))

print(chr(ord(input()) + 1))

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
C = input()
if C == "z":
  pass
else:
  print(C)

C = input()
print(chr(ord(C)+1))

Verdicts: Wrong Answer

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
a=input()
print(a+1)

a=input()
if a=="a":
  print("b")
if a=="b":
  print("c")
if a=="c":
  print("d")
if a=="d":
  print("e")
if a=="e":
  print("f")
if a=="f":
  print("g")
if a=="g":
  print("h")
if a=="h":
  print("i")
if a=="i":
  print("j")
if a=="j":
  print("k")
if a=="k":
  print("l")
if a=="l":
  print("m")
if a=="m":
  print("n")
if a=="n":
  print("o")
if a=="o":
  print("p")
if a=="p":
  print("q")
if a=="q":
  print("r")
if a=="r":
  print("s")
if a=="s":
  print("t")
if a=="t":
  print("u")
if a=="u":
  print("v")
if a=="v":
  print("w")
if a=="w":
  print("x")
if a=="x":
  print("y")
if a=="y":
  print("z")

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
letter = ord(input())
print(chr(c+1))

letter = ord(input())
print(chr(letter+1))

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
n,k,m=(int(x) for x in input().split())
a=[int(x) for x in input().split()]

sum = 0
for ai in a:
    sum+= ai

t = m * n  - sum
if t <= 0:
    print(0)
elif t<= k:
    print(t)
else:
    print(-1)





b = bytearray(input().encode())[0] + 0x01
print(b.to_bytes(1, 'big' ).decode())

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
import numpy as np
N,K=map(int,input().split())
A=list(map(int,input().split()))
A.sort()
A=np.array(A)
MOD=10**9+7

def cmb(n, k, mod, fac, ifac): #calc nCk under mod
    k = min(k, n-k)
    return fac[n] * ifac[k] * ifac[n-k] % mod

def make_tables(mod, n): #Make factorial and inverse tables under mod 
    fac = [1, 1] # factorial table
    ifac = [1, 1] #factorial of inverse table
    inverse = [0, 1] #inverse
 
    for i in range(2, n+1):
        fac.append((fac[-1] * i) % mod)
        inverse.append((-inverse[mod % i] * (mod//i)) % mod)
        ifac.append((ifac[-1] * inverse[-1]) % mod)
    return fac, ifac
MOD=10**9+7
Nmax=10**5
fac,ifac = make_tables(MOD,Nmax)

combs=[0]*N
for i in range(0,N-K+1):
  combs[i]=cmb(N-i-1, K-1, MOD, fac, ifac)
#print(combs)
neg=combs
pos=sorted(combs)
pos=np.array(pos)
neg=np.array(neg)
X=(A*pos-A*neg)
print(X.sum()%MOD)

alpha='abcdefghijklmnopqrstuvwxyza'
s=input()
for i in range(len(alpha)):
  if s==alpha[i]:
    print(alpha[i+1])
    break

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
import sys
from fractions import gcd
from itertools import permutations, combinations, accumulate
from collections import deque
from heapq import heappush, heappop, heapify
import math
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
MOD = 10**9 + 7

def main():
    c = ord(input())
    c += 1
    if c == 123:
        c = 97
    print(chr(c))

if __name__ == '__main__':
    main()

import sys
from fractions import gcd
from itertools import permutations, combinations, accumulate
from collections import deque
from heapq import heappush, heappop, heapify
import math
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
MOD = 10**9 + 7

def main():
    c = ord(input())
    c += 1
    if c == 123:
        c = 97
    print(chr(c))

if __name__ == '__main__':
    main()

def main():
    c = ord(input())
    c += 1
    if c == 123:
        c = 97
    print(chr(c))

if __name__ == '__main__':
    main()

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
N, M = map(int, input().split())
point = input().split()
thr = 0
good = 0
bad = 0

if M == 0:
    print("0 0")
else:
    for i in range(M - 1):
        if point[0] == str(thr):
            point = input().split()
            continue
        elif point[1] == "AC":
            good += 1
            thr = point[0]
            point = input().split()
            continue
        elif point[1] == "WA":
            bad += 1
            point = input().split()
            continue
    print(str(good), str(bad))


tmp = ord(input())
tmp += 1
print(chr(tmp))


Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sun Jan 12 22:19:09 2020

@author: nanasakiwataru
"""

def alphabet(C):
    ans = chr(ord(C) + 1)
    st = C + 'の次は'+ n + 'です。'
    return  st

n = alphabet('a')
print(n)



#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sun Jan 12 22:19:09 2020

@author: nanasakiwataru
"""

def alphabet(C):
    ans = chr(ord(C) + 1)
    st =C + 'の次は' + ans + 'です。'
    return  st


#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sun Jan 12 22:19:09 2020

@author: nanasakiwataru
"""

def alphabet(C):
    ans = chr(ord(C) + 1)
    st = C + 'の次は'+ ans + 'です。'
    return  st

n = alphabet('a')
print(n)



#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sun Jan 12 22:19:09 2020

@author: nanasakiwataru
"""


ans = chr(ord(C) + 1)
st = C + 'の次は' + ans + 'です。'
print(st)


#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sun Jan 12 22:19:09 2020

@author: nanasakiwataru
"""

C = input()
ans = chr(ord(C) + 1)
st = C + 'の次は' + ans + 'です。'
print(st)


#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sun Jan 12 22:19:09 2020

@author: nanasakiwataru
"""

C = input()
ans = chr(ord(C) + 1)
print(ans)

Verdicts: Runtime Error

Wrong Answer

Wrong Answer

Runtime Error

Wrong Answer

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
num = lambda c: chr(c+64)
s = str(input())

for i in range(1,26):
	if s == num(i).lower:
      print(num(i+1))



s = str(input())

print(chr(ord(s) + 1))

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
print(char(ord(input()) + 1))

print(chr(ord(input()) + 1))

Verdicts: Runtime Error

Accepted
Problem: Given is a lowercase English letter C that is not `z`. Print the letter that follows C in alphabetical order.

Submission attempts (in order):
alph = input()
print(ord(alph+1))

alph = input()
print(ord(alph)+1)

alph = input()
print(chr(ord(alph)+1))

Verdicts: Runtime Error

Wrong Answer

Accepted