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):
H,W = map(int,input().split())
S = [list(input()) for _ in range(H)]
from collections import deque
ans = 0
for i in range(H):
  for j in range(W):
    if S[i][j]=='#':
      continue
    inf = 10**5
    A = [[inf]*W for _ in range(H)]
    A[i][j]=0
    judge = [[False]*W for _ in range(H)]
    judge[i][j]=True
    q = deque([[i,j]])
    while q:
      a = q.popleft()
      x=a[0]
      y=a[1]
      b = A[x][y]
      for m in [[x-1,y],[x+1,y],[x,y-1],[x,y+1]]:
        h = m[0]
        w = m[1]
        if (h<0)or(h>H-1)or(w<0)or(w>W-1):
          continue
        if S[h][w]=='#':
          continue
        c = b+1
        if judge[h][w]:
          continue
        A[h][w]=c
        judge[h][w]=True
        q.append([h,w])
        
    A = [a for b in A for a in b if a!=inf]
    ans = max(ans,max(A))
    
print(ans)

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())
ac = [0]*(N+1)
wa = 0
for i in range(M):
    p,s = input().split()
    p = int(p)
    if s == 'AC':
        if ac[p] != -1:
            ac[p] = -1
    else:
        if ac[p] != -1:
            wa +=1
print(ac.count(-1),wa)

alp = "abcdefghijklmnopqrstuvwxyz"
C = input()
n = 0
while alp[n] != C:
    n += 1
