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):
#min
minsum=0
for i in range(n):
    if n-(i+1)>=k-1:
        minsum+=(a[i] * comb(n-i-1,k-1))%M
        minsum%=M
b=sorted(a,reverse=True)
#max
maxsum=0
for i in range(n):
    if n-(i+1)>=k-1:
        maxsum+=(b[i] * comb(n-i-1,k-1))%M
        maxsum%=M
print((maxsum-minsum)%M)

aaaa

a

a

a

aaaaaaaaaa


a        a


aa

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


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

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):
c = input()
abc = 'abcdefghijklmnopqrstuvwxyz'

for i in range(len(str(abc))):
    if abc[i] = c:
        print(abc[i+1])

C = input()
abc = 'abcdefghijklmnopqrstuvwxyz'

for i in range(len(str(abc))):
    if abc[i] == C:
        print(abc[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):
K,X = map(int, input().split())
if K*500 >= X:
    print('Yes')
else:
    print('No')


K,X = map(int, input().split())
if K*500 >= X:
    print('Yes')
else:
    print('No')

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',]
C = input()
print(l[l.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):
def prepare(n, MOD):
    
    f = 1
    factorials = [1]  
    for m in range(1, n + 1):
        f *= m
        f %= MOD
        factorials.append(f)
    
    inv = pow(f, MOD - 2, MOD)
    
    invs = [1] * (n + 1)
    invs[n] = inv
    for m in range(n, 1, -1):
        inv *= m
        inv %= MOD
        invs[m - 1] = inv
     
    return factorials, invs

def combinations_count(n, r, factorials, invs):
    return (factorials[n] * invs[n-r] * invs[r]) % (10 ** 9 + 7)
 
f = open("151_E_max01", "r")
n, k = map(int, f.readline().split())
a = sorted(list(map(int, f.readline().split())))

factorials, invs = prepare(n, 10 ** 9 + 7)

ans = 0
for i in range(n):
    if i <= n - k:
        ans -= a[i] * combinations_count(n-i-1, k-1, factorials, invs)
    
    if i >= k - 1:
        ans += a[i] * combinations_count(i, k-1, factorials, invs)
    
    ans = ans % (10 ** 9 + 7)
 
print(ans)

import string

key = input()
alphabet = string.ascii_lowercase
print(alphabet[alphabet.index(key) + 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()
st = 'abcdefghijklmnopqrstuvwxyz'
print(st[index(s)+1])

s = input()
st = 'abcdefghijklmnopqrstuvwxyz'
print(st[st.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):
c=input()
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']
print(l[l.index(c)+1]


c=input()
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']
print(l[l.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):
x = ord(input())
ind = (x - ord("A")+1)%26
print(chr(ind+ord("A")))

x = ord(input())
ind = (x - ord("a")+1)%26
print(chr(ind+ord("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):
C = input()
print(C+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 heapq
# from copy import deepcopy
# from collections import deque
# from collections import Counter
# from itertools import accumulate
# from itertools import permutations
# import numpy as np
# import math

n, k = map(int, input().split())
a = list(map(int, input().split()))
# n = int(input())
mod = 10 ** 9 + 7
a.sort(reverse = True)
# print(a)
ans = 0

def C(n, k, mod):
    if n == 0 and k == 0:
        return 1
    if n < k or k < 0:
        return 0
    x,y = 1,1
    while k > 0:
        x *= n
        y *= k
        n, k = n-1, k-1
        
    return x * pow(y, mod-2, mod) % mod


for i in range(0,n-k+1):
    ans += a[i] * C(n-i-1, k-1, mod)
    ans %= mod

a.reverse()
for i in range(0, n - k + 1):
    ans -= a[i] * C(n - i - 1, k - 1, mod)
    ans %= mod



print(ans)


# import math

# import heapq
# from collections import deque
# import numpy as np

# a,b = map(int, input().split())
# n = int(input())
# p = list(map(int,input().split()))
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):
s = str(input())
t = chr(ord('s') + 1)
print(t)



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



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):
#include <bits/stdc++.h>

using namespace std;
typedef long long ll;

int main() {
  char c;
  cin >> c;
  cout << char(c+1) << endl;
  return 0;
}

c = input()
alpha_list = 'abcdefghijkfmnopqrstuvrxyz'

for i in range(len(alpha_list)):
  if c == alpha_list[i]:
    print(alpha_list[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()
S='abcdefghijklmnopqrstuvwxyz"
for i in range(26):
  if c==S[i]:
    print(S[i+1])

c=input()
S='abcdefghijklmnopqrstuvwxyz'
for i in range(26):
  if c==S[i]:
    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):
c = input()

l = [chi(i) for i in range(65, 91)]
print(l[l.index(c) + 1])

c = input()

l = [chr(i) for i in range(97, 123)]
print(l[l.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):
from collections import deque

H, W = map(int, input().split())
S = [list(input()) for _ in range(H)]

dir = [(-1, 0), (1, 0), (0, -1), (0, 1)]

dist = [[-1] * W for _ in range(H)]

def BFS(y, x):
  
  que = deque()
  que.append((y, x))
  dist[y][x] = 0
  max_dist = 0
  while que:
    sy, sx = que.popleft()  # popleft?
    for dy, dx in dir:
      ny = sy + dy
      nx = sx + dx
      if 0 <= ny < H and 0 <= nx < W and S[ny][nx] != "#" and dist[ny][nx] == -1:
        que.append((ny, nx))
        dist[ny][nx] = dist[sy][sx] + 1
        max_dist = max(max_dist, dist[ny][nx])
  
  return max_dist

max_dist = 0
for sy in range(H):
  for sx in range(W):
    if S[sy][sx] != "#":
      dist = [[-1] * W for _ in range(H)]
      max_dist = max(max_dist, BFS(sy, sx))
      
print(max_dist)

C = input()
D = chr(ord(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):
C = input()

print(C++)

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

N = str(input())
print(chr(ord(N)+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):
from collections import deque
import numpy as np
import math

h, w = list(map(int, input().split()))
SHWs = [input() for i in range(h)]

def bfs(sy, sx):
    visited = [[-1]*w for i in range(h)]
    visited[sy][sx] = 0
    que = deque([[sy, sx]])
    while que:
        
        y,x = que.popleft()
        for i, j in [(1,0),(0,1),(-1,0),(0,-1)]:
            next_y, next_x = y+i, x+j
            # print(visited)
            if next_y < 0 or next_x < 0 or next_y > h-1 or next_x > w-1:
                continue
            if SHWs[next_y][next_x] == '.' and (visited[next_y][next_x] == -1 or visited[next_y][next_x] > visited[y][x]+1):
                visited[next_y][next_x] = visited[y][x] + 1
                que.append([next_y, next_x])
    
    return np.amax(np.array(visited))

            
ans = 0
for sy in range(h):
    for sx in range(w):
        if SHWs[sy][sx] == '#':
            continue
        count = bfs(sy=sy, sx=sx)

        if count > ans:
            ans = count


print(ans)



c = input()
ordc = ord(c)

if ordc != 122:
    print(chr(int(ordc)+1))
else:
    print('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):
s = input()
print(chr(ord(s)+1)))

c = 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):
a =[chr(ord('a') + i) for i in range(26)]
a.append("a")
c = input()
print(a[a.index(c)])



a =[chr(ord('a') + i) for i in range(26)]
c = input()
print(a[a.index(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,M = map(int,input().split())
ls = []
for i in range(M):
    p,m = map(str,input().split())
    ls.append([p,m])
    
ac = 0
wa = 0
now = ""
p = 0
c = 0
for i in range(M):
    if now == ls[i][0]:
        continue
    if ls[i][0] != ls[i-1][0] and c == 0:
        wa -= p
        p = 0
    if ls[i][1] == "AC":
        now = ls[i][0]
        ac += 1
        c = 1
    elif ls[i][1] == "WA":
        wa += 1
        c = 0
        p += 1
        
print(ac,wa)

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

if m * n - sum(a) <= 0:
    print(0)

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

n, k, m = map(int, input().split())
a = list(map(int, input().split()))

if n * m - sum(a) <= 0:
    print(0)

elif n * m - sum(a) > k:
    print('-1')
    
else:
    print(n * m - sum(a))

alp = input()
asc = ord(alp)
print(chr(asc + 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):
def cmb(n, k, mod, fac, ifac):
    
    k = min(k, n-k)
    return fac[n] * ifac[k] * ifac[n-k] % mod


def make_tables(mod, n):
    
    fac = [1, 1] 
    ifac = [1, 1] 
    inverse = [0, 1] 

    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
    
n,k=map(int,input().split())
a=sorted(list(map(int, input().split())))
MOD=10**9+7

fac, ifac=make_tables(MOD,n)

s=0
for i in range(k-1,n):
	s+=(a[i]-a[n-i-1])*cmb(i,k-1,MOD,fac,ifac)
	s%=10**9+7
print(s)



print(chr(ord(input().rstrip())))

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

str = sys.stdin.readlines()[0]
alp = "abcdefghijklmnopqrstuvwxyz"
print(alp[ord(str)-96])

import sys

str = sys.stdin.readline()
alp = "abcdefghijklmnopqrstuvwxyz"
print(alp[ord(str)-96])

str = input()
alp = "abcdefghijklmnopqrstuvwxyz"
print(alp[ord(str)-96])

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((input())+1))

n = input()
a = ord(n)
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):
from sys import stdin
lines = stdin.readlines()
 
C = str(lines[0])
 
print(chr(ord(C) + 1))

from sys import stdin
lines = stdin.readlines()
 
C = lines[0]

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

from sys import stdin
lines = stdin.readlines()
 
C = str(lines[0])
 
print(chr(ord(C) + 1))


C = str(input())

print(chr(ord(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):
total_subjects, max_points, target_points = map(int, input().split())
subject_points = list(map(int, input().split()))

calc_result = (total_subjects * target_points) - sum(subject_points)

if calc_result > max_points:
    print(-1)
elif calc_result < 0:
    print(0)
else:
    print(calc_result)


total_subjects, max_points, target_points = map(int, input().split())
subject_points = input().split()
total_points = 0

for subject_point in subject_points:
    total_points += int(subject_point)

calc_result = total_subjects * target_points - total_points

if calc_result > max_points:
    print(-1)
elif calc_result < 0:
    print(0)
else:
    print(calc_result)

total_subjects, max_points, target_points = map(int, input().split())
subject_points = list(map(int, input().split()))

calc_result = total_subjects * target_points - sum(subject_points)

if calc_result > max_points:
    print(-1)
elif calc_result < 0:
    print(0)
else:
    print(calc_result)

small_alpha = str(input())
alpha_list = [chr(ord('a') + i) for i in range(26)]
for num, alpha in enumerate(alpha_list):
    if alpha == small_alpha:
        print(alpha_list[num + 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):
 print(chr(ord(input()) + 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):
print(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()
b=a.next(a)
print(b)


alp='abcdefghijklmnopqrstuvwxyz'
s=str(input())
flag=False
for c in alp:
  if flag:
    print(c)
    break
  if c==s:
    flag=True

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

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

S = sum(A)
Score = M * N

n = Score - S

if n >=0 and n < 100:
    print(n)
elif n >= 100:
    print('-1')
else:
    print(0)

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

A = []

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

S = sum(A)
Score = M * N

n = Score - S

if n >=0 and n <= 100:
    print(n)
elif n > 100:
    print('-1')
else:
    print(0)


x = input()
l = [chr(i) for i in range(97, 97+26)]

for i in range(26):
    if l[i]== x:
        k = i
        
print(l[k+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 numpy as np
h,w=map(int,input().split())
s=[[0 for i in range(w)] for j in range(h)]
for i in range(h):
	s[i]=list(input())
# h,w=3,3
# s=[['.', '.', '.'], ['.', '.', '.'], ['.', '.', '.']]
v=[[1000000 for i in range(w)] for j in range(h)]
s=np.array(s)
v=np.array(v)
def search(H,W,p):
	m=0
	if H<h-1 and s[H+1][W]=='.' and v[H+1][W]>p+1:
		v[H+1][W]=p+1
		m=p+1
	if H>0 and s[H-1][W]=='.' and v[H-1][W]>p+1:
		v[H-1][W]=p+1
		m=p+1
	if W>0 and s[H][W-1]=='.' and v[H][W-1]>p+1:
		v[H][W-1]=p+1
		m=p+1
	if W<w-1 and s[H][W+1]=='.' and v[H][W+1]>p+1:
		v[H][W+1]=p+1
		m=p+1
	return m

def dijk():
	f=False
	global P
	global M
	for i in range(h):
		for j in range(w):
			if v[i][j]==P:
				m=search(i,j,P)
				M=max(m,M)
				f=True

	P+=1
	if f==False:
		return 0
	dijk()
M_=0
for i in range(h):
	for j in range(w):
		v[i][j]=0
		P=0
		M=0
		if s[i][j]!='.':
			continue
		dijk()
		M_=max(M,M_)
		v=[[1000000 for i in range(w)] for j in range(h)]
print(M_)

C=input()

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

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):
l = ['abcdefghijklmnopqrstuvwxyz']

print(l[l.index(input()) + 1])

c =input()
l = 'abcdefghijklmnopqrstuvwxyz'
 
print(l[l.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 = [int(i) for i in input().split()]
submissions = {str(i):[] for i in range(1,N+1)}
AC,WA = 0,0
for i in range(M):
    P,S = [j for j in input().split()]
    submissions[P].append(S)
for i in submissions:
    if 'AC' not in submissions[i]:
        continue
    for j in submissions[i]:
        if j == 'AC':
            AC+=1
            break
        WA +=1
print(AC,WA)

N,M = [int(i) for i in input().split()]
submissions = {str(i):[] for i in range(1,N+1)}
AC,WA = 0,0
for i in range(M):
    P,S = [j for j in input().split()]
    submissions[P].append(S)
for i in submissions:
    if(not 'AC' in submissions[i]):
        continue
    for j in submissions[i]:
        if j == 'AC':
            AC+=1
            break
        WA +=1
print(AC,WA)

N,M = [int(i) for i in input().split()]
submissions = {str(i):[] for i in range(1,N+1)}
AC,WA = 0,0
for i in range(M):
    P,S = [j for j in input().split()]
    submissions[P].append(S)
for i in submissions:
    for j in submissions[i]:
        if not 'AC' in j:
            break
        if j == 'AC':
            AC+=1
            break
        WA +=1
print(AC,WA)



N,M = [int(i) for i in input().split()]
submissions = {str(i):[] for i in range(1,N+1)}
AC,WA = 0,0
for i in range(M):
    P,S = [j for j in input().split()]
    submissions[P].append(S)
for i in submissions:
    if 'AC' not in submissions[i]:
        continue
    for j in submissions[i]:
        if j == 'AC':
            AC+=1
            break
        WA +=1
print(AC,WA)

C = input()
alphs = "abcdefghijklmnopqrstuvwxyz"
print(alphs[alphs.find(C)+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):
N, M = map(int, input().split())

A = [[0] * 2 for i in range(M)]

for i in range(M):
    A[i][0], A[i][1] = input().split()


AC = [0] * M
WA = [0] * M

for j in range(M)[::-1]:
    if A[j][1] == 'AC' and (A[j][0] in AC) is False:
        AC[j] = A[j][0]
    elif A[j][1] == 'WA' and (A[j][0] in AC) is True:
        WA[j] = A[j][0]

print(len(AC) - AC.count(0), len(WA) - WA.count(0))


C = input()

L = list('abcdefghijklmnopqrstuvwxyz')

for i in range(26):
    if C == L[i]:
        print(L[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):
print(int("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):
A = input()
if A = 'a':
  print('b')
elif A = 'b':
  print('c')
elif A = 'c':
  print('d')
elif A = 'd':
  print('e')
elif A = 'e':
  print('f')
elif A = 'f':
  print('g')
elif A = 'g':
  print('h')
elif A = 'h':
  print('i')
elif A = 'i':
  print('j')
elif A = 'j':
  print('k')
elif A = 'k':
  print('l')
elif A = 'l':
  print('m')
elif A = 'm':
  print('n')
elif A = 'n':
  print('o')
elif A = 'o':
  print('p')
elif A = 'p':
  print('q')
elif A = 'q':
  print('r')
elif A = 'r':
  print('s')
elif A = 's':
  print('t')
elif A = 't':
  print('u')
elif A = 'u':
  print('v')
elif A = 'v':
  print('w')
elif A = 'w':
  print('x')
elif A = 'x':
  print('y')
else:
  print('z')



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



c=str(input())

if len(c)==1 and c!="z":
	print(chr(ord(c)+1))
else:
	print('a')


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(char(ord(input())+1))

print(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):
s = str(input())
print(char(ord(s)+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):
tmp = Input()
ans = chr(ord(tmp) + 1)
print(ans)

N, K, M = map(int, input().split())
A = list(map(int, input().split()))
 
if  N*M - sum(A) >= K:
    print('-1')
else:
  print(N*M - sum(A))

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

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):
al = [ord(i) for i in range(ord("a"), ord("a")+26)]

str = input()

print(al[al.index(str)+1])

al = [chr(i) for i in range(ord("a"), ord("a")+26)]

str = input()

print(al[al.index(str)+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 strings import ascii_lowercase as lc
given = input()
print(lc[lc.index(given) + 1])

from string import ascii_lowercase as lc
given = input()
print(lc[lc.index(given) + 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()
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]
print(l[l.index(c)+1])

c=input()
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']
print(l[l.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()
print(chr(ord('C') + 1))


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

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


C=str(input())
abc=['a', 'b', 'c', 'd' , 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
print(abc[abc.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, K, M =map(int, input().split())
A = list(map(int, input().split()))


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





alphabet = input()
print(chr(ord(alphabet) + 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()
print(chr(ord("")+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):
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()
for i in range(len(A)):
  elif C == A[i]:
  break
print(A[i+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()
for i in range(len(A)):
  if C == A[i]:
    break
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):
c = 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):
print(str(ord(input())+1))

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

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

C = input()
alphabetlist = [chr(i) for i in range(97, 97+26)]
next_index = alphabetlist.index(C)+1
print(alphabetlist[next_index])

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 = input().split()
N = int(N)
M = int(M)
p = []
S = []
for i in range(M):
    a, b = input().split()
    a = int(a)
    p.append(a)
    S.append(b)
right = 0
wrong = 0
for j in range(M):
    if right[p[j] - 1] == 0:
        if S[k] == 'WA':
            wrong += 1
        elif S[k] == 'AC' and :
            right += 1
print(str(right) + ' ' + str(wrong))

N, M = input().split()
N = int(N)
M = int(M)
p = []
S = []
for i in range(M):
    a, b = input().split()
    a = int(a)
    p.append(a)
    S.append(b)
right = []
wrong = []
for j in range(N):
    right.append(0)
    wrong.append(0)
for k in range(M):
    if S[k] == 'WA' and right[p[k] - 1] == 0:
        wrong[p[k] - 1] += 1
    else if S[k] == 'AC':
        if right[p[k] - 1] == 0:
            right[p[k] - 1] += 1
print(str(sum(right)) + ' ' + str(sum(wrong)))

x = input()
y = ['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 y[i] == x:
        print(y[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):
print(chr(ord(input())+1)

C=input()
c=ord(C)
d=c+1
D=chr(d)
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):
lt=["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(26):
  if c=lt[i]:
    break
print(lt[i+1])

lt=["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(26):
  if c==lt[i]:
    break
print(lt[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):
#c welcome to atcoder
import sys
n,m=map(int,input().split())
ps=[]
num={}

ac=0
pena=0
if m==0:
    print('0 0')
    sys.exit()
for i in range(m):
    result=input().split()
    ps.append(result)

for x in ps:
    print(x[0])
    if x[0] not in num:
        num[x[0]]=0
    print(num[x[0]])
    if x[1]=="WA" and num[x[0]]==0:
        pena+=1
    if x[1]=="AC" and num[x[0]]==0:
        ac+=1
        num[x[0]]=1

print(num)

print(ac,pena)

#a 
c=input()
ans=ord(c)+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):
num_of_subs, full_score, avg = [ int(i) for i in input().split(" ") ]
prevScores =  0
for i in input().split(" "):
  prevScores += int(i)

last_score = (avg * num_of_subs) - prevScores

if last_score <= 0:
  print(0)
else:
  if last_score >= 100:
    print(-1)
  else:
    print(last_score)

inp = input()

import string
alphabets = list(string.ascii_lowercase)

print(alphabets[alphabets.index(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):
n,k,m=map(int, input().split())
for i in range(n-1):
  a[i]=int(input()) 
  Sum+=a[i]
if (Sum+k)/n<m:
  print(-1)
  break
else:
  print(n＊m-Sum)

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

moji =input()
moji = ord(moji)+1

print(chr(moji))

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

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

c=input()
s='abcdefghijklmnopqrstuvwxyz'
list=list(s)

n=list.index(c)
print(list[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()
al = ['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 = al.find('c')
print(al[i+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):
Alp="abcdefghijklmnopqrstuvwxyz"
Alp[Alp.index(input())+1]

Alp="abcdefghijklmnopqrstuvwxyz"
print(Alp[Alp.index(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):
N, K = map(int, input().split())
A = list(map(int, input().split()))

ans = 0
mod = 10 ** 9 + 7

A.sort()
for i in range(N-K):
    fs = A[i+K] - A[i]
    ans += fs % mod

print(ans % mod)

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
pen = [0] * n
pen_count = 0
for i in range(m):
    p, s = input().split()
    p = int(p) - 1
    if ac[p] == "AC":
        continue
    elif s == "AC":
        ac[p] = "AC"
    else:
        pen[p] += 1
 
for i in range(n):
    if ac[i] == "AC":
        pen_count += pen[i]
 
print(ac.count("AC"), pen_count)

n, m = map(int, input().split()) 
ac = [0] * n
pen = [0] * n
pen_count = 0
for i in range(m):
    p, s = input().split()
    p = int(p) - 1
    if ac[p] == "AC":
        continue
    elif s == "AC":
        ac[p] = "AC"
    else:
        pen[p] += 1

for i in range(n):
    if ac[i] == "AC":
        pen_count += pen[i]

print(ac.count("AC"), pen_count)

n, m = map(int, input().split())
ac = [0] * n
pen = [0] * n
pen_count = 0
for i in range(m):
    p, s = input().split()
    p = int(p) - 1
    if ac[p] == "AC":
        continue
    elif s == "AC":
        ac[p] = "AC"
    else:
        pen[p] += 1

for i in range(n):
    if ac[i] == "AC":
        pen_count += pen[i]

print(ac.count("AC"), pen_count)


c = input()
print(chr(ord(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):
import sys
input = sys.stdin.readline
 
def main():
    N, M = map(int, input().split())
 
    ac_check = [False] * N
    p_counts = [0] * N
 
    for i in range(M):
        p, s = input().strip().split()
        p = int(p) - 1
        if s == "AC":
            if not ac_check[p]:
                ac_check[p] = True
        else:
            if not ac_check[p]:
                p_counts[p] += 1
 
    ac_count = 0
    p_count = 0
    for i in range(N):
        if ac_check[i]:
            ac_count += 1
            p_count += p_counts[i]
    print(ac_count, p_count)
 
 
if __name__ == "__main__":
    main()

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):
N, M = map(int, input().split())
acc = [False] * N
pen = 0
for _ in range(M):
    p, S = input().split()
    p = int(p) - 1
    if S[0] == 'A':
        acc[p] = True
    else:
        if not acc[p]:
            pen += 1
print('{} {}'.format(sum(acc), pen))

import numpy as np

def main():
    C = input()
    print('{}'.format(chr(ord(C) + 1)))


if __name__ == '__main__':
    main()

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

goal = N*M

if K < M or (sum(A)+K) < goal:
    print("-1")
elif 0 <= goal - sum(A) <= K:
    print(goal - sum(A))
elif goal - sum(A) < 0:
    print("0")


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())
p_list = []
S = []
for _ in range(M):
    n, s = input().split()
    p_list.append(int(n))
    S.append(s)

wa = 0
ac = 0
ac_list = []
for i, p in enumerate(p_list):
    if p not in ac_list:
        if S[i] == "WA":
                wa += 1
        else:
                ac += 1
                ac_list.append(p)

print(ac, wa)

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):
C = input()

ary = "abcdefghijklmnopqrstuvwxyz".split("")

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

C = input()
 
ary = "a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z".split(",")
 
print(ary[ary.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, K, M = map(int, input().split())
L = list(map(int, input().split()))
diff = N*M-sum(L)
if diff <= K:
  print(max(0, diff))
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):
N,K,M = map(int,input().split())
a = list(map(int,input().split()))
now = sum(a)
goal = N*M
if now + K >= goal:
  if now >= goal:
    print(0)
  else:
    print(goal-now)
else:
  print(-1)

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

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

from collections import OrderedDict

n = int(input())
dic = OrderedDict()

for i in range(n):
    l,d = list(map(str,input().split()))
    dic[l] = d

a = str(input())

flag = False
time = 0

for key,value in dic.items():
    if flag == False:
        if key == a:
            flag = True
    else:
        time += int(value)

print(time)

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

a = str(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"]

print(alpha[alpha.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):
al = list("abcdefghijklmnopqistuvwxyz")

c = input()

print(al[al.index(c)]

al = list("abcdefghijklmnopqistuvwxyz")

c = input()

print(al[al.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, K, M = map(int, input().split())
List = [int(i) for i in input().split()]

Goal = N * M

sub = Goal - sum(List)
if sub > K:
    print(-1)
else:
    print(sub)


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):
from itertools import combinations as cc

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

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

total=0
mod = 10**9+7
for i in list(cc(a,k)):
	maxx=max(i)%mod
	minx=min(i)%mod
	total=(total%mod+(maxx-minx)%mod)%mod
	
print(total)



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):
a = input()
abc = 'abcdefghijklmnopqrstuvwxyz'

for i in range(26):
    if a = abc[i]:
        print(abc[i+1])
        break

a = input()
abc = 'abcdefghijklmnopqrstuvwxyz'

for i in range(26):
    if a == abc[i]:
        print(abc[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

args = sys.argv

a = "abcdefghijklmnopqrstuvwxyz"

c = args[1]
idx = a.index(c)
print(a[idx + 1])


import sys

args = sys.argv

a = "abcdefghijklmnopqrstuvwxyz"

c = input()
idx = a.index(c)
print(a[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):
N,K,M = input().split()
i = input().split() 
i2 = [int(s) for s in i]
score = sum(i2)
aim = int(N) * int(M)
d = aim - score
K = int(K)
if d > K:
    d = -1
elif 0 >=  d:
    d = 0
print(d)

c = 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"]
l = list.index(c) + 1
c = list[l]
print(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):
N, M = map(int, input().split())

l = [list(input().split()) for _ in range(M)]

answers = {}
wrongs = {}

for a in l:
    if a[1] == "AC":
        answers[a[0]] = a[1]
    elif a[1] == "WA":
        if not a[0] in answers:
            if a[0] in wrongs:
                wrongs[a[0]] = wrongs[a[0]] + 1
            else:
                wrongs[a[0]] = 1



result = [len(answers.keys()), sum(wrongs.values())]

print(result[0], result[1])



C = input()
letters = "abcdefghijklmnopqrstuvwz"
list_letters = list(letters)
print(list_letters[letters.find(C)])


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

total = sum(tests)

for i in range(K):
    if (total + i) / N >= M:
        print(i)
        exit(0)
print(-1)


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

l = [list(input().split()) for _ in range(M)]

answers = {}
wrongs = {}

for a in l:
    if a[1] == "AC":
        answers[a[0]] = a[1]
    elif a[1] == "WA":
        if not a[0] in wrongs:
            wrongs[a[0]] = 1
        elif a[0] in wrongs:
            wrongs[a[0]] = wrongs[a[0]] + 1


wc = 0
for k, v in wrongs.items():
    if k in answers.keys():
        wc += 1
result = [len(answers.keys()), wc]

print(result[0], result[1])



C = input()
letters = "abcdefghijklmnopqrstuvwxyz"
list_letters = list(letters)
print(list_letters[letters.find(C)+1])


Verdicts: Runtime Error

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):
str = input()

print chr(ord(str) + 1)

str = input()

print(chr(ord(str) + 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'

ans = alp[s.find(c)+1]


c = input()
alp = 'abcdefghijklmnopqrstuvwxyz'

ans = alp[s.find(c)+1]
print(ans)


c = input()
alp = 'abcdefghijklmnopqrstuvwxyz'

ans = alp[alp.find(c)+1]
print(ans)


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()
alpha = iter("abcdefghijklmnopqrstuvwxyz")
if C in alpha :
    A = alpha.next()
print(A)

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

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)    

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):
C = input()
print(chr(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, k, m = map(int, input().split())
a = list(map(int, input().split()))
if sum(a) + k < n * m:
  ans = -1
else :
  ans = n * m - sum(a)
  if ans < 0:
    ans = 0
print(ans)

x = input()
ans = ord(x) + 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):
from collections import deque

H,W=[int(i) for i in input().split()]
# c=[[i for i in input().split()] for _ in range(h)]
C=list(input() for _ in range(H))
C=list(list(i) for i in C) 

def bfs(maze,s1,s2,g1,g2):
    for y in range(H):
        for x in range(W):
            if maze[y][x]!='#':
                maze[y][x]=10**9

    maze[s1][s2]=0
    que=deque([[s1,s2]])
    while que:
        y,x=que.popleft()
        for i,j in [(1,0),(0,1),(-1,0),(0,-1)]:
            nexty,nextx=y+i,x+j
            if nexty >= 0 and nexty < H and nextx >= 0 and nextx < W:
                dist=maze[nexty][nextx]
                if dist!='#':
                    if dist>maze[y][x]+1:
                        maze[nexty][nextx]=maze[y][x]+1
                        que.append([nexty,nextx])
    return maze[g1][g2]

ans=0
for s1,c_w in enumerate(C):
    for s2,c in enumerate(c_w):
        if C[s1][s2]!="#":
            for g1,c_w in enumerate(C):
                for g2,c in enumerate(c_w):
                    if C[g1][g2]!="#":
                        temp=bfs(C,s1,s2,g1,g2)
                        ans=max(temp,ans)
print(ans)


z="ABCDEFGHIJKLMNOPQRSTUVWXYZ".lower()
c=input()
print(z[z.find(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())

alp = abcdefghijklmnopqrstuvwxyz

k=0
while k<25:
  if c == alp[k]:
    print(alp[k+1])
  else:
    k+=1
    

c=input()
al='abcdefghijklmnopqrstuvwxyz'
for x in range(26):
    if c==al[x]:
        print(al[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):
in_char = input()

alpha_bete = {"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 cnt, charct in enumerate(alpha_bete):
	if charact == in_char
  		print(alpha_bete[cnt+1])

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

Verdicts: Runtime Error

Accepted