Problem:


Score : 100 points

Problem Statement

An uppercase or lowercase English letter \alpha will be given as input.
If \alpha is uppercase, print A; if it is lowercase, print a.

Constraints

\alpha is an uppercase (A - Z) or lowercase (a - z) English letter.

Input

Input is given from Standard Input in the following format:

α

Output

If \alpha is uppercase, print A; if it is lowercase, print a.

Sample Input 1

B

Sample Output 1

A

B is uppercase, so we should print A.

Sample Input 2

a

Sample Output 2

a

a is lowercase, so we should print a.



Sample input:
B


Sample output:
A

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import sys
import math
from bisect import bisect_left
from bisect import bisect_right
from collections import defaultdict
from heapq import heappop, heappush
import itertools
from decimal import *

input = sys.stdin.readline

def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))
def inputStr(): return input()[:-1]

inf = float('inf')
mod = 1000000007

#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-

def main():
	A = inputStr()

	if A.isupper():
		print("A")
	else:
		print("a")



#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
if __name__ == "__main__":
	main()

Submission status: Accepted

Solution code:
char = input()
big = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
small = 'abcdefghijklmnopqrstuvwxyz'

if char in big:
    print('A')
else:
    print('a')

Submission status: Accepted

Solution code:
def solve(s):
    if s.upper() == s:
        return "A"
    else:
        return "a"


def main():
    s = input()
    res = solve(s)
    print(res)


def test():
    assert solve("B") == "A"
    assert solve("a") == "a"


if __name__ == "__main__":
    test()
    main()

Submission status: Accepted

Solution code:
a=input()
print("A"if a.isupper() else "a")

Submission status: Accepted

Solution code:
N = str(input())
if N==N.upper():
    print('A')
else:
    print('a')

Submission status: Accepted

Solution code:
s = input()
if 'A' <= s[0] and s[0] <= 'Z':
    print('A')
else:
    print('a')

Submission status: Accepted

Solution code:
def main():
    x = input().strip('\n')
    if 'A' <= x <= 'Z':
        print('A')
    else:
        print('a')


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
c = input()
if c.islower():
  print("a")
else:
  print("A")

Submission status: Accepted

Solution code:
def main():
    S = input()

    return 'A' if S.isupper() else 'a'

print(main())
#print('Yes' if main() else 'No')
#print('YES' if main() else 'NO')

Submission status: Accepted

Solution code:
x = input()
if x.isupper():
  print('A')
else:
  print('a')

Submission status: Accepted

Solution code:
S = input()

if str.isupper(S):
    print('A')
else:
    print('a')

Submission status: Accepted

Solution code:
a = input()
print('a' if a.lower()==a else 'A')

Submission status: Accepted

Solution code:
import sys
import math
import heapq
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
DVSR = 1000000007
def POW(x, y): return pow(x, y, DVSR)
def INV(x, m=DVSR): return pow(x, m - 2, m)
def DIV(x, y, m=DVSR): return (x * INV(y, m)) % m
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def FLIST(n):
    res = [1]
    for i in range(1, n+1): res.append(res[i-1]*i%DVSR)
    return res

C=input()

if C <= 'Z':
    print('A')
else:
    print('a')

Submission status: Accepted

Solution code:
a=input()
if a.isupper()==True:
    print('A')
else:
    print('a')

Submission status: Accepted

Solution code:
s=input()
if s.islower():
  print('a')
else:
  print("A")

Submission status: Accepted

Solution code:
import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np

rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.buffer.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.buffer.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7

s = rr()
if s in 'ABCDEFGHIJKLMOPQRSTUVWXYZ':
  print('A')
else:
  print('a')

Submission status: Accepted

Solution code:
n = ord(input())

if n >=97:
    print('a')
else:
    print('A')

Submission status: Accepted

Solution code:
C = input()
print('A' if 'A'<= C and C <= 'Z' else 'a')

Submission status: Accepted

Solution code:
a=str(input())
A=list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
if a in A:
  print("A")
else:
  print("a")

Submission status: Accepted

Solution code:
s=input()
if ord(s)>=65 and ord(s)<=90:
    print("A")
else:
    print("a")

Submission status: Accepted

Solution code:
a=str(input())
if str.isupper(a):
    print('A')
else:
    print('a')

Submission status: Accepted

Solution code:
a = input()
print("A" if a.upper()==a else "a")

