submission_id string | problem_id string | status string | code string | input string | output string | problem_description string |
|---|---|---|---|---|---|---|
s238715161 | p00061 | Wrong Answer | team_score=[]
while True:
x,y=map(int,input().split(','))
if x==y==0:
break
team_score.append((x,y))
team_score.sort(key=lambda x:x[1],reverse=True)
for i,j in team_score:
print(i) | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s624379866 | p00061 | Wrong Answer | def Inquiry(team):
ranking=1
score=team_score[0][1]
for i in team_score:
if score>i[1]:
ranking+=1
score=i[1]
if i[0]==team:
return ranking
team_score=[]
while True:
x,y=map(int,input().split(','))
if x==y==0:
break
team_score.append((x,y))
print(team_score)
team_score.sort(key=lambda x:x[1],reverse=True)
print(team_score)
while True:
try:
team=int(input())
print(Inquiry(team))
except EOFError:
break | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s984868420 | p00061 | Wrong Answer | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0061
"""
import sys
def calc_rank(data):
scores = {} # ?????????key, ???????????????id???????????????value??¨?????????????????????
for id, point in data:
if point in scores:
scores[point].append(id)
else:
scores[point] = [id]
ranks = [k for k in scores.keys()] # ranks.index(point) ?????????????????????????????????
ranks.sort(reverse=True)
ranks.insert(0, 0) # index???1?????????????????????????????????????????????????????\
return scores, ranks
def check_rank(scores, ranks, id):
for k, v in scores.items():
if id in v:
return ranks.index(k)
def main(args):
data = []
id, point = [int(x) for x in input().strip().split(',')]
while id != 0 or point != 0:
data.append((id, point))
id, point = [int(x) for x in input().strip().split(',')]
scores, ranks = calc_rank(data)
for line in sys.stdin:
id = int(line.strip())
result = check_rank(scores, ranks, id)
print(result)
if __name__ == '__main__':
main(sys.argv[1:]) | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s940224583 | p00061 | Wrong Answer | def get_input():
while True:
try:
yield ''.join(input())
except EOFError:
break
teams = [0 for i in range(101)]
points = [False for i in range(31)]
while True:
a,b = [int(i) for i in input().split(",")]
if a == 0 and b == 0:
break
teams[a] = b
points[b] = True
N = list(get_input())
for l in range(len(N)):
q = int(N[l])
p = teams[q]
ans = 0
for i in range(30,0,-1):
if points[i]:
ans += 1
if i == p:
break
print(ans)
| 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s287538025 | p00061 | Wrong Answer | points = [] ; times = 0
while True:
x = map(int,raw_input().split(','))
if x[0]==0 and x[1]==0: break
else:
points.append(x[1]) ; times += 1 ; continue
sets = dict(zip(range(times),list(points)))
points.sort(reverse=True)
while True:
try:
y = input() - 1
for val in xrange(times):
if sets[y] == points[val] : print val+1
except: break | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s987245875 | p00061 | Wrong Answer | a = []
while True:
p = map(int, raw_input().split(','))
if p[0] == 0 and p[1] == 0: break
a.append(p)
a.sort(key=lambda p: p[1], reverse=True)
a[0].append(1)
for i, p in zip(range(1, len(a) + 1), a)[1:]:
if a[i - 2][1] == p[1]:
p.append(a[i - 2][-1])
else:
p.append(a[i - 2][-1] + 1)
b = {i: [j, n] for i, n, j in a}
print b
try:
while True:
p = b[int(raw_input())]
print p[0]
except EOFError:
pass | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s641601694 | p00061 | Accepted | table = {}
while True:
p, s = map(int, input().split(","))
if p == 0:
break
table[p] = s
result = {v: i for i, v in enumerate(sorted(set(table.values()), reverse=True), start=1)}
try:
while True:
q = int(input())
print(result[table[q]])
except EOFError:
pass
| 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s587617732 | p00061 | Accepted | data = {}
while True:
team, score = input().split(',')
if team == score == '0': break
if int(score) in data:
data[int(score)].append(team)
else:
data[int(score)] = [team]
while True:
try:
n = input()
except:
break
for d in data.keys():
if n in data[d]:
tmp = reversed(list(data.keys()))
ind = list(tmp).index(d)
print(ind + 1) | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s164953008 | p00061 | Accepted | tp = {}
while 1:
t,p = map(int,raw_input().split(","))
if t == p == 0: break
tp[t] = p
plist = sorted([tp[key] for key in tp.keys()],reverse = True)
prank = {}
rank = 1
point = plist[0]
for i in range(len(plist)):
if plist[i] < point:
point = plist[i]
rank += 1
prank[point] = rank
while 1:
try:
team = int(raw_input())
except:
break
print prank[tp[team]] | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s394747761 | p00061 | Accepted | tp = {}
while 1:
t,p = map(int,raw_input().split(","))
if t == p == 0: break
tp[t] = p
plist = sorted(list(set([tp[key] for key in tp.keys()])),reverse = True)
while 1:
try:
team = int(raw_input())
except:
break
print plist.index(tp[team])+1 | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s431374906 | p00061 | Accepted | tp = {}
while 1:
t,p = map(int,raw_input().split(","))
if t==p==0:break
tp[t]=p
ls=sorted(list(set([tp[key] for key in tp.keys()])),reverse=True)
while 1:
try:team=int(raw_input())
except:break
print ls.index(tp[team])+1 | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s385892810 | p00061 | Accepted | import sys
d={}
while 1:
a,b=map(int,raw_input().split(","))
if a==b==0: break
d[a]=b
x=sorted(set(d.values()))[::-1]
for s in sys.stdin:
print x.index(d[int(s)])+1 | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s341266607 | p00061 | Accepted | from bisect import bisect
import sys
d = {}
p = []
for s in sys.stdin:
t,n = map(int,s.split(","))
if [t,n] == [0,0]: break
d[t] = n
p.append(n)
p = sorted(list(set(p)))
for s in sys.stdin:
print len(p)+1 -bisect(p, d[int(s)]) | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s813526626 | p00061 | Accepted | import sys
f = sys.stdin
teams = {}
scores = set()
while True:
team, score = map(int, f.readline().split(','))
if team == score == 0:
break
teams[team] = score
scores.update([score])
scores = sorted(list(scores))[::-1]
for line in f:
print(scores.index(teams[int(line)]) + 1) | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s600340676 | p00061 | Accepted | l = []
s = set()
while True:
n, a = input()
if n == a == 0:
break;
l.append(a)
s.add(a)
s = list(s)
s.reverse()
while True:
try:
n = input()
except:
break
print(s.index(l[n-1])+1) | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s483575173 | p00061 | Accepted | result = {}
while True:
num, accepted = map(int, raw_input().split(','))
if num == 0 and accepted == 0:
break
else:
result[num] = accepted
rank = 1
accepted = 0
for k, v in sorted(result.items(), key=lambda x: x[1], reverse=True):
if accepted > v:
rank += 1
result[k] = rank
accepted = v
while True:
try:
num = int(raw_input())
print result[num]
except EOFError:
break | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s262740623 | p00061 | Accepted | list = []
dict = {}
while True:
team,point = map(int,raw_input().split(","))
if team == 0 and point == 0:
break
dict[team] = point
if not point in list:
list.append(point)
list.sort()
list.reverse()
while True:
try:
team = int(raw_input())
except EOFError:
break
print list.index(dict[team]) + 1 | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s022404743 | p00061 | Accepted | import sys
d1 = {}
l = []
while True:
a,b = input().split(',')
if (a,b) == ('0','0'):
break
else:
d1[a] = int(b)
if (int(b) not in l):
l.append(int(b))
l.sort()
l.reverse()
for line in sys.stdin.readlines():
n = line.replace('\n','')
print(l.index(d1[n])+1) | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s393392587 | p00061 | Accepted | l=set()
s={}
while 1:
n,k=map(int,raw_input().split(','))
if n==k==0:
break
l.add(k)
s[n]=k
l2=sorted(list(l))[::-1]
while 1:
try:
n=int(raw_input())
print l2.index(s[n])+1
except:
break | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s506801142 | p00061 | Accepted | def Inquiry(team):
ranking=1
score=team_score[0][1]
for i in team_score:
if score>i[1]:
ranking+=1
score=i[1]
if i[0]==team:
return ranking
team_score=[]
while True:
x,y=map(int,input().split(','))
if x==y==0:
break
team_score.append((x,y))
#print(team_score)
team_score.sort(key=lambda x:x[1],reverse=True)
#print(team_score)
while True:
try:
team=int(input())
print(Inquiry(team))
except EOFError:
break | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s351244908 | p00061 | Accepted | #encoding=utf-8
import sys
data1, data2 = [], []
while True:
x = map(int, raw_input().split(","))
if sum(x) == 0:
break
data1.append([x[1], x[0]])
i = 1
data1 = sorted(data1)[::-1]
data1[0].insert(2,1)
ma = data1[0][0]
while True:
if ma == data1[i][0]:
data1[i].insert(2, (data1[i - 1][2]))
elif ma > data1[i][0]:
data1[i].insert(2,((data1[i - 1][2]) + 1))
ma = data1[i][0]
i += 1
if i >= len(data1):
break
for i in sys.stdin:
for j in xrange(len(data1)):
if int(i) == data1[j][1]:
print data1[j][2]
break | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s500696368 | p00061 | Accepted | arr = {}
rankScore = []
while True:
s = list(map(int, input().split(',')))
if s[0] == 0:
break
arr[s[0]] = s[1]
if s[1] not in rankScore:
rankScore.append(s[1])
rankScore.sort(reverse = True)
while True:
try:
num = int(input())
print(rankScore.index(arr[num])+1)
except:
break | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s200711087 | p00061 | Accepted | ps, ses = [], []
while True:
p, s = map(int, input().split(','))
if not p:
break
ps.append(p)
ses.append(s)
rank = []
for s in ses:
if s not in rank:
rank.append(s)
rank.sort(reverse=True)
while True:
try:
q = int(input())
except:
break
print(rank.index(ses[ps.index(q)]) + 1) | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s261441864 | p00061 | Accepted | import itertools
from operator import itemgetter
nums={}
while True:
p,s=map(int,input().split(','))
if(p==0 and s==0):break
if not s in nums:
nums[s]=[]
nums[s].append(p)
while True:
try:
q=int(input())
ans=len(nums)
for ns in nums.items():
if q in ns[1]:
print(ans)
break
ans-=1
except:
break | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s019995097 | p00061 | Accepted | nums={}
while True:
p,s=map(int,input().split(','))
if(p==0 and s==0):break
if not s in nums:
nums[s]=[]
nums[s].append(p)
while True:
try:
q=int(input())
ans=len(nums)
for ns in nums.items():
if q in ns[1]:
print(ans)
break
ans-=1
except:
break | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s088644816 | p00061 | Accepted | Poi = []
Tea = []
while True:
p,s = map(int,input().split(","))
if p == 0 and s == 0:
break
Poi.append(s)
Tea.append(p)
Poi_ran = sorted(sorted(set(Poi), key=Poi.index))
while True:
try:
q = int(input())
point = Poi[Tea.index(q)]
print(len(Poi_ran) - Poi_ran.index(point))
except EOFError:
break | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s172130185 | p00061 | Accepted | import sys
import fileinput
import math
ips = []
for line in fileinput.input():
ips.append(line)
data = []
i = 0
while True:
ip = [ int(i) for i in ips[i].strip().split(',')]
if ip == [0,0] : break;
else: data.append(ip)
i+=1
data = sorted(data,key=lambda x:-x[1])
counter = 0
score = -1
m = {}
for k, s in data:
if s != score:
counter+=1
score = s
m[k] = counter
for a in range(i+1, len(ips)):
ip = int(ips[a].strip())
print(m[ip]) | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s933661141 | p00061 | Accepted | ps=[]
while True:
p, s= map(int, input().split(","))
if p==s==0: break
ps.append((p, s))
o= sorted(set(s for p, s in ps), reverse=True)
zo= dict(zip(o, [i+1 for i in range(len(o))]))
while True:
try:
q= int(input())
for p, s in ps:
if p== q: print(zo[s])
except:
break | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s472191547 | p00061 | Accepted | p = []
while True:
s = input()
if s == "0,0":
break
p.append([int(i) for i in s.split(",")])
p.sort(key = lambda x : x[1], reverse = True)
while True:
try:
n = int(input())
except:
break
ans = 1
for i in range(len(p)):
if i != 0 and p[i][1] != p[i - 1][1]:
ans += 1
if p[i][0] == n:
print(ans)
break | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s513313260 | p00061 | Accepted | c=[]
d={}
while 1:
a,b=map(int,input().split(','))
if a==0:break
c+=[b]
d[a]=b
c=sorted(set(c))[::-1]
while 1:
try:print(c.index(d[int(input())])+1)
except:break | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s668016086 | p00061 | Accepted | po = []
t2p = {}
while True:
t, p = list(map(int, input().strip().split(',')))
if t==0 and p==0:
break
t2p[t] = p
po.append(p)
ps = sorted(list(set(po)),reverse=True)
while True:
try:
q = int(input().strip())
r = 1
for i in ps:
if t2p[q] < i:
r += 1
else:
break
print(r)
except EOFError:
break | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s898015485 | p00061 | Accepted | A = {}
while True:
p,s = map(int,input().split(','))
if p == 0:
break
A [p] = s
while True:
try:
q = int(input())
except EOFError:
break
st = {A [i] for i in A.keys() if i != q and A [i] > A [q]}
print(len(st) + 1) | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s353905240 | p00061 | Accepted | # -*- coding: utf-8 -*-
import sys
import os
scores = [0]
for s in sys.stdin:
p, s = map(int, s.split(','))
if p == s == 0:
break
else:
scores.append(s)
score_set = set(scores)
score_set = list(score_set)
score_set.sort(reverse=True)
for s in sys.stdin:
n = int(s)
teams_score = scores[n]
print(score_set.index(teams_score) + 1) | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s716731985 | p00061 | Accepted | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0061
"""
import sys
def calc_rank(data):
scores = {} # ?????????key, ???????????????id???????????????value??¨?????????????????????
for id, point in data:
if point in scores:
scores[point].append(id)
else:
scores[point] = [id]
ranks = [k for k in scores.keys()] # ranks.index(point) ???????????????????????????????????????????????????
ranks.sort(reverse=True)
ranks.insert(0, -1) # index???1?????????????????????????????????????????????????????\
return scores, ranks
def check_rank(scores, ranks, id):
for k, v in scores.items():
if id in v:
return ranks.index(k)
def main(args):
data = []
id, point = [int(x) for x in input().strip().split(',')]
while id != 0 or point != 0:
data.append((id, point))
id, point = [int(x) for x in input().strip().split(',')]
scores, ranks = calc_rank(data)
for line in sys.stdin:
id = int(line.strip())
result = check_rank(scores, ranks, id)
print(result)
if __name__ == '__main__':
main(sys.argv[1:]) | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s675875116 | p00061 | Accepted | # Aizu Problem 0061: Rank Checker
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
points = {}
while True:
no, p = [int(_) for _ in input().split(',')]
if no == p == 0:
break
if p not in points:
points[p] = []
points[p].append(no)
rank = sorted(list(points.keys()), reverse=True)
while True:
try:
team = int(input())
except EOFError:
break
for i in range(len(rank)):
if team in points[rank[i]]:
print(i + 1)
break | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s935750239 | p00061 | Accepted | score = [[] for i in range(31)]
while True:
try:
p, s = map(int, input().split(","))
if p == 0:
break
score[s].append(p)
except:
break
rank = {}
j = 1
for i in range(31)[::-1]:
if len(score[i]) > 0:
rank[i] = j
j += 1
while True:
try:
p = int(input())
for i in range(31):
if p in score[i]:
print(rank[i])
except:
break
| 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s086017549 | p00061 | Accepted | def get_input():
while True:
try:
yield ''.join(input())
except EOFError:
break
teams = [0 for i in range(101)]
points = [False for i in range(31)]
while True:
a,b = [int(i) for i in input().split(",")]
if a == 0 and b == 0:
break
teams[a] = b
points[b] = True
N = list(get_input())
for l in range(len(N)):
q = int(N[l])
p = teams[q]
ans = 0
for i in range(30,-1,-1):
if points[i]:
ans += 1
if i == p:
break
print(ans)
| 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s595870745 | p00061 | Accepted | import sys
d,e={},{}
for x in iter(input,'0,0'):
p,s=map(int,x.split(','))
d.setdefault(s,[]);d[s]+=[p]
e[p]=s
for y in sys.stdin:print(sorted(d.keys())[::-1].index(e[int(y)])+1)
| 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s574737004 | p00061 | Accepted | import sys
c,d=[],{}
for x in iter(input,'0,0'):
p,s=map(int,x.split(','))
c+=[s]
d[p]=s
for y in sys.stdin:print(sorted({*c})[::-1].index(d[int(y)])+1)
| 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s536066006 | p00061 | Accepted | import sys
c,d=[],{}
for x in iter(input,'0,0'):p,s=map(int,x.split(','));c+=[s];d[p]=s
for y in sys.stdin:print(sorted({*c})[::-1].index(d[int(y)])+1)
| 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s091969421 | p00061 | Accepted | lst = []
while True:
p, s = map(int, input().split(","))
if not p:
break
lst.append((s, p))
lst.sort(reverse=True)
dic = {}
rank = 0
solve_num = 0
for t in lst:
if solve_num == t[0]:
dic[t[1]] = rank
else:
rank += 1
solve_num = t[0]
dic[t[1]] = rank
while True:
try:
print(dic[int(input())])
except EOFError:
break
| 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s135522432 | p00061 | Accepted | import sys
from collections import Counter
p=[tuple(map(int,l.split(","))) for l in sys.stdin]
d=[i for i in p if len(i)==2][:-1]
rank=sorted(Counter([i[1] for i in d]).keys(),reverse=True)
m=sorted(d,key=lambda x:x[1],reverse=True)
tix=[i[0] for i in p if len(i)==1]
[print(rank.index(k[1])+1) for k in [i for i in m for j in tix if i[0]==j]]
| 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s344466821 | p00061 | Accepted | # AOJ 0061 Rank Checker
# Python3 2018.6.15 bal4u
team = {}
while True:
p, s = list(map(int, input().split(',')))
if p == 0: break
team[p] = s
tbl = sorted(team.items(), key=lambda x:x[1], reverse=True)
ans = [0]*101
ans[tbl[0][0]] = ord = 1
for i in range(1,len(tbl)):
if tbl[i][1] < tbl[i-1][1]: ord += 1
ans[tbl[i][0]]= ord
while True:
try:
print(ans[int(input())])
except EOFError:
break
| 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s420505212 | p00061 | Accepted | import sys
li=[0]*101
sc=[False]*31
ra=[0]*31
while True:
(n,s)=map(int,raw_input().split(","))
if (n,s)==(0,0):break
sc[s]=True
li[n]=s
r=1
for i in xrange(30,-1,-1):
if sc[i]:
ra[i]=r
r+=1
for line in sys.stdin.readlines():
print ra[li[int(line.strip())]] | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s836477317 | p00061 | Accepted |
import sys
import itertools
class Team:
def __init__(self, number, score):
self.number = number
self.score = score
class RankChecker:
def __init__(self):
self.teams = []
def add(self, team):
self.teams.append(team)
def aggregate(self):
self.teams.sort(key=lambda t: t.score, reverse=True)
r = 0
for k, g in itertools.groupby(self.teams, key=lambda t: t.score):
r += 1
for t in g:
t.rank = r
def check_rank(self, team_number):
team = filter(lambda t: t.number == team_number, self.teams)[0]
return team.rank
rc = RankChecker()
for line in sys.stdin:
num, score = map(int, line.strip().split(','))
if (num, score) == (0, 0):
break
rc.add(Team(num, score))
rc.aggregate()
for line in sys.stdin:
num = int(line)
print rc.check_rank(num) | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s533455583 | p00061 | Accepted | team = [0 for i in range(101)]
point= [[0 for i in range(2)] for i in range(31)]
while 1:
temp= map(int, raw_input().split(','))
if temp[0] ==0==temp[1]:
break
team[temp[0]]=temp[1]
if point[temp[1]][1]==0:
point[temp[1]][1]=1
for i in range(temp[1]+1):
point[i][0]+=1
while 1:
try:
n = input()
print point[team[n]][0]
except EOFError:
break | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s311173837 | p00061 | Accepted | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
L = []
while True:
line = stdin.readline()
if line.startswith('0,0'):
break
L.append(tuple(int(s) for s in line.split(',')))
L.sort(key=lambda (id, point): point, reverse=True)
for line in stdin:
n = int(line)
order = 0
p = 0
for id, point in L:
if p != point:
p = point
order += 1
if n == id:
break
print(order) | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s424261508 | p00061 | Accepted | t = []
while 1:
n,a = map(int, raw_input().split(','))
if n==a==0: break
t.append([a,n])
t.sort(reverse = True)
o = [0]*(len(t)+1); c = 1;
o[t[0][1]] = 1;
for i in xrange(1,len(t)):
if t[i-1][0]!=t[i][0]:
c += 1
o[t[i][1]] = c
while 1:
try:
n = input()
print o[n]
except EOFError:
break | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s555957660 | p00061 | Accepted | import sys
d={}
f=0
for s in sys.stdin:
if f==0:
a,b=map(int,s.split(","))
if a==0 and b==0:
x=sorted(set(d.values()))[::-1]
f=1
else:d[a]=b
else:
print x.index(d[int(s)])+1 | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s565222928 | p00061 | Accepted | import sys
d={}
f=0
for s in sys.stdin:
if f==0:
a,b=map(int,s.split(","))
if a!=0 or b!=0:d[a]=b
else:
x=sorted(set(d.values()))[::-1]
f=1
else:print x.index(d[int(s)])+1 | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s534764187 | p00061 | Accepted | flag = 1
data = []
query = []
while True:
try:
while flag:
n,s = map(int, raw_input().split(","))
if n == 0 and s == 0:
flag = 0
break
data.append([s,n])
query.append(int(raw_input()))
except:
break
data.sort(); data.reverse()
rank = 0
rslt = {}
mx = 31
for i in data:
if i[0] < mx:
rank += 1
mx = i[0]
rslt[i[1]] = rank
for i in query:
print rslt[i] | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s228408784 | p00061 | Accepted | teams = dict()
while 1:
a, b = map(int, raw_input().split(','))
if a == b == 0:
break
teams[a] = b
cur = 1 << 30
cur_rank = 0
ret = dict()
for k, v in sorted(teams.items(), key=lambda a: a[1], reverse=True):
if v < cur:
cur_rank += 1
cur = v
ret[k] = cur_rank
while 1:
try:
query = input()
print ret[query]
except EOFError:
break | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s359702095 | p00061 | Accepted | lst = []
while True:
p, s = map(int, input().split(','))
if p == 0 :
break
lst.append(s)
s = list(set(lst))
s.sort(reverse = True)
while True:
try:
num = int(input())
print(s.index(lst[num-1]) +1)
except EOFError:
break
| 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s855734803 | p00061 | Accepted | List = [0] * 101
while True :
p, s = map(int, input().split(","))
if p == 0 and s == 0 :
break
List[p] = s
Sorted_List = sorted(list(set(List)), reverse = True)
while True :
try :
q = int(input())
except EOFError :
break
print(Sorted_List.index(List[q])+1)
| 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s060643221 | p00061 | Accepted |
c = []
d = {}
while True:
a,b = map(int, input().split(','))
c += [b]
d[a] = b
if a == 0 : break
c = sorted(set(c))[::-1]
while True:
try:print(c.index(d[int(input())])+1)
except: break
| 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s254227732 | p00061 | Accepted | datas = []
while True:
n,s = (int(x) for x in input().split(","))
if n == 0:
break;
datas.append((n,s))
datas = sorted(datas,key = lambda x:x[1],reverse=True)
while True:
try:
q = int(input())
rank = 1
score = datas[0][1]
for n,s in datas:
if score > s:
score = s
rank += 1
if n == q:
break
print(rank)
except:
break
| 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s475262913 | p00061 | Accepted | #正解数で順位を決定
team=[]
point=[]
dic={}
while True:
p,s=map(int, input().split(","))
if p==s==0:
break
team.append([p,s])
if s not in point:
point.append(s)
point.sort(reverse=True)
#辞書(得点,順位)で作る
for i in range(len(point)):
dic[point[i]]=i+1
while True:
try:
n=int(input())
except EOFError:
break
print(dic[team[n-1][1]])
| 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s856714391 | p00061 | Accepted | P = [-1] * 101
while True:
t, p = [int(x) for x in input().split(",")]
if t == 0 and p == 0:
break
P[t] = p
L = sorted(set(P),reverse=True)
#print(L)
d = dict()
for rank, point in enumerate(L,start=1):
d[point] = rank
#print(d)
while True:
try:
t = int(input())
except:
break
p = P[t]
print(d[p])
| 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s986390082 | p00061 | Accepted | t = [0] * 101
while 1:
p, s = map(int, input().split(','))
if p == s == 0:
break
t[p] = s
rank = list(set(t))
rank.sort(reverse=True)
while 1:
try:
n = int(input())
print(rank.index(t[n])+1)
except:
break
| 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s754863749 | p00061 | Accepted | if __name__ == '__main__':
ans = []
ans2 = []
while True:
n,m = map(int,input().split(","))
if n == 0 and m == 0:
break
if m not in ans:
ans.append(m)
ans2.append((n,m))
ans.sort()
ans.reverse()
while True:
try:
x = int(input())
y = ans2[x-1][1]
ind = ans.index(y) + 1
print(ind)
except EOFError:
break
| 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s892339979 | p00061 | Accepted | def answer():
point={}
number=[]
number_n=[]
while 1:
N=list(map(int,input().split(",")))
if N==[0,0]:break
number.append(N)
number_n.append(N[1])
number_n=sorted(number_n)[::-1]
count=1
co=number_n[0]
for i in number_n:
if i in point:continue
elif i<co:
count +=1
co=i
point[co]=count
else:point[i]=count
data={}
for j in number:
if j[1] in point:data[j[0]]=point[j[1]]
return data
ans=answer()
while 1:
try:print(ans[int(input())])
except:break
| 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s614361037 | p00061 | Accepted | team=[0]*101
while 1:
p,s=map(int,input().split(","))
if p==s==0:break
team[p]=s
rank=list(set(team))
rank.sort(reverse=True)
while 1:
try:
n=int(input())
print(rank.index(team[n])+1)
except:break
| 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s753939159 | p00061 | Accepted | p = []
q = []
while(1):
a,b = [int(i) for i in input().split(",")]
if a == 0 and b == 0:
break
p.append(a)
q.append(b)
q_ = sorted(list(set(q)))
q_rank = [i+1 for i in range(len(q_))[::-1]]
q_dic = dict(zip(q_,q_rank))
rank = dict(zip(p,[q_dic[i] for i in q]))
while(1):
try:
a = int(input())
print(rank[a])
except EOFError:
break
| 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s559565404 | p00061 | Accepted | scorelist = []
while 1:
num, score = map(int, input().split(","))
if num == 0 and score == 0:
break
scorelist.append(score)
score_unique = list(set(scorelist))
score_unique.sort(reverse=True)
while 1:
try:
q = int(input())
except:
break
score = scorelist[q-1]
for i, s in enumerate(score_unique):
if score == s:
print(i + 1)
| 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s562766312 | p00061 | Runtime Error | # -*- coding: utf-8 -*-
import sys
class Team_class():
def __init__(self, id, score):
self.id = id
self.score = score
self.rank = 0
team = []
for line in sys.stdin:
id, s = map(int, line.split(','))
if id + s == 0:
break
team.append(Team_class(id, s))
for i in range(len(team)):
for j in range(i, len(team)):
if team[i].score < team[j].score:
team[i], team[j] = team[j], team[i]
tmpscore = team[0].score
tmprank = 1
for i in range(len(team)):
if tmpscore != team[i].score:
tmpscore = team[i].score
tmprank += 1
team[i].rank = tmprank
for line in sys.stdin:
print team[int(line)].rank | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s534427858 | p00061 | Runtime Error | # -*- coding: utf-8 -*-
import sys
class Team_class():
def __init__(self, id, score):
self.id = id
self.score = score
self.rank = 0
team = []
while True:
id, s = map(int, raw_input().split(','))
if id + s == 0:
break
team.append(Team_class(id, s))
for i in range(len(team)):
for j in range(i, len(team)):
if team[i].score < team[j].score:
team[i], team[j] = team[j], team[i]
tmpscore = team[0].score
tmprank = 1
for i in range(len(team)):
if tmpscore != team[i].score:
tmpscore = team[i].score
tmprank += 1
team[i].rank = tmprank
for line in sys.stdin:
print team[int(line)].rank | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s311785964 | p00061 | Runtime Error | import sys
c,d=[],{}
for x in iter(input,'0,0'):p,s=map(int,x.split(','));c+=[s];d[p]=s
for y in sys.stdin:print({*c}.sort()[::-1].index(d[int(y)])+1)
| 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s256495273 | p00061 | Runtime Error |
team = [0 for i in range(101)]
point= [[0 for i in range(2)] for i in range(31)]
while 1:
temp= map(int, raw_input().split(','))
if temp[0] ==0==temp[1]:
break
team[temp[0]]=temp[1]
if point[temp[1]][1]==0:
point[temp[1]][1]=1
for i in range(temp[1]+1):
point[i][0]+=1
while 1:
n = input()
print point[team[n]][0] | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s549105475 | p00061 | Runtime Error | team = [0 for i in range(101)]
point= [[0 for i in range(2)] for i in range(31)]
while 1:
temp= map(int, raw_input().split(','))
if temp[0] ==0==temp[1]:
break
team[temp[0]]=temp[1]
if point[temp[1]][1]==0:
point[temp[1]][1]=1
for i in range(temp[1]+1):
point[i][0]+=1
while 1:
try:
n = input()
print point[team[n]][0]
except EOFerror:
break | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
|
<H1>Rank Checker</H1>
<!--
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。参加者チーム数は不明ですが、かなり多い模様です（主催者のささやかな要望でもあります）。正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
-->
<p>
時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。
</p>
<p>
予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。
</p>
<pre>
<var>p<sub>1</sub></var>,<var>s<sub>1</sub></var>
<var>p<sub>2</sub></var>,<var>s<sub>2</sub></var>
...
...
<var>0</var>,<var>0</var>
</pre>
<p>
<var>p<sub>i</sub></var> (1 ≤ <var>p<sub>i</sub></var> ≤ 100 )、 <var>s<sub>i</sub></var> (0 ≤ <var>s<sub>i</sub></var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。
</p>
<p>
続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。
</p>
<pre>
<var>q<sub>1</sub></var>
<var>q<sub>2</sub></var>
:
</pre>
<p>
各問い合わせは１行に整理番号 <var>q<sub>i</sub></var> (1 ≤ <var>q<sub>i</sub></var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
各問い合わせについて、チームの順位を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
2
3
3
</pre>
<H2>Note</H2>
<p>
入力例のデータにおいて、チームを正解数順に整列すると：
</p>
<pre>
3,30
1,20
2,20
6,20
4,10
5,10
</pre>
<p>
となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。
</p> |
s590798126 | p00062 | Wrong Answer | while True:
try:
l = list(str(int(input())))
except:
break
for i in range(len(l)):
for j in range(len(l) - i-1):
l[j] = str(int(l[j])+int(l[j+1]))[-1]
print(l[0]) | 4823108376
1234567890
0123456789
| 5
6
4
|
<H1>一番下の行の数字は?</H1>
<p>
次のような数字のパターンを作ることを考えます。
</p>
<pre>
4 8 2 3 1 0 8 3 7 6
2 0 5 4 1 8 1 0 3
2 5 9 5 9 9 1 3
7 4 4 4 8 0 4
1 8 8 2 8 4
9 6 0 0 2
5 6 0 2
1 6 2
7 8
5
</pre>
<p>
このパターンは以下の規則に従っています。
</p>
<pre>
A B
C
</pre>
<p>
という数字の並びにおいて、C は A + B の 1 の位の数字である。たとえば、
</p>
<pre>
9 5
4
</pre>
<p>
では、9 + 5 = 14 の 1 の位の数字、すなわち 4 が 9 と 5 の斜め下に並べられます。また、
</p>
<pre>
2 3
5
</pre>
<p>
では、2 + 3 = 5 の 1 の位の数字、すなわち 5 が 2 と 3 の斜め下に並べられます。
</p>
<p>
一番上の行の 10 個の整数を読み込んで、一番下の行の 1 個の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、一番上の行の 10 個の数字が文字列として１行に与えられます。
</p>
<p>
データセットの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>データセットごとに、一番下の行の数字を１行に出力します。
<H2>Sample Input</H2>
<pre>
4823108376
1234567890
0123456789
</pre>
<H2>Output for the Sample Input</H2>
<pre>
5
6
4
</pre>
|
s310357169 | p00062 | Wrong Answer | n = map(int,tuple(raw_input()))
tmp=list(n)
while len(tmp)>1:
tmp2 = [str((int(tmp[i])+int(tmp[i+1])))[-1] for i in range(len(tmp)-1)]
tmp = tmp2
else:
print tmp[0] | 4823108376
1234567890
0123456789
| 5
6
4
|
<H1>一番下の行の数字は?</H1>
<p>
次のような数字のパターンを作ることを考えます。
</p>
<pre>
4 8 2 3 1 0 8 3 7 6
2 0 5 4 1 8 1 0 3
2 5 9 5 9 9 1 3
7 4 4 4 8 0 4
1 8 8 2 8 4
9 6 0 0 2
5 6 0 2
1 6 2
7 8
5
</pre>
<p>
このパターンは以下の規則に従っています。
</p>
<pre>
A B
C
</pre>
<p>
という数字の並びにおいて、C は A + B の 1 の位の数字である。たとえば、
</p>
<pre>
9 5
4
</pre>
<p>
では、9 + 5 = 14 の 1 の位の数字、すなわち 4 が 9 と 5 の斜め下に並べられます。また、
</p>
<pre>
2 3
5
</pre>
<p>
では、2 + 3 = 5 の 1 の位の数字、すなわち 5 が 2 と 3 の斜め下に並べられます。
</p>
<p>
一番上の行の 10 個の整数を読み込んで、一番下の行の 1 個の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、一番上の行の 10 個の数字が文字列として１行に与えられます。
</p>
<p>
データセットの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>データセットごとに、一番下の行の数字を１行に出力します。
<H2>Sample Input</H2>
<pre>
4823108376
1234567890
0123456789
</pre>
<H2>Output for the Sample Input</H2>
<pre>
5
6
4
</pre>
|
s922766578 | p00062 | Wrong Answer | while True:
try:
a = tuple(map(int, input()))
except:
break
while True:
b = []
for i in range(int(len(a)/2)):
b.append(int(str(a[i*2] + a[i*2+1])[-1]))
if len(b) == 1:
print(b[0])
break
a = b | 4823108376
1234567890
0123456789
| 5
6
4
|
<H1>一番下の行の数字は?</H1>
<p>
次のような数字のパターンを作ることを考えます。
</p>
<pre>
4 8 2 3 1 0 8 3 7 6
2 0 5 4 1 8 1 0 3
2 5 9 5 9 9 1 3
7 4 4 4 8 0 4
1 8 8 2 8 4
9 6 0 0 2
5 6 0 2
1 6 2
7 8
5
</pre>
<p>
このパターンは以下の規則に従っています。
</p>
<pre>
A B
C
</pre>
<p>
という数字の並びにおいて、C は A + B の 1 の位の数字である。たとえば、
</p>
<pre>
9 5
4
</pre>
<p>
では、9 + 5 = 14 の 1 の位の数字、すなわち 4 が 9 と 5 の斜め下に並べられます。また、
</p>
<pre>
2 3
5
</pre>
<p>
では、2 + 3 = 5 の 1 の位の数字、すなわち 5 が 2 と 3 の斜め下に並べられます。
</p>
<p>
一番上の行の 10 個の整数を読み込んで、一番下の行の 1 個の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、一番上の行の 10 個の数字が文字列として１行に与えられます。
</p>
<p>
データセットの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>データセットごとに、一番下の行の数字を１行に出力します。
<H2>Sample Input</H2>
<pre>
4823108376
1234567890
0123456789
</pre>
<H2>Output for the Sample Input</H2>
<pre>
5
6
4
</pre>
|
s391384342 | p00062 | Wrong Answer | while True:
try:
a = tuple(map(int, input()))
except EOFError:
break
while True:
b = []
for i in range(int(len(a)/2)):
b.append(int(str(a[i*2] + a[i*2+1])[-1]))
if len(b) == 1:
print(b[0])
break
a = b | 4823108376
1234567890
0123456789
| 5
6
4
|
<H1>一番下の行の数字は?</H1>
<p>
次のような数字のパターンを作ることを考えます。
</p>
<pre>
4 8 2 3 1 0 8 3 7 6
2 0 5 4 1 8 1 0 3
2 5 9 5 9 9 1 3
7 4 4 4 8 0 4
1 8 8 2 8 4
9 6 0 0 2
5 6 0 2
1 6 2
7 8
5
</pre>
<p>
このパターンは以下の規則に従っています。
</p>
<pre>
A B
C
</pre>
<p>
という数字の並びにおいて、C は A + B の 1 の位の数字である。たとえば、
</p>
<pre>
9 5
4
</pre>
<p>
では、9 + 5 = 14 の 1 の位の数字、すなわち 4 が 9 と 5 の斜め下に並べられます。また、
</p>
<pre>
2 3
5
</pre>
<p>
では、2 + 3 = 5 の 1 の位の数字、すなわち 5 が 2 と 3 の斜め下に並べられます。
</p>
<p>
一番上の行の 10 個の整数を読み込んで、一番下の行の 1 個の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、一番上の行の 10 個の数字が文字列として１行に与えられます。
</p>
<p>
データセットの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>データセットごとに、一番下の行の数字を１行に出力します。
<H2>Sample Input</H2>
<pre>
4823108376
1234567890
0123456789
</pre>
<H2>Output for the Sample Input</H2>
<pre>
5
6
4
</pre>
|
s117440272 | p00062 | Wrong Answer | while True:
try:
a = tuple(map(int, input()))
except EOFError:
break
while True:
b = []
for i in range(int(len(a)/2)):
b.append(int(str(a[i*2] + a[i*2+1])[-1]))
if len(b) == 1:
print(b[-1])
break
a = b | 4823108376
1234567890
0123456789
| 5
6
4
|
<H1>一番下の行の数字は?</H1>
<p>
次のような数字のパターンを作ることを考えます。
</p>
<pre>
4 8 2 3 1 0 8 3 7 6
2 0 5 4 1 8 1 0 3
2 5 9 5 9 9 1 3
7 4 4 4 8 0 4
1 8 8 2 8 4
9 6 0 0 2
5 6 0 2
1 6 2
7 8
5
</pre>
<p>
このパターンは以下の規則に従っています。
</p>
<pre>
A B
C
</pre>
<p>
という数字の並びにおいて、C は A + B の 1 の位の数字である。たとえば、
</p>
<pre>
9 5
4
</pre>
<p>
では、9 + 5 = 14 の 1 の位の数字、すなわち 4 が 9 と 5 の斜め下に並べられます。また、
</p>
<pre>
2 3
5
</pre>
<p>
では、2 + 3 = 5 の 1 の位の数字、すなわち 5 が 2 と 3 の斜め下に並べられます。
</p>
<p>
一番上の行の 10 個の整数を読み込んで、一番下の行の 1 個の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、一番上の行の 10 個の数字が文字列として１行に与えられます。
</p>
<p>
データセットの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>データセットごとに、一番下の行の数字を１行に出力します。
<H2>Sample Input</H2>
<pre>
4823108376
1234567890
0123456789
</pre>
<H2>Output for the Sample Input</H2>
<pre>
5
6
4
</pre>
|
s530540755 | p00062 | Wrong Answer | while True:
try:
a = tuple(int, input())
except:
break
while True:
b = []
for i in range(len(a)-1):
b.append(int(str(a[i] + a[i+1])[-1]))
print(b)
if len(b) == 1:
print(b[-1])
break
a = b | 4823108376
1234567890
0123456789
| 5
6
4
|
<H1>一番下の行の数字は?</H1>
<p>
次のような数字のパターンを作ることを考えます。
</p>
<pre>
4 8 2 3 1 0 8 3 7 6
2 0 5 4 1 8 1 0 3
2 5 9 5 9 9 1 3
7 4 4 4 8 0 4
1 8 8 2 8 4
9 6 0 0 2
5 6 0 2
1 6 2
7 8
5
</pre>
<p>
このパターンは以下の規則に従っています。
</p>
<pre>
A B
C
</pre>
<p>
という数字の並びにおいて、C は A + B の 1 の位の数字である。たとえば、
</p>
<pre>
9 5
4
</pre>
<p>
では、9 + 5 = 14 の 1 の位の数字、すなわち 4 が 9 と 5 の斜め下に並べられます。また、
</p>
<pre>
2 3
5
</pre>
<p>
では、2 + 3 = 5 の 1 の位の数字、すなわち 5 が 2 と 3 の斜め下に並べられます。
</p>
<p>
一番上の行の 10 個の整数を読み込んで、一番下の行の 1 個の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、一番上の行の 10 個の数字が文字列として１行に与えられます。
</p>
<p>
データセットの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>データセットごとに、一番下の行の数字を１行に出力します。
<H2>Sample Input</H2>
<pre>
4823108376
1234567890
0123456789
</pre>
<H2>Output for the Sample Input</H2>
<pre>
5
6
4
</pre>
|
s024120203 | p00062 | Wrong Answer | while True:
try:
a = tuple(int, input())
except:
break
while True:
b = []
for i in range(len(a)-1):
b.append(int(str(a[i] + a[i+1])[-1]))
if len(b) == 1:
print(b[-1])
break
a = b | 4823108376
1234567890
0123456789
| 5
6
4
|
<H1>一番下の行の数字は?</H1>
<p>
次のような数字のパターンを作ることを考えます。
</p>
<pre>
4 8 2 3 1 0 8 3 7 6
2 0 5 4 1 8 1 0 3
2 5 9 5 9 9 1 3
7 4 4 4 8 0 4
1 8 8 2 8 4
9 6 0 0 2
5 6 0 2
1 6 2
7 8
5
</pre>
<p>
このパターンは以下の規則に従っています。
</p>
<pre>
A B
C
</pre>
<p>
という数字の並びにおいて、C は A + B の 1 の位の数字である。たとえば、
</p>
<pre>
9 5
4
</pre>
<p>
では、9 + 5 = 14 の 1 の位の数字、すなわち 4 が 9 と 5 の斜め下に並べられます。また、
</p>
<pre>
2 3
5
</pre>
<p>
では、2 + 3 = 5 の 1 の位の数字、すなわち 5 が 2 と 3 の斜め下に並べられます。
</p>
<p>
一番上の行の 10 個の整数を読み込んで、一番下の行の 1 個の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、一番上の行の 10 個の数字が文字列として１行に与えられます。
</p>
<p>
データセットの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>データセットごとに、一番下の行の数字を１行に出力します。
<H2>Sample Input</H2>
<pre>
4823108376
1234567890
0123456789
</pre>
<H2>Output for the Sample Input</H2>
<pre>
5
6
4
</pre>
|
s280703704 | p00062 | Wrong Answer | while True:
try:
a = tuple(int, input())
except:
break
while True:
b = []
for i in range(len(a)-1):
b.append(int(str(a[i] + a[i+1])[-1]))
if len(b) == 1:
print(b[0])
break
a = b | 4823108376
1234567890
0123456789
| 5
6
4
|
<H1>一番下の行の数字は?</H1>
<p>
次のような数字のパターンを作ることを考えます。
</p>
<pre>
4 8 2 3 1 0 8 3 7 6
2 0 5 4 1 8 1 0 3
2 5 9 5 9 9 1 3
7 4 4 4 8 0 4
1 8 8 2 8 4
9 6 0 0 2
5 6 0 2
1 6 2
7 8
5
</pre>
<p>
このパターンは以下の規則に従っています。
</p>
<pre>
A B
C
</pre>
<p>
という数字の並びにおいて、C は A + B の 1 の位の数字である。たとえば、
</p>
<pre>
9 5
4
</pre>
<p>
では、9 + 5 = 14 の 1 の位の数字、すなわち 4 が 9 と 5 の斜め下に並べられます。また、
</p>
<pre>
2 3
5
</pre>
<p>
では、2 + 3 = 5 の 1 の位の数字、すなわち 5 が 2 と 3 の斜め下に並べられます。
</p>
<p>
一番上の行の 10 個の整数を読み込んで、一番下の行の 1 個の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、一番上の行の 10 個の数字が文字列として１行に与えられます。
</p>
<p>
データセットの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>データセットごとに、一番下の行の数字を１行に出力します。
<H2>Sample Input</H2>
<pre>
4823108376
1234567890
0123456789
</pre>
<H2>Output for the Sample Input</H2>
<pre>
5
6
4
</pre>
|
s969516002 | p00062 | Wrong Answer | list = []
str = input()
for i in range(len(str)):
list.append(int(str[i]))
while len(list) > 1:
length = len(list)
for i in range(length - 1):
list[i] = (list[i] + list[i+1]) % 10
del list[length - 1]
print(list[0]) | 4823108376
1234567890
0123456789
| 5
6
4
|
<H1>一番下の行の数字は?</H1>
<p>
次のような数字のパターンを作ることを考えます。
</p>
<pre>
4 8 2 3 1 0 8 3 7 6
2 0 5 4 1 8 1 0 3
2 5 9 5 9 9 1 3
7 4 4 4 8 0 4
1 8 8 2 8 4
9 6 0 0 2
5 6 0 2
1 6 2
7 8
5
</pre>
<p>
このパターンは以下の規則に従っています。
</p>
<pre>
A B
C
</pre>
<p>
という数字の並びにおいて、C は A + B の 1 の位の数字である。たとえば、
</p>
<pre>
9 5
4
</pre>
<p>
では、9 + 5 = 14 の 1 の位の数字、すなわち 4 が 9 と 5 の斜め下に並べられます。また、
</p>
<pre>
2 3
5
</pre>
<p>
では、2 + 3 = 5 の 1 の位の数字、すなわち 5 が 2 と 3 の斜め下に並べられます。
</p>
<p>
一番上の行の 10 個の整数を読み込んで、一番下の行の 1 個の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、一番上の行の 10 個の数字が文字列として１行に与えられます。
</p>
<p>
データセットの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>データセットごとに、一番下の行の数字を１行に出力します。
<H2>Sample Input</H2>
<pre>
4823108376
1234567890
0123456789
</pre>
<H2>Output for the Sample Input</H2>
<pre>
5
6
4
</pre>
|
s077243825 | p00062 | Wrong Answer | b = input()
a=list(b)
for i in range(10):
a[i]=int(a[i])
n=9
for i in range(10):
d = 1
for j in range(n):
c=a[j]+a[d]
c=c%10
a[j]=c
d+=1
n-=1
print(a[0])
| 4823108376
1234567890
0123456789
| 5
6
4
|
<H1>一番下の行の数字は?</H1>
<p>
次のような数字のパターンを作ることを考えます。
</p>
<pre>
4 8 2 3 1 0 8 3 7 6
2 0 5 4 1 8 1 0 3
2 5 9 5 9 9 1 3
7 4 4 4 8 0 4
1 8 8 2 8 4
9 6 0 0 2
5 6 0 2
1 6 2
7 8
5
</pre>
<p>
このパターンは以下の規則に従っています。
</p>
<pre>
A B
C
</pre>
<p>
という数字の並びにおいて、C は A + B の 1 の位の数字である。たとえば、
</p>
<pre>
9 5
4
</pre>
<p>
では、9 + 5 = 14 の 1 の位の数字、すなわち 4 が 9 と 5 の斜め下に並べられます。また、
</p>
<pre>
2 3
5
</pre>
<p>
では、2 + 3 = 5 の 1 の位の数字、すなわち 5 が 2 と 3 の斜め下に並べられます。
</p>
<p>
一番上の行の 10 個の整数を読み込んで、一番下の行の 1 個の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、一番上の行の 10 個の数字が文字列として１行に与えられます。
</p>
<p>
データセットの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>データセットごとに、一番下の行の数字を１行に出力します。
<H2>Sample Input</H2>
<pre>
4823108376
1234567890
0123456789
</pre>
<H2>Output for the Sample Input</H2>
<pre>
5
6
4
</pre>
|
s239427514 | p00062 | Accepted | import sys
for s in sys.stdin.readlines():
print(sum(int(n)*m for n, m in zip(s, [1, 9, 36, 84, 126, 126, 84, 36, 9, 1]))%10)
| 4823108376
1234567890
0123456789
| 5
6
4
|
<H1>一番下の行の数字は?</H1>
<p>
次のような数字のパターンを作ることを考えます。
</p>
<pre>
4 8 2 3 1 0 8 3 7 6
2 0 5 4 1 8 1 0 3
2 5 9 5 9 9 1 3
7 4 4 4 8 0 4
1 8 8 2 8 4
9 6 0 0 2
5 6 0 2
1 6 2
7 8
5
</pre>
<p>
このパターンは以下の規則に従っています。
</p>
<pre>
A B
C
</pre>
<p>
という数字の並びにおいて、C は A + B の 1 の位の数字である。たとえば、
</p>
<pre>
9 5
4
</pre>
<p>
では、9 + 5 = 14 の 1 の位の数字、すなわち 4 が 9 と 5 の斜め下に並べられます。また、
</p>
<pre>
2 3
5
</pre>
<p>
では、2 + 3 = 5 の 1 の位の数字、すなわち 5 が 2 と 3 の斜め下に並べられます。
</p>
<p>
一番上の行の 10 個の整数を読み込んで、一番下の行の 1 個の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、一番上の行の 10 個の数字が文字列として１行に与えられます。
</p>
<p>
データセットの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>データセットごとに、一番下の行の数字を１行に出力します。
<H2>Sample Input</H2>
<pre>
4823108376
1234567890
0123456789
</pre>
<H2>Output for the Sample Input</H2>
<pre>
5
6
4
</pre>
|
s175041398 | p00062 | Accepted | while True:
try: x = list(map(int,input()))
except: break
for i in range(10,1,-1):
for n in range(1,i):
x[n-1] = (x[n-1] + x[n]) % 10
print(x[0])
| 4823108376
1234567890
0123456789
| 5
6
4
|
<H1>一番下の行の数字は?</H1>
<p>
次のような数字のパターンを作ることを考えます。
</p>
<pre>
4 8 2 3 1 0 8 3 7 6
2 0 5 4 1 8 1 0 3
2 5 9 5 9 9 1 3
7 4 4 4 8 0 4
1 8 8 2 8 4
9 6 0 0 2
5 6 0 2
1 6 2
7 8
5
</pre>
<p>
このパターンは以下の規則に従っています。
</p>
<pre>
A B
C
</pre>
<p>
という数字の並びにおいて、C は A + B の 1 の位の数字である。たとえば、
</p>
<pre>
9 5
4
</pre>
<p>
では、9 + 5 = 14 の 1 の位の数字、すなわち 4 が 9 と 5 の斜め下に並べられます。また、
</p>
<pre>
2 3
5
</pre>
<p>
では、2 + 3 = 5 の 1 の位の数字、すなわち 5 が 2 と 3 の斜め下に並べられます。
</p>
<p>
一番上の行の 10 個の整数を読み込んで、一番下の行の 1 個の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、一番上の行の 10 個の数字が文字列として１行に与えられます。
</p>
<p>
データセットの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>データセットごとに、一番下の行の数字を１行に出力します。
<H2>Sample Input</H2>
<pre>
4823108376
1234567890
0123456789
</pre>
<H2>Output for the Sample Input</H2>
<pre>
5
6
4
</pre>
|
s387243870 | p00062 | Accepted | while True:
try:
nums = list(map(int, list(input())))
except:
break
while len(nums) > 1:
tmp = []
for i in range(len(nums)-1):
tmp.append(int(str(nums[i] + nums[i+1])[-1]))
nums = [] + tmp
print(nums[0]) | 4823108376
1234567890
0123456789
| 5
6
4
|
<H1>一番下の行の数字は?</H1>
<p>
次のような数字のパターンを作ることを考えます。
</p>
<pre>
4 8 2 3 1 0 8 3 7 6
2 0 5 4 1 8 1 0 3
2 5 9 5 9 9 1 3
7 4 4 4 8 0 4
1 8 8 2 8 4
9 6 0 0 2
5 6 0 2
1 6 2
7 8
5
</pre>
<p>
このパターンは以下の規則に従っています。
</p>
<pre>
A B
C
</pre>
<p>
という数字の並びにおいて、C は A + B の 1 の位の数字である。たとえば、
</p>
<pre>
9 5
4
</pre>
<p>
では、9 + 5 = 14 の 1 の位の数字、すなわち 4 が 9 と 5 の斜め下に並べられます。また、
</p>
<pre>
2 3
5
</pre>
<p>
では、2 + 3 = 5 の 1 の位の数字、すなわち 5 が 2 と 3 の斜め下に並べられます。
</p>
<p>
一番上の行の 10 個の整数を読み込んで、一番下の行の 1 個の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、一番上の行の 10 個の数字が文字列として１行に与えられます。
</p>
<p>
データセットの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>データセットごとに、一番下の行の数字を１行に出力します。
<H2>Sample Input</H2>
<pre>
4823108376
1234567890
0123456789
</pre>
<H2>Output for the Sample Input</H2>
<pre>
5
6
4
</pre>
|
s982033302 | p00062 | Accepted | def f(l):
return map(lambda x: (x[0] + x[1]) % 10, zip(l[:len(l)-1], l[1:]))
while True:
try:
l = map(int, raw_input().strip());
for i in range(9):
l = f(l)
print l[0]
except:
break; | 4823108376
1234567890
0123456789
| 5
6
4
|
<H1>一番下の行の数字は?</H1>
<p>
次のような数字のパターンを作ることを考えます。
</p>
<pre>
4 8 2 3 1 0 8 3 7 6
2 0 5 4 1 8 1 0 3
2 5 9 5 9 9 1 3
7 4 4 4 8 0 4
1 8 8 2 8 4
9 6 0 0 2
5 6 0 2
1 6 2
7 8
5
</pre>
<p>
このパターンは以下の規則に従っています。
</p>
<pre>
A B
C
</pre>
<p>
という数字の並びにおいて、C は A + B の 1 の位の数字である。たとえば、
</p>
<pre>
9 5
4
</pre>
<p>
では、9 + 5 = 14 の 1 の位の数字、すなわち 4 が 9 と 5 の斜め下に並べられます。また、
</p>
<pre>
2 3
5
</pre>
<p>
では、2 + 3 = 5 の 1 の位の数字、すなわち 5 が 2 と 3 の斜め下に並べられます。
</p>
<p>
一番上の行の 10 個の整数を読み込んで、一番下の行の 1 個の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、一番上の行の 10 個の数字が文字列として１行に与えられます。
</p>
<p>
データセットの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>データセットごとに、一番下の行の数字を１行に出力します。
<H2>Sample Input</H2>
<pre>
4823108376
1234567890
0123456789
</pre>
<H2>Output for the Sample Input</H2>
<pre>
5
6
4
</pre>
|
s687667648 | p00062 | Accepted | import sys
def solve(lis):
if len(lis) == 1 :print lis[0] ; return 0
l = [ (lis[i]+lis[i+1])%10 for i in xrange(len(lis)-1) ]
solve(l)
for s in sys.stdin:
solve([ int(e) for e in s[:-1] ]) | 4823108376
1234567890
0123456789
| 5
6
4
|
<H1>一番下の行の数字は?</H1>
<p>
次のような数字のパターンを作ることを考えます。
</p>
<pre>
4 8 2 3 1 0 8 3 7 6
2 0 5 4 1 8 1 0 3
2 5 9 5 9 9 1 3
7 4 4 4 8 0 4
1 8 8 2 8 4
9 6 0 0 2
5 6 0 2
1 6 2
7 8
5
</pre>
<p>
このパターンは以下の規則に従っています。
</p>
<pre>
A B
C
</pre>
<p>
という数字の並びにおいて、C は A + B の 1 の位の数字である。たとえば、
</p>
<pre>
9 5
4
</pre>
<p>
では、9 + 5 = 14 の 1 の位の数字、すなわち 4 が 9 と 5 の斜め下に並べられます。また、
</p>
<pre>
2 3
5
</pre>
<p>
では、2 + 3 = 5 の 1 の位の数字、すなわち 5 が 2 と 3 の斜め下に並べられます。
</p>
<p>
一番上の行の 10 個の整数を読み込んで、一番下の行の 1 個の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、一番上の行の 10 個の数字が文字列として１行に与えられます。
</p>
<p>
データセットの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>データセットごとに、一番下の行の数字を１行に出力します。
<H2>Sample Input</H2>
<pre>
4823108376
1234567890
0123456789
</pre>
<H2>Output for the Sample Input</H2>
<pre>
5
6
4
</pre>
|
s800692105 | p00062 | Accepted | import sys
f = sys.stdin
def next_line(line):
next_line = [0] * (len(line) - 1)
for i in range(len(next_line)):
next_line[i] = (line[i] + line[i + 1]) % 10
return next_line
for line in f:
line = list(map(int,line.strip()))
while 1 < len(line):
line = next_line(line)
print(*line) | 4823108376
1234567890
0123456789
| 5
6
4
|
<H1>一番下の行の数字は?</H1>
<p>
次のような数字のパターンを作ることを考えます。
</p>
<pre>
4 8 2 3 1 0 8 3 7 6
2 0 5 4 1 8 1 0 3
2 5 9 5 9 9 1 3
7 4 4 4 8 0 4
1 8 8 2 8 4
9 6 0 0 2
5 6 0 2
1 6 2
7 8
5
</pre>
<p>
このパターンは以下の規則に従っています。
</p>
<pre>
A B
C
</pre>
<p>
という数字の並びにおいて、C は A + B の 1 の位の数字である。たとえば、
</p>
<pre>
9 5
4
</pre>
<p>
では、9 + 5 = 14 の 1 の位の数字、すなわち 4 が 9 と 5 の斜め下に並べられます。また、
</p>
<pre>
2 3
5
</pre>
<p>
では、2 + 3 = 5 の 1 の位の数字、すなわち 5 が 2 と 3 の斜め下に並べられます。
</p>
<p>
一番上の行の 10 個の整数を読み込んで、一番下の行の 1 個の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、一番上の行の 10 個の数字が文字列として１行に与えられます。
</p>
<p>
データセットの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>データセットごとに、一番下の行の数字を１行に出力します。
<H2>Sample Input</H2>
<pre>
4823108376
1234567890
0123456789
</pre>
<H2>Output for the Sample Input</H2>
<pre>
5
6
4
</pre>
|
s616737949 | p00062 | Accepted | while True:
try:
n = map(int,tuple(raw_input()))
except EOFError:
break
tmp=list(n)
while len(tmp)>1:
tmp2 = [str((int(tmp[i])+int(tmp[i+1])))[-1] for i in range(len(tmp)-1)]
tmp = tmp2
else:
print int(tmp[0]) | 4823108376
1234567890
0123456789
| 5
6
4
|
<H1>一番下の行の数字は?</H1>
<p>
次のような数字のパターンを作ることを考えます。
</p>
<pre>
4 8 2 3 1 0 8 3 7 6
2 0 5 4 1 8 1 0 3
2 5 9 5 9 9 1 3
7 4 4 4 8 0 4
1 8 8 2 8 4
9 6 0 0 2
5 6 0 2
1 6 2
7 8
5
</pre>
<p>
このパターンは以下の規則に従っています。
</p>
<pre>
A B
C
</pre>
<p>
という数字の並びにおいて、C は A + B の 1 の位の数字である。たとえば、
</p>
<pre>
9 5
4
</pre>
<p>
では、9 + 5 = 14 の 1 の位の数字、すなわち 4 が 9 と 5 の斜め下に並べられます。また、
</p>
<pre>
2 3
5
</pre>
<p>
では、2 + 3 = 5 の 1 の位の数字、すなわち 5 が 2 と 3 の斜め下に並べられます。
</p>
<p>
一番上の行の 10 個の整数を読み込んで、一番下の行の 1 個の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、一番上の行の 10 個の数字が文字列として１行に与えられます。
</p>
<p>
データセットの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>データセットごとに、一番下の行の数字を１行に出力します。
<H2>Sample Input</H2>
<pre>
4823108376
1234567890
0123456789
</pre>
<H2>Output for the Sample Input</H2>
<pre>
5
6
4
</pre>
|
s208088480 | p00062 | Accepted | while True:
try:
n = tuple(map(int,raw_input()))
except EOFError:
break
tmp=list(n)
while len(tmp)>1:
tmp2 = [(tmp[i]+tmp[i+1])%10 for i in range(len(tmp)-1)]
tmp = tmp2
else:
print tmp[0] | 4823108376
1234567890
0123456789
| 5
6
4
|
<H1>一番下の行の数字は?</H1>
<p>
次のような数字のパターンを作ることを考えます。
</p>
<pre>
4 8 2 3 1 0 8 3 7 6
2 0 5 4 1 8 1 0 3
2 5 9 5 9 9 1 3
7 4 4 4 8 0 4
1 8 8 2 8 4
9 6 0 0 2
5 6 0 2
1 6 2
7 8
5
</pre>
<p>
このパターンは以下の規則に従っています。
</p>
<pre>
A B
C
</pre>
<p>
という数字の並びにおいて、C は A + B の 1 の位の数字である。たとえば、
</p>
<pre>
9 5
4
</pre>
<p>
では、9 + 5 = 14 の 1 の位の数字、すなわち 4 が 9 と 5 の斜め下に並べられます。また、
</p>
<pre>
2 3
5
</pre>
<p>
では、2 + 3 = 5 の 1 の位の数字、すなわち 5 が 2 と 3 の斜め下に並べられます。
</p>
<p>
一番上の行の 10 個の整数を読み込んで、一番下の行の 1 個の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、一番上の行の 10 個の数字が文字列として１行に与えられます。
</p>
<p>
データセットの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>データセットごとに、一番下の行の数字を１行に出力します。
<H2>Sample Input</H2>
<pre>
4823108376
1234567890
0123456789
</pre>
<H2>Output for the Sample Input</H2>
<pre>
5
6
4
</pre>
|
s591729292 | p00062 | Accepted | def suicide(lis):
if len(lis) == 1:
print lis[0]
return
pokakito = []
for i in range(len(lis)-1):
check = lis[i] + lis[i+1]
one = int(str(check)[-1])
pokakito.append(one)
else:
suicide(pokakito)
while True:
try:
lis = [int(char) for char in raw_input()]
suicide(lis)
except EOFError:
break | 4823108376
1234567890
0123456789
| 5
6
4
|
<H1>一番下の行の数字は?</H1>
<p>
次のような数字のパターンを作ることを考えます。
</p>
<pre>
4 8 2 3 1 0 8 3 7 6
2 0 5 4 1 8 1 0 3
2 5 9 5 9 9 1 3
7 4 4 4 8 0 4
1 8 8 2 8 4
9 6 0 0 2
5 6 0 2
1 6 2
7 8
5
</pre>
<p>
このパターンは以下の規則に従っています。
</p>
<pre>
A B
C
</pre>
<p>
という数字の並びにおいて、C は A + B の 1 の位の数字である。たとえば、
</p>
<pre>
9 5
4
</pre>
<p>
では、9 + 5 = 14 の 1 の位の数字、すなわち 4 が 9 と 5 の斜め下に並べられます。また、
</p>
<pre>
2 3
5
</pre>
<p>
では、2 + 3 = 5 の 1 の位の数字、すなわち 5 が 2 と 3 の斜め下に並べられます。
</p>
<p>
一番上の行の 10 個の整数を読み込んで、一番下の行の 1 個の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、一番上の行の 10 個の数字が文字列として１行に与えられます。
</p>
<p>
データセットの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>データセットごとに、一番下の行の数字を１行に出力します。
<H2>Sample Input</H2>
<pre>
4823108376
1234567890
0123456789
</pre>
<H2>Output for the Sample Input</H2>
<pre>
5
6
4
</pre>
|
s787282097 | p00062 | Accepted | import sys
for line in sys.stdin.readlines():
l = [int(i) for i in line.replace('\n','')]
while len(l) >1:
m = []
for i in range(len(l)-1):
m.append((l[i]+l[i+1])%10)
l = list(m)
print(l[0]) | 4823108376
1234567890
0123456789
| 5
6
4
|
<H1>一番下の行の数字は?</H1>
<p>
次のような数字のパターンを作ることを考えます。
</p>
<pre>
4 8 2 3 1 0 8 3 7 6
2 0 5 4 1 8 1 0 3
2 5 9 5 9 9 1 3
7 4 4 4 8 0 4
1 8 8 2 8 4
9 6 0 0 2
5 6 0 2
1 6 2
7 8
5
</pre>
<p>
このパターンは以下の規則に従っています。
</p>
<pre>
A B
C
</pre>
<p>
という数字の並びにおいて、C は A + B の 1 の位の数字である。たとえば、
</p>
<pre>
9 5
4
</pre>
<p>
では、9 + 5 = 14 の 1 の位の数字、すなわち 4 が 9 と 5 の斜め下に並べられます。また、
</p>
<pre>
2 3
5
</pre>
<p>
では、2 + 3 = 5 の 1 の位の数字、すなわち 5 が 2 と 3 の斜め下に並べられます。
</p>
<p>
一番上の行の 10 個の整数を読み込んで、一番下の行の 1 個の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、一番上の行の 10 個の数字が文字列として１行に与えられます。
</p>
<p>
データセットの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>データセットごとに、一番下の行の数字を１行に出力します。
<H2>Sample Input</H2>
<pre>
4823108376
1234567890
0123456789
</pre>
<H2>Output for the Sample Input</H2>
<pre>
5
6
4
</pre>
|
s857758950 | p00062 | Accepted | from math import *
PI = 3.1415926535898
while True:
try:
n = raw_input()
res = []
for x in n:
res.append(int(x))
while len(res) > 1:
t = []
for i in range(1, len(res)):
t.append((res[i]+res[i-1])%10)
res = t
print res[0]
except EOFError:
break | 4823108376
1234567890
0123456789
| 5
6
4
|
<H1>一番下の行の数字は?</H1>
<p>
次のような数字のパターンを作ることを考えます。
</p>
<pre>
4 8 2 3 1 0 8 3 7 6
2 0 5 4 1 8 1 0 3
2 5 9 5 9 9 1 3
7 4 4 4 8 0 4
1 8 8 2 8 4
9 6 0 0 2
5 6 0 2
1 6 2
7 8
5
</pre>
<p>
このパターンは以下の規則に従っています。
</p>
<pre>
A B
C
</pre>
<p>
という数字の並びにおいて、C は A + B の 1 の位の数字である。たとえば、
</p>
<pre>
9 5
4
</pre>
<p>
では、9 + 5 = 14 の 1 の位の数字、すなわち 4 が 9 と 5 の斜め下に並べられます。また、
</p>
<pre>
2 3
5
</pre>
<p>
では、2 + 3 = 5 の 1 の位の数字、すなわち 5 が 2 と 3 の斜め下に並べられます。
</p>
<p>
一番上の行の 10 個の整数を読み込んで、一番下の行の 1 個の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、一番上の行の 10 個の数字が文字列として１行に与えられます。
</p>
<p>
データセットの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>データセットごとに、一番下の行の数字を１行に出力します。
<H2>Sample Input</H2>
<pre>
4823108376
1234567890
0123456789
</pre>
<H2>Output for the Sample Input</H2>
<pre>
5
6
4
</pre>
|
s937734269 | p00062 | Accepted | while 1:
try:
n=raw_input()
l=[int(x) for x in n]
tmp=[]
while len(l)>1:
for i in range(len(l)-1):
tmp.append((l[i]+l[i+1])%10)
l=tmp[:]
tmp=[]
print l[0]
except:
break | 4823108376
1234567890
0123456789
| 5
6
4
|
<H1>一番下の行の数字は?</H1>
<p>
次のような数字のパターンを作ることを考えます。
</p>
<pre>
4 8 2 3 1 0 8 3 7 6
2 0 5 4 1 8 1 0 3
2 5 9 5 9 9 1 3
7 4 4 4 8 0 4
1 8 8 2 8 4
9 6 0 0 2
5 6 0 2
1 6 2
7 8
5
</pre>
<p>
このパターンは以下の規則に従っています。
</p>
<pre>
A B
C
</pre>
<p>
という数字の並びにおいて、C は A + B の 1 の位の数字である。たとえば、
</p>
<pre>
9 5
4
</pre>
<p>
では、9 + 5 = 14 の 1 の位の数字、すなわち 4 が 9 と 5 の斜め下に並べられます。また、
</p>
<pre>
2 3
5
</pre>
<p>
では、2 + 3 = 5 の 1 の位の数字、すなわち 5 が 2 と 3 の斜め下に並べられます。
</p>
<p>
一番上の行の 10 個の整数を読み込んで、一番下の行の 1 個の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、一番上の行の 10 個の数字が文字列として１行に与えられます。
</p>
<p>
データセットの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>データセットごとに、一番下の行の数字を１行に出力します。
<H2>Sample Input</H2>
<pre>
4823108376
1234567890
0123456789
</pre>
<H2>Output for the Sample Input</H2>
<pre>
5
6
4
</pre>
|
s774298580 | p00062 | Accepted | while True:
try:
A=[[]]*10
A[0]=list(map(int,input()))
for i in range(1,10):
A[i]=[0]*(10-i)
for i in range(1,10):
for j in range(0,len(A[i])):
A[i][j]=(A[i-1][j]+A[i-1][j+1])%10
print(A[9][0])
except EOFError:
break | 4823108376
1234567890
0123456789
| 5
6
4
|
<H1>一番下の行の数字は?</H1>
<p>
次のような数字のパターンを作ることを考えます。
</p>
<pre>
4 8 2 3 1 0 8 3 7 6
2 0 5 4 1 8 1 0 3
2 5 9 5 9 9 1 3
7 4 4 4 8 0 4
1 8 8 2 8 4
9 6 0 0 2
5 6 0 2
1 6 2
7 8
5
</pre>
<p>
このパターンは以下の規則に従っています。
</p>
<pre>
A B
C
</pre>
<p>
という数字の並びにおいて、C は A + B の 1 の位の数字である。たとえば、
</p>
<pre>
9 5
4
</pre>
<p>
では、9 + 5 = 14 の 1 の位の数字、すなわち 4 が 9 と 5 の斜め下に並べられます。また、
</p>
<pre>
2 3
5
</pre>
<p>
では、2 + 3 = 5 の 1 の位の数字、すなわち 5 が 2 と 3 の斜め下に並べられます。
</p>
<p>
一番上の行の 10 個の整数を読み込んで、一番下の行の 1 個の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、一番上の行の 10 個の数字が文字列として１行に与えられます。
</p>
<p>
データセットの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>データセットごとに、一番下の行の数字を１行に出力します。
<H2>Sample Input</H2>
<pre>
4823108376
1234567890
0123456789
</pre>
<H2>Output for the Sample Input</H2>
<pre>
5
6
4
</pre>
|
s212694525 | p00062 | Accepted | #encoding=utf-8
import sys
def inp():
for line in sys.stdin:
word = str(line[:-1])
while True:
tako = []
for i in xrange(len(word) - 1):
a = str(eval(word[i] + "+" + word[i+1]))
tako.append(a[-1])
word = "".join(tako)
if len(word) == 1:
break
print word
if __name__ == "__main__":
inp() | 4823108376
1234567890
0123456789
| 5
6
4
|
<H1>一番下の行の数字は?</H1>
<p>
次のような数字のパターンを作ることを考えます。
</p>
<pre>
4 8 2 3 1 0 8 3 7 6
2 0 5 4 1 8 1 0 3
2 5 9 5 9 9 1 3
7 4 4 4 8 0 4
1 8 8 2 8 4
9 6 0 0 2
5 6 0 2
1 6 2
7 8
5
</pre>
<p>
このパターンは以下の規則に従っています。
</p>
<pre>
A B
C
</pre>
<p>
という数字の並びにおいて、C は A + B の 1 の位の数字である。たとえば、
</p>
<pre>
9 5
4
</pre>
<p>
では、9 + 5 = 14 の 1 の位の数字、すなわち 4 が 9 と 5 の斜め下に並べられます。また、
</p>
<pre>
2 3
5
</pre>
<p>
では、2 + 3 = 5 の 1 の位の数字、すなわち 5 が 2 と 3 の斜め下に並べられます。
</p>
<p>
一番上の行の 10 個の整数を読み込んで、一番下の行の 1 個の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、一番上の行の 10 個の数字が文字列として１行に与えられます。
</p>
<p>
データセットの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>データセットごとに、一番下の行の数字を１行に出力します。
<H2>Sample Input</H2>
<pre>
4823108376
1234567890
0123456789
</pre>
<H2>Output for the Sample Input</H2>
<pre>
5
6
4
</pre>
|
s213424223 | p00062 | Accepted | # -*- coding: utf-8 -*-
import sys
for line in sys.stdin:
n = int(line)
A = []
for i in range(10):
A.append(n%10)
n /= 10
print (A[0]+5*A[2]+5*A[7]+A[9])%10 | 4823108376
1234567890
0123456789
| 5
6
4
|
<H1>一番下の行の数字は?</H1>
<p>
次のような数字のパターンを作ることを考えます。
</p>
<pre>
4 8 2 3 1 0 8 3 7 6
2 0 5 4 1 8 1 0 3
2 5 9 5 9 9 1 3
7 4 4 4 8 0 4
1 8 8 2 8 4
9 6 0 0 2
5 6 0 2
1 6 2
7 8
5
</pre>
<p>
このパターンは以下の規則に従っています。
</p>
<pre>
A B
C
</pre>
<p>
という数字の並びにおいて、C は A + B の 1 の位の数字である。たとえば、
</p>
<pre>
9 5
4
</pre>
<p>
では、9 + 5 = 14 の 1 の位の数字、すなわち 4 が 9 と 5 の斜め下に並べられます。また、
</p>
<pre>
2 3
5
</pre>
<p>
では、2 + 3 = 5 の 1 の位の数字、すなわち 5 が 2 と 3 の斜め下に並べられます。
</p>
<p>
一番上の行の 10 個の整数を読み込んで、一番下の行の 1 個の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、一番上の行の 10 個の数字が文字列として１行に与えられます。
</p>
<p>
データセットの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>データセットごとに、一番下の行の数字を１行に出力します。
<H2>Sample Input</H2>
<pre>
4823108376
1234567890
0123456789
</pre>
<H2>Output for the Sample Input</H2>
<pre>
5
6
4
</pre>
|
s830427799 | p00062 | Accepted | while True:
try:
data = list(map(int, list(input())))
except:
break
for _ in range(9):
for i in range(9):
data[i] = (data[i] + data[i + 1]) % 10
print(data[0]) | 4823108376
1234567890
0123456789
| 5
6
4
|
<H1>一番下の行の数字は?</H1>
<p>
次のような数字のパターンを作ることを考えます。
</p>
<pre>
4 8 2 3 1 0 8 3 7 6
2 0 5 4 1 8 1 0 3
2 5 9 5 9 9 1 3
7 4 4 4 8 0 4
1 8 8 2 8 4
9 6 0 0 2
5 6 0 2
1 6 2
7 8
5
</pre>
<p>
このパターンは以下の規則に従っています。
</p>
<pre>
A B
C
</pre>
<p>
という数字の並びにおいて、C は A + B の 1 の位の数字である。たとえば、
</p>
<pre>
9 5
4
</pre>
<p>
では、9 + 5 = 14 の 1 の位の数字、すなわち 4 が 9 と 5 の斜め下に並べられます。また、
</p>
<pre>
2 3
5
</pre>
<p>
では、2 + 3 = 5 の 1 の位の数字、すなわち 5 が 2 と 3 の斜め下に並べられます。
</p>
<p>
一番上の行の 10 個の整数を読み込んで、一番下の行の 1 個の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、一番上の行の 10 個の数字が文字列として１行に与えられます。
</p>
<p>
データセットの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>データセットごとに、一番下の行の数字を１行に出力します。
<H2>Sample Input</H2>
<pre>
4823108376
1234567890
0123456789
</pre>
<H2>Output for the Sample Input</H2>
<pre>
5
6
4
</pre>
|
s661547499 | p00062 | Accepted | def factorial(a):
if(a==1 or a==0):return 1
else:
return a*factorial(a-1)
def comb(a,b):
return factorial(a)//factorial(a-b)//factorial(b)
while True:
try:
st=input()
ans=0
for i in range(len(st)):
n=int(st[i])
ans+=n*comb(9,i)
print(ans%10)
except:
break | 4823108376
1234567890
0123456789
| 5
6
4
|
<H1>一番下の行の数字は?</H1>
<p>
次のような数字のパターンを作ることを考えます。
</p>
<pre>
4 8 2 3 1 0 8 3 7 6
2 0 5 4 1 8 1 0 3
2 5 9 5 9 9 1 3
7 4 4 4 8 0 4
1 8 8 2 8 4
9 6 0 0 2
5 6 0 2
1 6 2
7 8
5
</pre>
<p>
このパターンは以下の規則に従っています。
</p>
<pre>
A B
C
</pre>
<p>
という数字の並びにおいて、C は A + B の 1 の位の数字である。たとえば、
</p>
<pre>
9 5
4
</pre>
<p>
では、9 + 5 = 14 の 1 の位の数字、すなわち 4 が 9 と 5 の斜め下に並べられます。また、
</p>
<pre>
2 3
5
</pre>
<p>
では、2 + 3 = 5 の 1 の位の数字、すなわち 5 が 2 と 3 の斜め下に並べられます。
</p>
<p>
一番上の行の 10 個の整数を読み込んで、一番下の行の 1 個の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、一番上の行の 10 個の数字が文字列として１行に与えられます。
</p>
<p>
データセットの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>データセットごとに、一番下の行の数字を１行に出力します。
<H2>Sample Input</H2>
<pre>
4823108376
1234567890
0123456789
</pre>
<H2>Output for the Sample Input</H2>
<pre>
5
6
4
</pre>
|
s382862088 | p00062 | Accepted | while True:
try:
Num_lis = list(map(int,map(str,input())))
while len(Num_lis) > 1:
List1 = []
for i in range(len(Num_lis) - 1):
List1.append((Num_lis[i] + Num_lis[i + 1]) % 10)
Num_lis = List1
print(Num_lis[0])
except EOFError:
break | 4823108376
1234567890
0123456789
| 5
6
4
|
<H1>一番下の行の数字は?</H1>
<p>
次のような数字のパターンを作ることを考えます。
</p>
<pre>
4 8 2 3 1 0 8 3 7 6
2 0 5 4 1 8 1 0 3
2 5 9 5 9 9 1 3
7 4 4 4 8 0 4
1 8 8 2 8 4
9 6 0 0 2
5 6 0 2
1 6 2
7 8
5
</pre>
<p>
このパターンは以下の規則に従っています。
</p>
<pre>
A B
C
</pre>
<p>
という数字の並びにおいて、C は A + B の 1 の位の数字である。たとえば、
</p>
<pre>
9 5
4
</pre>
<p>
では、9 + 5 = 14 の 1 の位の数字、すなわち 4 が 9 と 5 の斜め下に並べられます。また、
</p>
<pre>
2 3
5
</pre>
<p>
では、2 + 3 = 5 の 1 の位の数字、すなわち 5 が 2 と 3 の斜め下に並べられます。
</p>
<p>
一番上の行の 10 個の整数を読み込んで、一番下の行の 1 個の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、一番上の行の 10 個の数字が文字列として１行に与えられます。
</p>
<p>
データセットの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>データセットごとに、一番下の行の数字を１行に出力します。
<H2>Sample Input</H2>
<pre>
4823108376
1234567890
0123456789
</pre>
<H2>Output for the Sample Input</H2>
<pre>
5
6
4
</pre>
|
s160580730 | p00062 | Accepted | import sys
for line in sys.stdin:
line = [int(v) for v in line.strip()]
while len(line) > 1:
line = [line[i]+line[i+1] for i in range(len(line)-1)]
print(str(line[0])[len(str(line[0]))-1]) | 4823108376
1234567890
0123456789
| 5
6
4
|
<H1>一番下の行の数字は?</H1>
<p>
次のような数字のパターンを作ることを考えます。
</p>
<pre>
4 8 2 3 1 0 8 3 7 6
2 0 5 4 1 8 1 0 3
2 5 9 5 9 9 1 3
7 4 4 4 8 0 4
1 8 8 2 8 4
9 6 0 0 2
5 6 0 2
1 6 2
7 8
5
</pre>
<p>
このパターンは以下の規則に従っています。
</p>
<pre>
A B
C
</pre>
<p>
という数字の並びにおいて、C は A + B の 1 の位の数字である。たとえば、
</p>
<pre>
9 5
4
</pre>
<p>
では、9 + 5 = 14 の 1 の位の数字、すなわち 4 が 9 と 5 の斜め下に並べられます。また、
</p>
<pre>
2 3
5
</pre>
<p>
では、2 + 3 = 5 の 1 の位の数字、すなわち 5 が 2 と 3 の斜め下に並べられます。
</p>
<p>
一番上の行の 10 個の整数を読み込んで、一番下の行の 1 個の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、一番上の行の 10 個の数字が文字列として１行に与えられます。
</p>
<p>
データセットの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>データセットごとに、一番下の行の数字を１行に出力します。
<H2>Sample Input</H2>
<pre>
4823108376
1234567890
0123456789
</pre>
<H2>Output for the Sample Input</H2>
<pre>
5
6
4
</pre>
|
s730386806 | p00062 | Accepted | while True:
try:
a = [int(i) for i in input()]
except:
break
while True:
na = []
for i in range(len(a) - 1):
na.append((a[i] + a[i + 1]) % 10)
if len(na) == 1:
print(na[0])
break
a = na | 4823108376
1234567890
0123456789
| 5
6
4
|
<H1>一番下の行の数字は?</H1>
<p>
次のような数字のパターンを作ることを考えます。
</p>
<pre>
4 8 2 3 1 0 8 3 7 6
2 0 5 4 1 8 1 0 3
2 5 9 5 9 9 1 3
7 4 4 4 8 0 4
1 8 8 2 8 4
9 6 0 0 2
5 6 0 2
1 6 2
7 8
5
</pre>
<p>
このパターンは以下の規則に従っています。
</p>
<pre>
A B
C
</pre>
<p>
という数字の並びにおいて、C は A + B の 1 の位の数字である。たとえば、
</p>
<pre>
9 5
4
</pre>
<p>
では、9 + 5 = 14 の 1 の位の数字、すなわち 4 が 9 と 5 の斜め下に並べられます。また、
</p>
<pre>
2 3
5
</pre>
<p>
では、2 + 3 = 5 の 1 の位の数字、すなわち 5 が 2 と 3 の斜め下に並べられます。
</p>
<p>
一番上の行の 10 個の整数を読み込んで、一番下の行の 1 個の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、一番上の行の 10 個の数字が文字列として１行に与えられます。
</p>
<p>
データセットの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>データセットごとに、一番下の行の数字を１行に出力します。
<H2>Sample Input</H2>
<pre>
4823108376
1234567890
0123456789
</pre>
<H2>Output for the Sample Input</H2>
<pre>
5
6
4
</pre>
|
s043840950 | p00062 | Accepted | s = []
while True:
try:
s.append(str(input()))
except EOFError:
break
def func(x):
array = []
if len(x) == 1:
return x[0]
for i in range(len(x)-1):
array.append((x[i] + x[i+1]) % 10)
return func(array)
for i in range(len(s)):
arr = list(s[i])
for j in range(len(arr)):
arr[j] = int(arr[j])
print(func(arr))
| 4823108376
1234567890
0123456789
| 5
6
4
|
<H1>一番下の行の数字は?</H1>
<p>
次のような数字のパターンを作ることを考えます。
</p>
<pre>
4 8 2 3 1 0 8 3 7 6
2 0 5 4 1 8 1 0 3
2 5 9 5 9 9 1 3
7 4 4 4 8 0 4
1 8 8 2 8 4
9 6 0 0 2
5 6 0 2
1 6 2
7 8
5
</pre>
<p>
このパターンは以下の規則に従っています。
</p>
<pre>
A B
C
</pre>
<p>
という数字の並びにおいて、C は A + B の 1 の位の数字である。たとえば、
</p>
<pre>
9 5
4
</pre>
<p>
では、9 + 5 = 14 の 1 の位の数字、すなわち 4 が 9 と 5 の斜め下に並べられます。また、
</p>
<pre>
2 3
5
</pre>
<p>
では、2 + 3 = 5 の 1 の位の数字、すなわち 5 が 2 と 3 の斜め下に並べられます。
</p>
<p>
一番上の行の 10 個の整数を読み込んで、一番下の行の 1 個の数を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、一番上の行の 10 個の数字が文字列として１行に与えられます。
</p>
<p>
データセットの数は 20 を超えません。
</p>
<H2>Output</H2>
<p>データセットごとに、一番下の行の数字を１行に出力します。
<H2>Sample Input</H2>
<pre>
4823108376
1234567890
0123456789
</pre>
<H2>Output for the Sample Input</H2>
<pre>
5
6
4
</pre>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.