output_description stringlengths 15 956 | submission_id stringlengths 10 10 | status stringclasses 3 values | problem_id stringlengths 6 6 | input_description stringlengths 9 2.55k | attempt stringlengths 1 13.7k | problem_description stringlengths 7 5.24k | samples stringlengths 2 2.72k |
|---|---|---|---|---|---|---|---|
Print the answer.
* * * | s228595256 | Accepted | p03814 | The input is given from Standard Input in the following format:
s | X = str(input())
A_list = []
Z_list = []
for i in range(len(X)):
if X[i] == "A":
A_list.append(i)
if X[i] == "Z":
Z_list.append(i)
print(int(Z_list[-1] - A_list[0] + 1))
| Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s132413022 | Runtime Error | p03814 | The input is given from Standard Input in the following format:
s | #!usr/bin/env python3
from collections import defaultdict
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = SR()
return l
mod = 1000000007
#A
"""
x = I()
if x < 1200:
print("ABC")
else:
print("ARC")
"""
#B
s = input()
n = len(s)
for i in range(n):
if s[i] == "A":
for j in range(i+1,n):
s[j] == "Z":
print(j-i+1)
quit()
#C
"""
x = I()
ans = 2*(x//11)+1
x %= 11
if x == 0:
ans -= 1
if x > 6:
ans += 1
print(ans)
"""
#D
"""
n = I()
a = LI()
d = defaultdict(int)
for i in a:
d[i] += 1
l = list(d.values())
k = len(l)+sum(l)
for i in d.keys():
d[i] = 1
ans = sum(list(d.values()))
ans -= 1 if k%2 else 0
print(ans)
"""
#E
#F
#G
#H
#I
#J
#K
#L
#M
#N
#O
#P
#Q
#R
#S
#T
| Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s262259543 | Runtime Error | p03814 | The input is given from Standard Input in the following format:
s | #!usr/bin/env python3
from collections import defaultdict
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = SR()
return l
mod = 1000000007
#A
"""
x = I()
if x < 1200:
print("ABC")
else:
print("ARC")
"""
#B
s = S()
n = len(s)
for i in range(n):
if s[i] == "A":
for j in range(i+1,n):
s[j] == "Z":
print(j-i+1)
quit()
#C
"""
x = I()
ans = 2*(x//11)+1
x %= 11
if x == 0:
ans -= 1
if x > 6:
ans += 1
print(ans)
"""
#D
"""
n = I()
a = LI()
d = defaultdict(int)
for i in a:
d[i] += 1
l = list(d.values())
k = len(l)+sum(l)
for i in d.keys():
d[i] = 1
ans = sum(list(d.values()))
ans -= 1 if k%2 else 0
print(ans)
"""
#E
#F
#G
#H
#I
#J
#K
#L
#M
#N
#O
#P
#Q
#R
#S
#T
| Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s142727154 | Wrong Answer | p03814 | The input is given from Standard Input in the following format:
s | import sys
from collections import defaultdict
operaciones = list()
p = 0
y = 0
lines = sys.stdin.readlines()
for linea in lines:
c = linea.split()
c = list(map(str, c))
list(c)
x = c[0]
a = list(x)
if "A" in a:
l = a.index("A")
aux = defaultdict(list)
for index, item in enumerate(a):
aux[item].append(index)
result = {item: indexs for item, indexs in aux.items() if len(indexs) > 0}
for llave, valor in result.items():
if llave == "A":
d = valor
elif llave == "Z":
pp = valor
minimo = min(d)
min1 = min(pp)
for k in range(len(pp) - 1):
if pp[k + 1] - pp[k] == 1:
y += 1
x = pp[k + 1]
if y > 0:
GH = a[minimo : x + y]
v = len(GH)
print(v)
sys.exit()
if min1 < minimo:
for l in range(len(pp) - 1):
if pp[l + 1] - pp[l] == 1:
y += 1
x = pp[l + 1]
if y > 0:
GH = a[minimo : x + y]
sys.exit()
if min1 < minimo:
maximo = max(pp)
gh = a[minimo : maximo + 1]
print(len(gh))
sys.exit()
gh = a[minimo : min1 + 1]
print(len(gh))
| Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s473550415 | Runtime Error | p03814 | The input is given from Standard Input in the following format:
s | #!/usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
def LI():
return list(map(int, stdin.readline().split()))
def LF():
return list(map(float, stdin.readline().split()))
def LI_():
return list(map(lambda x: int(x) - 1, stdin.readline().split()))
def II():
return int(stdin.readline())
def IF():
return float(stdin.readline())
def LS():
return list(map(list, stdin.readline().split()))
def S():
return list(stdin.readline().rstrip())
def IR(n):
return [II() for _ in range(n)]
def LIR(n):
return [LI() for _ in range(n)]
def FR(n):
return [IF() for _ in range(n)]
def LFR(n):
return [LI() for _ in range(n)]
def LIR_(n):
return [LI_() for _ in range(n)]
def SR(n):
return [S() for _ in range(n)]
def LSR(n):
return [LS() for _ in range(n)]
mod = 1000000007
inf = float("INF")
# A
def A():
x = II()
if x < 1200:
print("ABC")
else:
print("ARC")
return
# B
def B():
s = S()
a = inf
z = 0
for num, si in enumerate(s):
if si == "A":
a = min(a, num)
if si == "Z":
z = max(z, si)
print(z - a + 1)
return
# C
def C():
return
# D
def D():
return
# Solve
if __name__ == "__main__":
B()
| Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s959607524 | Accepted | p03814 | The input is given from Standard Input in the following format:
s | x = input()
print(x.rfind("Z") - x.find("A") + 1)
| Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s602444317 | Wrong Answer | p03814 | The input is given from Standard Input in the following format:
s | import math
import sys
def getinputdata():
# 配列初期化
array_result = []
data = input()
array_result.append(data.split(" "))
flg = 1
try:
while flg:
data = input()
array_temp = []
if data != "":
array_result.append(data.split(" "))
flg = 1
else:
flg = 0
finally:
return array_result
arr_data = getinputdata()
s = arr_data[0][0]
# print(s)
aposi = 0
zposi = 0
aflg = False
zflg = False
cnt = 0
for v in range(0, len(s)):
# print(s[v],aflg)
if s[v] == "A" and aflg and zflg:
# print(aposi,zposi,cnt)
if cnt < zposi - aposi:
cnt = zposi - aposi + 1
aflg = False
zflg = False
if s[v] == "A" and aflg == False:
# print(v)
aposi = v
aflg = True
if s[v] == "Z" and aflg == True:
zposi = v
zflg = True
# print(v)
if aflg and zflg:
# print(aposi,zposi)
if cnt < zposi - aposi:
cnt = zposi - aposi + 1
print(cnt)
else:
print(cnt)
| Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s445504630 | Accepted | p03814 | The input is given from Standard Input in the following format:
s | S = input()
resA = 0
resZ = 0
for i in range(1, len(S) + 1):
if S[i - 1] == "A" and resA == 0:
resA = i
elif S[i - 1] == "Z":
resZ = i
if resA != 0 and resZ != 0:
print(resZ - resA + 1)
else:
print(0)
| Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s347733358 | Runtime Error | p03814 | The input is given from Standard Input in the following format:
s |
s=input()
ds=list(s)
c1=0
while ds[c1]!='A'
c1+=1
c2=-1
while ds[c2]!='Z':
c2-=1
print(s[c1:c2])
| Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s547509379 | Runtime Error | p03814 | The input is given from Standard Input in the following format:
s | import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
s = input()
state = False
chk2 = False
chk = 0
for i in range(len(s)):
if state == False and s[i] == "A":
state = True
chk += 1
elif state == True and s[i] == "Z":
chk += 1
if ans < chk:
ans = chk
chk2 = True
chk = 0
state = False
elif state == False and s[i] == "Z" and chk2 = True:
ans += 1
elif state == False ans chk2 = True:
chk2 = False
elif state == True:
chk += 1
print(ans) | Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s012089779 | Accepted | p03814 | The input is given from Standard Input in the following format:
s | z = input()
print(z.rfind("Z") - z.find("A") + 1)
| Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s320512392 | Runtime Error | p03814 | The input is given from Standard Input in the following format:
s | ZABCZ
| Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s976011270 | Accepted | p03814 | The input is given from Standard Input in the following format:
s | 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()))
## dp ##
def DD2(d1, d2, init=0):
return [[init] * d2 for _ in range(d1)]
def DD3(d1, d2, d3, init=0):
return [DD2(d2, d3, init) for _ in range(d1)]
## math ##
def to_bin(x: int) -> str:
return format(x, "b") # rev => int(res, 2)
def to_oct(x: int) -> str:
return format(x, "o") # rev => int(res, 8)
def to_hex(x: int) -> str:
return format(x, "x") # rev => int(res, 16)
MOD = 10**9 + 7
def divc(x, y) -> int:
return -(-x // y)
def divf(x, y) -> int:
return x // y
def gcd(x, y):
while y:
x, y = y, x % y
return x
def lcm(x, y):
return x * y // gcd(x, y)
def enumerate_divs(n):
"""Return a tuple list of divisor of n"""
return [(i, n // i) for i in range(1, int(n**0.5) + 1) if n % i == 0]
def get_primes(MAX_NUM=10**3):
"""Return a list of prime numbers n or less"""
is_prime = [True] * (MAX_NUM + 1)
is_prime[0] = is_prime[1] = False
for i in range(2, int(MAX_NUM**0.5) + 1):
if not is_prime[i]:
continue
for j in range(i * 2, MAX_NUM + 1, i):
is_prime[j] = False
return [i for i in range(MAX_NUM + 1) if is_prime[i]]
## libs ##
from itertools import accumulate as acc
from collections import deque, Counter
from heapq import heapify, heappop, heappush
from bisect import bisect_left
# ======================================================#
def main():
s = IS()
n = len(s)
l = r = 0
for i, si in enumerate(s):
if si == "A":
l = i
break
for i, si in enumerate(s[::-1]):
if si == "Z":
r = n - i
break
print(r - l)
if __name__ == "__main__":
main()
| Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s870491947 | Runtime Error | p03814 | The input is given from Standard Input in the following format:
s | -*- coding: utf-8 -*-
import sys
import subprocess
import json
import time
import math
import re
import sqlite3
s = input()
print(s.rfind('Z') - s.find('A') + 1) | Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s893796932 | Accepted | p03814 | The input is given from Standard Input in the following format:
s | print(
len(input().lstrip("BCDEFGHIJKLMNOPQRSTUVWXYZ").rstrip("ABCDEFGHIJKLMNOPQRSTUVWXY"))
)
| Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s649883359 | Accepted | p03814 | The input is given from Standard Input in the following format:
s | hoge = input()
hoge_r = hoge[::-1]
print(len(hoge) - hoge.index("A") - hoge_r.index("Z"))
| Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s017380881 | Runtime Error | p03814 | The input is given from Standard Input in the following format:
s | import re
print(max(map(len, re.findall("A.*Z",input()))) | Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s555654312 | Accepted | p03814 | The input is given from Standard Input in the following format:
s | S = str(input())
Z = S.rfind("Z")
A = S.find("A")
print(str(Z - A + 1))
| Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s845208372 | Accepted | p03814 | The input is given from Standard Input in the following format:
s | print((lambda s: s.rfind("Z") - s.find("A") + 1)(input()))
| Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s110481157 | Wrong Answer | p03814 | The input is given from Standard Input in the following format:
s | N = input()
print(-N.find("A", 1) + N.rfind("Z", 1) + 1)
| Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s916646570 | Runtime Error | p03814 | The input is given from Standard Input in the following format:
s | s = str(input())
a = 0
z = 0
for i in range(len(s)):
if s[i] = "A":
a = min(a,i)
elif s[i] = "Z":
z = max(z,i)
print(z - a + 1) | Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s325336734 | Runtime Error | p03814 | The input is given from Standard Input in the following format:
s | s = str(input())
l = []
for i in range(len(s)):
for j in range(len(s)-1,0,-1):
if s[i] == "A":
if s[j] == "Z":
l.append((j+1-i)
break
print(max(l)) | Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s198192663 | Runtime Error | p03814 | The input is given from Standard Input in the following format:
s | s = str(input())
for i in range(len(s)):
if s[i] == 'A':
a = i
break
for i in reversed(range(len(s))):
if s[i] == 'Z':
z = i
break
print(z - a + 1) | Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s113517212 | Runtime Error | p03814 | The input is given from Standard Input in the following format:
s | s =input()
A=0
Z=0
for i in range(len(s)):
s[i] =="A":
A +=i+1
break
for j in range(len(s)):
s[-(j+1)] =="Z":
Z +=len(s)-j
break
print(Z-A+1)
| Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s696012413 | Runtime Error | p03814 | The input is given from Standard Input in the following format:
s | s=list(input())
x=0
y=0
while x=0:
if s[0]!="A":
del s[0]
else:
x=1
while y=0:
if s[-1]!="Z":
del s[-1]
else:
y=1
print(len(s))
| Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s458798222 | Runtime Error | p03814 | The input is given from Standard Input in the following format:
s | S = input()
s=0
for i in range(len(S)):
c = S[i]
s = i if c =="A" && s <> 0
if c =="Z":
print(S[s:i+1])
break | Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s676457484 | Runtime Error | p03814 | The input is given from Standard Input in the following format:
s | S = input()
s = 0
for i in range(len(S)):
c = S[i]
s = i if c == "A" and s == 0
if c == "Z":
print(S[s:i+1])
break | Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s943470918 | Runtime Error | p03814 | The input is given from Standard Input in the following format:
s | s = list(input())
a = 200000
z = 0
for i in range(len(s)):
if s[i] = 'A' and a > i:
a = i
if s[i] = 'Z' and z < i:
z = i
print(z-a+1) | Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s824824800 | Runtime Error | p03814 | The input is given from Standard Input in the following format:
s | S = input()
for i in len(S):
c = S[i]
s = i if c =='A'
if c =='Z':
print(S[s:i+1])
break | Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s467950913 | Runtime Error | p03814 | The input is given from Standard Input in the following format:
s | s = input()
cnt = 0
cntflg = True
for i in s:
if i == 'Z':
break
elif cntflg:
cnt += 1
elif i == 'A'
cnt = 1
cntflg = True
print(cnt) | Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s697498976 | Runtime Error | p03814 | The input is given from Standard Input in the following format:
s | -*- coding: utf-8 -*-
import sys
import subprocess
import json
import time
import math
import re
import sqlite3
s = input()
print(1)
| Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s826916802 | Runtime Error | p03814 | The input is given from Standard Input in the following format:
s | # -*- coding: utf-8 -*-
x = input()
a = 0
z = 0
for i in range(len(x)):
if x[i] == "A":
a = i
break
for i in range(len(x)):
if x[-(i+1)] == "Z":
z = len(x) - i
break
print(len(x[a:z])
| Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s239378458 | Runtime Error | p03814 | The input is given from Standard Input in the following format:
s | s = list(map(int, input().split())
int ans = 0;
for i in range(len(s)):
if s[i] == "A":
for i in range(len(s))
ans ++;
if s[i] == "Z":
out;
print(ans)
| Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s312910351 | Runtime Error | p03814 | The input is given from Standard Input in the following format:
s | s = list(input())
flag = 0
pos_a, pos_z = 1
length = 0
for i, ltr in enumerate(s, 1)
if ltr == 'A':
pos_a = i
flag = 1
elif ltr == 'Z':
if flag == 1:
pos_z = i
if pos_z - pos_a > length:
length = pos_z - pos_a
else:
flag = 0
print(length) | Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s097629751 | Runtime Error | p03814 | The input is given from Standard Input in the following format:
s | s = input()
cnt = 0
cntflg = False
endflg = False
for i in s:
if i == 'Z' and cntflg:
cnt += 1
endflg = True
elif i == 'Z' and endflg:
cnt += 1
elif endflg
break
elif cntflg:
cnt += 1
elif i == 'A' and not(cntflg):
cnt = 1
cntflg = True
print(cnt)
| Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s379742778 | Runtime Error | p03814 | The input is given from Standard Input in the following format:
s | package main
import "fmt"
func main() {
var s string
start := -1
end := -1
fmt.Scanf("%s", &s)
for i, _ := range s {
if s[i:i+1] == "A" && start == -1 {
start = i
}
if s[i:i+1] == "Z" {
end = i
}
}
fmt.Println(end-start+1)
}
| Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s162767752 | Runtime Error | p03814 | The input is given from Standard Input in the following format:
s | s = list(input())
flag = 0
pos_a, pos_z = 1, 1
length = 0
for i, ltr in enumerate(s, 1):
if ltr == 'A':
pos_a = i
flag = 1
elif ltr == 'Z' and flag == 1:
pos_z = i
if pos_z - (pos_a -1) > length:
length = pos_z - (pos_a -1)
else:
flag = 0
print(length) | Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s175812662 | Runtime Error | p03814 | The input is given from Standard Input in the following format:
s | s=str(input())
S=int()
G=int()
#Sに最初のAのインデックスを取得
for i in range(len(s)):
if s[i]=='A':
S=s.index(s[i])
break
ss=s[::-1]
#Gに最後のZのインデックスを取得
for j in range(len(ss)):
if ss[j]=='Z':
G=len(ss)-j-1
break
print(G-S+1 | Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s440122980 | Runtime Error | p03814 | The input is given from Standard Input in the following format:
s | first = s.find("A")
last = s.rfind("Z")
print(last - first + 1)
| Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s859611002 | Runtime Error | p03814 | The input is given from Standard Input in the following format:
s | Not found | Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s750385128 | Runtime Error | p03814 | The input is given from Standard Input in the following format:
s | S = input()
dAdAd1 1
a = S.find('A')
b = S.find('Z')
print(len(S)-a-b) | Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s930936249 | Runtime Error | p03814 | The input is given from Standard Input in the following format:
s | -*- coding: utf-8 -*-
s = input()
print(s.rfind('Z') - s.find('A') + 1) | Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s969679990 | Accepted | p03814 | The input is given from Standard Input in the following format:
s | # B
s = input()
A = s.index("A")
Z = s[::-1].index("Z")
print(max(0, len(s) - 1 - Z - A + 1))
| Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the answer.
* * * | s533984272 | Accepted | p03814 | The input is given from Standard Input in the following format:
s | strInp = input()
print(abs(strInp.find("A", 0) - strInp.rfind("Z", 0)) + 1)
| Statement
Snuke has decided to construct a string that starts with `A` and ends with
`Z`, by taking out a substring of a string s (that is, a consecutive part of
s).
Find the greatest length of the string Snuke can construct. Here, the test set
guarantees that there always exists a substring of s that starts with `A` and
ends with `Z`. | [{"input": "QWERTYASDFZXCV", "output": "5\n \n\nBy taking out the seventh through eleventh characters, it is possible to\nconstruct `ASDFZ`, which starts with `A` and ends with `Z`.\n\n* * *"}, {"input": "ZABCZ", "output": "4\n \n\n* * *"}, {"input": "HASFJGHOGAKZZFEGA", "output": "12"}] |
Print the maximum number of days Takahashi can hang out during the vacation,
or `-1`.
* * * | s323858315 | Wrong Answer | p02706 | Input is given from Standard Input in the following format:
N M
A_1 ... A_M | n = int(input().split()[0])
print(max(0, n - sum(map(int, input().split()))))
| Statement
Takahashi has N days of summer vacation.
His teacher gave him M summer assignments. It will take A_i days for him to do
the i-th assignment.
He cannot do multiple assignments on the same day, or hang out on a day he
does an assignment.
What is the maximum number of days Takahashi can hang out during the vacation
if he finishes all the assignments during this vacation?
If Takahashi cannot finish all the assignments during the vacation, print `-1`
instead. | [{"input": "41 2\n 5 6", "output": "30\n \n\nFor example, he can do the first assignment on the first 5 days, hang out on\nthe next 30 days, and do the second assignment on the last 6 days of the\nvacation. In this way, he can safely spend 30 days hanging out.\n\n* * *"}, {"input": "10 2\n 5 6", "output": "-1\n \n\nHe cannot finish his assignments.\n\n* * *"}, {"input": "11 2\n 5 6", "output": "0\n \n\nHe can finish his assignments, but he will have no time to hang out.\n\n* * *"}, {"input": "314 15\n 9 26 5 35 8 9 79 3 23 8 46 2 6 43 3", "output": "9"}] |
Print the maximum number of days Takahashi can hang out during the vacation,
or `-1`.
* * * | s968860938 | Wrong Answer | p02706 | Input is given from Standard Input in the following format:
N M
A_1 ... A_M | LI = lambda: list(map(int, input().split()))
MI = lambda: map(int, input().split())
yes = lambda: print("YES")
no = lambda: print("NO")
I = lambda: list(input())
J = lambda x: "".join(x)
II = lambda: int(input())
SI = lambda: input()
# ---khan17---template
n, m = MI()
a = LI()
c = n - sum(a)
print(c if c > 0 else -1)
| Statement
Takahashi has N days of summer vacation.
His teacher gave him M summer assignments. It will take A_i days for him to do
the i-th assignment.
He cannot do multiple assignments on the same day, or hang out on a day he
does an assignment.
What is the maximum number of days Takahashi can hang out during the vacation
if he finishes all the assignments during this vacation?
If Takahashi cannot finish all the assignments during the vacation, print `-1`
instead. | [{"input": "41 2\n 5 6", "output": "30\n \n\nFor example, he can do the first assignment on the first 5 days, hang out on\nthe next 30 days, and do the second assignment on the last 6 days of the\nvacation. In this way, he can safely spend 30 days hanging out.\n\n* * *"}, {"input": "10 2\n 5 6", "output": "-1\n \n\nHe cannot finish his assignments.\n\n* * *"}, {"input": "11 2\n 5 6", "output": "0\n \n\nHe can finish his assignments, but he will have no time to hang out.\n\n* * *"}, {"input": "314 15\n 9 26 5 35 8 9 79 3 23 8 46 2 6 43 3", "output": "9"}] |
Print the maximum number of days Takahashi can hang out during the vacation,
or `-1`.
* * * | s002195556 | Wrong Answer | p02706 | Input is given from Standard Input in the following format:
N M
A_1 ... A_M | m, n = [int(i) for i in input().split(" ")]
a_list = [int(i) for i in input().split(" ")]
play_m = m - sum(a_list)
print(play_m)
| Statement
Takahashi has N days of summer vacation.
His teacher gave him M summer assignments. It will take A_i days for him to do
the i-th assignment.
He cannot do multiple assignments on the same day, or hang out on a day he
does an assignment.
What is the maximum number of days Takahashi can hang out during the vacation
if he finishes all the assignments during this vacation?
If Takahashi cannot finish all the assignments during the vacation, print `-1`
instead. | [{"input": "41 2\n 5 6", "output": "30\n \n\nFor example, he can do the first assignment on the first 5 days, hang out on\nthe next 30 days, and do the second assignment on the last 6 days of the\nvacation. In this way, he can safely spend 30 days hanging out.\n\n* * *"}, {"input": "10 2\n 5 6", "output": "-1\n \n\nHe cannot finish his assignments.\n\n* * *"}, {"input": "11 2\n 5 6", "output": "0\n \n\nHe can finish his assignments, but he will have no time to hang out.\n\n* * *"}, {"input": "314 15\n 9 26 5 35 8 9 79 3 23 8 46 2 6 43 3", "output": "9"}] |
Print the maximum number of days Takahashi can hang out during the vacation,
or `-1`.
* * * | s795492227 | Accepted | p02706 | Input is given from Standard Input in the following format:
N M
A_1 ... A_M | D, N = map(int, input().split())
S = list(map(int, input().split()))
print(D - sum(S) if D >= sum(S) else "-1")
| Statement
Takahashi has N days of summer vacation.
His teacher gave him M summer assignments. It will take A_i days for him to do
the i-th assignment.
He cannot do multiple assignments on the same day, or hang out on a day he
does an assignment.
What is the maximum number of days Takahashi can hang out during the vacation
if he finishes all the assignments during this vacation?
If Takahashi cannot finish all the assignments during the vacation, print `-1`
instead. | [{"input": "41 2\n 5 6", "output": "30\n \n\nFor example, he can do the first assignment on the first 5 days, hang out on\nthe next 30 days, and do the second assignment on the last 6 days of the\nvacation. In this way, he can safely spend 30 days hanging out.\n\n* * *"}, {"input": "10 2\n 5 6", "output": "-1\n \n\nHe cannot finish his assignments.\n\n* * *"}, {"input": "11 2\n 5 6", "output": "0\n \n\nHe can finish his assignments, but he will have no time to hang out.\n\n* * *"}, {"input": "314 15\n 9 26 5 35 8 9 79 3 23 8 46 2 6 43 3", "output": "9"}] |
Print the maximum number of days Takahashi can hang out during the vacation,
or `-1`.
* * * | s206547317 | Runtime Error | p02706 | Input is given from Standard Input in the following format:
N M
A_1 ... A_M | M, N = input().split()
A1, Am = input().split()
if 1 <= int(N) < 10**6 and 1 <= int(M) < 10**4 and 1 <= int(A1) < 10**4:
if (int(A1) + int(Am)) <= int(M):
print((int(A1) + int(Am)) - int(M))
elif (int(A1) + int(Am)) == int(M):
print(0)
elif (int(A1) + int(Am)) > int(M):
print(-1)
| Statement
Takahashi has N days of summer vacation.
His teacher gave him M summer assignments. It will take A_i days for him to do
the i-th assignment.
He cannot do multiple assignments on the same day, or hang out on a day he
does an assignment.
What is the maximum number of days Takahashi can hang out during the vacation
if he finishes all the assignments during this vacation?
If Takahashi cannot finish all the assignments during the vacation, print `-1`
instead. | [{"input": "41 2\n 5 6", "output": "30\n \n\nFor example, he can do the first assignment on the first 5 days, hang out on\nthe next 30 days, and do the second assignment on the last 6 days of the\nvacation. In this way, he can safely spend 30 days hanging out.\n\n* * *"}, {"input": "10 2\n 5 6", "output": "-1\n \n\nHe cannot finish his assignments.\n\n* * *"}, {"input": "11 2\n 5 6", "output": "0\n \n\nHe can finish his assignments, but he will have no time to hang out.\n\n* * *"}, {"input": "314 15\n 9 26 5 35 8 9 79 3 23 8 46 2 6 43 3", "output": "9"}] |
Print the maximum number of days Takahashi can hang out during the vacation,
or `-1`.
* * * | s771915068 | Wrong Answer | p02706 | Input is given from Standard Input in the following format:
N M
A_1 ... A_M | x = input().split()
c = int(x[0])
v = input().split()
f = 0
for i in v:
f += int(i)
m = c - f
print(m)
| Statement
Takahashi has N days of summer vacation.
His teacher gave him M summer assignments. It will take A_i days for him to do
the i-th assignment.
He cannot do multiple assignments on the same day, or hang out on a day he
does an assignment.
What is the maximum number of days Takahashi can hang out during the vacation
if he finishes all the assignments during this vacation?
If Takahashi cannot finish all the assignments during the vacation, print `-1`
instead. | [{"input": "41 2\n 5 6", "output": "30\n \n\nFor example, he can do the first assignment on the first 5 days, hang out on\nthe next 30 days, and do the second assignment on the last 6 days of the\nvacation. In this way, he can safely spend 30 days hanging out.\n\n* * *"}, {"input": "10 2\n 5 6", "output": "-1\n \n\nHe cannot finish his assignments.\n\n* * *"}, {"input": "11 2\n 5 6", "output": "0\n \n\nHe can finish his assignments, but he will have no time to hang out.\n\n* * *"}, {"input": "314 15\n 9 26 5 35 8 9 79 3 23 8 46 2 6 43 3", "output": "9"}] |
Print the maximum number of days Takahashi can hang out during the vacation,
or `-1`.
* * * | s181247191 | Accepted | p02706 | Input is given from Standard Input in the following format:
N M
A_1 ... A_M | n, m = tuple(map(int, input().split(" ")))
print(max(n - sum(map(int, input().split(" "))), -1))
| Statement
Takahashi has N days of summer vacation.
His teacher gave him M summer assignments. It will take A_i days for him to do
the i-th assignment.
He cannot do multiple assignments on the same day, or hang out on a day he
does an assignment.
What is the maximum number of days Takahashi can hang out during the vacation
if he finishes all the assignments during this vacation?
If Takahashi cannot finish all the assignments during the vacation, print `-1`
instead. | [{"input": "41 2\n 5 6", "output": "30\n \n\nFor example, he can do the first assignment on the first 5 days, hang out on\nthe next 30 days, and do the second assignment on the last 6 days of the\nvacation. In this way, he can safely spend 30 days hanging out.\n\n* * *"}, {"input": "10 2\n 5 6", "output": "-1\n \n\nHe cannot finish his assignments.\n\n* * *"}, {"input": "11 2\n 5 6", "output": "0\n \n\nHe can finish his assignments, but he will have no time to hang out.\n\n* * *"}, {"input": "314 15\n 9 26 5 35 8 9 79 3 23 8 46 2 6 43 3", "output": "9"}] |
Print the maximum number of days Takahashi can hang out during the vacation,
or `-1`.
* * * | s461181888 | Runtime Error | p02706 | Input is given from Standard Input in the following format:
N M
A_1 ... A_M | yasumi = 0
syukudai = 1
nissu = list(map(int, input().split()))
syukudaiNissu = list(map(int, input().split()))
if sum(syukudaiNissu) > nissu[yasumi]:
print() - 1
print(nissu[yasumi] - sum(syukudaiNissu))
| Statement
Takahashi has N days of summer vacation.
His teacher gave him M summer assignments. It will take A_i days for him to do
the i-th assignment.
He cannot do multiple assignments on the same day, or hang out on a day he
does an assignment.
What is the maximum number of days Takahashi can hang out during the vacation
if he finishes all the assignments during this vacation?
If Takahashi cannot finish all the assignments during the vacation, print `-1`
instead. | [{"input": "41 2\n 5 6", "output": "30\n \n\nFor example, he can do the first assignment on the first 5 days, hang out on\nthe next 30 days, and do the second assignment on the last 6 days of the\nvacation. In this way, he can safely spend 30 days hanging out.\n\n* * *"}, {"input": "10 2\n 5 6", "output": "-1\n \n\nHe cannot finish his assignments.\n\n* * *"}, {"input": "11 2\n 5 6", "output": "0\n \n\nHe can finish his assignments, but he will have no time to hang out.\n\n* * *"}, {"input": "314 15\n 9 26 5 35 8 9 79 3 23 8 46 2 6 43 3", "output": "9"}] |
Print the maximum number of days Takahashi can hang out during the vacation,
or `-1`.
* * * | s103108812 | Accepted | p02706 | Input is given from Standard Input in the following format:
N M
A_1 ... A_M | n, _, *l = map(int, open(0).read().split())
print(max(n - sum(l), -1))
| Statement
Takahashi has N days of summer vacation.
His teacher gave him M summer assignments. It will take A_i days for him to do
the i-th assignment.
He cannot do multiple assignments on the same day, or hang out on a day he
does an assignment.
What is the maximum number of days Takahashi can hang out during the vacation
if he finishes all the assignments during this vacation?
If Takahashi cannot finish all the assignments during the vacation, print `-1`
instead. | [{"input": "41 2\n 5 6", "output": "30\n \n\nFor example, he can do the first assignment on the first 5 days, hang out on\nthe next 30 days, and do the second assignment on the last 6 days of the\nvacation. In this way, he can safely spend 30 days hanging out.\n\n* * *"}, {"input": "10 2\n 5 6", "output": "-1\n \n\nHe cannot finish his assignments.\n\n* * *"}, {"input": "11 2\n 5 6", "output": "0\n \n\nHe can finish his assignments, but he will have no time to hang out.\n\n* * *"}, {"input": "314 15\n 9 26 5 35 8 9 79 3 23 8 46 2 6 43 3", "output": "9"}] |
Print the maximum number of days Takahashi can hang out during the vacation,
or `-1`.
* * * | s510685340 | Accepted | p02706 | Input is given from Standard Input in the following format:
N M
A_1 ... A_M | N, M = [int(el) for el in input().split()]
sm = sum([int(el) for el in input().split()])
print(-1 if N < sm else N - sm)
| Statement
Takahashi has N days of summer vacation.
His teacher gave him M summer assignments. It will take A_i days for him to do
the i-th assignment.
He cannot do multiple assignments on the same day, or hang out on a day he
does an assignment.
What is the maximum number of days Takahashi can hang out during the vacation
if he finishes all the assignments during this vacation?
If Takahashi cannot finish all the assignments during the vacation, print `-1`
instead. | [{"input": "41 2\n 5 6", "output": "30\n \n\nFor example, he can do the first assignment on the first 5 days, hang out on\nthe next 30 days, and do the second assignment on the last 6 days of the\nvacation. In this way, he can safely spend 30 days hanging out.\n\n* * *"}, {"input": "10 2\n 5 6", "output": "-1\n \n\nHe cannot finish his assignments.\n\n* * *"}, {"input": "11 2\n 5 6", "output": "0\n \n\nHe can finish his assignments, but he will have no time to hang out.\n\n* * *"}, {"input": "314 15\n 9 26 5 35 8 9 79 3 23 8 46 2 6 43 3", "output": "9"}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s744543252 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | A, B = map(lambda S: int(S,16), input().split())
if A < B:
print("<")
elif A = B:
print("=")
else:
print(">")
| Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s845265333 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | a,b =input().split()
if a.isalpha() > b.isalpha():
print(">")
elif a.isalpha() < b.isalpha():
print("<")
else:
print("=") | Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s051340850 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | a, b = input().split()
if ( a < b) :
print('<')
elsif (a > b):
print('>')
else :
print('=')
| Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s146460121 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | from sys import stdin
import math
a=input()
if (a[0]<a[2]):
print("<")
elif(a[0]==a[2])
print("=")
else:
print(">") | Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s393702584 | Accepted | p03547 | Input is given from Standard Input in the following format:
X Y | import functools
import os
INF = float("inf")
def inp():
return int(input())
def inpf():
return float(input())
def inps():
return input()
def inl():
return list(map(int, input().split()))
def inlf():
return list(map(float, input().split()))
def inls():
return input().split()
def inpm(line):
return [inp() for _ in range(line)]
def inpfm(line):
return [inpf() for _ in range(line)]
def inpsm(line):
return [inps() for _ in range(line)]
def inlm(line):
return [inl() for _ in range(line)]
def inlfm(line):
return [inlf() for _ in range(line)]
def inlsm(line):
return [inls() for _ in range(line)]
def debug(fn):
if not os.getenv("LOCAL"):
return fn
@functools.wraps(fn)
def wrapper(*args, **kwargs):
print(
"DEBUG: {}({}) -> ".format(
fn.__name__,
", ".join(
list(map(str, args))
+ ["{}={}".format(k, str(v)) for k, v in kwargs.items()]
),
),
end="",
)
ret = fn(*args, **kwargs)
print(ret)
return ret
return wrapper
x, y = inls()
if x > y:
print(">")
if x < y:
print("<")
if x == y:
print("=")
| Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s118611554 | Accepted | p03547 | Input is given from Standard Input in the following format:
X Y | def intnum(str):
n = 0
if str in range(10):
n = int(str)
elif str in {"A"}:
n = 10
elif str in {"B"}:
n = 11
elif str in {"C"}:
n = 12
elif str in {"D"}:
n = 13
elif str in {"E"}:
n = 14
elif str in {"F"}:
n = 15
return n
x, y = map(intnum, input().split())
r = "="
if x > y:
r = ">"
elif x < y:
r = "<"
print(r)
| Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s304596953 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | A,B=input().split()
mydict = {"A":11, "B":12, "C":14, , "D":13, "E":14, "F":15}
print('>') if mydict(A) > mydict(B) else print('<') if mydict(A) < mydict(B) else print('=') | Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s429915873 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | a, b = input().split()
if a < b:
print('<')
elsif a > b:
print('>')
else:
print('=') | Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s263662077 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | a,b=input().split()
if (a<b):
print("<")
elsif (a>b):
print(">")
else:
print("=") | Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s772895938 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | X, Y = input().split()
if X = Y:
res = "="
elif X < Y:
res = "<"
else:
res = ">"
print(res)
| Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s018845077 | Accepted | p03547 | Input is given from Standard Input in the following format:
X Y | n, m = input().split()
print(["=", ["<", ">"][n > m]][n != m])
| Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s527382896 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | a,b=input().split()
if (a<b):
print("<")
elsif (a>b):
print(">")
else:
print("=") | Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s496433658 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | x,y=input().split()
if x>y:
print('>')
elif x=y:
print('=')
else:
print('<') | Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s891400395 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | N, M = map(int, input().split())
print((1900 * M + (N - M) * 100) * pow(2, M))
| Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s317161566 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | a, b input().split()
if a==b:
print("=")
else:
print("<" if a < b else ">") | Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s529588637 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | X,Y=map(str,input().split())
"A"=10
"B"=11
"C"=12
"D"=13
"E"=14
"F"=15
if X>Y:
print(">")
elif X=Y:
print("=")
else:
print("<")
| Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s430792868 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | x,y = input().split()
print('<') if x < y elif x > y print('>') else print('=') | Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s254207084 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | X = int(input())
Y = int(input())
if X==Y:
print("=")
elif X<Y:
print("<")
else:
print(">")
end | Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s688212221 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | l = list(int(input(),16).split)
if l[0] < l[1]:
print("<")
elif l[0] = l[1]:
print ("=")
elif l[0] > l[1]:
print(">") | Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s374681886 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | l = map(int(input(), 16).split())
if l[0] < l[1]:
print("<")
elif l[0] = l[1]:
print ("=")
elif l[0] > l[1]:
print(">")
| Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s475433312 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | X="X="input()
Y="Y="input()
A=10
B=11
C=12
D=13
E=14
F=15
if X<Y:
print(”Yが大きい”)
elif:
X=Y
print("X=Y")
else:
print("Xが大きい") | Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s721011058 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | l = list(map(int(input(), 16).split))
if l[0] < l[1]:
print("<")
elif l[0] = l[1]:
print ("=")
elif l[0] > l[1]:
print(">")
| Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s846504268 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | a,b = map(str,input().split())
A = 1
B = 2
C = 3
D = 4
E = 5
F = 6
if a < b:
print("<")
elif a = b:
print("=")
else:
print(">") | Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s849684240 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | x,y=map(str,input().split())
x=int(x,16)
y=int(y,16)
if int(x)<int(y):
print(<)
elif x==y:
print(=)
else:
print(>)
| Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s818939610 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | x,y=map(str,input().split())
x=int(x,16)
y=int(y,16)
if x<y:
print(<)
elif x==y:
print(=)
else:
print(>)
| Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s875874850 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | #include <iostream>
#include <algorithm>
#include <cstdio>
#include <regex>
#include <cmath>
#include <vector>
#include <queue>
#include <functional>
#include <numeric>
#include <iomanip>
#include <stack>
#include <string>
#include <map>
#include <set>
using namespace std;
template <class T>
using V = vector<T>;
template <class T>
using VV = V<V<T>>;
template <class T>
using VVV = V<VV<T>>;
template <class T, class U>
using P = pair<T, U>;
template <class S, class T, class U>
using TUP = tuple<S, T, U>;
using ll = long long;
using ull = unsigned long long;
using dbl = double;
using ld = long double;
using str = string;
using vll = V<ll>;
using vll2 = VV<ll>;
using vll3 = VVV<ll>;
using pll = P<ll, ll>;
using tll = TUP<ll, ll, ll>;
using vpll = V<pll>;
using tpll = V<tll>;
using vs = V<str>;
using vvs = V<vs>;
using vd = V<dbl>;
using vvd = V<vd>;
using qll = queue<ll>;
using qpll = queue<pll>;
using mapll = map<ll, ll>;
using setll = set<ll>;
#define int ll
#define fst first
#define snd second
#define PQ priority_queue
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define popb pop_back()
#define sz size()
#define bn begin()
#define ed end()
#define FOR(i, a, b) for (ll i = (a); i <= (ll)(b); i++)
#define rFOR(i, a, b) for (ll i = (b); i >= (ll)(a); i--)
#define REP(i, n) FOR(i, 0, (n)-1)
#define REP1(i, n) FOR(i, 1, (n))
#define VFOR(i, v) for (auto &(i) : v)
signed main () {
str X, Y;
cin >> X >> Y;
if (X < Y) {
cout << "<" << endl;
}else if(X > Y) {
cout << ">" << endl;
}else{
cout << "=" << endl;
}
return 0;
} | Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s195969898 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | x, y = map(int, input().split())
d = {'A':10, 'B':11, 'C':12, 'D':13, 'E':14, 'F':15}
if d[x] < d[y]:
print('<')
if d[x] = d[y]:
print('=')
else:
print('>')
| Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s795633389 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | x,y=map(str,input().split())
"A"="1"
"B"="2"
"C"="3"
"D"="4"
"E"="5"
"F"="6"
if int(x)<int(y):
print(<)
elif x==y:
print(=)
else:
print(>) | Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s206836007 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | X, Y = map(str, input().split())
"A" = 1
"B" = 2
"C" = 3
"D" = 4
"E" = 5
"F" = 6
if X > Y:
print(">")
elif X < Y:
print("<")
else:
print("=")
| Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s816879034 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | a = input().split(" ")
b = {"A":11,"B":12,"C":13,"D":14,"E":15:"F":16}
if b[a[0]] == b[a[1]]:
print("=")
elif b[a[0]] < b[a[1]]:
print("<")
else:
print(">") | Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s908596835 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
A B = input().split()
if A < B:
print('<')
elif A > B:
print('>')
elif A == B:
print('0')
| Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s488328160 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | alf = ['A','B','C','D','E','F']
a,b = map(str,input().split())
if alf.index(a)<alf.index(b):
print('<')
elif alf.index(a)=alf.index(b):
print('=')
else:
print('>')
| Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s054012826 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
A B = input().split()
if A < B:
print('<')
elif A > B:
print('>')
elif A == B:
print('=')
| Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s975072325 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | a,b=map(str,input().split())
if(a=="A"):
c=1
if(a=="B"):
c=2
if(a=="C"):
c=3
if(a=="D"):
c=4
if(a=="E"):
c=5
if(a=="F"):
c=6
if(b=="A"):
d=1
if(b=="B"):
d=2
if(b=="C"):
d=3
if(b=="D"):
d=4
if(b=="E"):
d=5
if(b=="F"):
d=6
if(c>d):
print(">")
if(c<d):
print("<")
if(c=d):
print("=") | Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s980772202 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | kazu = {"A":10,"B":11,"C":12,"D":13,"E":14,"F":15}
x, y = input().split()
if kazu[x] > kazu[y]:
print(">")
elif kazu[x] = kazu[y]:
print("=")
elif kazu[x] < kazu[y]:
print("<") | Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s675383320 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | x=["0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F",]
a,b=input().split();a,b=x.index(a),x.index(b)
if a>b:print(">")
elif a<b:print("<")
else;print("=") | Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s172640220 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | a, b = = input().split()
if a > b:
print(">")
elif a == b:
print("=")
else:
print("<") | Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s189303331 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | x,y = input().split(" ")
if x < y:
print("<")
elif x > y:
print(">")
else x == y:
print("=") | Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s180254081 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | a,b=input().split()
c=ord(a)
d=ord(b)
if c<d:
print("<")
elif c==d:
print("=")
else c>d:
print(">") | Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s607850668 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | x, y = input().split()
if x = y:
print('=')
elif x < y:
print('<')
else:
print('>')
| Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s771159070 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | a,b=map(int,input().split())
if a > b:
print(">")
else if a < b:
print("<")
else:
print("=")
| Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s117512700 | Accepted | p03547 | Input is given from Standard Input in the following format:
X Y | a, s = input().split()
print("=") if a == s else print("<") if a < s else print(">")
| Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s018579566 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | x, y = input().split()
if x > y:
print(">")
elsif x == y:
print("=")
else:
print("<") | Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s552321098 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | X, Y = input().split()
if X > Y:
print('>')
elif X = Y:
print('=')
else:
print('<') | Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s428217557 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | a, b = input(), split()
c = int(a, 16)
d = int(b, 16)
print(">" if c > d else "<" if c < d else "=")
| Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
If X is smaller, print `<`; if Y is smaller, print `>`; if they are equal,
print `=`.
* * * | s593333934 | Runtime Error | p03547 | Input is given from Standard Input in the following format:
X Y | x,y = input().split()
print('<' if x<y else '>' if x>y else '=' if x==y) | Statement
In programming, hexadecimal notation is often used.
In hexadecimal notation, besides the ten digits 0, 1, ..., 9, the six letters
`A`, `B`, `C`, `D`, `E` and `F` are used to represent the values 10, 11, 12,
13, 14 and 15, respectively.
In this problem, you are given two letters X and Y. Each X and Y is `A`, `B`,
`C`, `D`, `E` or `F`.
When X and Y are seen as hexadecimal numbers, which is larger? | [{"input": "A B", "output": "<\n \n\n10 < 11.\n\n* * *"}, {"input": "E C", "output": ">\n \n\n14 > 12.\n\n* * *"}, {"input": "F F", "output": "=\n \n\n15 = 15."}] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.