Submission status: Accepted

Solution code:
S = input()
a = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
print("A" if S in a else "a")

Submission status: Accepted

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

def main():
    s = input()

    if s.isupper():
        print('A')
    else:
        print('a')


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**6)

s = input()
#b = list(map(int, input().split()))
#n, m = map(int, input().split())
#s = input()
#s,t = input().split()
#a = [int(input()) for _ in range(n)]
#
#readline = sys.stdin.readline
#n,m = [int(i) for i in readline().split()]
#ab = [[int(i) for i in readline().split()] for _ in range(n)]

s_low = s.lower()

if s == s_low:
    print('a')
else:
    print('A')

Submission status: Accepted

Solution code:
s=input()
A=[chr(i) for i in range(65,65+26)]
a=[chr(i) for i in range(97,97+26)]
if s in A:
    print("A")
else:
    print("a")

Submission status: Accepted

Solution code:
k = "abcdefghijklmnopqrstuvwxyz"
o = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

if input() in o:
    print("A")
else:
    print("a")

Submission status: Accepted

Solution code:
a=str(input())
if a.isupper():
    print("A")
else:
    print("a")

Submission status: Accepted

Solution code:
S = input()
if 97 <= ord(S) <= 122:
    print("a")
else:
    print("A")

Submission status: Accepted

Solution code:
a = input()

if 97<=ord(a)<=97+26:
    print("a")
else:
    print("A")

Submission status: Accepted

Solution code:
#float型を許すな
#numpyはpythonで
#dp
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil,pi,factorial
from operator import itemgetter
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def SI(): return input().rstrip()
def printns(x): print('\n'.join(x))
def printni(x): print('\n'.join(list(map(str,x))))
inf = 10**17
mod = 10**9 + 7

alphasm=[chr(i) for i in range(97, 97+26)]
a=input().rstrip()
if a in alphasm:
    print("a")
else:
    print("A")

Submission status: Accepted

Solution code:
def main():
    DAI="QWERTYUIOPLKJHGFDSAZXCVBNM"
    a=input()
    if a in DAI:
        print("A")
    else:
        print("a")
if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
import sys
import math
import numpy as np
import functools
import operator
import collections
import itertools

S=input()
if "a"<=S<="z":
    print("a")
else:
    print("A")

Submission status: Accepted

Solution code:
st=input()
if st.isupper():
  print('A')
else:
  print('a')

Submission status: Accepted

Solution code:
s=input()
if ord(s)<=ord("Z"):
    print("A")
else:
    print("a")

Submission status: Accepted

Solution code:
S = str(input())
if S.islower() == True:
    print("a")
else:
    print("A")

Submission status: Accepted

Solution code:
a=input()
if ord(a)>=97:
    print('a')
else:
    print('A')

Submission status: Accepted

Solution code:
import sys
## io ##
def IS(): return sys.stdin.readline().rstrip()
def II(): return int(IS())
def MII(): return list(map(int, IS().split()))
def MIIZ(): return list(map(lambda x: x-1, MII()))
#======================================================#
def main():
    a = IS()
    if a.islower():
        print('a')
    else:
        print('A')

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline

if __name__ == '__main__':
  s=input().strip("\n")
  print('A' if s.isupper() else 'a')

Submission status: Accepted

Solution code:
a = input()
print('a' if ord(a) >= ord('a') else 'A')

Submission status: Accepted

Solution code:
s = input()
if s.islower():
    print('a')
else:
    print('A')

Submission status: Accepted

Solution code:
def check():
    S = input()
    if S==S.lower():
        return 'a'
    return 'A'
print(check())

Submission status: Accepted

Solution code:
A = input()

if A.upper() == A:
  print('A')
else:
  print('a')

Submission status: Accepted

Solution code:
a=input()
a_low=a.lower()
a_up=a.upper()
if a==a_low:
  print('a')
else:
  print('A')

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**6)


def main(input, print):
    a = input()
    if a.isupper():
        print('A')
    else:
        print('a')


if __name__ == '__main__':
    main(sys.stdin.readline, print)

Submission status: Accepted

Solution code:
x = input()
if x > 'Z':
  print('a')
else:
  print('A')

Submission status: Accepted

Solution code:
def main():
    x = input()
    if ord("a") <= ord(x) <= ord("z"):
        print("a")
    else:
        print("A")
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import bisect
import collections
import sys

