submission_id string | problem_id string | status string | code string | input string | output string | problem_description string |
|---|---|---|---|---|---|---|
s942454277 | p00047 | Accepted | p = "A"
while 1:
try: a, b = list(map(str, input().split(",")))
except: break
if a == p: p = b
elif b == p: p = a
print(p)
| B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s984633094 | p00047 | Accepted | import sys
result = "A"
for (p1, p2) in (l.strip().split(",") for l in sys.stdin.readlines()):
if result == p1:
result = p2
elif result == p2:
result = p1
print(result)
| B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s570058816 | p00047 | Accepted | #!/usr/bin/env python
# coding: utf-8
import sys
def exchageCup(cups, param):
cups[param[0]], cups[param[1]] = cups[param[1]], cups[param[0]]
def main():
params = [x.rstrip("\n").split(",") for x in sys.stdin.readlines()]
cups = {
"A": True,
"B": False,
"C": False}
for param in params:
exchageCup(cups, param)
for key in cups:
if cups[key]:
print key
if __name__ == '__main__':
main() | B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s432860916 | p00047 | Accepted | import sys
cap={"A":True,"B":False,"C":False}
for line in sys.stdin.readlines():
i,j=line.strip().split(",")
cap[i],cap[j]=cap[j],cap[i]
for k,v in cap.items():
if v:print k
#temp | B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s787548057 | p00047 | Accepted | p = 0
chA = ord("A")
while True:
try:
s, t = map(lambda x: ord(x) - chA, raw_input().split(","))
except EOFError as e:
break
if s == p:
p = t
elif t == p:
p = s
print("%s" % (chr(p + chA), )) | B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s436837404 | p00047 | Accepted | p = "A"
while True:
try:
s, t = raw_input().split(",")
except EOFError as e:
break
if s == p:
p = t
elif t == p:
p = s
print("%s" % (p, )) | B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s750863965 | p00047 | Accepted | p = {"A":True, "B":False, "C": False}
while True:
try:
s, t = raw_input().split(",")
except EOFError as e:
break
p[s], p[t] = p[t], p[s]
for i in p:
if p[i]:
print("%s" % (i, )) | B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s406515825 | p00047 | Accepted | def change(ball,x,y):
tmp = ball[x]
ball[x] = ball[y]
ball[y] = tmp
return ball
def jug(ball):
ball2 = ["A","B","C"]
for i in range(0,3):
if ball[i] == 1:
print ball2[i]
break
if __name__ == "__main__":
ball = [1,0,0]
while True:
try:
x = 0
y = 0
z = 0
a,b = map(str,raw_input().split(","))
if a == "A":
if b == "B":
x=0
y=1
elif b == "C":
x=0
y=2
elif a == "B":
if b == "A":
x=1
y=0
elif b == "C":
x=1
y=2
elif a == "C":
if b == "A":
x=2
y=0
elif b == "B":
x=2
y=1
ball = change(ball,x,y)
except EOFError:
break
jug(ball) | B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s041545346 | p00047 | Accepted |
import sys
class Cupgame:
def __init__(self, ballin):
self.ballin = ballin
def swap(self, x, y):
if x == self.ballin:
self.ballin = y
elif y == self.ballin:
self.ballin = x
else:
pass
cupgame = Cupgame('A')
for line in sys.stdin:
x, y = tuple(line.rstrip('\n').split(','))
cupgame.swap(x, y)
print cupgame.ballin | B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s820174991 | p00047 | Accepted | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
cups = {'A': 1, 'B': 0, 'C': 0}
for line in stdin:
t, s = line.strip().split(',')
cups[t], cups[s] = cups[s], cups[t]
for c in 'ABC':
if cups[c]:
print(c)
break | B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s743360667 | p00047 | Accepted | import sys
c = [1,0,0]
for s in sys.stdin:
cc = [ord(i)-ord('A') for i in s.rstrip().split(',')]
c[cc[0]], c[cc[1]] = c[cc[1]], c[cc[0]]
print chr(ord('A') + c.index(1)) | B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s262136389 | p00047 | Accepted | import sys
x = [1,0,0]
L = "ABC"
for s in sys.stdin:
a = L.index(s[0])
b = L.index(s[2])
x[a],x[b]=x[b],x[a]
print L[x.index(1)] | B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s965128152 | p00047 | Accepted | ls = {"A":0, "B":1, "C":2}
cup = [1,0,0]
while 1:
try:
x, y = map(str, raw_input().split(","))
tmp = cup[ls[x]]
cup[ls[x]] = cup[ls[y]]
cup[ls[y]] = tmp
except:
break
p = cup.index(1)
if p == 0:
print "A"
else:
print "B" if p == 1 else "C" | B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s604116211 | p00047 | Accepted | import sys
p="A"
for s in sys.stdin:
if p==s[0]: p=s[2]
elif p==s[2]: p=s[0]
print p | B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s247228012 | p00047 | Accepted | try:
a = 'A'
while True:
p, q = raw_input().split(',')
if p == a:
a = q
elif q == a:
a = p
except EOFError:
pass
print a | B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s487017402 | p00047 | Accepted | Ball = {'A': 1, 'B': 0, 'C': 0}
while 1:
try:
a, b = raw_input().split(',')
except EOFError:
break
Ball[a], Ball[b] = Ball[b], Ball[a]
for b in Ball:
if Ball[b] == 1:
print b | B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s674273659 | p00047 | Accepted | CUP = ['A', 'B', 'C']
def i(x):
if x=='A':
x = 0
if x=='B':
x = 1
if x=='C':
x = 2
return x
while True:
try:
x, y = input().split(',')
except:
break
x = i(x)
y = i(y)
CUP[x], CUP[y] = CUP[y], CUP[x]
ball = CUP.index('A')
if ball==0:
print('A')
if ball==1:
print('B')
if ball==2:
print('C')
| B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s358366399 | p00047 | Accepted | ans = 'A'
while True:
try:
a, b = input().split(',')
if a == ans:
ans = b
elif b == ans:
ans = a
else:
pass
except EOFError:
break
print(ans)
| B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s361066564 | p00047 | Accepted | balls = [1,0,0]
while 1:
try:
a,b = input().split(',')
i1 = ord(a) - ord("A")
i2 = ord(b) - ord("A")
balls[i1],balls[i2] = balls[i2],balls[i1]
except:
break
for i in range(0,3):
if balls[i]:
print(chr(i + ord("A")))
| B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s703882000 | p00047 | Accepted | cup = "ABC"
while True :
try :
x, y = input().split(",")
cup = cup.replace(x, "D")
cup = cup.replace(y, x)
cup = cup.replace("D", y)
except EOFError :
break
print(cup[0])
| B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s264855749 | p00047 | Accepted | import sys
readlines = sys.stdin.readlines
write = sys.stdout.write
def solve():
F = "ABC".index
S = [0]*3
S[0] = 1
for line in readlines():
a, b = map(F, line.strip().split(","))
S[a], S[b] = S[b], S[a]
write("%s\n" % "ABC"[S.index(1)])
solve()
| B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s557220332 | p00047 | Accepted | cup = "A"
while True:
try:
a,b = input().split(",")
except:
break
if cup == a:
cup = b
elif cup == b:
cup = a
print(cup)
| B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s497642262 | p00047 | Accepted | list=[]
cup={'A':1,'B':0,'C':0}
while True:
try:
x,y=map(str, input().split(','))
except:
keys=[k for k,v in cup.items() if v==1]
for i in range(len(keys)):
print(keys[i])
break
if cup[x]==1:
cup[y]=1
cup[x]=0
elif cup[y]==1:
cup[y]=0
cup[x]=1
| B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s261112592 | p00047 | Accepted | L = [ 1, 0, 0]
d = {}
for i in range(len("ABC")):
d["ABC"[i]] = i
while True:
try:
s, t = input().split(",")
L[d[s]], L[d[t]] = L[d[t]], L[d[s]]
pass
except EOFError:
break
for i in range(len(L)):
if L[i] > 0:
print("ABC"[i])
| B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s335874696 | p00047 | Accepted | m={'A':0,'B':1,'C':2}
a = 'A'
b='B'
while True:
try:
a, b = list(input().split(','))
except:
break
m[a],m[b]=m[b],m[a]
if m['A']==0: print('A')
elif m['B']==0: print ('B')
elif m['C']==0: print('C')
| B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s258445779 | p00047 | Accepted | b = {'A': 1, 'B': 0, 'C': 0}
while 1:
try:
x, y = input().split(',')
b[x], b[y] = b[y], b[x]
except:
for i in b.keys():
if b[i]:
print(i)
break
| B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s030289989 | p00047 | Accepted | # coding=utf-8
###
### for atcorder program
###
import sys
import math
# math class
class mymath:
### pi
pi = 3.14159265358979323846264338
### Prime Number
def pnum_eratosthenes(self, n):
ptable = [0 for i in range(n+1)]
plist = []
for i in range(2, n+1):
if ptable[i]==0:
plist.append(i)
for j in range(i+i, n+1, i):
ptable[j] = 1
return plist
### GCD
def gcd(self, a, b):
if b == 0:
return a
return self.gcd(b, a%b)
### LCM
def lcm(self, a, b):
return (a*b)//self.gcd(a,b)
### Mat Multiplication
def mul(self, A, B):
ans = []
for a in A:
c = 0
for j, row in enumerate(a):
c += row*B[j]
ans.append(c)
return ans
mymath = mymath()
### output class
class output:
### list
def list(self, l):
l = list(l)
#print(" ", end="")
for i, num in enumerate(l):
print(num, end="")
if i != len(l)-1:
print(" ", end="")
print()
output = output()
### input sample
#i = input()
#N = int(input())
#A, B, C = [x for x in input().split()]
#N, K = [int(x) for x in input().split()]
#inlist = [int(w) for w in input().split()]
#R = float(input())
#A.append(list(map(int,input().split())))
#for line in sys.stdin.readlines():
# x, y = [int(temp) for temp in line.split()]
#abc list
#abc = [chr(ord('a') + i) for i in range(26)]
### output sample
#print("{0} {1} {2:.5f}".format(A//B, A%B, A/B))
#print("{0:.6f} {1:.6f}".format(R*R*math.pi,R*2*math.pi))
#print(" {}".format(i), end="")
def get_input():
N = []
while True:
try:
N.append(input())
#N.append(int(input()))
#N.append(float(input()))
except EOFError:
break
return N
def conv(s):
num = 2
if s == 'A':
num = 0
elif s == 'B':
num = 1
return num
N = get_input()
C = [1, 0, 0]
for i in N:
a, b = [x for x in i.split(',')]
a = conv(a)
b = conv(b)
C[a], C[b] = C[b], C[a]
if C[0] == 1:
print("A")
elif C[1] == 1:
print("B")
else:
print("C")
| B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s056606870 | p00047 | Accepted | if __name__ == '__main__':
pos = ["o","x","x"]
ALF = ["A","B","C"]
while True:
try:
s1,s2 = input().split(",")
if s1 in ["A","B"] and s2 in ["A","B"]:
pos[0],pos[1] = pos[1],pos[0]
elif s1 in ["A","C"] and s2 in ["A","C"]:
pos[0],pos[2] = pos[2],pos[0]
elif s1 in ["B","C"] and s2 in ["B","C"]:
pos[1],pos[2] = pos[2],pos[1]
except EOFError:
break
print(ALF[pos.index("o")])
| B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s841473565 | p00047 | Accepted | Q={"A":1,"B":0,"C":0}
while True:
try:
N=list(input().split(","))
Q[N[0]],Q[N[1]]=Q[N[1]],Q[N[0]]
except:
for v,m in Q.items():
if m==1:
print(v)
break
| B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s758573898 | p00047 | Accepted | n = [0,1,2]
d = dict(zip(["A","B","C"],[0,1,2]))
d_ = dict(zip([0,1,2],["A","B","C"]))
while(1):
try:
a,b = input().split(",")
temp = n[d[a]]
n[d[a]] = n[d[b]]
n[d[b]] = temp
except EOFError:
print(d_[n.index(0)])
break
| B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s509867022 | p00047 | Accepted | ball = 'A'
while 1:
try:
cuplist = list(map(str, input().split(",")))
if cuplist == ['']:
break
except:
break
if cuplist[0] == ball:
ball = cuplist[1]
elif cuplist[1] == ball:
ball = cuplist[0]
print(ball)
| B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s233838686 | p00047 | Accepted | A, B, C = 1, 2, 3
while True:
try: n = input().split(',')
except:
if A == 1:
print('A')
elif B == 1:
print('B')
else:
print('C')
break
if 'A' in n and 'B' in n:
A, B = B, A
elif 'A' in n and 'C' in n:
A, C = C, A
elif 'B' in n and 'C' in n:
B, C = C, B
| B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s763047912 | p00047 | Runtime Error | ball = 0
while True:
try:
a, b = map(lambda x: ord(x) - ord("A") raw_input().strip().split(","))
if (a == ball):
ball = b;
print chr(ball + ord("A")) | B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s099514964 | p00047 | Runtime Error | ball = 0
while True:
try:
a, b = map(lambda x: ord(x) - ord("A") raw_input().strip().split(","))
if (a == ball):
ball = b;
except:
break;
print chr(ball + ord("A")) | B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s158902473 | p00047 | Runtime Error | let () =
let rec read pos =
try let l = read_line ()
|> Str.split (Str.regexp_string ",")
in
if (List.nth l 0) = pos then
read (List.nth l 1)
else if (List.nth l 1) = pos then
read (List.nth l 0)
else
read pos
with End_of_file -> pos
in print_endline (read "A")
;; | B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s871873229 | p00047 | Runtime Error | import sys
d = {'A': 1, 'B': 0, 'C': 0}
for line in sys.stdin:
a, t = line.split(',')
d[a], d[t] = d[t], d[a]
for k, v in d.items():
if v:
print(k) | B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s917134121 | p00047 | Runtime Error | import sys
d = {'A': 1, 'B': 0, 'C': 0}
_input = sys.stdin
for line in _input:
a, t = line.split(',')
d[a], d[t] = d[t], d[a]
for k, v in d.items():
if v:
print(k) | B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s835000232 | p00047 | Runtime Error | import sys
d = {'A': 1, 'B': 0, 'C': 0}
for line in sys.stdin:
a, t = line.split().split(',')
d[a], d[t] = d[t], d[a]
for k, v in d.items():
if v:
print(k) | B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s186321564 | p00047 | Runtime Error | import sys
d = {'A': True, 'B': False, 'C': False}
for line in sys.stdin:
a, t = line.split().split(',')
d[a], d[t] = d[t], d[a]
for k, v in d.items():
if v:
print(k) | B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s778220471 | p00047 | Runtime Error | d = {'A': True, 'B': False, 'C': False}
while True:
try:
line = input()
except:
break
a, t = line.split().split(',')
d[a], d[t] = d[t], d[a]
for k, v in d.items():
if v:
print(k) | B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s241289625 | p00047 | Runtime Error | import sys
d = {'A': True, 'B': False, 'C': False}
for line in sys.stdin:
a, t = line.split(',')
d[a], d[t] = d[t], d[a]
for k, v in d.items():
if v:
print(k) | B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s752451289 | p00047 | Runtime Error | Ans = "A"
while True:
Pos = list(map(str,input().split(",")))
if Pos == ['']:
print(Ans)
break
if Ans in Pos:
Ans = Pos[((Pos.index(Ans)) + 1) % 2] | B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s501507460 | p00047 | Runtime Error | Ans = "A"
while True:
try:
if Ans in Pos:
Ans = Pos[((Pos.index(Ans)) + 1) % 2]
except EOFError:
print(Ans)
break | B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s413333798 | p00047 | Runtime Error | Ans = "A"
while True:
try:
if Ans in Pos:
Ans = Pos[((Pos.index(Ans)) + 1) % 2]
except:
print(Ans)
break | B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s536900963 | p00047 | Runtime Error | cups=[True, False, False]
for line in sys.stdin:
l= line.strip().split(",")
if "A"in l and "B"in l:
cups[0], cups[1]= cups[1], cups[1]
elif "A"in l and "C"in l:
cups[0], cups[2]= cups[2], cups[0]
else:
cups[1], cups[2]= cups[2], cups[1]
for i in range(3):
if cups[i]:
if i== 0:
print('A')
elif i== 1:
print('B')
else:
print('C') | B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s323539676 | p00047 | Runtime Error | d = {"A":1, "B":0, "C":0}
while True:
try:
swap1, awap2 = input().split(",")
d[swap1], d[swap2] = d[swap2], d[swap1]
except:
break
print(d.keys()[d.values().index(1)])
| B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s767977443 | p00047 | Runtime Error | p = "A"
while True:
try:
s, t = raw_input().split(",")
except EOFError as e:
break
if s == p:
p = t
elif t == p:
p = s
print("%s" % (chA, )) | B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s606769558 | p00047 | Runtime Error | ls = {"A":0, "B":1, "C":2}
cup = [1,0,0]
while 1:
try:
x, y = map(str, raw_input().split(","))
tmp = cup[ls[x]]
cup[ls[x]] = cup[ls[y]]
cup[ls[y]] = cup[ls[x]]
except:
break
p = cup.index(1)
if c == 0:
print "A"
else:
print "B" if c == 1 else "C" | B,C
A,C
C,B
A,B
C,B
| A
|
<H1>カップゲーム</H1>
<center>
<table>
<tr>
<td><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_cupGame"></td>
</tr>
</table>
</center>
<br/>
<p>
3 つのカップがふせて置かれています。カップの置かれている場所を、順に A,B,C と呼ぶことにします。最初は A に置かれているカップの中にボールが隠されているとします。カップの位置を入れ替えると、中に入っているボールも一緒に移動します。
</p>
<p>
入れ替える２つのカップの位置を読み込んで、最終的にどの場所のカップにボールが隠されているかを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入れ替える２つのカップの位置が順番に複数行にわたり与えられます。各行に、入れ替える２つのカップの位置を表す文字（A, B, または C）がカンマ区切りで与えられます。
</p>
<p>
入れ替える操作は 50 回を超えません。
</p>
<H2>Output</H2>
<p>
ボールが入っているカップの場所（A, B, または C）を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
B,C
A,C
C,B
A,B
C,B
</pre>
<H2>Output for the Sample Input</H2>
<pre>
A
</pre>
|
s990468987 | p00048 | Wrong Answer | a,b=['light fly', 'fly', 'bantam', 'feather', 'light', 'light welter','welter', 'light middle', 'middle', 'light heavy', 'heavy'],[48, 51, 54, 57, 60, 64, 69, 75, 81, 91]
while 1:
try:
c=float(input())
except:break
for i in range(10):
if c<=b[i]:
print(a[i])
break
| 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s191648689 | p00048 | Wrong Answer | import sys
f = sys.stdin
classes = {'light fly':(00.00, 48.00),
'fly':(48.00, 51.00),
'bantam':(51.00, 54.00),
'feather':(54.00,57.00),
'light':(57.00,60.00),
'light welter':(60.00,64.00),
'welter':(64.00,69.00),
'light middle':(69.00,75.00),
'middle':(75.00,81.00),
'light heavy':(81.00,91.00),
'heavy':(91.00,1000.00)}
for line in f:
weight = float(line)
for class_name, weights in classes.items():
if weights[0] <= weight < weights[1]:
print(class_name)
break | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s484316174 | p00048 | Wrong Answer | # coding: utf-8
from __future__ import print_function
from bisect import bisect
def grade(weight):
return cls[bisect(bounds, weight)]
bounds = [48.001, 51.00, 54.00, 57.00, 60.00, 64.00, 69.00, 75.00, 81.00, 91.00]
cls = ["light fly", "fly", "bantam", "feather", "light", "light welter", "welter", "light middle", "middle", "light heavy", "heavy"]
weights = []
while True:
try:
w = float(raw_input())
weights.append(w)
except EOFError:
break
map(print, map(grade, weights)) | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s998698122 | p00048 | Wrong Answer | # coding: utf-8
from __future__ import print_function
from bisect import bisect
def grade(weight):
return cls[bisect(bounds, weight)]
bounds = [48.001, 51.001, 54.001, 57.001, 60.001, 64.001, 69.001, 75.001, 81.001, 91.001]
cls = ["light fly", "fly", "bantam", "feather", "light", "light welter", "welter", "light middle", "middle", "light heavy", "heavy"]
weights = []
while True:
try:
w = float(raw_input())
weights.append(w)
except EOFError:
break
map(print, map(grade, weights)) | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s588029353 | p00048 | Wrong Answer | # -*- coding: utf-8 -*-
import sys
for line in sys.stdin:
w = float(line)
if w <= 48.00:
print "light fly"
elif w <= 51.00:
print "fly"
elif w <= 54.00:
print "bantam"
elif w <= 57.00:
print "feather"
elif w <= 60.00:
print "light"
elif w <= 64.00:
print "light welterr"
elif w <= 69.00:
print "welter"
elif w <= 75.00:
print "light middle"
elif w <= 81.00:
print "middle"
elif w <= 91.00:
print "light heavy"
else:
print "heavy" | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s687849101 | p00048 | Wrong Answer | while True:
try:
i = float(input())
if i <= 48.0: print("light fly")
elif i >= 48.1 and i <= 51.0: print("fly")
elif i >= 51.1 and i <= 54.0: print("bantam")
elif i >= 54.1 and i <= 57.0: print("feather")
elif i >= 57.1 and i <= 60.0: print("light")
elif i >= 60.1 and i <= 64.0: print("light welter")
elif i >= 64.1 and i <= 69.0: print("welter")
elif i >= 69.1 and i <= 75.0: print("light middle")
elif i >= 75.1 and i <= 81.0: print("middle")
elif i >= 81.1 and i <= 91.0: print("light heavy")
else: print("heavy")
except:
break | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s419277370 | p00048 | Wrong Answer | # -*- coding: utf-8 -*-
def judge_class(s):
if s <= 48.00:
return 'light fly'
elif 48.00 < s <= 51.00:
return 'fly'
elif 51.00 < s <= 54.00:
return 'bantam'
elif 54.00 < s <= 57.00:
return 'feather'
elif 57.00 < s <= 60.00:
return 'light'
elif 60.00 < s <= 64.00:
return 'light welter'
elif 64.00 < s <= 69.00:
return 'welter'
elif 69.00 < s <= 75.00:
return 'light middle'
elif 75.00 < s <= 81.00:
return 'middle'
elif 81.00 < s <= 91.00:
return 'light heavy'
elif 91.00 <= s:
return 'heavy'
if __name__ == '__main__':
weight = float(input())
print(judge_class(weight))
# print(judge_class(60.2) == 'light welter') | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s500748601 | p00048 | Wrong Answer | # -*- coding: utf-8 -*-
def judge_class(s):
if s <= 48.00:
return 'light fly'
elif 48.00 < s <= 51.00:
return 'fly'
elif 51.00 < s <= 54.00:
return 'bantam'
elif 54.00 < s <= 57.00:
return 'feather'
elif 57.00 < s <= 60.00:
return 'light'
elif 60.00 < s <= 64.00:
return 'light welter'
elif 64.00 < s <= 69.00:
return 'welter'
elif 69.00 < s <= 75.00:
return 'light middle'
elif 75.00 < s <= 81.00:
return 'middle'
elif 81.00 < s <= 91.00:
return 'light heavy'
elif 91.00 <= s:
return 'heavy'
weight = float(input())
print(judge_class(weight)) | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s501464656 | p00048 | Wrong Answer | while True:
try:
d= float(input())
except:
break
print("light fly" if d<=48 else ("fly" if d<=51 else ("bantam" if d<=54 else("feather" if d<=57 else("light" if d<=60 else("light welter" if d<=64 else("welter" if d<=69 else("light middle" if d<=75 else("middle" if d<=81 else("light heavt" if d<=91 else "heavy")))))))))) | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s497111263 | p00048 | Wrong Answer | while True:
try:
d= float(input())
except:
break
print("light fly" if d<=48 else \
("fly" if d<=51 else \
("bantam" if d<=54 else\
("feather" if d<=57 else\
("light" if d<=60 else\
("light welter" if d<=64 else\
("welter" if d<=69 else\
("light middle" if d<=75 else\
("middle" if d<=81 else("light heavt" if d<=91 else "heavy")))))))))) | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s531099207 | p00048 | Wrong Answer | while True:
try:
d= float(input())
print("light fly" if d<=48 else ("fly" if d<=51 else ("bantam" if d<=54 else("feather" if d<=57 else("light" if d<=60 else("light welter" if d<=64 else("welter" if d<=69 else("light middle" if d<=75 else("middle" if d<=81 else("light heavt" if d<=91 else "heavy"))))))))))
except:
break | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s636485578 | p00048 | Wrong Answer | import sys
for e in sys.stdin:
e=float(e)
h=['light ','']
a=h[e>91]+'heavy'if e>81 else h[e>75]+'middle'if e>69 else h[e>64]+'welter'if e>60 else'light'if e>57 else'feather'if e>51 else'bantam'if e>51 else h[e>48]+'fly'
print(a)
| 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s606075513 | p00048 | Wrong Answer | import bisect
w = [48, 51, 54, 57, 60, 64, 69, 75, 81, 91]
c = ["light fly", "fly", "bantam", "feather", "feather", "light welter", "welter", "light middle", "middle", "light heavy", "heavy"]
while 1:
try:print(c[bisect.bisect_left(w,float(input()))])
except:break
| 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s221817872 | p00048 | Wrong Answer | import sys
WEIGHT=[91.0, 81.0, 75.0, 69.0, 64.0, 60.0, 57.0, 54.0, 51.0, 48.0,1]
GRADE=['heavy', 'light heavy', 'middle', 'light', 'welter', 'light welter', 'light', 'feather', 'bantam', 'fly', 'light fly']
for line in sys.stdin.readlines():
weight=float(line.strip())
for i in xrange(len(GRADE)):
if weight/WEIGHT[i]>1:
print GRADE[i]
break | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s985810581 | p00048 | Wrong Answer | import sys
WEIGHT=[91.0, 81.0, 75.0, 69.0, 64.0, 60.0, 57.0, 54.0, 51.0, 48.0,0.001]
GRADE=['heavy', 'light heavy', 'middle', 'light', 'welter', 'light welter', 'light', 'feather', 'bantam', 'fly', 'light fly']
for line in sys.stdin.readlines():
weight=float(line.strip())
for i in xrange(len(GRADE)):
if weight/WEIGHT[i]>1:
print GRADE[i]
break | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s701042288 | p00048 | Wrong Answer | import sys
WEIGHT=[91.0, 81.0, 75.0, 69.0, 64.0, 60.0, 57.0, 54.0, 51.0, 48.0,0.001]
GRADE=['heavy', 'light heavy', 'middle', 'light', 'welter', 'light welter', 'light', 'feather', 'bantam', 'fly', 'light fly']
for line in sys.stdin.readlines():
weight=float(line.strip())
for i in xrange(len(GRADE)):
if weight/WEIGHT[i]>1:
print GRADE[i]
break
if weight==0:print GRADE[-1] | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s825216005 | p00048 | Wrong Answer | import sys
WEIGHT=[91.0, 81.0, 75.0, 69.0, 64.0, 60.0, 57.0, 54.0, 51.0, 48.0,-1]
GRADE=['heavy', 'light heavy', 'middle', 'light', 'welter', 'light welter', 'light', 'feather', 'bantam', 'fly', 'light fly']
for line in sys.stdin.readlines():
weight=float(line.strip())
for i in xrange(len(GRADE)):
if weight>WEIGHT[i]:
print GRADE[i]
break | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s800134512 | p00048 | Wrong Answer | import sys
WEIGHT=[91.0, 81.0, 75.0, 69.0, 64.0, 60.0, 57.0, 54.0, 51.0, 48.0,-1]
GRADE=['heavy', 'light heavy', 'middle', 'light', 'welter', 'light welter', 'light', 'feather',
'bantam', 'fly', 'light fly']
try:
for line in sys.stdin.readlines():
weight=float(line.strip())
for i in xrange(len(GRADE)):
if weight>WEIGHT[i]:
print GRADE[i]
break
except:
pass | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s685171853 | p00048 | Wrong Answer | def jug(a):
if a <= 48.0:
print "light fly"
elif a <= 51.0:
print "fly"
elif a <= 45.0:
print "bantam"
elif a <= 57.0:
print "feather"
elif a <= 60.0:
print "light"
elif a <= 64.0:
print "light welter"
elif a <= 69.0:
print 'welter'
elif a <= 75.0:
print "light middle"
elif a <= 81.0:
print "middle"
elif a <= 91.0:
print "light heavy"
else:
print "heavy"
while True:
try:
a = float(raw_input())
jug(a)
except EOFError:
break | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s939512427 | p00048 | Wrong Answer | while True:
try:
w = float(raw_input())
if w <= 48.0:
print "light fly"
elif w <= 51.0:
print "fly"
elif w <= 54.0:
print "bantam"
elif w <= 57.0:
print "feather"
elif w <= 60:
print "light"
elif w <= 64.0:
print "light welter"
elif w <= 69.0:
print "welter"
elif w <= 75.0:
print "light middle"
elif w <= 81.0:
print "light heavy"
else:
print "heavy"
except:
break | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s677706268 | p00048 | Time Limit Exceeded | while True:
try:
w=float(input())
if w<=48:
judge='light fly'
elif 48<=w<=51:
judge='fly'
elif 51<=w<=54:
judge='bantam'
elif 54<=w<=57:
judge='feather'
elif 57<=w<=60:
judge='light'
elif 60<=w<=64:
judge='light welter'
elif 64<=w<=69:
judge='welter'
elif 69<=w<=75:
judge='light middle'
elif 75<=w<=81:
judge='middle'
elif 81<=w<=91:
judge='light heavy'
else:
judge='heavy'
print(judge)
except:
pass | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s360507437 | p00048 | Accepted | while(True):
try: s = float(input())
except: break
if 91.0<s : print("heavy"); continue
if 81.0<s : print("light heavy"); continue
if 75.0<s : print("middle"); continue
if 69.0<s : print("light middle"); continue
if 64.0<s : print("welter"); continue
if 60.0<s : print("light welter"); continue
if 57.0<s : print("light"); continue
if 54.0<s : print("feather"); continue
if 51.0<s : print("bantam"); continue
if 48.0<s : print("fly"); continue
print("light fly")
| 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s809405094 | p00048 | Accepted | while 1:
try:
n=float(input())
if n>91:
print("heavy")
elif n>81:
print("light heavy")
elif n>75:
print("middle")
elif n>69:
print("light middle")
elif n>64:
print("welter")
elif n>60:
print("light welter")
elif n>57:
print("light")
elif n>54:
print("feather")
elif n>51:
print("bantam")
elif n>48:
print("fly")
else:
print("light fly")
except:break
| 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s726415577 | p00048 | Accepted | a,b=['light fly', 'fly', 'bantam', 'feather', 'light', 'light welter','welter', 'light middle', 'middle', 'light heavy', 'heavy'],[48, 51, 54, 57, 60, 64, 69, 75, 81, 91]
while 1:
try:
c=float(input())
except:break
for i in range(10):
if c<=b[i]:
print(a[i])
break
else: print(a[10])
| 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s684477387 | p00048 | Accepted | while True:
try:
weight = float(input())
if(weight <= 48.00):
print("light fly")
elif(weight <= 51.00):
print("fly")
elif(weight <= 54.00):
print("bantam")
elif(weight <= 57.00):
print("feather")
elif(weight <= 60.00):
print("light")
elif(weight <= 64.00):
print("light welter")
elif(weight <= 69.00):
print("welter")
elif(weight <= 75.00):
print("light middle")
elif(weight <= 81.00):
print("middle")
elif(weight <= 91.00):
print("light heavy")
else:
print("heavy")
except:
break;
| 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s286513811 | p00048 | Accepted | min = 40.00
max = 150.00
measure = [min, 48.00, 51.00, 54.00, 57.00, 60.00, 64.00, 69.00, 75.00, 81.00, 91.00, max]
className = ['light fly',
'fly',
'bantam',
'feather',
'light',
'light welter',
'welter',
'light middle',
'middle',
'light heavy',
'heavy']
while True:
try:
weight = float(input())
except:
break;
for i in range(11):
if(measure[i] < weight and weight <= measure[i + 1]):
print(className[i])
| 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s048882792 | p00048 | Accepted | # AOJ 0048
# Class
# 5/1/2019
min = 40.00
max = 150.00
measure = [min, 48.00, 51.00, 54.00, 57.00, 60.00, 64.00, 69.00, 75.00, 81.00, 91.00, max]
className = ['light fly',
'fly',
'bantam',
'feather',
'light',
'light welter',
'welter',
'light middle',
'middle',
'light heavy',
'heavy']
while True:
try:
weight = float(input())
except:
break;
for i in range(11):
if(measure[i] < weight and weight <= measure[i + 1]):
print(className[i])
| 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s801460819 | p00048 | Accepted | while True:
try:
w = float(input())
if w <= 48:
print('light fly')
elif w <= 51:
print('fly')
elif w <= 54:
print('bantam')
elif w <= 57:
print('feather')
elif w <= 60:
print('light')
elif w <= 64:
print('light welter')
elif w <= 69:
print('welter')
elif w <= 75:
print('light middle')
elif w <= 81:
print('middle')
elif w <= 91:
print('light heavy')
else:
print('heavy')
except:
break | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s247324134 | p00048 | Accepted | from sys import *
for s in stdin:
d = float(s)
if d <= 48.0: print "light fly"; continue
if d <= 51.0: print "fly"; continue
if d <= 54.0: print "bantam"; continue
if d <= 57.0: print "feather"; continue
if d <= 60.0: print "light"; continue
if d <= 64.0: print "light welter"; continue
if d <= 69.0: print "welter"; continue
if d <= 75.0: print "light middle"; continue
if d <= 81.0: print "middle"; continue
if d <= 91.0: print "light heavy"; continue
print "heavy" | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s686116137 | p00048 | Accepted | import sys
f = sys.stdin
classes = {'light fly':(00.00, 48.00),
'fly':(48.00, 51.00),
'bantam':(51.00, 54.00),
'feather':(54.00,57.00),
'light':(57.00,60.00),
'light welter':(60.00,64.00),
'welter':(64.00,69.00),
'light middle':(69.00,75.00),
'middle':(75.00,81.00),
'light heavy':(81.00,91.00),
'heavy':(91.00,1000.00)}
for line in f:
weight = float(line)
for class_name, weights in classes.items():
if weights[0] < weight <= weights[1]:
print(class_name)
break | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s209575149 | p00048 | Accepted | while True:
try:
n = float(input())
except:
break
if n <= 48:
print("light fly")
elif n > 48 and n <= 51:
print("fly")
elif n > 51 and n <= 54:
print("bantam")
elif n > 54 and n <= 57:
print("feather")
elif n > 57 and n <= 60:
print("light")
elif n > 60 and n <= 64:
print("light welter")
elif n > 64 and n <= 69:
print("welter")
elif n > 69 and n <= 75:
print("light middle")
elif n > 75 and n <= 81:
print("middle")
elif n > 81 and n <= 91:
print("light heavy")
else:
print("heavy") | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s903437752 | p00048 | Accepted | while True:
try:
weight=input()
if weight<=48.00:
print "light fly"
elif weight>91.00:
print "heavy"
else:
if weight<=51.00:
print "fly"
elif weight<=54.00:
print "bantam"
elif weight<=57.00:
print "feather"
elif weight<=60.00:
print "light"
elif weight<=64.00:
print "light welter"
elif weight<=69.00:
print "welter"
elif weight<=75.00:
print "light middle"
elif weight<=81.00:
print "middle"
else:
print "light heavy"
except:
break | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s320122620 | p00048 | Accepted | while True:
try:
weight = float(raw_input())
if weight <= 48.00:
print 'light fly'
elif 48.00 < weight <= 51.00:
print 'fly'
elif 51.00 < weight <= 54.00:
print 'bantam'
elif 54.00 < weight <= 57.00:
print 'feather'
elif 57.00 < weight <= 60.00:
print 'light'
elif 60.00 < weight <= 64.00:
print 'light welter'
elif 64.00 < weight <= 69.00:
print 'welter'
elif 69.00 < weight <= 75.00:
print 'light middle'
elif 75.00 < weight <= 81.00:
print 'middle'
elif 81.00 < weight <= 91.00:
print 'light heavy'
elif 91.00 < weight:
print 'heavy'
except EOFError:
break | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s698040135 | p00048 | Accepted | while 1:
try:
i=float(raw_input())
if i<=48.00:
print "light fly"
elif i<=51.00:
print "fly"
elif i<=54.00:
print "bantam"
elif i<=57.00:
print "feather"
elif i<=60.00:
print "light"
elif i<=64.00:
print "light welter"
elif i<=69.00:
print "welter"
elif i<=75.00:
print "light middle"
elif i<=81.00:
print "middle"
elif i<=91.00:
print "light heavy"
else:
print "heavy"
except:
break | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s907286048 | p00048 | Accepted | import sys
a,b,o,ab = 0,0,0,0
for line in sys.stdin.readlines():
w = float(line)
if w <= 48:
print('light fly')
elif 48 < w <= 51:
print('fly')
elif 51 < w <= 54:
print('bantam')
elif 54 < w <= 57:
print('feather')
elif 57 < w <= 60:
print('light')
elif 60 < w <= 64:
print('light welter')
elif 64 < w <= 69:
print('welter')
elif 69 < w <= 75:
print('light middle')
elif 75 < w <= 81:
print('middle')
elif 81 < w <= 91:
print('light heavy')
else:
print('heavy') | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s871130023 | p00048 | Accepted | def Class(x):
if x<=48.0:
print("light fly")
elif 48.0<x<=51.0:
print("fly")
elif 51.0<x<=54.0:
print("bantam")
elif 54.0<x<=57.0:
print("feather")
elif 57.0<x<=60.0:
print("light")
elif 60.0<x<=64.0:
print("light welter")
elif 64.0<x<=69.0:
print("welter")
elif 69.0<x<=75.0:
print("light middle")
elif 75.0<x<=81.0:
print("middle")
elif 81.0<x<=91.0:
print("light heavy")
else:
print("heavy")
while True:
try:
x=float(input())
Class(x)
except EOFError:
break | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s669816373 | p00048 | Accepted | import sys
for line in sys.stdin:
if float(line) <= 48.00: print "light fly"
elif 48.0 < float(line) <= 51.0: print "fly"
elif 51.0 < float(line) <= 54.0: print "bantam"
elif 54.0 < float(line) <= 57.0: print "feather"
elif 57.0 < float(line) <= 60.0: print "light"
elif 60.0 < float(line) <= 64.0: print "light welter"
elif 64.0 < float(line) <= 69.0: print "welter"
elif 69.0 < float(line) <= 75.0: print "light middle"
elif 75.0 < float(line) <= 81.0: print "middle"
elif 81.0 < float(line) <= 91.0: print "light heavy"
else:print "heavy" | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s326643557 | p00048 | Accepted | # -*- coding: utf-8 -*-
import sys
for line in sys.stdin:
w = float(line)
if w <= 48.00:
print "light fly"
elif w <= 51.00:
print "fly"
elif w <= 54.00:
print "bantam"
elif w <= 57.00:
print "feather"
elif w <= 60.00:
print "light"
elif w <= 64.00:
print "light welter"
elif w <= 69.00:
print "welter"
elif w <= 75.00:
print "light middle"
elif w <= 81.00:
print "middle"
elif w <= 91.00:
print "light heavy"
else:
print "heavy" | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s118414607 | p00048 | Accepted | import sys
for i in sys.stdin:
n = float(i)
if n <= 48:
print("light fly")
elif n <= 51:
print("fly")
elif n <= 54:
print("bantam")
elif n <= 57:
print("feather")
elif n <= 60:
print("light")
elif n <= 64:
print("light welter")
elif n <= 69:
print("welter")
elif n <= 75:
print("light middle")
elif n <= 81:
print("middle")
elif n <= 91:
print("light heavy")
else:
print("heavy") | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s642495628 | p00048 | Accepted | while True:
try:
i = float(input())
if i <= 48.0: print("light fly")
elif i <= 51.0: print("fly")
elif i <= 54.0: print("bantam")
elif i <= 57.0: print("feather")
elif i <= 60.0: print("light")
elif i <= 64.0: print("light welter")
elif i <= 69.0: print("welter")
elif i <= 75.0: print("light middle")
elif i <= 81.0: print("middle")
elif i <= 91.0: print("light heavy")
else: print("heavy")
except:
break | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s936989731 | p00048 | Accepted | name = ['light fly', 'fly', 'bantam', 'feather', 'light', 'light welter',
'welter', 'light middle', 'middle', 'light heavy', 'heavy']
ws = [48, 51, 54, 57, 60, 64, 69, 75, 81, 91]
while True:
try:
w = float(input())
except:
break
for i in range(10):
if w <= ws[i]:
print(name[i])
break
else:
print(name[10]) | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s064920182 | p00048 | Accepted | # -*- coding: utf-8 -*-
def judge_class(s):
if s <= 48.00:
return 'light fly'
elif 48.00 < s <= 51.00:
return 'fly'
elif 51.00 < s <= 54.00:
return 'bantam'
elif 54.00 < s <= 57.00:
return 'feather'
elif 57.00 < s <= 60.00:
return 'light'
elif 60.00 < s <= 64.00:
return 'light welter'
elif 64.00 < s <= 69.00:
return 'welter'
elif 69.00 < s <= 75.00:
return 'light middle'
elif 75.00 < s <= 81.00:
return 'middle'
elif 81.00 < s <= 91.00:
return 'light heavy'
elif 91.00 <= s:
return 'heavy'
while True:
try:
weight = float(input())
print(judge_class(weight))
except:
break | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s237229452 | p00048 | Accepted | while True:
try:
W = float(input())
if W <= 48:
print("light fly")
elif W <= 51:
print("fly")
elif W <= 54:
print("bantam")
elif W <= 57:
print("feather")
elif W <= 60:
print("light")
elif W <= 64:
print("light welter")
elif W <= 69:
print("welter")
elif W <= 75:
print("light middle")
elif W <= 81:
print("middle")
elif W <= 91:
print("light heavy")
else:
print("heavy")
except EOFError:
break
| 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s296119350 | p00048 | Accepted | level=["heavy","light heavy","middle","light middle","welter","light welter","light","feather","bantam","fly"]
weight=[91,81,75,69,64,60,57,54,51,48]
while True:
try:
w=float(input())
except:
break
f=False
for wei,lev in zip(weight,level):
if w>wei:
print(lev)
f=True
break
if not f:
print("light fly")
| 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s231734648 | p00048 | Accepted | level=["heavy","light heavy","middle","light middle","welter",
"light welter","light","feather","bantam","fly"]
weight=[91,81,75,69,64,60,57,54,51,48]
while True:
try:
w=float(input())
except:
break
f=False
for wei,lev in zip(weight,level):
if w>wei:
print(lev)
f=True
break
if not f:
print("light fly") | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s884406942 | p00048 | Accepted | a,b=['light fly', 'fly', 'bantam', 'feather', 'light', 'light welter','welter', 'light middle', 'middle', 'light heavy', 'heavy'],[48, 51, 54, 57, 60, 64, 69, 75, 81, 91]
while 1:
try:
c=float(input())
except:break
for i in range(10):
if c<=b[i]:
print(a[i])
break
else: print(a[10]) | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s215338212 | p00048 | Accepted | d={48:'light fly',51:'fly',54:'bantam',57:'feather',60:'light',64:'light welter',69:'welter',75:'light middle',81:'middle',91:'light heavy'}
while True:
try:
w=float(input())
except:
break
for k,v in sorted(d.items()):
if w<=k:
print(d[k])
break
else:
print("heavy") | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s167032436 | p00048 | Accepted | def weigh(w):
if w <= 48.0:
print('light fly')
elif w > 48.0 and w <= 51.0:
print('fly')
elif w > 51.0 and w <= 54.0:
print('bantam')
elif w > 54.0 and w <= 57.0:
print('feather')
elif w > 57.0 and w <= 60.0:
print('light')
elif w > 60.0 and w <= 64.0:
print('light welter')
elif w > 64.0 and w <= 69.0:
print('welter')
elif w > 69.0 and w <= 75.0:
print('light middle')
elif w > 75.0 and w <= 81.0:
print('middle')
elif w > 81.0 and w <= 91.0:
print('light heavy')
else:
print('heavy')
return 0
d = []
while True:
try:
d.append(float(input()))
except EOFError:
break
for i in range(len(d)):
weigh(d[i]) | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s033125804 | p00048 | Accepted | rank = ['heavy','light heavy','middle','light middle','welter','light welter','light','feather','bantam','fly','light fly']
lwgt=[91.00,81.00,75.00,69.00,64.00,60.00,57.00,54.00,51.00,48.00,0.0]
while True:
try:
wgt = float(input().strip())
for i in range(len(lwgt)):
if wgt > lwgt[i]:
print(rank[i])
break
except EOFError:
break | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s691470794 | p00048 | Accepted | while True:
try:
N = float(input())
except EOFError:
break
if N <= 48.0:
print('light fly')
elif N <= 51.0:
print('fly')
elif N <= 54.0:
print('bantam')
elif N <= 57.0:
print('feather')
elif N <= 60.0:
print('light')
elif N <= 64.0:
print('light welter')
elif N <= 69.0:
print('welter')
elif N <= 75.0:
print('light middle')
elif N <= 81.0:
print('middle')
elif N <= 91.0:
print('light heavy')
else:
print('heavy') | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s362778433 | p00048 | Accepted | classes = ["light fly","fly","bantam","feather","light","light welter","welter","light middle","middle","light heavy","heavy"]
border = [48,51,54,57,60,64,69,75,81,91]
while True:
try:
w = float(input())
for i in range(len(border)):
if w <= border[i]:
print(classes[i])
break
else: print(classes[-1])
except EOFError: break | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
s156387167 | p00048 | Accepted | # -*- coding: utf-8 -*-
import sys
import os
import math
import itertools
for s in sys.stdin:
w = float(s)
if w <= 48:
print('light fly')
elif w <= 51:
print('fly')
elif w <= 54:
print('bantam')
elif w <= 57:
print('feather')
elif w <= 60:
print('light')
elif w <= 64:
print('light welter')
elif w <= 69:
print('welter')
elif w <= 75:
print('light middle')
elif w <= 81:
print('middle')
elif w <= 91:
print('light heavy')
else:
print('heavy') | 60.2
70.2
48.0
80.2
| light welter
light middle
light fly
middle
|
<H1>階級</H1>
<p>
ボクシングは体重によって階級が分けられています。体重を読み込んで、その階級を出力するプログラムを作成してください。階級と体重の関係は以下の表のとおりとします。
</p>
<center>
<table border=1>
<tr><td bgcolor="#88AAFF" width="120">階級</td><td bgcolor="#88AAFF" width="240">体重（kg）</td></tr>
<tr><td>light fly</td><td>48.00kg 以下</td></tr>
<tr><td>fly</td><td>48.00kg 超 51.00kg 以下</td></tr>
<tr><td>bantam</td><td>51.00kg 超 54.00kg 以下</td></tr>
<tr><td>feather</td><td>54.00kg 超 57.00kg 以下</td></tr>
<tr><td>light</td><td>57.00kg 超 60.00kg 以下</td></tr>
<tr><td>light welter</td><td>60.00kg 超 64.00kg 以下</td></tr>
<tr><td>welter</td><td>64.00kg 超 69.00 kg 以下</td></tr>
<tr><td>light middle</td><td>69.00kg 超 75.00 kg 以下</td></tr>
<tr><td>middle</td><td>75.00kg 超 81.00 kg 以下</td></tr>
<tr><td>light heavy</td><td>81.00kg 超 91.00 kg 以下</td></tr>
<tr><td>heavy</td><td>91.00kg 超</td></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、体重を表す１つの実数 <var>w</var> (40 ≤ <var>w</var> ≤ 150) が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、対応する階級を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
60.2
70.2
48.0
80.2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
light welter
light middle
light fly
middle
</pre>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.