print(alp[n+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()
print(chr(ord(c)+1)

c=input()
d=ord(c)+1
e=chr(d)
print(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):
import math


N = int(input())
x = [0] * N
y = [0] * N
xy = []
for i in range(N):
    xy.append(list(map(int, input().split())))


def signed_area(p1, p2, p3):
    area = (p2[0] - p1[0]) * (p3[1] - p1[1])\
            - (p3[0] - p1[0]) * (p2[1] - p1[1])
    return area/2


def convex_hull(p_list):
    p_sort = []
    for i in p_list:
        p_sort.append(i[0])

    
    min_index = p_sort.index(min(p_sort))
    min_p = p_list.pop(min_index)
    p_list.insert(0, min_p)

    
    p_length = len(p_list)
    count = 0
    index = 0
    while True:
        count += 1
        index += 1

        area_sign = signed_area(p_list[0], p_list[index], p_list[index + 1])

        
        if area_sign < 0:
            p_list[index], p_list[index + 1] = p_list[index + 1], p_list[index]
            count = 0

        if count == p_length - 1:
            break

        if index == p_length - 2:
            index = 0

    
    index = -1
    count = 0
    while True:
        index += 1
        count += 1

        area_sign = signed_area(p_list[index],
                                p_list[index + 1],
                                p_list[index + 2])
        if area_sign < 0:
            del p_list[index + 1]
            count = 0

        if count == len(p_list):
            break

        if index >= len(p_list) - 3:
            index = -1
    return p_list


def euc(p1, p2):
    return (p1[0]-p2[0])**2 + (p1[1]-p2[1])**2


def find_max_euc(xy):
    ans = []
    max_dis = 0
    n = len(xy)
    for i in range(n):
        for j in range(n):
            dis = math.sqrt(euc(xy[j], xy[i]))
            if dis >= max_dis+1e-05:
                max_dis = dis
                ans = [xy[j], xy[i]]
    return ans


if len(xy) == 2:
    dis = math.sqrt(euc(xy[0], xy[1]))
    print(dis/2)
else:
    xy = convex_hull(xy)
    xy = find_max_euc(xy)
    dis = math.sqrt(euc(xy[0], xy[1]))
    print(dis/2)


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()
c=c.upper()
c=chr(ord(c+1))
print(c)

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


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

x =input()
x=x.upper()
x=chr(ord(x) + 1)
print(x)

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

Verdicts: Runtime Error

Runtime Error

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):
N,K,M=map(int, input().split(' '))
Ai =input().split(' ')
Ais = [int(s) for s in Ai]

goal = M*N
if __name__=='__main__':
  rest=goal-sum(Ais)
  print( max(0,rest) if rest<=K else -1 )



N,K,M=map(int, input().split(' '))
Ai =input().split(' ')
Ais = [int(s) for s in Ai]

goal = M*N
current = sum(Ais)

if __name__=='__main__':
  rest=goal-sum(Ais)
  print( max(0,rest) if rest<=K else -1 )


alpha = 'abcdefghijklmnopqrstuvwxyz'
if __name__=='__main__':
    print(alpha[alpha.index(input())])

alpha = 'abcdefghijklmnopqrstuvwxyz'
if __name__=='__main__':
    print(alpha[1+alpha.index(input())])


Verdicts: Runtime Error

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):
n, m = map(int, input().split())


li = []

for i in range(m):
    p,q = map(str, input().split())
    li.append((int(p),q))

wa = 0

se = {i for i in li if i[1]=='AC'}
ac = len(se)

flag = True
for i in range(m-1):
    if li[i][0]!=li[i+1][0]:
        flag = True
    elif li[i][0]==li[i+1][0] and li[i][1]=='AC':
        flag = False
    elif li[i][0]==li[i+1][0] and li[i][1]=='WA' and flag:
        wa += 1

print(ac, wa)

import string
c = input()

upper = string.ascii_lowercase
ind = upper.index(c)
print(upper[ind+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):
import sys
# row = sys.stdin.readline
row = open('input.txt', 'r').readline
def read_string(row):
    return row().rstrip()
  
inp = read_string(row)
print(chr(ord(inp) + 1))

import sys

row = sys.stdin.readline
# row = open('input.txt', 'r').readline
def read_string(row):
    return row().rstrip()
  
inp = read_string(row)
print(chr(ord(inp) + 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):
import sys

for alpha in sys.stdin:
	sys.stdout.write(chr(ord(alpha)+1))

import sys

alphas = [chr(i) for i in range(ord('a'), ord('z') +1)]
for alpha in sys.stdin:
	print(alphas[alphas.index(alpha)+1])

alpha = input()
print(chr(ord(alpha)+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):
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):
a,b,c=(int(x) for x in input().split())
s = list(map(int, input().split()))
t = 0
for x in s:
  t += x
l = a + 1
chk = l * c
chk -= t
if chk > b:
  print(-1)
elseif chk < 0:
  print(0)
else:
  print(chk)

s = input()
print chr(ord(s[0]) + 1)

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

s = input()
print(chr(ord(s)+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):
str1 = input()
asc = ord(str1) + 1
print(asc)
ans = chr(asc)
print(ans)


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

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):
m = input()
print(chr(rd(m)+1))

m = input()
print(chr(ord(m)+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 = list(map(int, input().split()))
A = list(map(int, input().split()))

a_sum = sum(A)
x = N * M - a_sum

if K < x:
    x = -1
elif x < 0:
    x = 0
print(x)


c = input()

txt = 'abcdefghijklmnopqrstuvwxyz'
for i in range(26):
    if txt[i] == c:
        print(txt[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()
ans = char(ord(a) + 1)

print(ans)

s = input()

print(chr(ord(s) + 1)


s = input()

print(char(ord(s) + 1)


s = input()

print(char(ord(s) + 1))


s = input()

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


Verdicts: 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):
chr1 = input(chr)
new = ord(chr1)+1
print(chr(new))

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

str1 = input()
new = ord(str1)+1
print(chr(new))

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):
n = input()
n = ord(n)
n += 1

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

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

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

s = input()
list_s = list(range(97, 97+26))
for i in range(26):
    if ord(s) == list_s[i]:
        print(chr(list_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):
N = input()

M = ord('N')+1

J = chr(M)

print(J)


N = input()

ans = chr(ord('N'+1))

print(ans)
          

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

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

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):
a


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(ord(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):
import numpy as np
print(char(ord(input()[0])+1))

print(chr(ord(input()[0])+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=map(int,input().split())
a=list(map(int,input().split()))
mod=10**9+7
a.sort()
def fact(n):
  if n==0:
    return 1
  else:
    s=1
    for i in range(1,n+1):
      s=s*i
    return s
def comb(n,k,mod):
  return (fact(n)//fact(k)//fact(n-k))%mod

if k>1:
  s=0
  for i in range(0,n-k):
    for j in range(i+k-1,n-1):
      s+=((a[j]-a[i])*comb(j-i-1,k-2,mod))%mod
  print(s%mod)
else:
  print(0)


C=str(input())
a=ord(C)
print(chr(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):
nput()
if x =='a':
    print('b')
if x =='b':
    print('c')
if x =='c':
    print('d')
if x =='d':
    print('e')
if x =='e':
    print('f')
if x =='f':
    print('g')
if x =='g':
    print('h')
if x =='h':
    print('i')
if x =='i':
    print('j')
if x =='j':
    print('k')
if x =='k':
    print('l')
if x =='l':
    print('m')
if x =='m':
    print('n')
if x =='n':
    print('o')
if x =='o':
    print('p')
if x =='p':
    print('q')
if x =='q':
    print('r')
if x =='r':
    print('s')
if x =='s':
    print('t')
if x =='t':
    print('u')
if x =='u':
    print('v')
if x =='v':
    print('w')
if x =='w':
    print('x')
if x =='x':
    print('y')
if x =='y':
    print('z')


import numpy as np
N, K, M = map(int,input().split())
A = list(map(int,input().split()))
A = np.array(A)
if M*N-np.mean(A)*(N-1) < 0:
    print(0)
elif M*N-np.mean(A)*(N-1)<K:
    print(Decimal(str(M*N-np.mean(A)*(N-1))).quantize(Decimal('0'), rounding=ROUND_HALF_UP))
else:
    print(-1)



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


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()
abcStr = "abcdefghijklmnopqrstuvwxyz"
print(abcStr[index(a)+1])

c=input()
abcStr = "abcdefghijklmnopqrstuvwxyz"
d=abcStr[abcStr.index(c)+1]
print(d)

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())
p = []
s = []
wacounter = 0
walist = []
for i in range(0, n):
  walist.append(0)
point = 0
point_to_num = [] 
for i in range(0, m):
  list = input().split()
  p.append(int(list[0]))
  s.append(list[1])
 
for i in range(0, m):
  if s[i] == "AC" and not p[i] in point_to_num: 
    point_to_num.append(p[i]) 
    
  elif s[i] == "WA" and not p[i] in point_to_num: 
      wacounter += 1
      walist[p[i]-1] += 1
for i in range(0, n):
  if not i + 1 in point_to_num:
    wacounter = wacounter - walist[i]
print(len(point_to_num), wacounter)
    


s = input()
n = ord(s)

print(chr(n+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())
cnt = 0
wa = 0
ac = 0
sumi = []
b = {}
for x in range(m):
    a = input().split()
    if a[1] == 'WA':
        try:
            b[a[0]] += 1
        except KeyError:
            b[a[0]] = 1
    if a[1] == 'AC' and not a[0] in sumi:
        sumi.append(a[0])
        ac += 1
        try:
            wa += b[a[0]]
        except KeyError:
            continue
print(ac, wa)

import sys
n, m = map(int, input().split())
wa, ac = 0, 0
memo = []
hi = n
if n < m:
    hi = m
b = [0] * hi
table = [sys.stdin.readline().split() for x in range(m)]
for x in range(m):
    if table[x][1] == 'AC' and not table[x][0] in memo:
        memo.append(table[x][0])
        ac += 1
        wa += b[int(table[x][0])]
    elif table[x][1] == 'WA':
        b[int(table[x][0])] += 1
print(ac, wa)


n, m = map(int, input().split())
cnt = 0
wa = 0
ac = 0
sumi = []
b = {}
for x in range(m):
    a = input().split()
    if a[1] == 'WA' and not a[0] in sumi:
        try:
            b[a[0]] += 1
        except KeyError:
            b[a[0]] = 1
    elif a[1] == 'AC' and not a[0] in sumi:

        sumi.append(a[0])
        ac += 1
        try:
            wa += b[a[0]]
        except KeyError:
            continue
print(ac, wa)


a = input()


print(chr(ord(a) + 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):
from sys import stdin

def main():
	l = stdin.readline().strip()
	print(l)
	print(l + " is followed by " +chr(ord(l)+1)+".")
main()


from sys import stdin

def main():
	l = stdin.readline().strip()
	print(chr(ord(l)+1))
	print(l + " is followed by " +chr(ord(l)+1)+".")
main()


C=input()
CN=ord(C)
print(chr((CN)+1))
print(C+" is followed by "+chr((CN)+1)+".")

métele_algonomas=input()
caja_china = ord(métele_algonomas)
dedos = caja_china + 1
print(chr(dedos))



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):
C = input('')
chr(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):
a=input()
print('chr(ord(a)+1)')


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


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


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):
c=input()
print (chr(ord(c) + 1)


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

c=input()
a=[chr(i) for i in range(97, 97+26)]
print(a[a.index(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):
c = input()
c = c + 1
print(c)

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

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

L = N * M
S = sum(A)

if L - S > K or S >= L:
    print(-1)
else:
    print(L - S)

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

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()

print(chr(ord(C)+1)


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

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

# import itertools
# import math

# import numpy as np

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

H = readline().decode('utf8')
print(chr(ord(H) + 1))




import sys

# import itertools
# import math

# import numpy as np

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

H = readline().decode('utf8').strip()
print(chr(ord(H) + 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):
import numpy as np

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

N, M = x[0], x[1]

ac, wa = np.array([0 for i in range(N)]), np.array([0 for i in range(N)])

for i in range(M):
    num, result = input().split()
    num = int(num) - 1

    if ac[num] == 1:
        pass
    else:
        if result == "AC":
            ac[num] = 1
        else:
            wa[num] += 1

print(np.sum(ac), np.sum(wa))


input_line = input()

print(chr(ord(input_line)+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):
al = "abcdefghijklmnopqrstuvwxyz"
i = input()
for a in ramge(al):
  if al[a] == i:
    print(al[a+1])

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



al = "abcdefghijklmnopqrstuvwxyz"
i = input()
for a in range(len(al)):
  if al[a] == i:
    print(al[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):
N, M = map(int, input().split())
grid = [[c for c in input()] for _ in range(N)]
mat = [[float('inf')]*(M*N) for _ in range(N*M)]

DX = [0, 0, 1, -1]
DY = [-1, 1, 0, 0]
for row in range(N):
    for col in range(M):
        if grid[row][col] == "#":
            continue
        for dx, dy in zip(DX, DY):
            if 0 <= row+dx < N and 0 <= col+dy < M:
                if grid[row+dx][col+dy] == "#":
                    continue
                mat[(row+dx)*M+col+dy][row*M+col] = 1
                mat[row*M+col][(row+dx)*M+col+dy] = 1
for k in range(N*M):
    for i in range(N*M):
        for j in range(N*M):
            mat[i][j] = min(mat[i][j], mat[i][k] + mat[k][j])
ans = 0
for srow in range(N):
    for scol in range(M):
        if grid[srow][scol] == "#":
            continue
        for erow in range(N):
            for ecol in range(M):
                if grid[erow][ecol] == "#":
                    continue
                else:
                    ans = max(mat[srow*M+scol][erow*M+ecol], ans)
print(ans)


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


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


Verdicts: 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):
print(chr(ord(str(input())+1)))

print(chr(ord(str(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):
import queue
import copy
 
def ngoin(bo,now):
    return 0 <= now[0] and now[0] < len(bo) and 0 <= now[1] and now[1] < len(bo[0])
 
def minido(bo,si,sj):
    tb = [[False for i in range(len(bo[0]))] for j in range(len(bo))]
    q = queue.Queue()
    q.put([si,sj,0])
    tb[si][sj] = True
    ret = 0
    while not q.empty():
        now = q.get()
        ret = now[2]
        if ngoin(bo,[now[0]-1,now[1]]):
            if bo[now[0]-1][now[1]] and not tb[now[0]-1][now[1]]:
                q.put([now[0]-1,now[1],now[2]+1])
                tb[now[0]-1][now[1]] = True
                
        if ngoin(bo,[now[0],now[1]+1]):
            if bo[now[0]][now[1]+1] and not tb[now[0]][now[1]+1]:
                q.put([now[0],now[1]+1,now[2]+1])
                tb[now[0]][now[1]+1] = True
                
        if ngoin(bo,[now[0]+1,now[1]]):
            if bo[now[0]+1][now[1]] and not tb[now[0]+1][now[1]]:
                q.put([now[0]+1,now[1],now[2]+1])
                tb[now[0]+1][now[1]] = True
                
        if ngoin(bo,[now[0],now[1]-1]):
            if bo[now[0]][now[1]-1] and not tb[now[0]][now[1]-1]:
                q.put([now[0],now[1]-1,now[2]+1])
                tb[now[0]][now[1]-1] = True
    return ret
            
 
h,w = map(int,input().split())
bo = [[True if x == '.' else False for x in input()] for i in range(h)]
grap = [[float('inf') for i in range(h*w)] for j in range(h*w)]
ans = 0
for i in range(h*w):
    grap[i][i] = 0
for si in range(h):
    for sj in range(w):
        if not bo[si][sj]:
            continue
        ans = max(ans,minido(bo,si,sj))
                
print(ans)


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):
alpha = 'c'
a_code = ord('a')
z_code = ord('z')
alpha_code = ord(alpha)
if alpha_code >= a_code and alpha_code < z_code:
	next_alpha_code = alpha_code + 1
	next_alpha = chr(next_alpha_code)
	print(alpha + 'の次は' + next_alpha + 'です。')

alpha = input()
alpha_code = ord(alpha)
next_alpha_code = alpha_code + 1
next_alpha = chr(next_alpha_code)
print(alpha + 'の次は' + next_alpha + 'です。')

alpha = input()
a_code = ord('a')
z_code = ord('z')
alpha_code = ord(alpha)
if alpha_code >= a_code and alpha_code < z_code:
	next_alpha_code = alpha_code + 1
	next_alpha = chr(next_alpha_code)
	print(alpha + 'の次は' + next_alpha + 'です。')

alpha = input()
a_code = ord('a')
z_code = ord('z')
alpha_code = ord(alpha)
if alpha_code >= a_code and alpha_code < z_code:
	next_alpha_code = alpha_code + 1
	next_alpha = chr(next_alpha_code)
	print(alpha + 'の次は' + next_alpha + 'です。')
else:print('a ~ yを入力してください')

alpha = input()

alpha_code = ord(alpha)
next_alpha_code = alpha_code + 1
next_alpha = chr(next_alpha_code)
print(next_alpha)

Verdicts: Wrong Answer

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):
from collections import deque

def bfs(maze, h, w, si, sj):
    q = deque([[si, sj]])
    score = [[0] * w for i in range(h)]

    pattern = [[1, 0], [-1, 0], [0, 1], [0, -1]]
    while len(q) > 0:
        i, j = q.popleft()
        for move in pattern:
            ni, nj= i + move[0], j + move[1]
            if ni < 0 or h <= ni or nj < 0 or w <= nj:
                continue
            p = maze[ni][nj]
            if p == '#':
                continue
            if p == '.' and not score[ni][nj]:
                score[ni][nj] = score[i][j] + 1
                q.append([ni, nj])
    return max(sum(score, []))
  
h, w = map(int, input().split())
maze = [input() for i in range(h)]
scores = []
for si  in range(h):
    for sj in range(w):
        memo.append((si, sj))
        if maze[si][sj] == "#":
            continue
        scores.append(bfs(maze, h, w, si, sj))
print(max(scores))

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):
t = 1

C = input()
alpha = 'abcdefghijklmnopqrstuvwxyz'
index = alpha.index(C)
print(alpha[index + 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,M=map(int,input().split())
keep=[]
lis=[]
ac=[0]*N
wa=[0]*N
WA=0
for i in range(M):
    ps=input().split()
    keep.append(ps)
    
for j in range(M):
    if keep[j][1]=="AC":
        ac[int(keep[j][0])-1]=1
    elif ac[int(keep[j][0])-1]==0:
        wa[int(keep[j][0])-1]+=1
AC=sum(ac)
for k in range(N):
    WA+=ac[k]*wa[k]
    
print(AC,WA)


N,M=map(int,input().split())
keep=[]
lis=[]
ac=[0]*N
wa=[0]*N
WA=0
for i in range(M):
    ps=input().split()
    keep.append(ps)
    
for j in range(M):
    if keep[j][1]=="AC":
        ac[int(keep[j][0])-1]=1
    elif ac[int(keep[j][0])-1]==0:
        wa[int(keep[j][0])-1]+=1
AC=sum(ac)
for j in range(M):
    WA+=ac[j]*wa[j]
    
print(AC,WA)


S=input()
num=ord(S)
print(chr(num+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 = 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 i in range(len(alpha)):
    alphabet = alpha[i]
    if a == alphabet:
        print(alphabet)
        break

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

a = 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 i in range(len(alpha)):
    
    alphabet = alpha[i]
    if a == alphabet:
        s = i + 1    
        alphabet = alpha[s]
        print(alphabet)
        break
        

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):
x = input()
print(chr(ord(x)+1)

x = input()
y = chr(ord(x) + 1)
print(y)


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())
An=list(map(int,input().split()))
rest=M*N-sum(An)
if rest<=K:
        print(max(rest,0))
else:
        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):
C = print(chr(ord(input("input:")) + 1))

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

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

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):
ch = input()
out = char(ord(ch)+1)
print(out)

ch = input()
out = char(ord(ch)+1)
print(out)

ch = input()
out = chr(ord(ch)+1)
print(out)

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
N,M = map(int,input().split())
if M == 0:
	print('0 0')
	sys.exit()


p = [0]*M
s = [0]*M

for i in range(M):
	p[i],s[i] = input().split()

cor_count = 0
pen_count = 0
AC_list = []

for i in range(M):
	if not p[i] in AC_list:
		if s[i] == 'AC':
			AC_list.append(p[i])
		else:
			pen_count += 1

#print(AC_list)
cor_count = len(set(AC_list))
if M != 0:
	print(cor_count,pen_count)





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):
alfa=['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("'"+c+"'"+"の次は'"+alfa[alfa.index(c)+1]+"'です。")


from collections import deque
from copy import deepcopy

def bfs(pos,map):
      while pos:
        x,y,depth=pos.popleft()
        if map[x][y]=="#":
            continue
        map[x][y]="#"
        if map[x-1][y]!="#":
          pos.append([x-1,y,depth+1])
        if map[x+1][y]!="#":
          pos.append([x+1,y,depth+1])
        if map[x][y+1]!="#":
          pos.append([x,y+1,depth+1])
        if map[x][y-1]!="#":
          pos.append([x,y-1,depth+1])
      return depth
H,W=map(int,input().split())
ans=0
fence=["#"]*(W+2)
field=[fence]
for _ in range(H):
  L=list(input())
  field.append(["#"]+L+["#"])
field.append(fence)
for i in range(1,H+1):
  for j in range(1,W+1):
    if field[i][j]==".": 
      pos=deque([[i,j,0]])
      depth=bfs(pos,deepcopy(field))
      if ans<depth:
        ans=depth
print(ans)

alfa=['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(alfa[alfa.index(c)+1])

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 = [chr(i) for i in range(ord('a'), ord('z'))]
print(C.sort(C))

C = str(input())
alf = "abcdefghijklmnopqrstuvwxyz"
for i in range(len(alf)):
  if C == alf[i]:
    print(alf[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,K,M=list(map(int,input().split()))
listA=list(map(int,input().split()))
S=sum(listA)
if S>=M*N-K and S<N*M:
  print(M*N-S)
elif S>=M*N:
    print(0)
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):
import queue
from itertools import product

H, W = map(int, input().split())
road_grid = [row for row in input()]

# for each start point, find the furthest travellable point
# then return largest path length of all these
# ps y is down, x is right
furthest_so_far = -1
for y_init, x_init in product(range(H), range(W)):
    if road_grid[y_init][x_init] == "#": continue
    boundary = queue.Queue()
    boundary.put((y_init, x_init))
    steps_taken = [[-1]*W for _ in range(H)]
    steps_taken[y_init][x_init] = 0
    while not boundary.empty():
        y, x = boundary.get()
        neighbours = [(y+1, x), (y, x+1), (y-1, x), (y, x-1)]
        for (new_y, new_x) in neighbours:
            if (0 <= new_y < H and 0 <= new_x < W
                and steps_taken[new_y][new_x] == -1 and road_grid[new_y][new_x] == "."):
                steps_taken[new_y][new_x] = steps_taken[y][x] + 1
                boundary.put((new_y, new_x))
    furthest_so_far = max(furthest_so_far, max(max(steps_taken)))
print(furthest_so_far)


x = input()
print(chr(ord(x)+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 = input().split()
N = int(N)
K = int(K)
M = int(M)
A = input().split()
A = [int(s) for s in A]
AN = M * N - sum(A)
if (AN <= K) and (AN >= 0):
	print (AN)
else:
	print (-1)

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

A = input().split()
A = [int(s) for s in A]

AN = M * N - sum(A)

if (AN <= K) and (AN >= 0):
	print (AN)
elif AN < 0:
	print (0)
else:
	print (-1)

N,K,M = input().split()
N = int(N)
K = int(K)
M = int(M)
A = input().split()
A = [int(s) for s in A]
AN = M * N - sum(A)
if (AN <= K) and (AN >= 0):
	print (AN)
elif AN < 0:
	print (0)
else:
	print (-1)

N,K,M = input().split()
N = int(N)
K = int(K)
M = int(N)
A = input().split()
A = [int(s) for s in A]
AN = M * N - sum(A)
if (AN <= K) and (AN >= 0):
	print (AN)
elif AN < 0:
	print (0)
else:
	print (-1)

N,K,M = input().split()
N = int(N)
K = int(K)
M = int(M)
A = input().split()
A = [int(s) for s in A]
AN = M * N - sum(A)
if AN <= K:
	print (AN)
else:
	print ('-1')


N,K,M = input().split()
N = int(N)
K = int(K)
M = int(N)
print(N)
A = input().split()
print(A)
A = [int(s) for s in A]
print(A)
AN = M * N - sum(A)
if (AN <= K) and (AN >= 0):
	print (AN)
elif AN < 0:
	print (0)
else:
	print ('-1')

N,K,M = input().split()
N = int(N)
K = int(K)
M = int(N)
# print(N)
A = input().split()
# print(A)
A = [int(s) for s in A]
# print(A)
AN = M * N - sum(A)
if (AN <= K) and (AN >= 0):
	print (AN)
else:
	print ('-1')

N,K,M = input().split()
N = int(N)
K = int(K)
M = int(M)
print(N)
A = input().split()
print(A)
A = [int(s) for s in A]
print(A)
AN = M * N - sum(A)
print (AN)
if (AN <= K) and (AN >= 0):
	print (AN)
elif AN < 0:
	print (0)
else:
	print (-1)

N,K,M = input().split()
N = int(N)
K = int(K)
M = int(N)
A = input().split()
A = [int(s) for s in A]
AN = M * N - sum(A)
if (AN <= K) and (AN >= 0):
	print (AN)
else:
	print ('-1')

N,K,M = input().split()
N = int(N)
K = int(K)
M = int(M)
A = input().split()
A = [int(s) for s in A]
AN = M * N - sum(A)
if (AN <= K) and (AN >= 0):
	print (AN)
else:
	print ('-1')

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

A = input().split()
A = [int(s) for s in A]

AN = M * N - sum(A)

if (AN <= K) and (AN >= 0):
	print (AN)
else:
	print (-1)

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()
if (C != 'z') and (C in a):
	i = a.index(C)
	print (a[i+1])

Verdicts: Runtime Error

Runtime Error

Runtime Error

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):
i1 = list(map(int,input().split()))
i2 = list(map(int,input().split()))

x = sum(i2)

for i in range(i1[1]):
    if (x+i)/(i1[0]) >= i1[2]:
        print(i)
        break
    else if i == i1[1]-1:
        print(-1)

z = 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 b in range(26):
    if a[b]==z:
        c=b+1
print(a[c])

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()
ord_s = ord(c)
chr_s = chr(ord_s)
print(chr_s) 

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

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)))


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=input().split(" ")
r = ["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(r[r.index(c)+1])

c=input()
r = ["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(r[r.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):
N, M = map(int, input().split())
Q_n = [0] * N
C = [0] * N

Ans = 0
Pen = 0
for i in range(M):
    p, S = input().split()
    p = int(p)-1
    if (S == 'AC') and (Q_n[p] == 0):
        Q_n[p] = 1
        Ans += 1
        Pen += C[p]
    elif (S == 'WA'):
        C[p] += 1
        
print(Ans, Pen)
  


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 = input()
data = [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(0,len(data)-1):
  if data[i]  == n:
    print(data[i+1])
    

n = input()
data = ['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(0,len(data)-1):
  if data[i]  == n:
    print(data[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):
al = input()

# ald = [1:a,2:b,3:c,4:d,5:e,6:f,8:g,9:h,10:i,11:j,12:k,13:l,14:m,15:n,16:o,16:p,17:q,18:r,19:s,20:t,21:u,22:v,23:w,24:x,25:y,26:z]

ald = {'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'}

if al in ald:
    print(ald[al])

al = input()

# ald = [1:a,2:b,3:c,4:d,5:e,6:f,8:g,9:h,10:i,11:j,12:k,13:l,14:m,15:n,16:o,16:p,17:q,18:r,19:s,20:t,21:u,22:v,23:w,24:x,25:y,26:z]

ald = [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]

if al in ald:
    print(ald[al])

alpha = input()

# ald = [1:a,2:b,3:c,4:d,5:e,6:f,8:g,9:h,10:i,11:j,12:k,13:l,14:m,15:n,16:o,16:p,17:q,18:r,19:s,20:t,21:u,22:v,23:w,24:x,25:y,26:z]

ald = {'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'}


if alpha in ald:
    print(ald[alpha])

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):
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]
C=input()
idx=alphabet.index(C)
print(alphabet[idx+1])

C=input()
al=[]
for idx in range(97,123):
  al.append(chr(idx))
idx = al.index(C)
print(al[idx+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()
arr="abcdefghijklmnopqrstuvwxyz"
arr[arr.index(x)+1]

x=input()
arr="abcdefghijklmnopqrstuvwxyz"
print(arr[arr.index(x)+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,M = map(int,input().split())
A = [input().split() for i in range(M)]
s1=list()
s2=list()
p=0
w=0
for i in range(M):
    if A[i][0] not in s2 and A[i][1]=="WA":
        s1 +=A[i][0]
    if A[i][0] not in s2 and A[i][1]=="AC":
        p+=1 
        s2 +=A[i][0]
        w += int(s1.count(A[i][0]))        
print(p,w)

N = input()
A =[chr(i) for i in range(97, 97+26)]
for k in range(len(A)):
    if N==A[k]:
        print(A[k+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()
z = [a,b,c,d,e,f,g,h,i,j,k,l,n,m,o,p,q,r,s,t,u,v,w,x,y,z]
xi = z.index(x)
print(z[xi+a1])

x = input()
z = ord(x)
xi = chr(z+1)
print(xi)

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))

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 math
def comb(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
N,K = map(int, input().split())
A = list(map(int, input().split()))
A.sort()
max=0
min=0
for i in range(K-1,N):
    max+=A[i]*comb(i,K-1)

for i in range(N-K+1):
    min+=A[i]*comb(N-1-i,K-1)
ans=(max-min)%(10**9 +7)
print(ans)


C = input()
H = [chr(i) for i in range(97,97+26)]
l = len(H)
for i in range(l):
    if (C==H[i]):
        ans=H[i+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):
C=input()
chr(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):
s = input()
  print(chr(ord(s)+1))

s = 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(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()
print(chr(ord(c[0])+1))

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

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=input()
print(chr(ord(c)+1)

n,k,m=map(int,input().split())
a=list((map(int,input(),split()))
ans=max(0,n*m-sum(a))
print(ans if n*m-s<=k else -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):
import sys
import numpy as np

S = []
for e in sys.stdin:
    S.append(e.rstrip())

H, M = map(int, S[0].split())

meiro = []
for i in range(H):
    meiro.append([])
    for k in S[i + 1]:
        if k == '.':
            meiro[i].append(1)
        else:
            meiro[i].append(0)
meiro_array = np.array(meiro)
susumikata = [[1, 0], [-1, 0], [0, 1], [0, -1]]


def BFS(y, x):
    global max_distance
    if meiro_array[x, y] == 1:
        max_distance = 0
        reached = {(x, y): 0}
        for i in range(H * M):
            zahyous = [k for k, v in reached.items() if v == i]
            for zahyou in zahyous:
                for susumi in susumikata:
                    new_zahyou = tuple([zahyou[0] + susumi[0], zahyou[1] + susumi[1]])
                    if not(0 <= new_zahyou[0] < H and 0 <= new_zahyou[1] < M):
                        a = 0
                    elif new_zahyou not in reached.keys() and meiro_array[new_zahyou] == 1:
                        reached[new_zahyou] = i + 1
                        max_distance = i + 1

    return max_distance


keiro_max = []
for x in range(H):
    for y in range(M):
        keiro_max.append(BFS(x, y))

print(max(keiro_max))


C = input()

Alphabet = 'abcdefghijklmnopqrstuvwxyz'
Alphabet_list = [i for i in Alphabet]
print(Alphabet_list[Alphabet_list.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):
N,M = list(map(int,input().split()))
A = ['a']*N
B = [0]*N
ans1 = 0
ans2 = 0
for i in range(M):
  C,D = input().split()
  C = int(C)-1
  if A[C] == D == 'WA':
    ans1 += 1
    B[C] += 1
  if A[C] == 'a' and D == 'WA':
    ans1 += 1
    B[C] += 1
  if A[C] == 'WA' and D == 'AC':
    ans2 += 1
    A[C] = 'AC'
  if A[C] == 'a' and D == 'AC':
    ans2 += 1
    A[C] = 'AC'
for i in range(N):
  if A[i] == 'a':
    ans1 -= B[i]
print('{0} {1}'.format(ans2,ans1))


listA = [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()
for i in range(24):
  if C == listA[i]:
    print(listA[i+1])

listA = ['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()
for i in range(25):
  if C == listA[i]:
    print(listA[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):
"""
author : dokueki
"""
s = input()
t = "abcdefghijklmnopqrstuvwxyza"
for i in range(len(t)):
    if t[i] == a:
        print(t[i+1])
        break
        

"""
author : dokueki
"""
s = input()
t = "abcdefghijklmnopqrstuvwxyz"
for i in range(len(t)):
    if t[i] == s:
        print(t[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()
alpha_list = 'abcdefghijklmnopqrstuvwxyz'
if C == alpha_list[i]:
  print(alpha_list[i+1])


C = input()
alpha_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]
i = alpha_list.index(C)
print(alpha_list[i+1])

C = input()
alpha_list = 'abcdefghijklmnopqrstuvwxyz'
for i in range(len(alpha_list)-1):
  if C == alpha_list[i]:
    print(alpha_list[i+1])


Verdicts: Runtime Error

Runtime Error

Accepted