sys.setrecursionlimit(1000000)
ACMOD = 1000000007
INF = 1 << 62




if __name__ == '__main__':
    a = input()
    if a.islower():
        print("a")
    else:
        print("A")

Submission status: Accepted

Solution code:
input = raw_input
a = input()

if a == a.lower():
    print("a")
else:
    print("A")

Submission status: Accepted

Solution code:
al = input()
if al in "ABCDEFGHIJKLMNOPQRSTUVWXYZ":
    print("A")
else:
    print('a')

Submission status: Accepted

Solution code:
#: Author - Soumya Saurav
import sys,io,os,time
from collections import defaultdict
from collections import OrderedDict
from collections import deque
from itertools import combinations
from itertools import permutations
import bisect,math,heapq
alphabet = "abcdefghijklmnopqrstuvwxyz"

#input = sys.stdin.readline

########################################
c = input()
if ord(c) >= 97:
	print("a")
else:
	print("A")

Submission status: Accepted

Solution code:
s = input()
if ord(s) >= ord('A') and ord(s) <= ord('Z'):
    print('A')
else:
    print('a')

Submission status: Accepted

Solution code:
import sys
import math
def II():
	return int(sys.stdin.readline())

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

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

def SI():
	return sys.stdin.readline().strip()
s = SI()
if s.islower():
	print("a")
else:
	print("A")

Submission status: Accepted

Solution code:
c = input()
print('A' if ord(c)<96 else 'a')

Submission status: Accepted

Solution code:
S = input()
if S.isupper():
  print("A")
else:
  print('a')

Submission status: Accepted

Solution code:
s = input()
if s == s.lower():
  print('a')
else:
  print('A')

Submission status: Accepted

Solution code:
def main():
    a = input()
    if a.lower() == a:
        print('a')
    else:
        print('A')

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
a=input()
if a==a.upper():
    print('A')
else:
    print('a')

Submission status: Accepted

Solution code:
from string import ascii_lowercase
a = input()
if a in ascii_lowercase:
    print('a')
else:
    print('A')

Submission status: Accepted

Solution code:
c = input()
if c.isupper():
    print("A")
else:
    print("a")

Submission status: Accepted

Solution code:
a = input()
if(str.isupper(a)):
  print('A')
else:
  print('a')

Submission status: Accepted

Solution code:
from string import ascii_letters, ascii_lowercase, ascii_uppercase

ch = input().rstrip()

if ch in ascii_uppercase:
    print('A')
else:
    print('a')

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline

def main():
    n = input().strip()
    if n.islower():
        print('a')
    else:
        print('A')

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
a = input()

if 'A' <= a <= 'Z':
    print('A')
else:
    print('a')

Submission status: Accepted

Solution code:
def main():
    a = input()

    if a.isupper():
        print('A')
    else:
        print('a')

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
def main():
    import sys
    input = sys.stdin.readline
    s = input().strip()
    if ord(s) < 97:
        print('A')
    else:
        print('a')

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
s = input()
if "a" <= s and s <= "z":
    print("a")
else:
    print("A")

Submission status: Accepted

Solution code:
a = input('')

if a.isupper():
    print('A')
else:
    print('a')

Submission status: Accepted

Solution code:

if __name__ == '__main__':
    a = input()
    if a.islower():
        print('a')
    else:
        print('A')

Submission status: Accepted

Solution code:
s = input()

if str.isupper(s):
    print("A")
else:
    print("a")

Submission status: Accepted

Solution code:
N = input()
if N.islower():
  print("a")
else:
  print("A")

Submission status: Accepted

Solution code:
a=input()
if a.lower()==a:
    print("a")
else:
    print("A")

Submission status: Accepted

Solution code:
s = str(input())

if s.isupper():
  print("A")
else:
  print("a")

Submission status: Accepted

Solution code:
A = input()

if A == A.upper():
    print('A')
else:
    print('a')

Submission status: Accepted

Solution code:
import sys
import math
import itertools
n=input()
#a=list(map(int,input().split()))
if(n==n.lower()):
    print('a')
else:
    print('A')

Submission status: Accepted

Solution code:
s = str(input())
if ord("a") <= ord(s) <= ord("z"):
  print("a")
else:
  print("A")

Submission status: Accepted

