s_id stringlengths 10 10 | p_id stringlengths 6 6 | u_id stringlengths 10 10 | date stringlengths 10 10 | language stringclasses 1 value | original_language stringclasses 11 values | filename_ext stringclasses 1 value | status stringclasses 1 value | cpu_time int64 0 100 | memory stringlengths 4 6 | code_size int64 15 14.7k | code stringlengths 15 14.7k | problem_id stringlengths 6 6 | problem_description stringlengths 358 9.83k | input stringlengths 2 4.87k | output stringclasses 807 values | __index_level_0__ int64 1.1k 1.22M |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
s172130185 | p00061 | u921312486 | 1482227887 | Python | Python3 | py | Accepted | 40 | 7736 | 489 | 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]) | p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,941 |
s933661141 | p00061 | u546285759 | 1484030184 | Python | Python3 | py | Accepted | 30 | 7664 | 324 | 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 | p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,942 |
s472191547 | p00061 | u661290476 | 1484316093 | Python | Python3 | py | Accepted | 30 | 7688 | 405 | 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 | p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,943 |
s513313260 | p00061 | u078042885 | 1486084467 | Python | Python3 | py | Accepted | 20 | 7636 | 185 | 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 | p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,944 |
s668016086 | p00061 | u032662562 | 1488345227 | Python | Python3 | py | Accepted | 30 | 7668 | 423 | 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 | p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,945 |
s898015485 | p00061 | u964040941 | 1490228891 | Python | Python3 | py | Accepted | 20 | 7632 | 267 | 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) | p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,946 |
s353905240 | p00061 | u462831976 | 1493158621 | Python | Python3 | py | Accepted | 20 | 7524 | 374 | # -*- 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) | p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,947 |
s716731985 | p00061 | u811733736 | 1503471560 | Python | Python3 | py | Accepted | 30 | 7652 | 1,209 | # -*- 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:]) | p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,948 |
s675875116 | p00061 | u957021183 | 1505107815 | Python | Python3 | py | Accepted | 50 | 7724 | 598 | # 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 | p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,949 |
s935750239 | p00061 | u024715419 | 1518487260 | Python | Python3 | py | Accepted | 20 | 5600 | 454 | 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
| p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,950 |
s086017549 | p00061 | u043254318 | 1518625266 | Python | Python3 | py | Accepted | 20 | 5600 | 551 | 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)
| p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,951 |
s595870745 | p00061 | u150984829 | 1519383002 | Python | Python3 | py | Accepted | 20 | 5604 | 182 | 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)
| p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,952 |
s574737004 | p00061 | u150984829 | 1519383257 | Python | Python3 | py | Accepted | 20 | 5608 | 156 | 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)
| p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,953 |
s536066006 | p00061 | u150984829 | 1519383340 | Python | Python3 | py | Accepted | 20 | 5600 | 152 | 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)
| p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,954 |
s091969421 | p00061 | u352394527 | 1527525757 | Python | Python3 | py | Accepted | 30 | 5596 | 364 | 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
| p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,955 |
s135522432 | p00061 | u136916346 | 1527929010 | Python | Python3 | py | Accepted | 30 | 6000 | 346 | 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]]
| p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,956 |
s344466821 | p00061 | u847467233 | 1529114043 | Python | Python3 | py | Accepted | 20 | 5596 | 425 | # 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
| p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,957 |
s420505212 | p00061 | u647766105 | 1356348238 | Python | Python | py | Accepted | 10 | 6560 | 297 | 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())]] | p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,958 |
s836477317 | p00061 | u542421762 | 1370868619 | Python | Python | py | Accepted | 20 | 4392 | 903 |
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) | p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,959 |
s533455583 | p00061 | u471115210 | 1374649935 | Python | Python | py | Accepted | 20 | 4256 | 418 | 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 | p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,960 |
s311173837 | p00061 | u782850731 | 1377245471 | Python | Python | py | Accepted | 10 | 4280 | 583 | #!/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) | p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,961 |
s424261508 | p00061 | u260980560 | 1385988376 | Python | Python | py | Accepted | 10 | 4236 | 346 | 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 | p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,962 |
s555957660 | p00061 | u912237403 | 1389820008 | Python | Python | py | Accepted | 10 | 4208 | 237 | 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 | p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,963 |
s565222928 | p00061 | u912237403 | 1389820564 | Python | Python | py | Accepted | 10 | 4208 | 227 | 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 | p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,964 |
s534764187 | p00061 | u633068244 | 1393686408 | Python | Python | py | Accepted | 10 | 4228 | 485 | 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] | p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,965 |
s228408784 | p00061 | u491763171 | 1400476869 | Python | Python | py | Accepted | 20 | 4236 | 406 | 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 | p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,966 |
s359702095 | p00061 | u187074069 | 1594895866 | Python | Python3 | py | Accepted | 20 | 5600 | 279 | 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
| p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,967 |
s855734803 | p00061 | u240091169 | 1592054310 | Python | Python3 | py | Accepted | 30 | 5600 | 322 | 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)
| p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,968 |
s060643221 | p00061 | u713674793 | 1586874316 | Python | Python3 | py | Accepted | 20 | 5600 | 213 |
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
| p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,969 |
s254227732 | p00061 | u630911389 | 1584442185 | Python | Python3 | py | Accepted | 20 | 5596 | 472 | 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
| p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,970 |
s475262913 | p00061 | u606731189 | 1576830112 | Python | Python3 | py | Accepted | 20 | 5592 | 438 | #正解数で順位を決定
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]])
| p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,971 |
s856714391 | p00061 | u803862921 | 1572061069 | Python | Python3 | py | Accepted | 20 | 5600 | 365 | 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])
| p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,972 |
s986390082 | p00061 | u824708460 | 1567042069 | Python | Python3 | py | Accepted | 20 | 5600 | 260 | 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
| p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,973 |
s754863749 | p00061 | u548252256 | 1561800242 | Python | Python3 | py | Accepted | 20 | 5592 | 515 | 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
| p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,974 |
s892339979 | p00061 | u647694976 | 1558499831 | Python | Python3 | py | Accepted | 20 | 5596 | 600 | 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
| p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,975 |
s614361037 | p00061 | u990228206 | 1551920313 | Python | Python3 | py | Accepted | 20 | 5592 | 233 | 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
| p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,976 |
s753939159 | p00061 | u563075864 | 1544357554 | Python | Python3 | py | Accepted | 20 | 5600 | 388 | 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
| p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,977 |
s559565404 | p00061 | u717526540 | 1542695990 | Python | Python3 | py | Accepted | 20 | 5592 | 404 | 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)
| p00061 |
<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> | 1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
| 2
2
3
3
| 10,978 |
s239427514 | p00062 | u197615397 | 1531137435 | Python | Python3 | py | Accepted | 20 | 5600 | 130 | 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)
| p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 10,979 |
s175041398 | p00062 | u553148578 | 1531471810 | Python | Python3 | py | Accepted | 20 | 5596 | 157 | 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])
| p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 10,980 |
s387243870 | p00062 | u193025715 | 1408891738 | Python | Python3 | py | Accepted | 30 | 6724 | 271 | 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]) | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 10,981 |
s982033302 | p00062 | u560838141 | 1410783757 | Python | Python | py | Accepted | 20 | 4204 | 197 | 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; | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 10,982 |
s687667648 | p00062 | u506132575 | 1417074418 | Python | Python | py | Accepted | 10 | 4196 | 206 | 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] ]) | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 10,983 |
s800692105 | p00062 | u567380442 | 1423103241 | Python | Python3 | py | Accepted | 30 | 6720 | 321 | 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) | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 10,984 |
s616737949 | p00062 | u879226672 | 1427479413 | Python | Python | py | Accepted | 20 | 4212 | 269 | 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]) | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 10,985 |
s208088480 | p00062 | u879226672 | 1427480067 | Python | Python | py | Accepted | 20 | 4204 | 248 | 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] | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 10,986 |
s591729292 | p00062 | u873482706 | 1434890231 | Python | Python | py | Accepted | 20 | 4220 | 386 | 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 | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 10,987 |
s787282097 | p00062 | u775586391 | 1449456377 | Python | Python3 | py | Accepted | 30 | 7636 | 214 | 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]) | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 10,988 |
s857758950 | p00062 | u461370825 | 1449760418 | Python | Python | py | Accepted | 20 | 6492 | 363 | 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 | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 10,989 |
s937734269 | p00062 | u140201022 | 1450862958 | Python | Python | py | Accepted | 10 | 6324 | 278 | 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 | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 10,990 |
s774298580 | p00062 | u075836834 | 1458410591 | Python | Python3 | py | Accepted | 20 | 7520 | 244 | 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 | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 10,991 |
s212694525 | p00062 | u148101999 | 1460598033 | Python | Python | py | Accepted | 20 | 6460 | 418 | #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() | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 10,992 |
s213424223 | p00062 | u130979865 | 1461642402 | Python | Python | py | Accepted | 20 | 6276 | 190 | # -*- 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 | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 10,993 |
s830427799 | p00062 | u358919705 | 1478612772 | Python | Python3 | py | Accepted | 20 | 7656 | 211 | 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]) | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 10,994 |
s661547499 | p00062 | u186082958 | 1481060970 | Python | Python3 | py | Accepted | 30 | 7648 | 350 | 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 | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 10,995 |
s382862088 | p00062 | u301729341 | 1481438298 | Python | Python3 | py | Accepted | 20 | 7536 | 339 | 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 | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 10,996 |
s160580730 | p00062 | u546285759 | 1482221443 | Python | Python3 | py | Accepted | 40 | 7620 | 209 | 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]) | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 10,997 |
s730386806 | p00062 | u661290476 | 1484320167 | Python | Python3 | py | Accepted | 20 | 7648 | 281 | 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 | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 10,998 |
s043840950 | p00062 | u711765449 | 1485870126 | Python | Python3 | py | Accepted | 30 | 7600 | 393 | 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))
| p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 10,999 |
s454606396 | p00062 | u078042885 | 1486082207 | Python | Python3 | py | Accepted | 20 | 7620 | 157 | while 1:
try:n=input()
except:break
n=list(map(int,n))
while len(n)>1:
n= [(i+j)%10 for i,j in zip(n[:len(n)-1],n[1:])]
print(*n) | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,000 |
s364460417 | p00062 | u078042885 | 1486082840 | Python | Python3 | py | Accepted | 30 | 7656 | 151 | while 1:
try:n=input()
except:break
n=list(map(int,n))
while len(n)>1:
n= [(i+j)%10 for i,j in zip(n[:-1],n[1:])]
print(*n) | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,001 |
s272220179 | p00062 | u078042885 | 1486082957 | Python | Python3 | py | Accepted | 20 | 7648 | 138 | while 1:
try:n=input()
except:break
while len(n)>1:
n= [(int(i)+int(j))%10 for i,j in zip(n[:-1],n[1:])]
print(*n) | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,002 |
s210638567 | p00062 | u032662562 | 1488463011 | Python | Python3 | py | Accepted | 20 | 7692 | 341 | def shorten(f):
#print(f)
if len(f) == 1:
return(f[0])
else:
g = []
v = f[0]
for i in f[1:]:
g.append((v + i)%10)
v = i
return(shorten(g))
while True:
try:
f = list(map(int, list(input().strip())))
print(shorten(f))
except EOFError:
break | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,003 |
s371388989 | p00062 | u964040941 | 1490229397 | Python | Python3 | py | Accepted | 20 | 7648 | 274 | while True:
try:
S = input()
except EOFError:
break
while len(S) > 1:
T = ''
for i in range(0,len(S) - 1):
x = int(S [i])
y = int(S [i + 1])
T += str((x + y) % 10)
S,T = T,S
print(S) | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,004 |
s860281655 | p00062 | u462831976 | 1493159243 | Python | Python3 | py | Accepted | 30 | 7580 | 339 | # -*- coding: utf-8 -*-
import sys
import os
for s in sys.stdin:
s = s.strip()
lst = list(s)
while len(lst) > 1:
lst2 = []
for i in range(len(lst) - 1):
a = int(lst[i])
b = int(lst[i+1])
c = (a + b) % 10
lst2.append(str(c))
lst = lst2
print(lst[0]) | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,005 |
s558158642 | p00062 | u811733736 | 1503244905 | Python | Python3 | py | Accepted | 40 | 7668 | 543 | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0062
"""
import sys
def solve(data):
work = data[:]
while len(work) != 1:
# print(work)
temp = []
for i in range(len(work)-1):
temp.append((work[i] + work[i+1]) % 10)
work = temp[:]
return work[0]
if __name__ == '__main__':
# ??????????????\?????¨???????????????
for line in sys.stdin:
data = [int(x) for x in list(line.strip())]
result = solve(data)
print(result) | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,006 |
s257904143 | p00062 | u855694108 | 1504610808 | Python | Python3 | py | Accepted | 20 | 7696 | 517 | import sys
def main():
for line in sys.stdin:
a = list(line)
del a[-1]
for x in range(len(a)):
a[x] = int(a[x])
for x in range(9):
b = []
for y in range(len(a) - 1):
hoge = a[y] + a[y + 1]
if hoge > 9:
hoge -= 10
else:
pass
b.append(hoge)
else:
a = b
print(a[0])
if __name__ == "__main__":
main() | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,007 |
s430856781 | p00062 | u957021183 | 1505108380 | Python | Python3 | py | Accepted | 20 | 7848 | 381 | # Aizu Problem 0062: What is the Bottommost
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
while True:
try:
A = [int(_) for _ in input().strip()]
except EOFError:
break
for _ in range(9):
A = [(A[i]+A[i+1]) % 10 for i in range(len(A) - 1)]
print(A[0]) | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,008 |
s534455446 | p00062 | u546285759 | 1507788238 | Python | Python3 | py | Accepted | 30 | 7740 | 216 | while True:
try:
nums = input()
except:
break
a = list(map(int, list(nums)))
while len(a) > 1:
a = list(map(int, [str(a[i]+a[i+1])[-1] for i in range(len(a)-1)]))
print(*a) | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,009 |
s695587548 | p00062 | u546285759 | 1507788486 | Python | Python3 | py | Accepted | 20 | 7688 | 196 | while True:
try:
nums = input()
except:
break
a = list(map(int, list(nums)))
while len(a) > 1:
a = [(a[i]+a[i+1])%10 for i in range(len(a)-1)]
print(*a) | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,010 |
s743339396 | p00062 | u737311644 | 1517621572 | Python | Python3 | py | Accepted | 20 | 5592 | 352 | while True:
try:
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])
except:break
| p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,011 |
s770793616 | p00062 | u306037418 | 1518316729 | Python | Python3 | py | Accepted | 20 | 5604 | 286 | import sys
for line in sys.stdin:
n = line
temp = []
for i in line[:-1]:
temp.append(int(i))
n = temp
while len(n) > 1:
temp = []
for i in range(len(n)-1):
temp.append(int(str(n[i] + n[i+1])[-1]))
n = temp
print(n[0])
| p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,012 |
s977638145 | p00062 | u024715419 | 1518488560 | Python | Python3 | py | Accepted | 20 | 5596 | 275 | def calc(inp):
if len(inp) == 1:
return inp
out = ""
for i in range(len(inp) - 1):
out = out + str(int(inp[i]) + int(inp[i + 1]))[-1]
return calc(out)
while True:
try:
s = input()
print(calc(s))
except:
break
| p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,013 |
s785346603 | p00062 | u043254318 | 1518630133 | Python | Python3 | py | Accepted | 20 | 5600 | 448 | def get_input():
while True:
try:
yield ''.join(input())
except EOFError:
break
N = list(get_input())
for l in range(len(N)):
S = N[l]
table = [[0 for i in range(10)] for j in range(10)]
for i in range(len(S)):
table[0][i] = int(S[i])
for i in range(1,10):
for j in range(0,10-i):
table[i][j] = (table[i-1][j] + table[i-1][j+1]) % 10
print(table[9][0])
| p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,014 |
s855415821 | p00062 | u150984829 | 1519384153 | Python | Python3 | py | Accepted | 20 | 5612 | 144 | import sys
f=lambda x:f([(x[i]+x[i+1])%10 for i in range(len(x)-1)])if len(x)>1 else x
for e in sys.stdin:print(*f([int(i)for i in e.strip()]))
| p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,015 |
s578295690 | p00062 | u150984829 | 1519384484 | Python | Python3 | py | Accepted | 20 | 5604 | 127 | import sys
for e in sys.stdin:
e=e.strip()
while len(e)>1:e=[(int(e[i])+int(e[i+1]))%10 for i in range(len(e)-1)]
print(*e)
| p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,016 |
s070610132 | p00062 | u150984829 | 1519384689 | Python | Python3 | py | Accepted | 20 | 5604 | 132 | import sys
for e in sys.stdin:
e=list(map(int,e.strip()))
while len(e)>1:e=[(e[i]+e[i+1])%10 for i in range(len(e)-1)]
print(*e)
| p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,017 |
s507890712 | p00062 | u150984829 | 1519384972 | Python | Python3 | py | Accepted | 20 | 5608 | 123 | import sys
for e in sys.stdin:
e=e.strip()
while len(e)>1:e=[(int(a)+int(b))%10 for a,b in zip(e[:-1],e[1:])]
print(*e)
| p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,018 |
s725068139 | p00062 | u150984829 | 1519386023 | Python | Python3 | py | Accepted | 20 | 5604 | 105 | import sys
n=[1,9,36,84,126]
for e in sys.stdin:print(sum(int(a)*k for a,k in zip(e[:-1],n+n[::-1]))%10)
| p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,019 |
s546174380 | p00062 | u150984829 | 1519386380 | Python | Python3 | py | Accepted | 20 | 5608 | 146 | import sys
n=[1,9,36,84,126]
for x in sys.stdin:
a,b,c,d,e,f,g,h,i,j=map(int,x[:-1])
print(sum(s*t for s,t in zip(n,[a+j,b+i,c+h,d+g,e+f]))%10)
| p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,020 |
s674366177 | p00062 | u150984829 | 1519386760 | Python | Python3 | py | Accepted | 20 | 5608 | 114 | import sys
for x in sys.stdin:
print(sum(s*(int(t)+int(u))for s,t,u in zip([1,9,36,84,126],x[:5],x[9:4:-1]))%10)
| p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,021 |
s970209054 | p00062 | u150984829 | 1519386929 | Python | Python3 | py | Accepted | 20 | 5612 | 106 | import sys
for e in sys.stdin:
print(sum(int(a)*k for a,k in zip(e[:5]+e[9:4:-1],[1,9,36,84,126]*2))%10)
| p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,022 |
s302044933 | p00062 | u150984829 | 1519386945 | Python | Python3 | py | Accepted | 20 | 5608 | 104 | import sys
for e in sys.stdin:print(sum(int(a)*k for a,k in zip(e[:5]+e[9:4:-1],[1,9,36,84,126]*2))%10)
| p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,023 |
s841672215 | p00062 | u150984829 | 1519386999 | Python | Python3 | py | Accepted | 20 | 5604 | 103 | import sys
for e in sys.stdin:print(sum(k*int(a)for k,a in zip([1,9,36,84,126]*2,e[:5]+e[9:4:-1]))%10)
| p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,024 |
s811804991 | p00062 | u352394527 | 1527526288 | Python | Python3 | py | Accepted | 30 | 5600 | 235 | def solve(nums):
while len(nums) > 1:
nums = [nums[i] + nums[i + 1] for i in range(len(nums) -1)]
return nums[0] % 10
while True:
try:
s = list(map(int, list(input())))
print(solve(s))
except EOFError:
break
| p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,025 |
s588924973 | p00062 | u136916346 | 1527929603 | Python | Python3 | py | Accepted | 20 | 5604 | 236 | import sys
red=lambda a:"".join(map(str,[(int(a[i])+int(a[i+1]))%10 for i in range(len(a)-1)]))
tl=[]
l=[i.strip() for i in sys.stdin]
for i in l:
while len(i) != 1:
i=red(i)
tl.extend([int(i)])
[print(i) for i in tl]
| p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,026 |
s129504580 | p00062 | u847467233 | 1529036914 | Python | Python3 | py | Accepted | 30 | 5592 | 232 | # AOJ 0062: What is the Bottommost?
# Python3 2018.6.15 bal4u
while True:
try:
a = list(map(int, input()))
except EOFError:
break
for i in range(9, 0, -1):
for j in range(1, i+1): a[j-1] = (a[j-1]+a[j]) % 10
print(a[0])
| p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,027 |
s640724489 | p00062 | u735362704 | 1355681311 | Python | Python | py | Accepted | 20 | 7256 | 491 | #!/usr/bin/env python
# coding: utf-8
import sys
def get_answer(param):
answer = []
for i in xrange(param.__len__() - 1):
c = str(param[i] + param[i + 1])[-1]
answer.append(int(c))
if (answer.__len__() == 1):
return answer[0]
else:
return get_answer(answer)
def main():
params = [map(int, line.rstrip()) for line in sys.stdin.readlines()]
for param in params:
print get_answer(param)
if __name__ == '__main__':
main() | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,028 |
s690542699 | p00062 | u647766105 | 1356349293 | Python | Python | py | Accepted | 10 | 6560 | 219 | import sys
def calc(lis):
for i in xrange(9):
for j in xrange(9-i):
lis[j]=(lis[j]+lis[j+1])%10
return lis
for line in sys.stdin.readlines():
print calc([int(x) for x in line.strip()])[0] | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,029 |
s148799599 | p00062 | u542421762 | 1370871089 | Python | Python | py | Accepted | 10 | 4220 | 281 |
import sys
def solv(nums):
for i in range(9):
nums = foo(nums)
return nums[0]
def foo(nums):
nums = map(lambda a: (a[0] + a[1]) % 10, zip(nums, nums[1:]))
return nums
for line in sys.stdin:
nums = map(int, list(line.rstrip()))
print solv(nums) | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,030 |
s134851520 | p00062 | u782850731 | 1377252785 | Python | Python | py | Accepted | 10 | 4228 | 337 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
for line in stdin:
L = [int(c) for c in line.strip()]
while len(L) > 1:
L = [(L[i] + L[i + 1]) % 10 for i in range(len(L) - 1)]
print(L[0]) | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,031 |
s242907176 | p00062 | u865312527 | 1378316916 | Python | Python | py | Accepted | 10 | 4220 | 217 | import sys
for rec in sys.stdin.readlines():
d=map(int,list(rec.rstrip()))
while len(d)>1:
tmp=[]
for i in range(1,len(d)):
tmp.append((d[i-1]+d[i])%10)
d=tmp
print d[0] | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,032 |
s707947841 | p00062 | u912237403 | 1389888863 | Python | Python | py | Accepted | 10 | 4204 | 196 | import sys
for s in sys.stdin:
x=["0123456789".index(c) for c in s[:-1]]
while True:
a=len(x)-1
x=[(x[i]+x[i+1])%10 for i in range(a)]
if a==1: break
print x[0] | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,033 |
s117052299 | p00062 | u633068244 | 1393687693 | Python | Python | py | Accepted | 10 | 4200 | 208 | while True:
try:
n = list(raw_input())
for i in range(9,0,-1):
for j in range(i):
n[j] = (int(n[j])+int(n[j+1]))%10
print n[0]
except:
break | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,034 |
s822664849 | p00062 | u633068244 | 1393687870 | Python | Python | py | Accepted | 10 | 4208 | 208 | while True:
try:
n = list(map(int, raw_input()))
for i in range(9,0,-1):
for j in range(i):
n[j] = (n[j]+n[j+1])%10
print n[0]
except:
break | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,035 |
s698205320 | p00062 | u633068244 | 1393688100 | Python | Python | py | Accepted | 20 | 4200 | 208 | while True:
try:
n = list(map(int, raw_input()))
for i in range(9,0,-1):
for j in range(i):
n[j] = (n[j]+n[j+1])%10
print n[0]
except:
break | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,036 |
s440092063 | p00062 | u246033265 | 1400423281 | Python | Python | py | Accepted | 10 | 4208 | 210 | try:
while True:
a = map(int, raw_input())
for i in range(9, 0, -1):
for j in range(i):
a[j] = (a[j] + a[j + 1]) % 10
print a[0]
except EOFError:
pass | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,037 |
s427117376 | p00062 | u491763171 | 1400470577 | Python | Python | py | Accepted | 10 | 4220 | 295 | while 1:
try:
numbers = map(int, raw_input())
except EOFError:
break
dp = [[0] * 10 for _ in xrange(10)]
dp[0] = numbers
for i in xrange(9):
for j in xrange(len(dp[i]) - 1):
dp[i + 1][j] = (dp[i][j] + dp[i][j + 1]) % 10
print dp[-1][0] | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,038 |
s161679598 | p00062 | u436634575 | 1402319422 | Python | Python3 | py | Accepted | 30 | 6720 | 210 | while True:
try:
line = input()
except EOFError:
break
a = list(map(int, line))
while len(a) > 1:
a = [(a[i] + a[i + 1]) % 10 for i in range(len(a) - 1)]
print(a[0]) | p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,039 |
s992696412 | p00062 | u747915832 | 1597762732 | Python | Python3 | py | Accepted | 20 | 5620 | 1,474 | while True:
try:
A = list(input())
except:
break
A2 = []
for i in range(9):
n = int(A[i]) + int(A[i+1])
n_str = str(n)
n_2 = n_str[len(n_str)-1]
A2.append(n_2)
A3 = []
for i in range(8):
n = int(A2[i]) + int(A2[i+1])
n_str = str(n)
n_2 = n_str[len(n_str)-1]
A3.append(n_2)
A4 = []
for i in range(7):
n = int(A3[i]) + int(A3[i+1])
n_str = str(n)
n_2 = n_str[len(n_str)-1]
A4.append(n_2)
A5 = []
for i in range(6):
n = int(A4[i]) + int(A4[i+1])
n_str = str(n)
n_2 = n_str[len(n_str)-1]
A5.append(n_2)
A6 = []
for i in range(5):
n = int(A5[i]) + int(A5[i+1])
n_str = str(n)
n_2 = n_str[len(n_str)-1]
A6.append(n_2)
A7 = []
for i in range(4):
n = int(A6[i]) + int(A6[i+1])
n_str = str(n)
n_2 = n_str[len(n_str)-1]
A7.append(n_2)
A8 = []
for i in range(3):
n = int(A7[i]) + int(A7[i+1])
n_str = str(n)
n_2 = n_str[len(n_str)-1]
A8.append(n_2)
A9 = []
for i in range(2):
n = int(A8[i]) + int(A8[i+1])
n_str = str(n)
n_2 = n_str[len(n_str)-1]
A9.append(n_2)
A10 = []
for i in range(1):
n = int(A9[i]) + int(A9[i+1])
n_str = str(n)
n_2 = n_str[len(n_str)-1]
A10.append(n_2)
print(int(A10[0]))
| p00062 |
<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>
| 4823108376
1234567890
0123456789
| 5
6
4
| 11,040 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.