Solution code:
x=input()
if(x.isupper()):
    print("A")
else:
    print("a")

Submission status: Accepted

Solution code:

import heapq
from collections import defaultdict, deque
from math import ceil, factorial, gcd
from itertools import accumulate, permutations
import sys
sys.setrecursionlimit(10 ** 7)
import bisect
# ----------

INF = float("inf")
MOD = 10 ** 9 + 7
# ----------

import string

a = input().strip()

if a in string.ascii_uppercase:
    print('A')
else:
    print('a')

Submission status: Accepted

Solution code:
import sys

stdin = sys.stdin


def ni(): return int(ns())


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


def naa(N): return [na() for _ in range(N)]


def ns(): return stdin.readline().rstrip()  # ignore trailing spaces


a = ns()

if a >= "A" and a <= "Z":
    print("A")
else:
    print("a")

Submission status: Accepted

Solution code:
import sys

readline = sys.stdin.readline
readall = sys.stdin.read
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
prl = lambda x: print(*x ,sep='\n')


a = ns()
b = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
if a in b:
    print('A')
else:
    print('a')

Submission status: Accepted

Solution code:
a = input()

if 'A' <= a <= 'Z':
    print('A')
else:
    print('a')

Submission status: Accepted

Solution code:
import sys
import collections
INF = 10**18
ans = 0
import math

if __name__ == "__main__":
    a = input()
    if a.islower():
        print("a")
    else:
        print("A")

Submission status: Accepted

Solution code:
def main():
    s = input()
    S = s.upper()
    if s == S:
        print("A")
    else:
        print("a")    
    
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
s = input()
if 65<=ord(s)<=90:
  print('A')
else:
  print('a')

Submission status: Accepted

Solution code:
a = input()

print('Aa'[a == a.lower()])

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
alpha = input()

if alpha.islower():
    print("a")
else:
    print("A")

Submission status: Accepted

Solution code:
def main():
    #n = int(input())
    #n=map(int, input().split())
    s = input()
    if(s>"Z"):
        res = "a"
    else:
        res = "A"
    print(res)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
s=input()
if s.lower()==s:
  print('a')
else:
  print('A')

Submission status: Accepted

Solution code:
s = input()
if s.upper() == s:
    print('A')
else:
    print('a')

Submission status: Accepted

Solution code:
from math import *

a=input()
if ord(a)<97:
	print("A")
else:
	print("a")

Submission status: Accepted

Solution code:
a=input()
if ord('a')<=ord(a)<=ord('z'):
    print('a')
else:
    print('A')

Submission status: Accepted

Solution code:
a = input()
alphabet = [chr(i) for i in range(97, 97+26)]
if a in alphabet:
    print('a')
else:
    print('A')

Submission status: Accepted

Solution code:
a = input()

if str.isupper(a) == True:
    print("A")
else:
    print("a")

Submission status: Accepted

Solution code:
def solve():
    a = input()
    if a.isupper():
        print("A")
    else:
        print("a")
    return 0

if __name__ == "__main__":
    solve()

Submission status: Accepted

Solution code:
alp="abcdefghijklmnopqrstuvwxyz"
if input() in alp:
    print("a")
else:
    print("A")

Submission status: Accepted

Solution code:
#coding: utf-8
alp = [chr(i) for i in range(97, 97+26)]
a = input()
if a in alp:
    print('a')
else:
    print('A')

Submission status: Accepted

Solution code:
s = input().strip()

if s.lower()==s:
    print("a")
else:
    print("A")

Submission status: Accepted

Solution code:
a = str(input())

if a.upper() == a:
    res = "A"
else:
    res = "a"

print(res)

Submission status: Accepted

Solution code:
n = input()
if n.isupper():
  print("A")
else:
  print("a")

Submission status: Accepted

Solution code:
#

import sys
input=sys.stdin.readline

def main():
    c=input()
    if c.isupper():
        print("A")
    else:
        print("a")
    
    
    
if __name__=="__main__":
    main()

Submission status: Accepted

Solution code:
def main():
    a = input()
    if a.isupper():
        print('A')
    else:
        print('a')

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
if __name__ == '__main__':
    letter = input()
    if letter.isupper():
        print('A')
    else:
        print('a')

Submission status: Accepted

Solution code:
c = input()

if ord('a') <= ord(c) <= ord('z'):
    print('a')
else:
    print('A')

Submission status: Accepted

Solution code:
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do(): 
    a=STR()
    if a==a.upper():
        print('A')
    else:
        print('a')
if __name__ == '__main__':
    do()

Submission status: Accepted

Solution code:
alpha = input().strip()

if alpha.islower():
  print("a")
else:
  print("A")

Submission status: Accepted

Solution code:
s = input()
if(s.upper() == s):
  print('A')
else:
  print('a')

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!
N = input()
#A, B = map(int, input().split())
#List = list(map(int, input().split()))

if N.islower():
    print("a")
else:
    print("A")

Submission status: Accepted

Solution code:
a = input()
if a.islower():
  print("a")
else:
  print("A")

Submission status: Accepted

Solution code:
l = 'ABDEFGHIJKLMNOPQRSTUVWXYZ'
if input() in l:
    print('A')
else:
    print('a')

Submission status: Accepted

Solution code:
a= input()

if a in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ':
    print('A')
else:
    print('a')

Submission status: Accepted

Solution code:
S = input()

Alp = [chr(i) for i in range(97, 97+26)]
print("a" if S in Alp else "A")

Submission status: Accepted

Solution code:
import sys
from collections import defaultdict, Counter, namedtuple, deque
import itertools
import functools
import bisect
import heapq
import math
# from fractions import gcd

MOD = 10 ** 9 + 7
# MOD = 998244353
# sys.setrecursionlimit(10**8)

s = input()
sl = s.lower()
if s == sl:
    print("a")
else:
    print("A")

Submission status: Accepted

Solution code:
def main():
    a = input()
    if a.isupper():
        print('A')
    else:
        print('a')



if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
def main():
    s = input()
    if s.islower():
        print('a')
    else:
        print('A')


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
import itertools
from collections import deque,defaultdict,Counter
from itertools import accumulate
import bisect
from heapq import heappop,heappush,heapify
import math
from copy import deepcopy
import queue
#import numpy as np
# sympy as syp(素因数分解とか)
Mod = 1000000007
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1] 
for i in range(2, 10**5 + 1):
    fact.append((fact[-1] * i) % Mod)
    inv.append((-inv[Mod % i] * (Mod // i)) % Mod)
    factinv.append((factinv[-1] * inv[-1]) % Mod)
    
def cmb(n, r, p):
    if (r < 0) or (n < r):
        return 0
    r = min(r, n - r)
    return fact[n] * factinv[r] * factinv[n - r] % p
    
def sieve_of_eratosthenes(n):
    if not isinstance(n,int):
        raise TypeError("n is not int")
    if n<2:
        raise ValueError("n is not effective")
    prime = [1]*(n+1)
    for i in range(2,int(math.sqrt(n))+1):
        if prime[i] == 1:
            for j in range(2*i,n+1):
                if j%i == 0:
                    prime[j] = 0
    res = []
    for i in range(2,n+1):
        if prime[i] == 1:
            res.append(i)
    return res

 
class UnionFind:
    def __init__(self,n):
        self.parent = [i for i in range(n+1)]
        self.rank = [0 for i in range(n+1)]
    
    def findroot(self,x):
        if x == self.parent[x]:
            return x
        else:
            y = self.parent[x]
            y = self.findroot(self.parent[x])
            return y
    
    def union(self,x,y):
        px = self.findroot(x)
        py = self.findroot(y)
        if px < py:
            self.parent[y] = px
        else:
            self.parent[px] = py
 
    def same_group_or_no(self,x,y):
        return self.findroot(x) == self.findroot(y)

def main():  #startline-------------------------------------------
    s = input()
    print("A" if s.lower() != s else "a")
if __name__ == "__main__":
    main() #endline===============================================

Submission status: Accepted

Solution code:

import sys
import math
import itertools
import collections

a = input()
if a.upper() == a:
    print("A")
else:
    print("a")

Submission status: Accepted

Solution code:
a=input()
print("a" if a==a.lower() else "A")

Submission status: Accepted

Solution code:
import sys
import heapq
import re
from itertools import permutations
from bisect import bisect_left, bisect_right
from collections import Counter, deque
from math import factorial, sqrt, ceil, gcd
from functools import lru_cache, reduce
from decimal import Decimal
INF = 1 << 60
MOD = 1000000007
sys.setrecursionlimit(10 ** 7)

# UnionFind
class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

# ダイクストラ
def dijkstra_heap(s, edge, n):
    #始点sから各頂点への最短距離
    d = [10**20] * n
    used = [True] * n #True:未確定
    d[s] = 0
    used[s] = False
    edgelist = []
    for a,b in edge[s]:
        heapq.heappush(edgelist,a*(10**6)+b)
    while len(edgelist):
        minedge = heapq.heappop(edgelist)
        #まだ使われてない頂点の中から最小の距離のものを探す
        if not used[minedge%(10**6)]:
            continue
        v = minedge%(10**6)
        d[v] = minedge//(10**6)
        used[v] = False
        for e in edge[v]:
            if used[e[1]]:
                heapq.heappush(edgelist,(e[0]+d[v])*(10**6)+e[1])
    return d

# 素因数分解
def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr

# 2数の最小公倍数
def lcm(x, y):
    return (x * y) // gcd(x, y)

# リストの要素の最小公倍数
def lcm_list(numbers):
    return reduce(lcm, numbers, 1)

# リストの要素の最大公約数
def gcd_list(numbers):
    return reduce(gcd, numbers)

# 素数判定
def is_prime(n):
    if n <= 1:
        return False
    p = 2
    while True:
        if p ** 2 > n:
            break
        if n % p == 0:
            return False
        p += 1
    return True


# limit以下の素数を列挙
def eratosthenes(limit):
    A = [i for i in range(2, limit+1)]
    P = []

    while True:
        prime = min(A)
        
        if prime > sqrt(limit):
            break
            
        P.append(prime)
            
        i = 0
        while i < len(A):
            if A[i] % prime == 0:
                A.pop(i)
                continue
            i += 1
            
    for a in A:
        P.append(a)
            
    return P

# 同じものを含む順列
def permutation_with_duplicates(L):

    if L == []:
        return [[]]

    else:
        ret = []

        # set（集合）型で重複を削除、ソート
        S = sorted(set(L))

        for i in S:

            data = L[:]
            data.remove(i)

            for j in permutation_with_duplicates(data):
                ret.append([i] + j)

        return ret


# ここから書き始める
a = input()
if a in "abcdefghijklmnopqrstuvwxyz":
    print("a")
else:
    print("A")

Submission status: Accepted

Solution code:
a=input()
alp='abcdefghijklmnopqrstuvwxyz'
alps=set()
for i in alp:
  alps.add(i)
  
if a in alps:
  print('a')
else:
  print('A')

Submission status: Accepted

Solution code:
alp = input()
if alp.upper() == alp:
    print('A')
else:
    print('a')

Submission status: Accepted

Solution code:
cap = input()

if cap == str.upper(cap):
    print("A")
else:
    print("a")

Submission status: Accepted

Solution code:
import os
import sys
from io import BytesIO, IOBase
# region fastio

BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

# ------------------------------

from math import factorial
from collections import Counter, defaultdict, deque
from heapq import heapify, heappop, heappush

def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
def comb(n, m): return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0
def perm(n, m): return factorial(n) // (factorial(n - m)) if n >= m else 0
def mdis(x1, y1, x2, y2): return abs(x1 - x2) + abs(y1 - y2)
mod = 998244353
INF = float('inf')

# ------------------------------
# f = open('../input.txt')
# sys.stdin = f

def main():
    c = input()
    if c.isupper():
        print('A')
    else:
        print('a')


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
import sys

sys.setrecursionlimit(10**6)
input = sys.stdin.readline
#read = sys.stdin.buffer.read

sletter = ['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']
bletter = ['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']

def main():
    s = input()[:-1]
    if s in sletter:
        print('a')
    else:
        print('A')


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
s = input().strip()
print("a" if s == s.lower() else "A")

Submission status: Accepted

Solution code:
import sys
def rs(): return sys.stdin.readline().rstrip()
def ri(): return int(rs())
def rs_(): return [_ for _ in rs().split()]
def ri_(): return [int(_) for _ in rs().split()]

a = rs()
if a in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ':
    print('A')
else:
    print('a')

Submission status: Accepted

Solution code:
a=input()
if a==a.lower():
    print("a")
else:
    print("A")

Submission status: Accepted

Solution code:
S = input()
if S in 'abcdefghijklmnopqrstuvwxyz':
    print('a')
else:
    print('A')