import sys
from math import floor, sqrt
from bisect import bisect_right

primes = [2]

def isPrime(v):
    threshold = floor(sqrt(v))
    for p in primes:
        if p > threshold:
            break
        if v % p == 0:
            return False
    return True

for v in range(3, 1000000, 2):
    if isPrime(v):
        primes.append(v)

values = []
for line in sys.stdin:
    values.append(int(line))

for v in values:
    print(bisect_right(primes, v))

import sys, math

class Eratos(object):
    def __init__(self, N):
        self.N = N
        self._primes = {i:True for i in range(2, N+1)}

    def filter(self):
        end = self.N
        if self.N > 5:
            end = math.ceil(self.N**0.5) + 1
        for n in range(2, end):
            if not self._primes[n]:
                continue
            for x in range(n*2, self.N+1, n):
                if x in self._primes:
                    self._primes[x] = False

    def primes(self, x):
        return [k for k,v in self._primes.items() if v == True and k <= x]

def run():
    e = Eratos(999999)
    e.filter()
    for _n in sys.stdin:
        N = int(_n)
        print(len(e.primes(N)))

if __name__ == '__main__':
    run()

Prime Number

Write a program which reads an integer <var>n</var> and prints the number of prime numbers which are less than or equal to <var>n</var>. A prime number is a natural number which has exactly two distinct natural number divisors: 1 and itself. For example, the first four prime numbers are: 2, 3, 5 and 7.

Input

Input consists of several datasets. Each dataset has an integer <var>n</var> (1 ≤ <var>n</var> ≤ 999,999) in a line.

The number of datasets is less than or equal to 30.

Output

For each dataset, prints the number of prime numbers.

Sample Input

10
3
11

Output for the Sample Input

4
2
5


import sys
from math import floor, sqrt
from bisect import bisect_right

primes = [2]

def isPrime(v):
    threshold = floor(sqrt(v))
    for p in primes:
        if p > threshold:
            break
        if v % p == 0:
            return False
    return True

for v in range(3, 1000000, 2):
    if isPrime(v):
        primes.append(v)

print(len(primes))

values = []
for line in sys.stdin:
    values.append(int(line))

for v in values:
    print(bisect_right(primes, v))


def run():
    w = [i + 1 for i in range(int(input()))]
    n = int(input())
    for _ in range(n):
        s1, s2 = list(map(int, input().split(',')))
        w[s1-1], w[s2-1] = w[s2-1], w[s1-1]
    print('\n'.join([str(_w) for _w in w]))

if __name__ == '__main__':
    run()

w=int(input())
n=int(input())

lis=[i+1 for i in range(w)]

for _ in range(n):
    a,b=map(int,input().split(","))
    a-=1
    b-=1
    x=lis[a]
    lis[a]=lis[b]
    lis[b]=x

for i in range(w):
    print(lis[i])

Drawing Lots

Let's play Amidakuji.

In the following example, there are five vertical lines and four horizontal lines. The horizontal lines can intersect (jump across) the vertical lines.

In the starting points (top of the figure), numbers are assigned to vertical lines in ascending order from left to right. At the first step, 2 and 4 are swaped by the first horizontal line which connects second and fourth vertical lines (we call this operation (2, 4)). Likewise, we perform (3, 5), (1, 2) and (3, 4), then obtain "4 1 2 5 3" in the bottom.

Your task is to write a program which reads the number of vertical lines <var>w</var> and configurations of horizontal lines and prints the final state of the Amidakuji. In the starting pints, numbers 1, 2, 3, ..., <var>w</var> are assigne to the vertical lines from left to right.

Input

<var>w</var>
<var>n</var>
<var>a1</var>,<var>b1</var>
<var>a2</var>,<var>b2</var>
.
.
<var>an</var>,<var>bn</var>

<var>w</var> (<var>w</var> ≤ 30) is the number of vertical lines. <var>n</var> (<var>n</var> ≤ 30) is the number of horizontal lines. A pair of two integers <var>ai</var> and <var>bi</var> delimited by a comma represents the <var>i</var>-th horizontal line.

Output

The number which should be under the 1st (leftmost) vertical line

The number which should be under the 2nd vertical line

:

The number which should be under the <var>w</var>-th vertical line

Sample Input

5
4
2,4
3,5
1,2
3,4

Output for the Sample Input

4
1
2
5
3


#!/usr/bin/env python
#-*- coding:utf-8 -*-

import sys
import math

w = int(input())
n = int(input())
s = []

for _ in range(n):
    x = input().split(',')
    s.append((int(x[0]), int(x[1])))

result = [i for i in range(1, w+1)]
print(len(result))

for x, y in s:
    result[x-1], result[y-1] = result[y-1], result[x-1]

for x in result:
    print(x)


while True:
    N=int(input())

    if N==0:
        break

    num=0
    res=-11111111
    for i in range(N):
        a=int(input())
        num=max(num+a, a)
        #print(num)
        res=max(num, res)
        #print(res)

    print(res)

while 1:
    n=int(input())
    if n==0:break
    nlist=[]
    nans=-100001
    for i in range(n):
        nlist.append(int(input()))
    nkeep=0
    for i in nlist:
        if nkeep<0:
            nkeep=i
        else:
            nkeep+=i
        if nans<nkeep:nans=nkeep
    if max(nlist)<0:nans=max(nlist)
    print(nans)

Maximum Sum Sequence

Given a sequence of numbers <var>a1</var>, <var>a2</var>, <var>a3</var>, ..., <var>an</var>, find the maximum sum of a contiguous subsequence of those numbers. Note that, a subsequence of one element is also a contiquous subsequence.

Input

The input consists of multiple datasets. Each data set consists of:

<var>n</var>
<var>a1</var>
<var>a2</var>
.
.
<var>an</var>

You can assume that 1 ≤ <var>n</var> ≤ 5000 and -100000 ≤ <var>ai</var> ≤ 100000.

The input end with a line consisting of a single 0.

Output

For each dataset, print the maximum sum in a line.

Sample Input

7
-5
-1
6
4
9
-6
-7
13
1
2
3
2
-2
-1
1
2
3
2
1
-2
1
3
1000
-200
201
0

Output for the Sample Input

19
14
1001


while 1:
    n=int(input())
    if n==0:break
    nlist=[]
    nans=-100001
    for i in range(n):
        nlist.append(int(input()))
    nkeep=0
    for i in nlist:
        if i>0 and nkeep>=0:
            nkeep+=i
        elif nkeep<0:
            nkeep=i
        if nans<nkeep:nans=nkeep
    if max(nlist)<0:nans=max(nlist)
    print(nans)


平面上の図形

縦 8、横 8 のマスからなる図 1 のような平面があります。

□	□	□	□	□	□	□	□

□	□	□	□	□	□	□	□

□	□	□	□	□	□	□	□

□	□	□	□	□	□	□	□

□	□	□	□	□	□	□	□

□	□	□	□	□	□	□	□

□	□	□	□	□	□	□	□

□	□	□	□	□	□	□	□

図１

この平面上に、以下の A から G の図形のどれかが一つだけ置かれています。

A

■	■

■	■

B

	■

	■

	■

	■

C

■	■	■	■

D

	■

■	■

■

E

■	■

	■	■

F

■

■	■

	■

G

	■	■

■	■

たとえば、次の図 2 の例では E の図形が置かれています。

□	□	□	□	□	□	□	□

□	□	□	□	□	□	□	□

□	■	■	□	□	□	□	□

□	□	■	■	□	□	□	□

□	□	□	□	□	□	□	□

□	□	□	□	□	□	□	□

□	□	□	□	□	□	□	□

□	□	□	□	□	□	□	□

図２

平面の中で図形が占めているマスを 1、占めていないマスを 0 で表現した数字の列を読み込んで、置かれている図形の種類（A〜G）を出力するプログラムを作成してください。

ただし、ひとつの平面に置かれている図形は必ず１つで、複数の図形が置かれていることはありません。また、A〜G で表される図形以外のものが置かれていることはありません。

Input

入力は複数のデータセットからなります。

１つのデータセットとして、平面の中で図形が占めているマスを 1、占めていないマスを 0 で表現した 8 文字からなる 8 つの文字列が与えられます。例えば、図 2 に対応する文字列の並びは次のようになります。

0	0	0	0	0	0	0	0

0	0	0	0	0	0	0	0

0	1	1	0	0	0	0	0

0	0	1	1	0	0	0	0

0	0	0	0	0	0	0	0

0	0	0	0	0	0	0	0

0	0	0	0	0	0	0	0

0	0	0	0	0	0	0	0

データセットの間は１つの空行で区切られています。データセットの数は 50 を超えません。

Output

各データセットごとに、平面に与えられた図形の種類（A〜G のいずれか）を１行に出力してください。

Sample Input

00000000
00000000
01100000
00110000
00000000
00000000
00000000
00000000

00011110
00000000
00000000
00000000
00000000
00000000
00000000
00000000

00000000
00000000
00110000
00110000
00000000
00000000
00000000
00000000

Output for the Sample Input

E
C
A


w=str(input())
for i in range(len(w)):
    if i>len(w):break
    if w[i]=="a" and w[i+1]=="p" and w[i+2]=="p" and w[i+3]=="l" and w[i+4]=="e":
        w=w[:i]+"peach"+w[i+5:]
        continue
    if w[i]=="p" and w[i+1]=="e" and w[i+2]=="a" and w[i+3]=="c" and w[i+4]=="h":
        w=w[:i]+"apple"+w[i+5:]
print(w)

りんごと桃

福島県は果物の産地としても有名で、その中でも特に桃とりんごは全国でも指折りの生産量を誇っています。ところで、ある販売用の英文パンフレットの印刷原稿を作ったところ、手違いでりんごに関する記述と桃に関する記述を逆に書いてしまいました。

あなたは、apple と peach を修正する仕事を任されましたが、なにぶん面倒です。１行の英文を入力して、そのなかの apple という文字列を全て peach に、peach という文字列を全てapple に交換した英文を出力するプログラムを作成してください。

Input

英文（半角英数字、空白、記号を含む）が１行に与えられます。入力される文字列の長さは 1000 以下です。

Output

apple とpeach という文字列を交換した英文を１行に出力します。

Sample Input

the cost of one peach is higher than that of one apple.

Output for the Sample Input

the cost of one apple is higher than that of one peach.


string=input()
print(string)
string1=string.replace('peach','tmp')
string2=string1.replace('apple','peach')
string3=string2.replace('tmp','apple')
print(string3)


import sys
f = sys.stdin

for line in f:
    a, b, n = map(int, line.split())
    s = 0
    for i in range(n):
        a = a % b * 10
        s += a // b % 10
    print(s)

while True:
    try:
        a, b, n = map(int, input().split())
    except:
        break

    s = str(a/b)
    sum = 0
    x = s.index(".")+1
    for i in s[x:x+n]:
        sum += int(i)

    print(sum)

小数位の和

<var>a</var>, <var>b</var>, <var>n</var> は、いずれも正の整数であるとします。分数 <var>a</var> / <var>b</var> の小数第 <var>i</var> 位の数を <var>f(i)</var> とします (0 ≤ <var>f(i)</var> ≤ 9)。このとき、<var>i = 1</var> から <var>n</var> までの <var>f(i)</var> の和を <var>s</var> とします。

<var>s = f(1) + f(2) +</var> ... <var>+ f(n)</var>

<var>a</var>, <var>b</var>, <var>n</var> を読み込んで、 <var>s</var> を出力して終了するプログラムを作成してください。

Input

入力は複数のデータセットからなります。各データセットとして、3 つの整数 <var>a</var> (1 ≤ <var>a</var> ≤ 1000), <var>b</var> (1 ≤ <var>b</var> ≤ 10000), <var>n</var> (1 ≤ <var>n</var> ≤ 100) が空白区切りで１行に与えられます。

データセットの数は 100 を超えません。

Output

データセットごとに、<var>s</var> を１行に出力します。

Sample Input

1 2 3
2 3 4
5 4 3
4 3 2

Output for the Sample Input

5
24
7
6


while True:
	try:
		a, b, n = list(map(int ,input().split(" ")))
		val = ("{0:." + str(n + 1) + "f}").format(a / b)
		ans = sum(list(map(int, list(str(val)[2:-1]))))
		print(ans)
	except:
		break


data = {}

while True:
    team, score = input().split(',')
    if team == score == '0': break
    if int(score) in data:
        data[int(score)].append(team)
    else:
        data[int(score)] = [team]

while True:
    try:
        n = input()
    except:
        break
    for d in data.keys():
        if n in data[d]:
            tmp = reversed(list(data.keys()))
            ind = list(tmp).index(d)
            print(ind + 1)

table = {}
while True:
    p, s = map(int, input().split(","))
    if p == 0:
        break
    table[p] = s
result = {v: i for i, v in enumerate(sorted(set(table.values()), reverse=True), start=1)}

try:
    while True:
        q = int(input())
        print(result[table[q]])
except EOFError:
    pass

Rank Checker

時は2020 年。パソコン甲子園 2020 の予選結果を保存したデータがあります。このデータには、各チームに振られる整理番号と正解数が保存されています。ここでは、正解数で順位を決定するものとし、正解数の多いほうから順に 1 位、2 位 ... と順位をつけていくこととします。

予選結果のデータと整理番号をキーボードから入力して、その番号のチームの順位を出力するプログラムを作成してください。

Input

入力データは２つの部分からなります。前半の部分は、予選結果のデータ、後半の部分は順位を知りたいチーム番号の問い合わせです。予選結果のデータの形式は以下の通りです。

<var>p1</var>,<var>s1</var>
<var>p2</var>,<var>s2</var>
...
...
<var>0</var>,<var>0</var>

<var>pi</var> (1 ≤ <var>pi</var> ≤ 100 )、 <var>si</var> (0 ≤ <var>si</var> ≤ 30) はそれぞれ <var>i</var> チーム目の整理番号と正解数を表す整数です。整理番号と正解数がともに 0 のときこのデータの入力が終わるものとします。

続いて後半の問い合わせが複数与えられます。問い合わせの形式は以下の通りです。

<var>q1</var>
<var>q2</var>
:

各問い合わせは１行に整理番号 <var>qi</var> (1 ≤ <var>qi</var> ≤ 30) が与えられます。これを入力の最後まで処理して下さい。問い合わせの数は 100 を超えません。

Output

各問い合わせについて、チームの順位を１行に出力して下さい。

Sample Input

1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5

Output for the Sample Input

2
2
3
3

Note

入力例のデータにおいて、チームを正解数順に整列すると：

3,30
1,20
2,20
6,20
4,10
5,10

となります。ここでは、正解数を基に順位を決定するため、30問正解チームを1位、20問正解チームを2位、10問正解チームを3位とします（上位のチーム数を考慮し、10問正解チームを5位とする通常の順位付けとは異なることに注意して下さい）。


team_score=[]
while True:

	x,y=map(int,input().split(','))
	if x==y==0:
		break
	team_score.append((x,y))

team_score.sort(key=lambda x:x[1],reverse=True)
for i,j in team_score:
	print(i)


from math import atan2

class Point(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y

class Vector(object):
    def __init__(self, p1, p2):
        self.x = p2.x - p1.x
        self.y = p2.y - p1.y

    def cross(self, other: "Vector") -> float:
        return self.x*other.y - self.y*other.x

def grahams_scan(a: list):
    a.sort(key=lambda p: p.y)
    bottom_x, bottom_y = a[0].x, a[0].y
    _a = sorted(a[1:], key=lambda p: atan2(bottom_y-p.y, bottom_x-p.x)) + [a[0]]
    result = [a[0], _a[0]]

    for next_point in _a[1:]:
        while Vector(result[-1], result[-2]).cross(Vector(result[-1], next_point)) >= 0:
            result.pop()
        result.append(next_point)
    return result

while True:
    n = int(input())
    if not n:
        break
    a = [Point(*map(float, input().split(","))) for _ in [0]*n]
    result = grahams_scan(a)
    print(n-len(result)+1)

eps = 1e-10

def add(a, b):
    return 0 if abs(a + b) < eps * (abs(a) + abs(b)) else a + b

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, p):
        return Point(add(self.x, p.x), add(self.y, p.y))

    def __sub__(self, p):
        return Point(add(self.x, -p.x), add(self.y, -p.y))

    def __mul__(self, d):
        return Point(self.x * d, self.y * d)

    def dot(self, p):
        return add(self.x * p.x, self.y * p.y)

    def det(self, p):
        return add(self.x * p.y, -self.y * p.x)

    def __str__(self):
        return "({}, {})".format(self.x, self.y)

def convex_hull(ps):
    ps = [Point(x, y) for x, y in sorted([(p.x, p.y) for p in ps])]
    upper_hull = get_bounds(ps)
    ps.reverse()
    lower_hull = get_bounds(ps)
    del upper_hull[-1]
    del lower_hull[-1]
    upper_hull.extend(lower_hull)
    return upper_hull

def get_bounds(ps):
    qs = [ps[0], ps[1]]
    for p in ps[2:]:
        while len(qs) > 1 and (qs[-1] - qs[-2]).det(p - qs[-1]) <= 0:
            del qs[-1]
        qs.append(p)
    return qs

while True:
    n = int(input())
    if n == 0: break
    points = []
    for i in range(n):
        x, y = map(float, input().split(','))
        points.append(Point(x, y))
    print(len(points) - len(convex_hull(points)))

輪ゴム

<var>n</var> 本の釘を平板上の座標 <var>P1</var> (<var>x1</var>, <var>y1</var>), <var>P2</var> (<var>x2</var>, <var>y2</var>), <var>P3</var> (<var>x3</var>, <var>y3</var>),..., <var>Pn</var> (<var>xn</var>, <var>yn</var>) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。

釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。

図１
図２

ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、<var>n</var> は 3 以上 100 以下の整数です。

Input

複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。

<var>n</var>
<var>x1</var>, <var>y1</var>
<var>x2</var>, <var>y2</var>
...
...
<var>xn</var>, <var>yn</var>

<var>n</var> が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。

Output

データセットごとに、ゴムと接していない釘の本数を出力してください。

例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。

図３
図４

Sample Input

4
1.0,0.0
0.0,1.0
2.0,1.0
1.0,2.0
9
-509.94,892.63
567.62,639.99
-859.32,-64.84
-445.99,383.69
667.54,430.49
551.12,828.21
-940.2,-877.2
-361.62,-970
-125.42,-178.48
0

Output for the Sample Input

0
3

Hint

以下は２つめのサンプル入力に対する図です。


from math import atan2

def grahams_scan(a: list):
    a.sort(key=lambda x: x[1])
    x1, y1 = a[0]
    a = [((x1, y1), 0)] +\
        sorted([((x2, y2), atan2(y2-y1, x2-x1)) for x2, y2 in a[1:]], key=lambda x: x[1]) +\
        [((x1, y1), 0)]
    result = [(x1, y1)]
    for ((x2, y2),_), ((x3, y3),_) in zip(a[1:], a[2:]):
        if (x1-x2)*(y3-y2) - (y1-y2)*(x3-x2) < 0:
            result.append((x2, x3))
            x1, y1 = x2, y2
    return result

while True:
    n = int(input())
    if not n:
        break
    a = [tuple(map(float, input().split(","))) for _ in [0]*n]
    r = grahams_scan(a)
    print(n-len(r))


m_ = [31,28,31,30,31,30,31,31,30,31,30,31]
m_sum = [0]
m_sum.extend([sum(m_[0:i+1]) for i in range(12)])
def mtod(m,d):
    s = m_sum[m-1] + d
    return s
def dtom(s):
    for i in range(13):
        if s < m_sum[i]:
            return i,s - m_sum[i-1]

def minus(a,b):
    if a >= b:
        return a-b
    else:
        return a + 365 - b

meiji = 1000*1868 + mtod(9,8)
taisho = 1000*1912 + mtod(7,30)
showa = 1000*1926 + mtod(12,25)
heisei = 1000*1989 + mtod(1,8)

while(1):
    try:
        y,m,d = [int(i) for i in input().split()]
        s = 1000*y + mtod(m,d)
        if s < meiji:
            print("pre-meiji")
        elif s < taisho:
            print("meiji", int(s/1000) -int(meiji/1000) + 1, m ,d)
        elif s < showa:
            print("taisho", int(s/1000) -int(taisho/1000) + 1, m,d)
        elif s < heisei:
            print("showa", int(s/1000) -int(showa/1000) + 1, m,d)
        else:
            print("heisei", int(s/1000) -int(heisei/1000) + 1, m,d)
    except EOFError:
        break

import sys
f = sys.stdin

from datetime import date

eras = {'pre-meiji':{'start':None, 'end':date(1868,9,7)},
'meiji':{'start':date(1868, 9, 8), 'end':date(1912,7,29)},
'taisho':{'start':date(1912, 7, 30), 'end':date(1926,12,24)},
'showa':{'start':date(1926, 12, 25), 'end':date(1989,1,7)},
'heisei':{'start':date(1989, 1, 8), 'end':None}}

for line in f:
    y, m, d = map(int, line.split())
    target = date(y,m,d)
    for era_name, period in eras.items():
        if (period['start'] is None or period['start'] <= target) and(period['end'] is None or target <= period['end']):
            if era_name == 'pre-meiji':
                print(era_name)
            else:
                print(era_name, target.year - period['start'].year + 1, target.month, target.day)
            break

西暦和暦変換

西暦で表された年月日を、元号を用いた和暦に変換し、その年月日を出力するプログラムを作成してください。入力は例に示すように 3 つの整数であり、順に西暦年、月、日です。これを、出力例に示すように変換してください。なお、明治以前の年月日が入力された場合は「pre-meiji」と表示してください。

各年号の最初の年は「元年」ではなく「１年」と出力することとします。

元号	期間

meiji	1868. 9. 8	〜	1912. 7.29

taisho	1912. 7.30	〜	1926.12.24

showa	1926.12.25	〜	1989. 1. 7

heisei	1989. 1. 8	〜

入力

複数のデータが与えられます。各データとして年、月、日を表す３つの整数が空白区切りで１行に与えられます。

 入力の終わりまで処理してください。データの数は 50 を超えません。

出力

空白区切りの元号、年、月、日、または「pre-meiji」を１行に出力してください。

Sample Input

2005 9 3
1868 12 2
1868 9 7

Output for the Sample Input

heisei 17 9 3
meiji 1 12 2
pre-meiji


# from sys import exit
init = False
while(True):
    A, B = [int(n) for n in input().split()]
    if A == 0 and B == 0:
        exit()
    if init:
        print()

    # N = int(input())
    # a = [int(input()) for _ in range(N)]
    # S = str(input())
    # L = len(S)
    # T = str(input())
    # exit()
    aaa = False
    for a in range(A, B+1):
        if a % 4 == 0:
            if a % 100 == 0 and a % 400 != 0:
                continue
            print(a)
            aaa = True
    if (not aaa):
        print("NA")
    init = True

import sys
f = sys.stdin

def is_leapyear(year):
    return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)
i = 0
while True:
    a, b = map(int, f.readline().split())
    if a == b == 0:
        break
    if i:
        print()
    leapyear = [year for year in range(a, b + 1) if is_leapyear(year)]
    print('\n'.join(map(str, leapyear)) if leapyear else 'NA')
    i += 1

うるう年

 西暦 <var>a</var> 年から <var>b</var> 年までの間にあるすべてのうるう年を出力するプログラムを作成してください。

 うるう年の条件は、次のとおりとします。ただし、0 < <var>a</var> ≤ <var>b</var> < 3,000 とします。与えられた期間にうるう年がない場合には "NA"と出力してください。

 西暦年が 4 で割り切れる年であること。

 ただし、100 で割り切れる年はうるう年としない。

 しかし、400 で割り切れる年はうるう年である。

Input

複数のデータセットが与えられます。各データセットの形式は以下のとおりです：

<var>a</var> <var>b</var>

<var>a</var>, <var>b</var> がともに 0 のとき入力の終了とします。データセットの数は 50 を超えません。

Output

データセットごとに、西暦または NA を出力してください。

データセットの間に１つの空行を入れてください。

Sample Input

2001 2010
2005 2005
2001 2010
0 0

Output for the Sample Input

2004
2008

NA

2004
2008


def isLeap(y):
    return y % 4 == 0 and (y != 100 or y == 400)

flag2 = False
while True:
    a,b = map(int,input().split())
    if a == 0: break
    if flag2:print()
    flag2 = True

    flag = True
    for y in range(a,b + 1):
        if isLeap(y):
            print(y)
            flag = False
    if(flag):print("NA")


while True:
  l = [int(i) for i in input().split()]
  if l == [0,0,0]:
    break
  l.sort()
  r = (l[0]**2+l[1]**2)**(1/2)/2
  n = int(input())
  for i in range(n):
    r1 = int(input())
    if r < r1:
      print('OK')
    else:
      print('NA')

import math

while True:
    d, w, h = [int(x) for x in input().split()]
    if d == w == h == 0:
        break
    dw = math.sqrt(d * d + w * w)
    dh = math.sqrt(d * d + h * h)
    wh = math.sqrt(w * w + h * h)
    min_ = min(dw, dh, wh)
    n = int(input())
    for i in range(n):
        r = int(input()) * 2
        if r > min_:
            print('OK')
        else:
            print('NA')

Carry a Cheese

Jerry is a little mouse. He is trying to survive from the cat Tom. Jerry is carrying a parallelepiped-like piece of cheese of size A × B × C. It is necessary to trail this cheese to the Jerry's house. There are several entrances in the Jerry's house. Each entrance is a rounded hole having its own radius R. Could you help Jerry to find suitable holes to be survive?

Your task is to create a program which estimates whether Jerry can trail the cheese via each hole.
The program should print "OK" if Jerry can trail the cheese via the corresponding hole (without touching it). Otherwise the program should print "NA".

You may assume that the number of holes is less than 10000.

Input

The input is a sequence of datasets. The end of input is indicated by a line containing three zeros. Each dataset is formatted as follows:

A B C
n
R1
R2

 .
 .
Rn

n indicates the number of holes (entrances) and Ri indicates the radius of i-th hole.

Output

For each datasets, the output should have n lines. Each line points the result of estimation of the corresponding hole.

Sample Input

10 6 8
5
4
8
6
2
5
0 0 0

Output for the Sample Input

NA
OK
OK
NA
NA


# -*- coding: utf-8 -*-
"""
"""
import sys

def solve(d, w, h, holes):
    result = []
    # ???????????\????????£?????¢???1????????????: ????????????r x 2**0.5
    for r in holes:
        side_max = max(w, h)
        if r*2**0.5 >= side_max:
            result.append('OK')
        else:
            result.append('NA')
    return result

def main(args):
    while True:
        #d, w, h = 10, 6, 8
        #holes = [4, 8, 6, 2, 5]
        d, w, h = [int(x) for x in input().split(' ')]
        if d == 0 and w == 0 and h == 0:
            break
        num = int(input())
        holes = [int(input()) for _ in range(num)]
        result = solve(d, w, h, holes)
        for r in result:
            print(r)

if __name__ == '__main__':
    main(sys.argv[1:])


import re
while True:
    try:
        s = input()
    except EOFError:
        break

    for x in '0123456789':
        t = s.replace('X', x)
        a, b, c = re.split(r'[+=]', t)

        if len(a) > 1 and a[0] == '0': continue
        if len(b) > 1 and b[0] == '0': continue
        if len(c) > 1 and c[0] == '0': continue
        a, b, c = map(int, (a, b, c))
        if a + b != c: continue

        print(x)
        break
    else:
        print('NA')

while(True):
    try:
        a,c = input().split("=")
        a,b = a.split("+")
        for i in range(10):
            if i==0 and ((len(a)>1 and a[0]=="X") or (len(b)>1 and b[0]=="X") or (len(c)>1 and c[0]=="X")):
                continue
            if int(a.replace("X",str(i)))+int(b.replace("X",str(i))) == int(c.replace("X",str(i))):
                print(i)
                break
        else:
            print("NA")
    except:
        break

覆面算

 数式の一部を隠してしまって、隠した数字を探す問題を覆面算といいます。今回は、数式の中のある数字のいくつかを X で隠してしまった式を扱います。以下の数式を入力して、結果を出力するプログラムを作成してください。

  数式

「数字列 + 数字列 = 数字列」の形で、1 行の単純な足し算式です。

 「数字列」は、数字 0 から 9 と文字 X の並びです。

 2 桁以上の「数字列」の左端の数字は 0 ではないものとします。

  X は、数式全体の中で必ず 1 つ以上含まれます。

  結果

  覆面算の答えです。数式が成り立つ様な X の値で 0 ~ 9 のどれか 1 つです。2 つ以上の答えはないものとします。

  答えがない場合、結果は“NA”としてください。

Input

複数のデータセットが与えられます。各データセットとして、X を 1 つ以上含む足し算式(空白を含まない 126 文字以内の文字列) が１行に与えられます。データセットの数は 150 を超えません。

Output

各データセットについて、覆面算の結果を１行に出力してください。数字 0 ~ 9 または NA を出力してください。

Sample Input

123+4X6=X79
12X+4X6=X79
XX22+89=X2XX

Output for the Sample Input

5
NA
1


while True:
    try:
        s = input().replace('=', '==')
    except EOFError:
        break

    for x in '0123456789':
        t = s.replace('X', x)
        if t[0] == '0' or t[t.index('+')+1] == '0' or t[t.index('=')+2] == '0':
            continue
        if eval(t):
            print(x)
            break
    else:
        print('NA')


import sys
sys.setrecursionlimit(20000)
h= 0
w = 0
list1 = []

def dfs(x, y, f):
    list1[y] = list1[y][:x] + '1' + list1[y][x+1:]

    if y - 1 >= 0:
        if list1[y - 1][x] == f:
            dfs(x, y - 1, f)
    if y + 1 < h:
        if list1[y + 1][x] == f:
            dfs(x, y + 1, f)
    if x - 1 >= 0:
        if list1[y][x - 1] == f:
            dfs(x - 1, y, f)
    if x + 1 < w:
        if list1[y][x + 1] == f:
            dfs(x + 1, y, f)
    return

while True:
    h, w = list(map(lambda x: int(x),input().split(" ")))
    if 0 in (h, w):
        break
    n = 0
    for i in range(0, h):
        list1.append(input())
    for i in range(0, h):
        for j in range(0, w):
            if list1[i][j] != '1':
                dfs(j, i, list1[i][j])
                n+=1
    print(n)
    list1=[]

h = w = 0
slist =[]
list1=[]
def dfs(f):
    while True:
        if len(slist) == 0:
            return 1
        coordinate= slist.pop()
        #print(coordinate)
        x = coordinate[0]
        y = coordinate[1]

        list1[y] = list1[y][:x] + '1' + list1[y][x + 1:]
        if x + 1 < w:
            if list1[y][x + 1] == f:
                slist.append([x + 1,y])
        if x - 1 >= 0:
            if list1[y][x-1] == f:
                slist.append([x - 1, y])
        if y + 1 < h:
            if list1[y + 1][x] == f:
                slist.append([x, y + 1])
        if y -1 >= 0:
            if list1[y -1][x] == f:
                slist.append([x, y - 1])

while True:
    h, w = list(map(lambda x: int(x),input().split(" ")))
    if 0 in (h, w):
        break
    n = 0
    for i in range(0, h):
        list1.append(input())
    for i in range(0, h):
        for j in range(0, w):
            if list1[i][j] != '1':
                slist.append([j,i])
                n += dfs(list1[i][j])
            #print(list1)
    print(n)
    list1=[]

Property Distribution

 タナカ氏が <var>HW</var> アールの果樹園を残して亡くなりました。果樹園は東西南北方向に <var>H × W</var> の区画に分けられ、区画ごとにリンゴ、カキ、ミカンが植えられています。タナカ氏はこんな遺言を残していました。

      果樹園は区画単位でできるだけ多くの血縁者に分けること。ただし、ある区画の東西南北どれかの方向にとなりあう区画に同じ種類の果物が植えられていた場合は、区画の境界が分からないのでそれらは 1 つの大きな区画として扱うこと。

 例えば次のような 3 × 10 の区画であれば ('リ'はリンゴ、'カ'はカキ、'ミ'はミカンを表す)

同じ樹がある区画の間の境界を消すと次のようになり、

 結局 10 個の区画、つまり 10 人で分けられることになります。

雪が降って区画の境界が見えなくなる前に分配を終えなくてはなりません。あなたの仕事は果樹園の地図をもとに分配する区画の数を決めることです。

果樹園の地図を読み込み、分配を受けられる血縁者の人数を出力するプログラムを作成してください。

Input

複数のデータセットが与えられます。各データセットは空白で区切られた <var>H</var>, <var>W</var> (<var>H, W</var> ≤ 100) を含む行から始まり、続いて <var>H × W</var> の文字からなる <var>H</var> 行の文字列が与えられます。この文字列には、リンゴを表す '@'、カキを表す '#'、ミカンを表す '*'、の 3 文字しか現れません。

入力はゼロが２つの行で終わります。データセットの数は 20 を超えません。

Output

各データセットごとに、分配を受ける人数を１行に出力してください。

Sample Input

10 10
####*****@
@#@@@@#*#*
@##***@@@*
#****#*@**
##@*#@@*##
*@@@@*@@@#
***#@*@##*
*@@@*@@##@
*@*#*@##**
@****#@@#@
0 0

Output for the Sample Input

33


h = 0
w = 0
list1 = []

def dfs(x, y, f):
    list1[y] = list1[y][:x] + '1' + list1[y][x+1:]

    if y + 1 < h:
        if list1[y + 1][x] == f:
            dfs(x, y + 1, f)
    if x - 1 >= 0:
        if list1[y][x - 1] == f:
            dfs(x - 1, y, f)
    if x + 1 < w:
        if list1[y][x + 1] == f:
            dfs(x + 1, y, f)
    return 1

h, w = list(map(lambda x: int(x),input().split(" ")))
n = 0

for i in range(0, h):
    list1.append(input())
for i in range(0, h):
    for j in range(0, w):
        if list1[i][j] != '1':
           n += dfs(j, i, list1[i][j])

#print(list1)
print(n)


import re

A = ">'(=+)#\\1~$"
B = ">\^(Q=)+~~$"

for i in range(int(input())):
    s = input()
    r = re.match(A, s)
    if re.match(A, s): print('A')
    elif re.match(B, s): print('B')
    else: print('NA')

n=int(input())
for times in range(n):
	s=input()
	ans="NA"

	#A???????????§
	if s[:2]==">'" and s[-1]=="~":
		t=s[2:-1].split("#")

		if len(t)==2 and len(t[0])>0:
			valid=True
			for v in t[0]:
				if v!="=":
					valid=False
					break
			if valid and t[0]==t[1]:
				ans="A"

	#B???????????§
	elif s[:2]==">^" and s[-2:]=="~~":
		t=s[2:-2]

		if len(t)>0 and len(t)%2==0:
			valid=True
			for i in range(0,len(t),2):
				if t[i:i+2]!="Q=":
					valid=False
					break
			if valid:
				ans="B"

	print(ans)

ヘビ

ある世界には，文字だけでできた不思議なヘビが住んでいます。このヘビには現在A種とB種の2種類が確認されていますが、それ以外の種類がいる可能性もあります。

A種は，">'"の後に"="が1個以上並んだ後、"#"が来て、さらに前と同じ個数の"="が来た後、"~"（半角チルダ）で終わります。

B種は，">^"の後に "Q="が1個以上並んだ後、"~~"で終わります。

A種の例： >'====#====~        >'==#==~

B種の例： >^Q=Q=Q=Q=~~        >^Q=Q=~~

ヘビを文字列データとして受け取り、それがどんな種類であるかを判別して、A種の場合は「A」、B種の場合は「B」、それ以外の種類の場合は「NA」を出力するプログラムを作成してください。

Input

入力は以下の形式で与えられます。

<var>n</var>
<var>S1</var>
<var>S2</var>
:
<var>Sn</var>

1 行目に判別されるヘビの数 <var>n</var>（1 ≤ <var>n</var> ≤ 10000）、続く <var>n</var> 行に <var>i</var> 匹目のヘビを表す文字列 <var>Si</var> (200文字以下の、空白を含まない文字列) がそれぞれ１行に与えられます。

Output

<var>i</var> 行目に <var>i</var> 匹目のヘビの種類 A、B または NA を出力してください。

Sample Input

3
>'======#======~
>^Q=Q=Q=Q=Q=Q=Q=Q=Q=~~
>'===#====~

Output for the Sample Input

A
B
NA


for _ in [0]*int(input()):
    s=input()
    if s[1]=='\'':
        l=s.find('#')
        r=s.rfind('~')
        print('A' if l-1==r-l else 'NA')
    else:
        r=s.rfind('~~')
        print('B' if s[1:r].count('Q')==s[1:r].count('=') else 'NA')


# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0144

"""
import sys
from sys import stdin
input = stdin.readline
from enum import Enum

class Graph(object):
    """ single source shortest path """
    class Status(Enum):
        """ ?????????????¨??????¶??? """
        white = 1  # ????¨????
        gray = 2  # ?¨???????
        black = 3  #?¨???????

    def __init__(self, n, data):
        self.num_of_nodes = n+1
        self.color = [Graph.Status.white] * self.num_of_nodes  # ????????????????¨??????¶???
        self.M = [[float('inf')] * self.num_of_nodes for _ in range(self.num_of_nodes)]
        for i in range(self.num_of_nodes):
            self.M[i][i] = 0
        self._make_matrix(data)  # data????????????????????£??\??????(?????\?¶???¨???????????????????????§????????????)
        self.d = [float('inf')] * self.num_of_nodes  # ?§???????????????????(?????????)
        self.p = [-1] * self.num_of_nodes  # ????????????????????????????¨?????????????????????????

    def _make_matrix(self, data):
        for d in data:
            r = d[0]
            for t in d[2:]:
                self.M[r][t] = 1

    def dijkstra(self, start):
        self.d[start] = 0
        self.p[start] = -1
        while True:
            mincost = float('inf')
            # ??\??????????????§??????????????¨?????????????????????u???????????????
            for i in range(len(self.d)):
                if self.color[i] != Graph.Status.black and self.d[i] < mincost:  # S????±???????????????????S??¨??\?¶?????????????????????????????????????????°???????????????????
                    mincost = self.d[i]
                    u = i  # u??????????????????ID
            if mincost == float('inf'):
                break
            self.color[u] = Graph.Status.black  # ?????????u???S????±???????????????´???
            for v in range(len(self.d)):
                if self.color[v] != Graph.Status.black and self.M[u][v] != float('inf'):
                    # v????????????????????????????????°??????S???????????£???u????????????????????????????????????????????°??????????????±??§??´??°??????
                    if self.d[u] + self.M[u][v] < self.d[v]:
                        self.d[v] = self.d[u] + self.M[u][v]
                        self.p[v] = u
                        self.color[v] = Graph.Status.gray

    def warshallFloyd(self):
        V = self.num_of_nodes
        for k in range(V):
            for i in range(V):
                for j in range(V):
                    self.M[i][j] = min(self.M[i][j], self.M[i][k] + self.M[k][j])

def main(args):
    n = int(input())
    network = []
    for _ in range(n):
        network.append([int(x) for x in input().split()])

    packets = []
    p = int(input())
    for _ in range(p):
        packets.append([int(x) for x in input().split()])

    g = Graph(n, network)
    g.warshallFloyd()

    for s, d, v in packets:
        if g.M[s][d] < v:
            print(g.M[s][d]+1)
        else:
            print('NA')

if __name__ == '__main__':
    main(sys.argv[1:])

パケット転送

インターネットでは、データはパケットに分割され、パケットごとにルータと呼ばれる中継機器を介して宛先に転送されます。各ルータはパケットに記載された宛先から次に転送すべきルータを判断します。さらに、無限にルータ間を転送され続けることを防ぐため、パケットには TTL（Time To Live） という値が付加されています。ルータは受け取ったパケットの TTL を 1 減算し、その結果が 0 ならそのパケットを破棄し、それ以外なら次のルータに転送します。

そこで、ネットワークの設計を手助けするプログラムを作ることになりました。ネットワークの接続情報と送信パケットの情報を入力として、各パケットが宛先ルータに到着するまでに経由するルータの数のうち最小の値を表示するプログラムを作成してください。

ネットワークは図のように複数のルータとそれらを結ぶケーブルで構成されています。ただし、各接続（ケーブル）は単方向であることに注意してください。各ルータが直接つながっているルータの番号の配列がネットワークの接続の情報として与えられます。ルータの数を <var>n</var> とすれば、各ルータは 1 から <var>n</var> までの整数で識別されます。送信元から宛先ルータまでの経路が複数ある場合は、経由するルータの数が少ない方の値を出力してください。また、パケットが宛先に到達しない場合は NA と出力してください。

例えば、以下の図のようなネットワークで、送信元ルータが 6、宛先ルータが 5 の場合を考えます。最短経路は 6→1→5 であり経由するルータは 3 個です。この場合、TTL はルータ 6、1 でそれぞれ減算されるので、送信時の TTL が 3 以上であればパケットは到達できます。宛先ルータでは TTL を減算する必要はありません。また、送信元と宛先が同じルータになるようなパケットは無いものとします。

Input

入力は以下の形式で与えられます。

<var>n</var>
<var>r1</var> <var>k1</var> <var>t11</var> <var>t12</var> ... <var>t1k1</var>
<var>r2</var> <var>k2</var> <var>t21</var> <var>t22</var> ... <var>t2k2</var>
:
<var>rn</var> <var>kn</var> <var>tn1</var> <var>tn2</var> ... <var>tnkn</var>
<var>p</var>
<var>s1</var> <var>d1</var> <var>v1</var>
<var>s2</var> <var>d2</var> <var>v2</var>
:
<var>sp</var> <var>dp</var> <var>vp</var>

1 行目にルータの総数 <var>n</var>（<var>n</var> ≤ 100）、続く <var>n</var> 行に <var>i</var> 番目のルータの接続情報が与えられます。接続情報として、<var>i</var> 番目のルータの番号 <var>ri</var>、<var>i</var> 番目のルータと直接接続しているルータの個数 <var>ki</var>、<var>i</var> 番目のルータから送信できるルータの番号 <var>ti1</var>, <var>ti2</var>, ... <var>tiki</var>が与えられます。

続く行にパケットの個数 <var>p</var>（<var>p</var> ≤ 1000）、続く <var>p</var> 行に <var>i</var> 番目のパケットの情報が与えられます。パケットの情報として、 送信元ルータの番号 <var>si</var>, 宛先ルータの番号 <var>di</var>, TTL の値 <var>vi</var> (0 ≤ <var>vi</var> ≤ 10000) が与えられます。

Output

各パケットごとに、経由するルータの個数または NA を１行に出力してください。

Sample Input

7
1 4 2 5 4 3
2 1 5
3 1 6
4 1 7
5 2 7 6
6 1 1
7 0
6
1 2 2
1 5 3
1 2 1
5 1 3
6 3 3
1 7 4

Output for the Sample Input

2
2
NA
3
3
3


from collections import deque
n = int(input())
rlst = [None] * (n + 1)
#print(rlst)
for _ in range(n):
  lst = list(map(int, input().split()))
  r = lst[0]
  print(r)
  lst = lst[2:]
  rlst[r] = lst

p = int(input())

for _ in range(p):
  s, d, v = map(int, input().split())
  visited = [False] * (n + 1)
  visited[s] = True
  que = deque()
  que.append((s, 1))
  while que:
    node, dist = que.pop()
    if node == d:
      print(dist)
      break
    if dist < v:
      for to in rlst[node]:
        if not visited[to]:
          que.append((to, dist + 1))
  else:
    print("NA")


n=1000000
p=[1]*(n+1)
p[0],p[1]=0,0
for i in range(2,int(n**0.5)+1):
    if p[i]:
        for j in range(i*i,n+1,i):
            p[j]=0
#p=[i for i in range(n+1) if p[i]==1]
while 1:
    n=int(input())
    if n==0: break
    for i in range(n,2,-1):
        if (p[i],p[i-2])==(1,1):
            print(i-2,i)
            break

primes = [0, 0] + [1]*9999
for i in range(2, 100):
    for j in range(i*i, 10001, i):
        primes[j] = 0

while True:
    n = int(input())
    if n == 0:
        break
    for i in range(2, n+1)[::-1]:
        if primes[i-2] and primes[i]:
            print(i-2, i)
            break

Twin Prime

Prime numbers are widely applied for cryptographic and communication technology.
A twin prime is a prime number that differs from another prime number by 2.
For example, (5, 7) and (11, 13) are twin prime pairs.

In this problem, we call the greater number of a twin prime "size of the twin prime."

Your task is to create a program which reads an integer n and prints a twin prime which has the maximum size among twin primes less than or equals to n

You may assume that 5 ≤ n ≤ 10000.

Input

The input is a sequence of datasets. The end of the input is indicated by a line containing one zero. Each dataset is formatted as follows:

n (integer)

Output

For each dataset, print the twin prime p and q (p < q). p and q should be separated by a single space.

Sample Input

12
100
200
300
0

Output for the Sample Input

5 7
71 73
197 199
281 283


from itertools import takewhile
pnum, tmp = [], [i for i in range(2, 10000)]
while tmp[0] < 101:
    v = tmp.pop(0)
    pnum.append(v)
    tmp = list(filter(lambda x: x%v!=0, tmp))
for t in tmp: pnum.append(t)
del pnum[0:2]
while True:
    n = int(input())
    if n==0: break
    prime = list(takewhile(lambda x: x<=n, pnum))
    for i in range(len(prime))[:0:-1]:
        if prime[i]-prime[i-1]==2:
            print(prime[i-1], prime[i])
            break


# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0152

"""
import sys
from sys import stdin
input = stdin.readline

def bowling_score(data):
    name_id = data[0]
    data = data[1:]

    frame = 1
    scores = [0] * 11

    while frame <= 10:
        if data[0] == 10:
            scores[frame] = data[0] + data[1] + data[2]
            data = data[1:]
            frame += 1
        elif data[0] + data[1] == 10:
            scores[frame] = data[0] + data[1] + data[2]
            data = data[2:]
            frame += 1
        else:
            scores[frame] = data[0] + data[1]
            data = data[2:]
            frame += 1
    return name_id, sum(scores[1:])

def main(args):
    while True:
        m = int(input())
        if m == 0:
            break
        results = []
        for _ in range(m):
            data = [int(x) for x in input().split()]
            name_id, score = bowling_score(data)
            results.append([-score, name_id])

        results.sort()
        for s, i in results:
            print(i, -s)

if __name__ == '__main__':
    main(sys.argv[1:])

def score(x):
    s=0;t=1
    for _ in[0]*10:
        a=2;b=3
        if x[t]==10:a=1
        elif x[t]+x[t+1]!=10:b=2
        s+=sum(x[t:t+b]);t+=a
    return x[0],s

while 1:
    n=int(input())
    if n==0:break
    A=sorted([score(list(map(int,input().split()))) for _ in [0]*n])
    for a,b in sorted(A,key=lambda x:-x[1]):print(a,b)

ボウリング

クラスのレクリエーションとしてボウリングを行うことになりました。参加者ごとの投球情報を入力とし、得点の高い順に成績情報を出力するプログラムを作成してください。なお、同点の場合は学籍番号の若い順に出力してください。ただし参加者は 3 名以上 40 名以下とし、1人当たり1ゲームずつ投球しているものとします。

ボウリングとは、プレイヤーに対して頂点を向けて正三角形に並べられた、10 本のピンをめがけてボールを転がし、ピンを倒すスポーツです。 1 回目の投球ですべて転倒した場合をストライクと言い、その投球のみで次のフレームに進みます。ストライクでない場合は、残ったピンをそのままにして 2 回目の投球を行います。2 回目の投球ですべて転倒した場合をスペアと言います。2 回目の投球終了後、次のフレームに進みます。

1 ゲームは 10 のフレームから構成され、第 1 から第 9 の各フレームは 2 回投球できます。各フレームの開始時点では、10 本のピンがすべて立った状態で用意されます。第 10 フレームは、ストライクもしくはスペアが出た場合には計 3 回の投球を、それ以外の場合は 2 回の投球を行い、ゲーム終了となります。

スコア例１

スコア例２（最高得点300点の場合）

スコア計算の方法

 各フレームにおいてスペア、ストライクがない場合は、 2 回の投球で倒したピンの本数がそのフレームの得点となります。（スコア例１の第 4 フレームと第 8 フレーム）

スペアを出した場合、倒した本数である 10 点に加え、次の投球で倒したピンの本数がこのフレームの得点に加算されます。（スコア例１の第 1 フレームと第 2 フレームの関係など）スコア例１の第 1 フレームでは第 2 フレームの 1 投で倒した 10 本（点）を加えた 20 点が得点となります。第 3 フレームも同様の計算方法です。

ストライクを出した場合、倒した本数である 10 点に加え、続く 2 回の投球で倒したピンの本数が加算されます。（スコア例１の第 2 フレームと第 3 フレームの関係など）もちろん続く 2 投中にストライクの場合があります。（スコア例１の第 5 フレームと第 6、7 フレームの関係など）

第 10 フレームのみ、スペア、ストライクを出した場合、3 投して倒したピンの総数が第 10 フレームの得点として加算されます。

各フレームの得点の合計が 1 ゲームの得点となり、最高得点は 300 点となります。

Input

複数のデータセットの並びが入力として与えられます。入力の終わりはゼロひとつの行で示されます。
各データセットは以下の形式で与えられます。

<var>m</var>
<var>score1</var>
<var>score2</var>
:
<var>scorem</var>

1行目に参加者数 <var>m</var> （3 ≤ <var>m</var> ≤ 40）、続く<var>m</var> 行に<var>i</var> 人目の参加者情報 <var>scorei</var> が与えられます。各参加者情報は１行ずつ次の形式で与えられます。

<var>id</var> <var>s1</var> <var>s2</var> ... <var>sn</var>

先頭に学籍番号<var>id</var> (0 ≤ <var>id</var> ≤ 9999)、続いて第 <var>j</var> 投の転倒ピン数 <var>sj</var> (0 ≤ <var>sj</var> ≤ 10) が与えられます。総投球数 <var>n</var> は、12 以上 21 以下であり、得点計算に必要なピン数が過不足なく与えられるものとします。

Output

入力データセットごとに、学籍番号と得点を、得点の高い順（同点の場合は学籍番号の若い順）に出力します。学籍番号と得点を１つの空白で区切って１行に出力してください。

Sample Input

3
1010 6 3 10 7 1 0 7 9 1 10 6 2 4 3 9 1 9 0
1200 5 3 9 1 7 1 0 0 8 1 10 10 4 3 9 1 8 2 9
1101 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
4
3321 8 2 10 9 1 7 0 10 10 10 0 8 10 10 10 10
3332 5 0 10 9 1 4 1 9 0 10 10 7 1 5 2 8 1
3335 10 10 10 10 10 10 10 10 10 10 10 10
3340 8 2 7 3 6 4 8 2 8 2 9 1 7 3 6 4 8 2 9 1 7
0

Output for the Sample Input

1200 127
1010 123
1101 60
3335 300
3321 200
3340 175
3332 122


# from sys import exit

while(True):
    N = int(input())
    if N == 0:
        exit()
    score = [[] for _ in range(N)]
    ids = [0 for _ in range(N)]
    for i in range(N):
        score[i] = [int(n) for n in input().split()]
        ids[i] = score[i][0]
        cnt = 0 # フレームのための
        frame = 0 # 10フレームの処理
        sum = 0
        ans = 0
        # ストライクなら二回分、スペアなら一回分
        double = 0
        triple = 0
        for s in score[i][1:]:
            if triple and frame != 10:
                ans += 3*s
                # if i == 1:print(3*s, frame)
                triple -= 1
                double -= 1
            elif double and frame != 10:
                ans += 2*s
                # if i == 1:print(2*s, frame)
                double -= 1
            else:
                # if i == 1:print(s, frame)
                ans += s
            sum += s
            cnt += 1

            # ストライク
            if cnt == 1 and s == 10:
                cnt = 0
                sum = 0
                if double:
                    triple += 1
                    double = 2
                else:
                    double += 2
                frame+=1
            # スペア
            elif cnt == 2 and sum == 10:
                if double:
                    triple += 1
                else:
                    double += 1
            # フレームのリセット
            if (cnt == 2):
                # print("AAA" + str(sum), cnt)
                cnt = 0
                sum = 0
                frame+=1
        score[i] = (ids[i], ans)
    score = sorted(score, key=lambda x: x[0])
    score = sorted(score, key=lambda x: -x[1])
    n = len(score)
    for s in score:
        if n:
            print(s[0], s[1], end=" \n")
        else:
            print(s[0], s[1])


while True:
  a = int(input())
  if a == 0:
    break
  count = 0
  while a != 1:
    if a % 2 == 0:
      a //= 2
      count += 1
    else:
      a = (a * 3) + 1
      count += 1
  print(count)

def f(n, t):
    if n % 2 == 0:
        n = int(n / 2)
    else:
        n = n * 3 + 1
    t += 1
    if n == 1:
        return t
    else:
        return f(n, t)

while True:
    _n = int(input())
    if _n == 0:
        break
    print(0 if _n == 1 else f(_n, 0))

コラッツの予想

正の整数 <var>n</var> に対し、

<var>n</var> が偶数の時は 2 で割る。

<var>n</var> が奇数の時は 3 倍し、1 を足す。

という操作を繰り返すと結果が 1 になります。任意の正の整数 <var>n</var> に対してこの操作を繰り返すと必ず 1 になるであろうというのが「コラッツの予想」と呼ばれる問題です。この問題は日本では、「角谷の問題」としても知られている未解決の問題です。コンピュータを利用して非常に大きな数 3 × 253 = 27,021,597,764,222,976 以下については反例がないことが知られていますが、数学的には証明されていません。

整数 <var>n</var> を入力とし、結果が 1 になるまでに繰り返される操作の回数を出力するプログラムを作成してください。整数 <var>n</var> は 1 以上でかつ上記の計算を繰り返す途中の値が 1000000 以下となる程度の整数とします。たとえば、入力として 3 を受け取った場合は、操作列は

3 → 10 → 5 → 16 → 8 → 4 → 2 → 1

になるので、操作の回数（上の矢印の個数）である 7 を出力します。

Input

複数のデータセットの並びが入力として与えられます。入力の終わりはゼロひとつの行で示されます。
各データセットとして１つの整数 <var>n</var> (<var>n</var> ≤ 1000000) が１行に与えられます。

データセットの数は 50 を越えない。

Output

データセットごとに操作の回数を１行に出力します。

Sample Input

3
10
0

Output for the Sample Input

7
6


def f(n, t):
    if n % 2 == 0:
        n = int(n / 2)
    else:
        n = n * 3 + 1
    t += 1
    if n == 1:
        return t
    else:
        return f(n, t)

while True:
    _n = int(input())
    if _n == 0:
        break
    print(f(_n, 0))


while 1:
    a=int(input())
    if a<0:break
    ans='' if a!=0 else '0'
    while a:ans,a=str(a%4)+ans,a//4
    print(ans)

while True:
    v = int(input())
    if v == -1:
        break
    if v < 4:
        print(v)
    else:
        b = str(bin(v))[2:]
        bb = [b[i:i+2] for i in range(len(b)-2, -1, -2)]
        if len(b) % 2 != 0:
            bb.append(b[0])
        ans = []
        for t in bb:
            tmp = 0
            for i, v in enumerate(t[::-1]):
                tmp += pow(2, i) * int(v)
            ans.append(tmp)
        print(''.join(map(str, ans[::-1])))

４進数

10 進数は現在使われている一般的な記数法で、0、1、2、3、4、5、6、7、8、9 の10 個の記号を用いて全ての数字を表します。

2 進数はコンピュータの世界でよく使われる記数法で、0 と1 の二つの記号を用いて全ての数字を表します。

4 進数で用いられるのは 0、1、2、3 の 4 つの数字だけです。4 進数では 0 から順に数を増やしていったときに 4 まで来たら次の位に桁上がりします。そのため、10 進数の 4 は桁上がりして「10」という表現になります。

10 進数
0
1
2
3
4
5
6
7
8
9
10
...

2 進数
0
1
10
11
100
101
110
111
1000
101
1010
...

4 進数
0
1
2
3
10
11
12
13
20
21
22
...

昔ハワイでは魚やタロイモを指にはさんで数えていたので、10 進数ではなく4 進数を使っていたそうです。

10 進数で入力される整数 <var>n</var> を 4 進数に変換し出力するプログラムを作成してください。

Input

複数のデータセットの並びが入力として与えられます。入力の終わりは -1 ひとつの行で示されます。各データセットとして１つの整数 <var>n</var> (0 ≤ <var>n</var> ≤ 1000000) が１行に与えられます。

データセットの数は 2000 を超えません。

Output

入力データセット毎に 4 進数に変換した結果を１行に出力します。

Sample Input

7
4
0
12
10
10000
-1

Output for the Sample Input

13
10
0
30
22
2130100


import sys
def main():
    for line in sys.stdin:
        n = int(line)
        if n == -1:
            break
        else:
            if n != 0:
                hoge = []
                while True:
                    foo = n // 4
                    bar = n % 4
                    if foo >= 4:
                        hoge.append(bar)
                        n = foo
                    elif foo < 4:
                        hoge.append(bar)
                        hoge.append(foo)
                        break
                hoge.reverse()
                hoge = [str(hoge[i]) for i in range(len(hoge))]
                fuga = ""
                for i in range(len(hoge)):
                    fuga += hoge[i]
                print(fuga)
            elif n == 0:
                print(n)

if __name__ == "__main__":
    main()


import sys
_allinput = []
for inp in sys.stdin:
	_allinput += inp.strip().split(" ")
def _input():
	for put in _allinput:
		yield put
_obj = _input();
def __input():
	return _obj.__next__()
def nextInt():
	return int(__input())
def check(lst,L):
	tot = 1
	curSum = 0
	for i in lst:
		if curSum + i <= L:
			curSum += i
		else:
			curSum = i
			tot += 1
	return tot

def solve(lst,m):
	l = max(lst)
	r = 1000000 * m;
	while l != r:
		mid = int((l+r)/2);
		if check(lst,mid) <= m: r = mid
		else: l = mid + 1
	return l
try:
	while True:
		m,n = nextInt(),nextInt()
		if m > 0 or n > 0:
			lst = [nextInt() for i in range(0,n)]
			print(solve(lst,m))
		else:
			break
except:
	'''
	'''

class Solve:
    def __init__(self):
        self.M, self.N = map(int, input().split())
        self.bs = [int(input()) for i in range(self.N)]

        self.S = min(sum(self.bs), 1500000)
        self.l, self.r = 0, self.S

    def check(self, W):
        w = W
        i = 1
        for b in self.bs:
            if(w >= b):
                w -= b
            elif(W >= b):
                if(i >= self.M):
                    return False
                i += 1
                w = W - b
            else:
                return False
        return True

    def solve(self):
        while self.r - self.l > 1:
            m = (self.l + self.r) // 2
            if self.check(m):
                self.r = m
            else:
                self.l = m
        return self.r

while True:
    s = Solve()
    if s.M == 0 and s.N == 0:
        break
    print(s.solve())

本棚

太郎君はとある小説にはまっています。その小説は全部で <var>n</var> 巻あり、各巻で本の厚さが異なります。太郎君はこの小説が大変気に入ったので、その小説専用の本棚を買おうと思っています。しかし、部屋に大きな本棚を置くとかなり狭くなってしまうので、出来るだけ本棚の幅が小さくなるように工夫しなければなりません。床から天井の高さを測ったところ、どうやら <var>m</var> 段の本棚なら置けることが分かりました。そこで、小説 <var>n</var> 巻をどのように分ければ <var>m</var> 段の本棚の幅を最小に出来るでしょうか?
 太郎君にはこだわりがあり、各段に納める小説は巻の番号順に並んでいなければなりません。

 本棚の段数、小説の巻数、各本の厚さを入力として、全巻を 1巻から順に収めることができる本棚の中で幅が最小となるものの幅を求めるプログラムを作成してください。ただし、本棚の枠の大きさは幅に含めないこととします。

Input

複数のデータセットの並びが入力として与えられます。入力の終わりはゼロふたつの行で示されます。各データセットは以下の形式で与えられます。

<var>m</var> <var>n</var>
<var>w1</var>
<var>w2</var>
:
<var>wn</var>

１行目に部屋に置くことができる本棚の段数 <var>m</var> (1 ≤ <var>m</var> ≤ 20)、 小説の巻数 <var>n</var> (1 ≤ <var>n</var> ≤ 100) が与えられます。続く <var>n</var> 行に第 <var>i</var> 巻の本の厚さを表す整数 <var>wi</var> (1 ≤ <var>wi</var> ≤ 1000000) が与えられます。

ただし、本棚の幅は 1500000 を超えないものとします。

データセットの数は 50  を超えません。

Output

データセット毎に最小となる本棚の幅を１行に出力します。

Sample Input

3 9
500
300
800
200
100
600
900
700
400
4 3
1000
1000
1000
0 0

Output for the Sample Input

1800
1000


def nibutan(f_id,e_id,f_num,yn):

    m_id = int((f_id + e_id) / 2)
    m_num = w_lis[m_id]

    if e_id - f_id <= 1:
        if yn == 0:
            return e_id
        else:
            return f_id
    else:
        if m_num > f_num:
            return(nibutan(f_id,m_id -1,f_num,yn))
        elif m_num < f_num:
            return(nibutan(m_id + 1,e_id,f_num,yn))
        else:
            return  m_num

while True:
    global w_lis
    b_lis = []
    w_lis = []
    dan_num = []
    wa = 0
    m,n = map(int,input().split())
    if m == n == 0:
        break
    for i in range(n):
        num = int(input())
        wa += num
        b_lis.append(num)
        w_lis.append(wa)
    best_num = wa / m
    bid = 0
    n_si = 0
    for i in range(m):
        bid = nibutan(bid,n - 1,n_si + best_num,i)
        si = w_lis[bid]
        dan_num.append(si)
    print(max(dan_num))


from sys import stdin
readline = stdin.readline

from itertools import product
from operator import itemgetter
from math import isinf

def scrap_top_left(picture):
    for py, px in product(range(len(picture)), repeat=2):
        if picture[py][px] != -1:
            return px, py

def is_match(window, picture, wx, wy):
    for py, px in product(range(len(picture)), repeat=2):
        if picture[py][px] == -1:
            continue
        if window[wy + py][wx + px] != picture[py][px]:
            return False
    return True

def search(window, picture):
    for wy, wx in product(range(len(window) - len(picture) + 1), repeat=2):
        if is_match(window, picture, wx, wy):
            px, py = scrap_top_left(picture)
            return wx + px + 1, wy + py + 1
    return float('inf'), float('inf')

# http://d.hatena.ne.jp/odz/20070622/1182497414
def rotate_clockwise(matrix):
    return [list(row) for row in zip(*reversed(matrix))]

while True:
    window_size, picture_size = map(int, readline().split())
    if window_size == 0:
        break
    window = [list(map(int, readline().split())) for _ in range(window_size)]
    picture = [list(map(int, readline().split())) for _ in range(picture_size)]
    top_left = []
    for _ in range(4):
        top_left.append(search(window, picture))
        picture = rotate_clockwise(picture)
    top_left = min(top_left, key=itemgetter(1, 0))
    if isinf(top_left[0]):
        print('NA')
    else:
        print(*top_left)

while 1:
    N, M = map(int, input().split())
    if N == 0:
        break
    W = [list(map(int, input().split())) for i in range(N)]
    P = [list(map(int, input().split())) for i in range(M)]
    P0 = [[0]*M for i in range(M)]

    ans = []
    for t in range(4):
        P1 = []
        for i in range(M):
            for j in range(M):
                if P[i][j] == -1:
                    continue
                P1.append((i, j, P[i][j]))
        for y in range(N-M+1):
            for x in range(N-M+1):
                for i, j, p in P1:
                    if W[y+i][x+j] != p:
                        break
                else:
                    i, j, p = P1[0]
                    ans.append((y+i+1, x+j+1))
                    break
            else:
                continue
            break
        for i in range(M):
            for j in range(M):
                P0[M-1-j][i] = P[i][j]
        P0, P = P, P0
    if ans:
        y, x = min(ans)
        print(x, y)
    else:
        print("NA")

写真に写っている景色は?

 A 君は会津に観光にやってきました。宿泊したホテルの窓からは会津盆地が一望できます。景色を眺めていると、床に写真の切れ端が落ちているのに気がつきました。どうやら窓から外の景色を撮ったようです。「どの辺りを撮ったのかな」と、A 君は窓の外の景色と写真が同じ大きさになるように写真をかざして、写真と窓の外の景色が一致する場所を探し始めました。

 それでは、A 君がやっていることをコンピュータでやってみましょう。窓の外の景色を <var>n × n</var> マスの正方形に分割します (<var>n</var> を景色の大きさと呼びます)。各マスには、そのマスの画像の情報を表す 0 以上の整数が書かれています。マスの位置は座標 (<var>x, y</var>) で表します。各マスの座標は以下の通りになります。

 写真の切れ端は、<var>m × m</var> マスの正方形で表されます (<var>m</var> を写真の切れ端の大きさと呼びます) 。この正方形の中で、切れ端の部分のマスには画像の情報が、切れ端に含まれない部分のマスには -1 が書かれています。たとえば、下図では、色が塗られている部分が実際の写真の切れ端の形を表しています。切れ端に穴が開いていることはありますが、必ず 1 つにつながっています。 (0 以上の値をもつマスが頂点だけで接しているときは、つながっていないものとみなします。) また、値 -1 のマスが縦または横 1 列に端から端まで並ぶことはありません。

  窓から見える景色の中で、写真の切れ端を 0、90、180、270 度回転させたいずれかと一致する領域を探します。たとえば、景色が下図のように表わせるとき、上図の切れ端を反時計回りに90 度回転させると、色が塗られた領域に一致します。

 窓から見える景色と写真の切れ端の情報を入力とし、景色の中で、切れ端を 0、90、180、270 度回転させたいずれかと一致する領域の最も上端に近いマスのうち、最も左端に近いマスの座標を出力するプログラムを作成してください。

 一致する領域が複数ある場合は、それらの領域内にあるマスの中で、最も上端に近いマスのうち、最も左端に近いマスの座標を出力してください。一致する領域がないときは、NA と出力します。

Input

複数のデータセットの並びが入力として与えられます。入力の終わりはゼロふたつの行で示されます。各データセットは以下の形式で与えられます。

<var>n</var> <var>m</var>
<var>w11</var> <var>w12</var> ... <var>w1n</var>
<var>w21</var> <var>w22</var> ... <var>w2n</var>
:
<var>wn1</var> <var>wn2</var> ... <var>wnn</var>
<var>p11</var> <var>p12</var> ... <var>p1m</var>
<var>p21</var> <var>p22</var> ... <var>p2m</var>
:
<var>pm1</var> <var>pm2</var> ... <var>pmm</var>

1 行目に<var>n, m</var> (1 ≤ <var>n</var> ≤ 100, 1 ≤ <var>m</var> ≤ 50, <var>m</var> ≤ <var>n</var>) が与えられます。

続く <var>n</var> 行に窓から見える景色の情報 <var>wij</var> (0 ≤ <var>wij</var> ≤ 15)、続く <var>m</var> 行に写真の切れ端のデータの情報 <var>pij</var> (-1 ≤ <var>pij</var> ≤ 15) が与えられます。

データセットの数は 100 を超えません。

Output

入力データセットごとに、マスの位置の座標または NA を１行に出力します。

Sample Input

8 4
2 1 3 1 1 5 1 3
2 3 2 4 1 0 2 1
0 3 1 2 1 1 4 2
1 2 3 2 1 1 5 4
0 2 0 1 1 3 2 1
1 3 1 2 2 4 3 2
5 1 2 1 4 1 1 5
4 1 1 0 1 2 2 1
2 -1 -1 -1
0 3 -1 -1
-1 2 2 4
-1 1 -1  1
5 3
1 0 2 3 5
2 3 7 2 1
2 5 4 2 2
8 9 0 3 3
3 6 0 4 7
-1 -1 2
-1 3 5
0 4 -1
0 0

Output for the Sample Input

4 2
NA


from sys import stdin
readline = stdin.readline

from itertools import product
from operator import itemgetter
from math import isinf

def scrap_top_left(picture):
    for py, px in product(range(len(picture)), repeat=2):
        if picture[py][px] != -1:
            return px, py

def is_match(window, picture, wx, wy):
    for py, px in product(range(len(picture)), repeat=2):
        if picture[py][px] == -1:
            continue
        if window[wy + py][wx + px] != picture[py][px]:
            return False
    return True

def search(window, picture):
    for wy, wx in product(range(len(window) - len(picture)), repeat=2):
        if is_match(window, picture, wx, wy):
            px, py = scrap_top_left(picture)
            return wx + px + 1, wy + py + 1
    return float('inf'), float('inf')

# http://d.hatena.ne.jp/odz/20070622/1182497414
def rotate_clockwise(matrix):
    return [list(row) for row in zip(*reversed(matrix))]

while True:
    window_size, picture_size = map(int, readline().split())
    if window_size == 0:
        break
    window = [list(map(int, readline().split())) for _ in range(window_size)]
    picture = [list(map(int, readline().split())) for _ in range(picture_size)]
    top_left = []
    for _ in range(4):
        top_left.append(search(window, picture))
        picture = rotate_clockwise(picture)
    top_left = min(top_left, key=itemgetter(1, 0))
    if isinf(top_left[0]):
        print('NA')
    else:
        print(*top_left)


from decimal import Decimal

while 1:
    n = Decimal(input())
    if n < 0:break
    d1 = int(n)
    d2 = n - d1
    s1 = format(d1,'b').zfill(8)
    if len(s1) > 8:
        print('NA')
        continue
    r = str(s1) + '.'
    for i in range(4):
        spam = int(d2 * 2)
        r += str(spam)
        d2 = d2*2 - spam
    if d2 > 0:
        print('NA')
        continue
    print(r)

while(True):
    n = float(input())
    if n < 0: break
    if int(n*16)-n*16: print("NA"); continue
    else:
        s = bin(int(n*16))[2:].zfill(12)
        print(s[:-4]+"."+s[-4:])

博士が愛した２進数

  「君の靴のサイズはいくつかね」

  初対面の私に、いきなり博士は尋ねました。

  「 23.5 です」

  「ほお、実にきりのいい数字だ。2 の 4 乗に 2 の 2 乗と 2 の 1 乗と 2 の 0 乗と 2 の  -1  乗を 加えた数だ」

  続けて博士は尋ねました。

  「君、身長はいくつかね」

  「はい、158.1 です」

  博士は腕組みをして目を閉じました。しばらくの沈黙の後、口を開きました。

  「ナァ~」

  その後一緒に過ごした時間の中で、博士の行動がだんだん理解できるようになりました。

  まず、 私が博士の求めに応じて実数を言います。実数が整数部 8 桁以内で小数部 4 桁以内の 2 進数で表される場合、博士は 2 進数への変換結果を満足げに語ります。そうでない場合、悲しげに「ナァ~」 と鳴きます。これは、私が負の実数を言うまで繰り返されるのです。

  さて、博士は年齢とともにだんだんに長い計算が難しくなってきました。そこで、みなさんが博士に代わって、実数を入力し 2 進数に変換・出力するプログラムを作ってあげてください。ただし、2 進表現が制限桁数 (整数部 8 桁以内 + 小数部 4 桁以内) に収まらない場合は、NA (半角英字) を出力してください。入力される実数は整数部 8 桁以内、小数部 4 桁以内に収まるものとし、出力する 2 進表現は整数部 8 桁、小数部 4 桁で出力してください。

Input

複数のデータセットの並びが入力として与えられます。入力の終わりは負の実数ひとつの行で示されます。
各データセットとして１つの実数 <var>n</var> が１行に与えられます。

データセットの数は 1200 を超えません。

Output

入力データセットごとに 2 進数への変換結果を出力します。

Sample Input

23.5
158.1
-1.0

Output for the Sample Input

00010111.1000
NA


# AOJ 0220 Binary Digit A Doctor Loved
# Python3 2018.6.23 bal4u

while 1:
	s = input()
	if s[0] == '-': break
	w = len(s)
	if s.find('.') < 0: a, b = int(s), 0
	elif w == 1: a, b = 0, 0
	elif s[0] == '.': a, b = 0, int(s[1:])
	else:
		if s[w-1] == '.': s += '0'
		a, b = map(int, s.split('.'))
	if a > 255:
		print("NA")
		continue
	sa = format(a, '08b')
	sb, s = '', str(b)
	k = 10**len(s)
	for i in range(4):
		b *= 2
		if b >= k: sb += '1'
		else: sb += '0'
		b %= k
	if b == 0: print(sa, '.', sb, sep='')
	else: print("NA")


from collections import deque
def bfs(bldg):
    dict = {}

    que = deque([(bldg[0][0],0,0),(bldg[1][0],1,0)])

    while len(que):
        h, b, t = que.popleft()
        try:
            if dict[(h, b)] <= t:
                continue
        except KeyError:
            dict[(h, b)] = t

        if h == len(bldg[0]) - 3:
            return t
        t += 1
        if 100 < t:
            break
        que.append((bldg[b^1][h + 2],b^1,t))
    return 'NA'

def building():
    bldg = f.readline().split() + ['2', '2']

    scaffold = 0
    for i in range(len(bldg)):
        if '2' == bldg[i]:
            bldg[i] = scaffold
        else:
            scaffold = i
        if '0' == bldg[i]:
            bldg[i] = i

    scaffold = None
    for i in reversed(range(len(bldg))):
        if '1' == bldg[i]:
            if scaffold is None:
                scaffold = i
            bldg[i] = scaffold
        else:
            scaffold = None
    return bldg

import sys
f = sys.stdin

while True:
    n = int(f.readline())
    if n == 0:
        break
    print(bfs([building(),building()]))

def bfs(b):
    mem=[[False for i in range(n)]for j in range(2)]
    st=[0,0]
    for i in range(2):
        if b[i][0]!=1:continue
        while st[i]<n-1 and b[i][st[i]+1]==1:
            st[i]+=1
        if st[i]==n-1:return 0
    mem[0][st[0]]=True
    mem[1][st[1]]=True
    que=[[0,st[0],0],[1,st[1],0]]
    while len(que)!=0:
        d=que.pop(0)
        des=(d[0]+1)%2
        cst=d[2]+1
        for i in range(3):
            fl=d[1]+i
            if fl>=n:break
            state=b[des][fl]
            if state!=2 and fl==n-1:
                return cst
            if state==0:
                if mem[des][fl]==False:
                    que.append([des,fl,cst])
                    mem[des][fl]=True
            elif state==1:
                k=1
                while True:
                    if fl+k>=n:return cst
                    if b[des][fl+k]!=1:
                        if mem[des][fl+k-1]==False:
                            que.append([des,fl+k-1,cst])
                            mem[des][fl+k-1]=True
                        break
                    else: k+=1

            elif state==2:
                k=1
                while True:
                    if b[des][fl-k]!=2:
                        if mem[des][fl-k]==False:
                            que.append([des,fl-k,cst])
                            mem[des][fl-k]=True
                        break
                    else:k+=1
    return -1
while True:
    n=int(input())
    if n==0:break
    b=[[int(p)for p in input().split(" ")],[int(p)for p in input().split(" ")]]
    count=bfs(b)
    print(str(count)if count>=0 else "NA")

忍者のビル登り

 忍者のあつしさんは、毎日朝早くから夜遅くまで忍者ビルの屋上から町を警備しています。この忍者ビルは、隣接する 2 つの同じ階数のビルであり、あつしさんは警備のために、ビルとビルの間をジャンプしながら屋上へ向かうことを日課としています。

 この 2 つのビルは頻繁に清掃が行われるため、ビル登りの助けとなるはしごや障害となる滑りやすい部分があります。  しかも、はしごや滑りやすい部分の位置は毎日変わります。   そのためあつしさんは、屋上へ向かう方法を毎日考えなければいけません。

 あつしさんは二つ並んだ同じ階数のビルの壁を跳び移りながら、ビルの屋上を目指します。ジャンプ
はどちらか一方のビルの1階から始められます。向かい側のビルへジャンプするときには、同じ階・1つ上の階・2 つ上の階の、いずれかに飛び移ることができます。

 壁には以下の 3 種類があり、それぞれの壁にジャンプした後の移動が決まっています。

0. 普通の壁: 上下の移動はしない。次のジャンプはそこから行う。

1. はしご: はしごは 2 つ以上の階にまたがってかかっており、今いるはしごの一番上まで移動する。次のジャンプはそこから行う。

2. すべる壁: 普通の壁かはしごの一番上まで滑り落ちる。次のジャンプはそこから行う。

 また、壁は 1 階から屋上のすぐ下の最上階まであり、屋上へはそのビルの最上階からのみ行くことが
できます。また、ビルの最下階の壁はすべる壁にはなりません。

 2 つのビルの階数 <var>n</var> と 2 つのビルの壁の種類を入力とし、最少で何回目のジャンプで最上階までたどり着き、屋上まで行くことができるかを出力するプログラムを作成してください。なお、どちらのビルの屋上にたどり着いてもよいものとします。ただし、あつしさんがどちらのビルの屋上へもたどり着けない場合は“NA”と出力してください。

Input

複数のデータセットの並びが入力として与えられます。入力の終わりはゼロひとつの行で示されます。
各データセットは以下の形式で与えられます。

<var>n</var>
<var>a1</var> <var>a2</var> ... <var>an</var>
<var>b1</var> <var>b2</var> ... <var>bn</var>

１行目にビルの階数 <var>n</var> (3 ≤ <var>n</var>  ≤ 100) が与えられます。２行目に１ つ目のビルの 1 階から <var>n</var> 階までの壁の情報 <var>ai</var>、３行目に２つ目のビルの 1 階から <var>n</var> 階までの壁の情報 <var>bi</var> が与えられます。<var>ai, bi</var> は<var>i</var> 階目の壁の情報を表し、0 が普通の壁、1 がはしご(<var>i</var> 階と <var>i</var>+1 階にまたがる)、2 がすべる壁を表します。

データセットの数は 60 を超えません。

Output

入力データセットごとに、ジャンプの回数を１行に出力します。

Sample Input

8
0 0 0 2 2 2 0 0
1 1 1 1 0 0 0 0
4
1 1 2 2
0 0 2 2
0

Output for the Sample Input

4
NA


def bfs(b):
    mem=[[False for i in range(n)]for j in range(2)]
    mem[0][0]=True
    mem[1][0]=True
    que=[[0,0,0],[1,0,0]]
    while len(que)!=0:
        d=que.pop(0)
        state=b[d[0]][d[1]]
        if state!=2 and d[1]==n-1:
            return d[2]

        if state==0:
            for i in range(3):
                if d[1]+i>=n:break
                if d[0]==0 and mem[1][d[1]+i]==False:
                    que.append([1,d[1]+i,d[2]+1])
                    mem[1][d[1]+i]=True
                elif d[0]==1 and mem[0][d[1]+i]==False:
                    que.append([0,d[1]+i,d[2]+1])
                    mem[0][d[1]+i]=True
        elif state==1:
            k=1
            while True:
                if d[1]+k>=n:return d[2]
                if b[d[0]][d[1]+k]!=1:
                    for i in range(3):
                        if d[1]+k+i-1>=n:break
                        if d[0]==0 and mem[1][d[1]+k+i-1]==False:
                            que.append([1,d[1]+k+i-1,d[2]+1])
                            mem[1][d[1]+k+i-1]=True
                        elif d[0]==1 and mem[0][d[1]+k+i-1]==False:
                            que.append([0,d[1]+k+i-1,d[2]+1])
                            mem[0][d[1]+k+i-1]=True
                    break
                else: k+=1

        elif state==2:
            k=1
            while True:
                if b[d[0]][d[1]-k]!=2:
                    for i in range(3):
                        if d[1]-k+i>=n:break
                        if d[0]==0 and mem[1][d[1]-k+i]==False:
                            que.append([1,d[1]-k+i,d[2]+1])
                            mem[1][d[1]-k+i]=True
                        elif d[0]==1 and mem[0][d[1]-k+i]==False:
                            que.append([0,d[1]-k+i,d[2]+1])
                            mem[0][d[1]-k+i]=True
                    break
                else:k+=1
    return 0
while True:
#for t in range(1):
    n=int(input())
    #n=8
    if n==0:break
    b=[[int(p)for p in input().split(" ")],[int(p)for p in input().split(" ")]]
    #b=[[0,0,0,2,2,2,0,0],[1,1,1,1,0,0,0,0]]
    count=bfs(b)
    print(str(count)if count!=0 else "NA")


while 1:
    N = int(input())
    if N == 0:break
    R = [[0 for i in range(N+1)] for i in range(N+1)]

    def dfs_max(cur, pre):
        _max = -R[cur][pre]
        for i in range(N+1):
            if R[cur][i] > 0 and i != pre:
                _max = max(_max, dfs_max(i, cur) + R[cur][i])
    #    print('max : %d' % _max)
        return _max

    total = 0
    for i in range(N-1):
        a, b, t = list(map(int, input().split()))
        R[a][b] = t
        R[b][a] = t
        total += (t * 2)

    for i in range(2, N+1):
        spam = [x for x in R[i] if x > 0]
        if(len(spam) <= 1):
            total -= (spam[0] * 2)

    print((total - dfs_max(1, 0)))

from collections import deque
while 1:
    N = int(input())
    if N == 0:
        break

    G = [[] for i in range(N)]
    for i in range(N-1):
        a, b, t = map(int, input().split())
        a -= 1; b -= 1
        G[a].append((b, t))
        G[b].append((a, t))
    D = [-1]*N; P = [0]*N
    que = deque([0])
    D[0] = 0
    while que:
        v = que.popleft()
        c = D[v]
        for w, d in G[v]:
            if D[w] != -1:
                continue
            D[w] = c + d
            P[w] = d
            que.append(w)
    ans = 0
    m = 0
    for i in range(N):
        if not i or len(G[i]) > 1:
            ans += P[i]*2
            m = max(m, D[i])
    ans -= m
    print(ans)

サージェント・ライアン

 「ライアン軍曹を救え」という指令のもと、アイヅ軍の救出部隊はドイツリーの水上都市で敵軍と激しい戦闘を繰り広げていました。彼らは無事に軍曹と合流しましたが、敵の戦車が多く、救出ヘリを呼べずにいました。そこで、彼らは敵の戦車を混乱させるため、都市にある橋を全て爆破するという作戦を実行することにしました。

作戦はすぐに司令部に伝えられ、救出ヘリの準備が進められました。救出ヘリを飛ばすためには、いつ橋が全て爆破されるかを予測しなければなりません。軍のプログラマであるあなたの任務は、救出部隊が全ての橋の爆破に必要な時間を計算することです。

水上都市は <var>N</var> 個の島で構成されており、島と島との間には橋がかかっています。すべての島はツリー状に繋がっています(下図参照)     。ある島からある島への経路は、一通りだけ存在します。各橋を渡るには、橋ごとに決められた時間がかかり、どちらの方向にもその時間で橋を渡ることが可能です。

 救出部隊はボートなど水上を移動する手段を持っていないので島と島の間を移動するには橋を通る他ありません。救出部隊は、その時いる島に隣接している橋のうち、必要なものを一瞬で爆破することができます。救出部隊が全ての橋を爆破するのに必要な最小の時間はいくらでしょうか。ただし、島の中での移動時間は考えません。

 島の数、それぞれの橋情報を入力とし、橋を全て爆破するのに必要な最小の時間を出力するプログラムを作成してください。島はそれぞれ 1 から <var>N</var> の番号で表されます。橋は <var>N</var>-1 本あります。橋情報は、その橋が隣接している二つの島の番号(<var>a</var>, <var>b</var>)と、その橋を渡るのに必要な時間 <var>t</var> で構成されます。救出部隊は島番号 1 の島からスタートするものとします。

Input

複数のデータセットの並びが入力として与えられる。入力の終わりはゼロひとつの行で示される。各データセットは以下の形式で与えられる。

<var>N</var>
<var>a1</var> <var>b1</var> <var>t1</var>
<var>a2</var> <var>b2</var> <var>t2</var>
:
<var>aN-1</var> <var>bN-1</var> <var>tN-1</var>

入力はすべて整数で与えられる。1 行目に島の数 <var>N</var> (2 ≤ <var>N</var> ≤ 20) が与えられる。

続く <var>N</var>-1 行に <var>i</var> 番目の橋の情報が与えられる。 <var>ai</var>, <var>bi</var>, <var>ti</var> (1 ≤ <var>ti</var> ≤ 500) は、<var>i</var> 番目の橋を通って島 <var>ai</var> と島 <var>bi</var> の間を時間 <var>ti</var> で移動できることを表す。

データセットの数は 100 を超えない。

Output

データセットごとに、橋を全て爆破するのに必要な最小の時間を1行に出力する。

Sample Input

7
1 2 5
2 3 2
3 4 3
2 5 3
5 6 3
5 7 8
0

Output for the Sample Input

12


N = int(input())
R = [[0 for i in range(N+1)] for i in range(N+1)]

def dfs_max(cur, pre):
    _max = -R[cur][pre]
    for i in range(N+1):
        if R[cur][i] > 0 and i != pre:
            _max = max(_max, dfs_max(i, cur) + R[cur][i])
#    print('max : %d' % _max)
    return _max

total = 0
for i in range(N-1):
    a, b, t = list(map(int, input().split()))
    R[a][b] = t
    R[b][a] = t
    total += (t * 2)

for i in range(2, N+1):
    spam = [x for x in R[i] if x > 0]
    if(len(spam) <= 1):
        total -= (spam[0] * 2)

print((total - dfs_max(1, 0)))


import sys
f = sys.stdin

q = int(f.readline())
for line in f:
    c, a, n = map(int, line.split())
    can = min(c,a,n)
    c -= can
    a -= can

    cca = min(c // 2, a)
    c -= cca * 2
    ccc = c // 3
    print(can + cca + ccc)

for i in range(int(input())):
    res = 0
    c,a,n = list(map(int,input().split()))
    res = min(n,a,c)
    c -= res
    a -= res
    if c >= 2 and a >= 1:
        cca = min(c//2,a)
        c -= cca*2
        res += cca

    if c >=3:
        res += c//3

    print(res)

陣形

プログラマー養成校であるアカベ高校では、チーム戦の競技プログラマーの役割を以下の３タイプに分けています。

Ｃ：
コーダー
言語を熟知しており、コーディングを行う。

Ａ：
アルゴリズマー
論理的思考が得意であり、アルゴリズムを考える。

Ｎ：
ナビゲーター
読解力に長けており、問題の分析・デバッグをする。

この高校では以下のいずれかの陣形で３人一組のチームを構成しています。

ＣＣＡ：
バランスがとれている安定型

ＣＣＣ：
スピードを見込めるがリスクの高い速攻型

ＣＡＮ：
正確に問題を解く慎重型

競技プログラミング部のコーチであるあなたは、これらの部員をうまく組み合わせ、できるだけ多くのチームを結成できるよう、毎年気を配っています。そこで、コーダーの人数、アルゴリズマーの人数、ナビゲーターの人数が入力として与えられたとき、最大何チーム作れるかを出力するプログラムを作成してください。

入力

入力は1つのデータセットからなる。入力データは以下の形式で与えられる。

<var>Q</var>
<var>c1</var> <var>a1</var> <var>n1</var>
<var>c2</var> <var>a2</var> <var>n2</var>
:
<var>cQ</var> <var>aQ</var> <var>nQ</var>

1行目の<var>Q</var>(0 ≤ <var>Q</var> ≤ 100)はチーム数を求めたい年数である。続く<var>Q</var>行に各年の役割別の人数が与えられる。各行にはコーダーの人数<var>ci</var>(0 ≤ <var>ci</var> ≤ 1000)、アルゴリズマーの人数<var>ai</var>(0 ≤ <var>ai</var> ≤ 1000)、ナビゲーターの人数<var>ni</var>(0 ≤ <var>ni</var> ≤ 1000)が与えられる。

出力

年ごとに、作成できる最大のチーム数を1行に出力する。

入力例

4
3 0 0
1 1 1
9 4 1
0 1 2

出力例

1
1
4
0


for i in range(int(input())):
    res = 0
    c,a,n = list(map(int,input().split()))
    res = min(n,a,c)
    c -= res
    a -= res
    if c >= 2 and a >= 1:
        res += min(c//2,a)
        c -= res*2

    if c >=3:
        res += c//3

    print(res)


def gcd(m, n):
    r = m % n
    return gcd(n, r) if r else n
def f(v):
    d = v.find(".")
    if d == -1:
        return int(v), 1
    a = int(v[:d]+v[d+1:])
    n = 10**(len(v)-d-1)
    if a == 0:
        return 0, 1
    g = gcd(n, a)
    return int(a/g), int(n/g)
s = input()
d = s.find(".")
l = s.find("(")
r = s.find(")")
if l == -1:
    res = f(s)
else:
    assert l>=2 and r == len(s)-1
    aa, na = f(s[:l])
    ab, nb = f("0." + "0"*(l-d-1) + s[l+1:r])
    t = r-l-1
    a = (10**t - 1)*aa*nb + 10**t*ab*na
    n = (10**t - 1)*na*nb

    g = gcd(a, n)
    res = int(a/g), int(n/g)
print("%d/%d" % res)

from math import gcd

s = input()
x, y = s.split(".")
if "(" in s:
  da = y.index("(")
  db = y.index(")") - 1
  ya, b = y.split("(")
  lb = len(b) - 1
  a = int(x + ya)
  b = int(b[:-1])
  deco = a * (10 ** db - 10 ** (db - lb)) + b * 10 ** da
  nume = 10 ** da * (10 ** db - 10 ** (db - lb))
  div = gcd(deco, nume)
  print(deco // div, nume // div, sep="/")
else:
  da = len(y)
  a = int(x + y)
  deco = a
  nume = 10 ** da
  div = gcd(deco, nume)
  print(deco // div, nume // div, sep="/")

実数既約分数化

  実数のうち、小数部が循環するものと有限桁のものは分数として表すことができます。

分数で表すことができる実数が与えられたとき、その実数と等しい既約分数（それ以上約分できない分数）を出力するプログラムを作成せよ。

Input

  入力は以下の形式で与えられる。

<var>str</var>

  １行に、変換したい実数を表す文字列 <var>str</var> が与えられる。実数の値は 0 より大きい。文字列は数字か「.」、「(」、「)」を含む、長さが 3 以上 8 以下の文字列である。「.」は小数点、「(」は数字の循環の始まり、「)」は数字の循環の終わりを示す。整数部にも小数部にも、必ず１桁以上の数字が与えられるとする。ただし、循環小数が与えられた場合、文字列は以下の条件を満たす。

 循環の始まりと終わりのペアは、小数点の右側に一度だけ現れる。

 循環の終わりを示す「)」は、文字列の末尾に現れる。

 循環の始まりと終わりの間には、必ず１桁以上の数字が与えられる。

Output

実数を既約分数で表した形式（分子の整数に続けて「/」区切りで分母の整数を並べたもの）で出力する。

Sample Input 1

0.(3)

Sample Output 1

1/3

Sample Input 2

1.0

Sample Output 2

1/1

Sample Input 3

5.2(143)

Sample Output 3

52091/9990

Sample Input 4

0.0739

Sample Output 4

739/10000


def gcd(m, n):
    r = m % n
    return gcd(n, r) if r else n
def f(v):
    d = v.find(".")
    a = int(v[:d]+v[d+1:])
    n = 10**(len(v)-d-1)
    if a == 0:
        return 0, 1
    g = gcd(n, a)
    return a/g, n/g
s = input()
l = s.find("(")
r = s.find(")")
if l == -1:
    print("%d/%d" % f(s))
else:
    va, na = f(s[:l])
    vb, nb = f("0." + "0"*(l-2) + s[l+1:r])
    t = r-l-1
    vb *= 10**t
    nb *= 10**t - 1

    ng = gcd(na, nb)
    va *= nb; vb *= na
    v = va+vb; n = na*nb
    g = gcd(v, n)
    v /= g; n /= g
    print("%d/%d" % (v, n))


a,b,c=map(int,input().split())
if c <= a:
 print("0")
elif c <= a+b:
 print(c-a)
else:
 print("NA")

m, f, b = map(int, input().split())
if m >= b:
    print(0)
elif b > m+f:
    print("NA")
else:
    print(b-m)

Shopping

You are now in a bookshop with your friend Alice to buy a book, "The Winning Strategy for the Programming Koshien Contest,” just released today. As you definitely want to buy it, you are planning to borrow some money from Alice in case the amount you have falls short of the price. If the amount you receive from Alice still fails to meet the price, you have to abandon buying the book this time.

  Write a program to calculate the minimum amount of money you need to borrow from Alice given the following three items of data: the money you and Alice have now and the price of the book.

Input

  The input is given in the following format.

<var>m</var> <var>f</var> <var>b</var>

A line containing the three amounts of money is given: the amount you have with you now <var>m</var> (0 ≤ <var>m</var> ≤ 10000), the money Alice has now <var>f</var> (0 ≤ <var>f</var> ≤ 10000) and the price of the book <var>b</var> (100 ≤ <var>b</var> ≤ 20000).

Output

Output a line suggesting the minimum amount of money you need to borrow from Alice. Output "NA" if all the money Alice has with him now is not a sufficient amount for you to buy the book.

Sample Input 1

1000 3000 3000

Sample Output 1

2000

Sample Input 2

5000 3000 4500

Sample Output 2

0

Sample Input 3

500 1000 2000

Sample Output 3

NA


m,f,b=map(int,input().split())
ans=0
if m>b:
    ans=0
elif m<b:
    ans=b-m
elif ans>f:
    ans="NA"
print(ans)


a, b, x = map(int, input().split())
c = 0
while x > 0:
    if x > 500:
        c += a if a < 2*b else 2*b
        x-=1000
    else:
        c += b if b < a else a
        x-=500
print(c)

Heat Stroke

We have had record hot temperatures this summer. To avoid heat stroke, you decided to buy a quantity of drinking water at the nearby supermarket. Two types of bottled water, 1 and 0.5 liter, are on sale at respective prices there. You have a definite quantity in your mind, but are willing to buy a quantity larger than that if: no combination of these bottles meets the quantity, or, the total price becomes lower.

  Given the prices for each bottle of water and the total quantity needed, make a program to seek the lowest price to buy greater than or equal to the quantity required.

Input

The input is given in the following format.

$A$ $B$ $X$

  The first line provides the prices for a 1-liter bottle $A$ ($1\leq A \leq 1000$), 500-milliliter bottle $B$ ($1 \leq B \leq 1000$), and the total water quantity needed $X$ ($1 \leq X \leq 20000$). All these values are given as integers, and the quantity of water in milliliters.

Output

  Output the total price.

Sample Input 1

180 100 2400

Sample Output 1

460

Sample Input 2

200 90 2018

Sample Output 2

450


import math

A, B, X = list(map(int, input().split(' ')))

amount = 0
cost = 0
if A/1000 < B/500:
    amount = math.floor(X/1000)*1000
    cost = math.floor(X/1000)*A
else:
    amount = math.floor(X/500)*500
    cost = math.floor(X/500)*B

if X-amount > 0 and X-amount <= 500:
    cost += A if A <= B else B
elif X-amount <= 1000:
    cost += A if A < 2*B else 2*B

print(cost)


n = int(input())
while (n!=0):
    wlist = []
    for i in range(n):
        wlist.append(str(input()))
    ufr = {"u":1 ,"f":2, "r":3}
    up = 1
    for w in wlist:
        tmp = 0
        if (w == "North"):
            tmp = ufr["u"]
            ufr["u"] = ufr["f"]
            ufr["f"] = 7-tmp
        elif (w == "East"):
            tmp = ufr["r"]
            ufr["r"] = ufr["u"]
            ufr["u"] = 7-tmp
        elif (w == "West"):
            tmp = ufr["u"]
            ufr["u"] = ufr["r"]
            ufr["r"] = 7-tmp
        elif (w=="South"):
            tmp = ufr["f"]
            ufr["f"] = ufr["u"]
            ufr["u"] = 7-tmp
        elif (w=="Right"):
            tmp = ufr["f"]
            ufr["f"] = ufr["r"]
            ufr["r"] = 7-tmp
        else:
            tmp = ufr["r"]
            ufr["r"] = ufr["f"]
            ufr["f"] = 7-tmp
        up += ufr["u"]
    print(up)
    n=int(input())

import math
import string
import itertools
import fractions
import heapq
import collections
import re
import array
import bisect

while(True):
    dice = [1, 2, 3, 4, 5, 6]
    score = 1
    n = int(input())
    if n == 0:
        break

    for i in range(n):
        action = input().rstrip()
        if action == "North":
            tmp = dice[0]
            dice[0] = dice[1]
            dice[1] = dice[5]
            dice[5] = dice[4]
            dice[4] = tmp
        elif action == "East":
            tmp = dice[0]
            dice[0] = dice[3]
            dice[3] = dice[5]
            dice[5] = dice[2]
            dice[2] = tmp
        elif action == "West":
            tmp = dice[0]
            dice[0] = dice[2]
            dice[2] = dice[5]
            dice[5] = dice[3]
            dice[3] = tmp
        elif action == "South":
            tmp = dice[0]
            dice[0] = dice[4]
            dice[4] = dice[5]
            dice[5] = dice[1]
            dice[1] = tmp
        elif action == "Right":
            tmp = dice[1]
            dice[1] = dice[2]
            dice[2] = dice[4]
            dice[4] = dice[3]
            dice[3] = tmp
        elif action == "Left":
            tmp = dice[1]
            dice[1] = dice[3]
            dice[3] = dice[4]
            dice[4] = dice[2]
            dice[2] = tmp
        score += dice[0]
    print(score)

サイコロが以下の図のような向きで置かれている．

ここで使用するサイコロは，この図のように，上側に 1，南側に 2 があるときは，東側に 3 があるものとする．サイコロの向かいあう面の和は必ず 7 なので，見えない面はそれぞれ北側 5，西側 4，下側 6 になっている．

　この初期配置の状態から指示に従ってサイコロを動かしていく．ただし，指示は以下の 6 通りの操作を何回か行うものである．

North，East，South，West の各操作は指示された方向へサイコロを 90 度回転させる．
　Right，Left の 2 つの操作は上下の面はそのままで水平方向に 90 度回転させる．（回転させる向きに要注意．）

　初期配置で上の面に出ている目 1 を初期値とし， 1 回の操作が終わるたびに，上の面に出ている目の数を加算していき，指示にしたがってすべての操作を終えたときの合計値を出力するプログラムを作成しなさい.

　入力ファイルの 1 行目には総指示回数 n が書かれていて，続く n 行の各行には「North，East，South，West，Right，Left」のいずれか 1 つの指示が書かれているものとする．ただし， n ≦ 10000 とする．

  入力例１	入力例２

5	8

North	West

North	North

East	Left

South	South

West	Right

	North

	Left

	East

  出力例１	  出力例２

21	34

入力

入力は複数のデータセットからなる．n が 0 のとき入力が終了する．データセットの数は 5 を超えない．

出力

データセットごとに、合計値を１行に出力する．

入力例

5
North
North
East
South
West
8
West
North
Left
South
Right
North
Left
East
0

出力例

21
34

各データセットの出力（合計値）の後に改行を入れること。

上記問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。


#!/usr/bin/env python
# -*- coding: utf-8 -*-

x = ['Front', 'Right', 'Back', 'Left']
y = ['Front', 'Top', 'Back', 'Bottom']
z = ['Top', 'Right', 'Bottom', 'Left']

def turn(dice, direction):
    _dice = dice
    # x?????????
    if direction == 'Right':
        for i in range(4):
            _dice[x[i]] = dice[x[(i+1)%4]]

    if direction == 'Left':
        for i in range(4):
            _dice[x[i]] = dice[x[(i-1)%4]]

    # y?????????
    if direction == 'North':
        for i in range(4):
            _dice[y[i]] = dice[y[(i+1)%4]]
    if direction == 'South':
        for i in range(4):
            _dice[y[i]] = dice[y[(i-1)%4]]

    # z?????????
    if direction == 'East':
        for i in range(4):
            _dice[z[i]] = dice[z[(i+1)%4]]
    if direction == 'West':
        for i in range(4):
            _dice[z[i]] = dice[z[(i-1)%4]]

    return _dice

if __name__ == '__main__':
    while True:
        n = int(input())
        if n == 0:
            break

        dice = {'Top': 1, 'Front': 2, 'Right': 3,
                'Left': 4, 'Back': 5, 'Bottom': 6}
        ret = 0

        for i in range(n):
            dice = turn(dice, input())
            ret += dice['Top']

        print(ret)


def compress(digits):
  compressed_list = list()
  for digit in digits:
    if compressed_list == [] or compressed_list[-1][1] != digit:
      compressed_list.append([1, digit])
    else:
      compressed_list[-1][0] += 1

  return compressed_list

def decompress(compressed_list):
  new_digits = ""
  for pair in compressed_list:
    new_digits += "{}{}".format(*pair)

  return new_digits

while 1:
  proc_num = int(input())
  if proc_num == 0:
    break
  digits = input().strip()

  for i in range(proc_num):
    compressed_list = compress(digits)
    digits = decompress(compressed_list)
  print(digits)

while True:
    n = int(input())
    if not n:
        break
    s = input().strip()

    while n:
        prev, cnt, new = s[0], 1, ''
        for c in s[1:]:
            if c == prev:
                cnt += 1
            else:
                new += str(cnt) + prev
                prev, cnt = c, 1
        new += str(cnt) + prev
        s = new
        n -= 1
    print(s)

 0 から 9 までの数字だけで構成された文字列が与えられたとき,その文字列から次の規則に従って新しい文字列を作る操作を考える.与えられた文字列を左端から1文字ずつ順に読んで行き,同じ数字 a が r 個続いていた場合,個数 r と数字a を空白で区切らずにこの順で書き出す.与えられた文字列の右端まで読み,最後の書き出しが終わったところまでを途中何回書き出しがあったとしても全部まとめて操作1回とカウントする.2回目以降の操作は前回の操作により書き出された文字列を与えられた文字列として同様の操作を実施する.例えば “122244” という文字列が与えられた場合には左端から順に1個の1, 3個の2,2個の4なのでこの操作1回で得られる文字列は “113224” であり,“44444444444” (11 個の4)の場合には得られる文字列は “114” となる.

  100 文字以下の与えられた文字列に上の操作を n 回実施した文字列を出力するプログラムを作成せよ.ただし, n ≤ 20 とする.

  入力データ は 2 行からなり,1 行目に操作回数 n, 2 行目に最初の文字列が書かれている.

  入力例

  5

11

  出力例

13112221

入力

入力は複数のデータセットからなる．n が 0 のとき入力が終了する．データセットの数は 5 を超えない．

出力

データセットごとに、指定された回数の操作を施した文字列 を１行に出力する．

入力例

5
11
5
11
0

出力例

13112221
13112221

上記問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。


# coding: utf-8
def solve(li):
    cnt = 1
    ans = []
    for i in range(len(li)-1):
        tar = int(li[i])
        if tar==int(li[i+1]):
            cnt+=1
        else:
            ans.append(cnt)
            ans.append(tar)
            cnt = 1
    tar = int(li[i+1])
    ans.append(cnt)
    ans.append(tar)
    return ans

while True:
    n = int(input())
    if n ==0: break
    a = input()
    la = list(a)
    i=0
    while i<n:
        la = solve(la)
        i+=1
    for x in la:
        print(x, end='')
    print()


import sys
def line():return sys.stdin.readline().strip()
def a(n,k,s):
    if k == 0:print(s[1:])
    elif k > 0:
        for i in range(1,n + 1)[::-1]:
            a(i,k - i,s + " " + str(i))
while True:
    n = int(line())
    if n == 0:break
    a(n,n,"")

while True:
    n = int(input())
    if not n:
        break
    results = {(n,)}
    for i in range(1, n):
        right_list = list((k,) for k in range(1, n // (i + 1) + 1))
        for j in range(i - 1):
            next_list = []
            for right in right_list:
                for k in range(right[0], (n - sum(right)) // (i - j) + 1):
                    next_list.append((k,) + right)
            right_list = next_list
        for right in right_list:
            results.add((n - sum(right),) + right)
    for result in sorted(results, reverse=True):
        print(*result)

同じ大きさの正方形の紙が n 枚ある.これらの紙の下部を水平に揃えて何列かに並べる.ただし,隣り合う列は左側が右側より低くならないように並べなければならない.例えば, n = 5 のときは,次のような 7 通りの並べ方が可能である.

   これらを,各列に並んだ正方形の個数の列で表すことにする.例えば, n = 5 の
ときは,それぞれ,

          (5) (4, 1) (3, 2) (3, 1, 1) (2, 2, 1) (2, 1, 1, 1) (1, 1, 1, 1, 1)

と表わされる.

   n を入力したとき, 辞書式順序で全て出力するプログラムを作成せよ.n ≤30
とする.ただし, 辞書式順序とは2つの並べ方 (a1, a2 , ..., as) が並べ方 (b1, b2, ..., bt ) に対して, a1 > b1 または, ある整数 i > 1 が存在して a1 = b1 , ..., ai-1 = bi-1 かつ ai > bi が成り立つとき (a1, a2, ..., as) が (b1 , b2, ..., bt) より先に出力されるように並べることである.

   入力データ は 1 行からなり,1 行目に n が書かれている.

   出力には並べ方を辞書式順序で 1 行に1通りずつ書き最後に改行を入れること. 並べ方は (a1, a2, ..., as) の出力は整数 a1, a2, . . . , as をこの順番に空白で区切って出力すること.

  入力例１

5

  出力例１

5

4 1

3 2

3 1 1

2 2 1

2 1 1 1

1 1 1 1 1

入力

入力は複数のデータセットからなる．n が 0 のとき入力が終了する．データセットの数は 5 を超えない．

出力

データセットごとに、辞書式順序で全て出力する．

入力例

5
5
0

出力例

5
4 1
3 2
3 1 1
2 2 1
2 1 1 1
1 1 1 1 1
5
4 1
3 2
3 1 1
2 2 1
2 1 1 1
1 1 1 1 1

上記問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。


def main():
    pass
if __name__ == "__main__":
    main()


n, m = map(int, input().split())

accums = [0]
for i in range(n - 1):
    accums.append(accums[-1] + int(input()))

result = 0
k = 0
for i in range(m):
    a = int(input())
    result += abs(accums[k + a] - accums[k])
    k += a

print(result % 100000)

n, m = map(int, input().split())

accums = [0]
for i in range(n - 1):
    accums.append(accums[-1] + int(input()))

result = 0
k = 0
for i in range(m):
    a = int(input())
    result = (result + abs(accums[k + a] - accums[k])) % 100000
    k += a

print(result)

旅人

  問題

あなたは JOI 街道を旅する旅人である.JOI 街道は東西にまっすぐに延びた道路で,JOI 街道上には n 個の宿場町がある.宿場町には西から東の順に 1 から n までの番号が付けられている.JOI 街道上の最も西の宿場町が宿場町 1 であり,最も東の宿場町が宿場町 n である.

あなたは,宿場町 1 から出発して m 日間の旅に出ることになった.あなたの旅程は数列 a1 , a2 , . . . , am に従い,次のように決められている.ai は i 日目の移動方法を表す 0 ではない整数である.i 日目にあなたが出発する宿場町を宿場町 k とおくと,i 日目にあなたは宿場町 k から宿場町 k + ai までまっすぐに移動することを意味する.

宿場町の個数 n,旅の日数 m,宿場町間の距離の情報と,移動方法を表す数列a1 , a2 , . . . , am が与えられたとき,m 日間の旅におけるあなたの移動距離の合計を100000 = 105 で割った余りを求めるプログラムを作成せよ.

入出力の例に対応する図

入力

1 行目には整数 n, m が空白区切りで書かれている.n (2 ≤ n ≤ 100000 = 105 ) はJOI 街道上の宿場町の個数を,m (1 ≤ m ≤ 100000 = 105 ) は旅の日数を表す.

続く n − 1 行は JOI 街道上の宿場町間の距離を表す.i + 1 行目 (1 ≤ i ≤ n − 1) に
は宿場町 i と宿場町 i + 1 の距離を表す正整数 si (1 ≤ si ≤ 100) が書かれている.

続く m 行には m 日間の移動方法を表す数列が書かれている.i + n 行目 (1 ≤ i ≤ m)
には i 日目のあなたの移動方法を表す 0 ではない整数 ai が書かれている.

採点用データにおいて,宿場町 1 より西に移動することや,宿場町 n より東に移
動することはない.

採点用データのうち,配点の 50% 分については,n ≤ 100 かつ m ≤ 100 を満たす.

 出力

出力 は, m 日間の旅におけるあなたの移動距離の合計を 100000 = 105 で割った余りを含む 1 行からなる.

 入出力例

入力例 1

7 5
2
1
1
3
2
1
2
-1
3
2
-3

出力例 1

18

1 日目に,あなたは宿場町 1 から宿場町 3 まで移動する.2 日目に,あなたは宿場
町 3 から宿場町 2 まで移動する.そして,3 日目に宿場町 2 から宿場町 5 まで移動
し,4 日目に宿場町 5 から宿場町 7 まで移動し,5 日目に宿場町 7 から宿場町 4 ま
で移動する.5 日間の旅におけるあなたの移動距離の合計は 18 である.

上記問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。


# -*- coding: utf-8 -*-
# !/usr/bin/env python
# vim: set fileencoding=utf-8 :

"""
#
# Author:   Noname
# URL:      https://github.com/pettan0818
# License:  MIT License
# Created: 木 11/ 9 19:01:14 2017

# Usage
#
"""
from itertools import accumulate

def data_req():
    n_yado, m_ryotei = [int(i) for i in input().split(" ")]
    yado_distance = []
    ryotei = []
    for _ in range(n_yado - 1):
        yado_distance.append(int(input()))
    for _ in range(m_ryotei):
        ryotei.append(int(input()))

    return yado_distance, ryotei

def search(distance, ryotei):
    """search.

    >>> search([2, 1, 1, 3, 2, 1], [2, -1, 3, 2, -3])
    18
    """
    acc = [0] + list(accumulate(distance, lambda x, y: x+y))
    ryotei_index = [0] + list(accumulate(ryotei, lambda x, y: x+y))
    # print(ryotei_index)
    res = []
    for index in enumerate(ryotei_index):
        if index[0] == 0:
            continue
        index = index[0]
        # print(index)
        # print(ryotei_index[index])
        # print(ryotei_index[index - 1])
        dist = abs(acc[ryotei_index[index]] - acc[ryotei_index[index - 1]])
        res.append(dist)
        # print(sum(res))
    # his = []
    #
    # for index in range(len(ryotei_index)):
    #     his.append(acc[ryotei_index[index + 1]] - acc[ryotei_index[index]])
    #
    # return sum(his)
    return sum(res)

if __name__ == '__main__':
    dis, ryotei = data_req()
    search(dis, ryotei)


n, l = map(int,input().split())
#ai = [[int(input()),i] for i in range(n)]
ai = [[] for _ in range(l)]
for i in range(n):
    ai[int(input())].append(i)
time = [0]*(n+2)

for i in range(l-1,0,-1):
    for j in ai[i]:
        time[j+1] = max(time[j],time[j+2]) + l - i

print(max(time))

n, l = map(int,input().split())
ai = [[int(input()),i] for i in range(n)]

ai.sort(key = lambda x: x[0])
time = [0]*(n+2)
for i in ai:
    idx = i[1]
    time[idx+1] = max(time[idx],time[idx+2]) + l - i[0]

print(max(time))

つらら

 問題

カナダに住む JOI 君の家の軒下には,立派なつららが出来ている.せっかくなので,JOI 君はつららについて調べてみることにした.

JOI 君の家の軒下には N 本(2 ≤ N ≤ 100000 = 105 )のつららが出来ている.これらのつららは一直線上に並んでおり,軒下の左端から i cm(1 ≤ i ≤ N )の位置に i 本目のつららが出来ている.i 本目のつららの長さは最初 ai cm(ai は 1 以上の整数)である.これらのつららは,次のような規則によって伸びていく:

 i 本目のつららは,i − 1 本目のつららと i + 1 本目のつららの両方よりも長い場合にのみ,1 時間につき 1 cm ずつ伸びる(ただし,両端のつららに関しては片方の隣のみ考える.すなわち,1 本目のつららは 2 本目のつららより長ければ伸び,N 本目のつららは N − 1 本目のつららより長ければ伸びる).

 どのつららも,L cm(2 ≤ L ≤ 50000)に達した瞬間に,根元から折れる(折れたつららは,以後長さ 0 cm のつららとみなす)
.

最初の段階で,隣り合う 2 本のつららの長さはすべて異なっている.このとき,十分な時間が経過すれば,N 本すべてのつららが折れて長さ 0 cm となる.JOI 君は,つららがこのような状態になるまでの時間を知りたくなった.

N 本のつららの最初の長さとつららの限界の長さ L が与えられると,すべてのつららが折れるまでにかかる時間を求めるプログラムを作成せよ.

入力

入力の 1 行目には,つららの本数を表す整数 N とつららの限界の長さを表す整数
L が,空白を区切りとしてこの順に書かれている.入力の i + 1 行目 (1 ≤ i ≤ N) に
は, i 本目のつららの最初の長さを表す整数 ai (1 ≤ ai < L) が書かれている.

採点用データのうち,配点の 30% 分については,N ≤
500 かつ L ≤
1000 を満
たす.

 出力

出力 は,すべてのつららが折れるまでにかかる時間を表す 1 つの整数のみを含む 1 行からなる.

 入出力例

入力例 1

4 6
4
2
3
5

出力例 1

8

例 1 の場合,1, 2, 3, 4 本目のつららは,それぞれ 2, 8, 4, 1 時間後に折れる.した
がって,すべてのつららが折れるまでにかかる時間は 8 時間であるので,8 を出力
する.

入力例 2

6 10
3
4
1
9
5
1

出力例 2

15

上記問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。


def greedy(N,L,ices):
    counts = 1
    while True:
        # print(ices)
        for i in range(len(ices)):
            if 0 < i < N-1:
                if ices[i] > ices[i-1] and ices[i] > ices[i+1]:
                    ices[i] += 1
                    if ices[i] >= L:
                        ices[i] = 0
            elif i == 0:
                if ices[i] > ices[1]:
                    ices[i] += 1
                    if ices[i] >= L:
                        ices[i] = 0
            elif i == N-1:
                if ices[i] > ices[N-2]:
                    ices[i] += 1
                    if ices[i] >= L:
                        ices[i] = 0

        if ices.count(0) == N:
            print(counts)
            return
        counts += 1

N,L = map(int,input().rstrip().split())
ices = []
while True:
    ice = int(input().rstrip())
    ices.append(ice)
    if len(ices) == N:
        break

# N = 4
# L = 6
# ices = [4,2,3,5]

greedy(N,L,ices)


s = input()
n = int(input())
ans = 0
for _ in range(n):
    t = input()
    t += t[:len(s)]
    if s in t:
        ans += 1
else:
    print(ans)

_find=str(input())
n=int(input())

count=0

for i in range(n):
    s=str(input())
    l=list(s)

    for j in range(len(_find)-1):
        l.append(s[j])

    ss="".join(l)

    if _find in ss:
        count=count+1

print(count)

指輪 (Ring)

問題

あなたは N 個の指輪を持っている．どの指輪にも，アルファベットの大文字 10 文字からなる文字列が刻印されている．指輪には文字列の最初と最後がつながった形で文字が刻印されている．指輪に刻印された文字列を逆順に読む心配はない．

探したい文字列が与えられたとき，その文字列を含む指輪が何個あるかを求めるプログラムを作成せよ．

入力

入力は 2+N 行からなる．

1 行目には，1 文字以上 10 文字以下のアルファベットの大文字からなる探したい文字列が書かれている．

2 行目には，指輪の個数 N ( 1 ≦ N ≦ 100 )が書かれている．

2+i 行目(1 ≤ i ≤ N )には， i 個目の指輪に刻印されている 10 文字からなる文字列が書かれている．

出力

探したい文字列を含む指輪の個数を表す整数を 1 行で出力せよ．

入出力例

入力例 1

ABCD
3
ABCDXXXXXX
YYYYABCDXX
DCBAZZZZZZ

出力例 1

2

入力例 2

XYZ
1
ZAAAAAAAXY

出力例 2

1

入力例 2 の指輪には「XYZ」という文字列が 1 つ含まれている．これは、指輪の文字列の最初と最後がつながっているためである．

入力例 3

PQR
3
PQRAAAAPQR
BBPQRBBBBB
CCCCCCCCCC

出力例 3

2

入力例 3 の 1 個目の指輪には「PQR」という文字列が 2 つ含まれており， 2 個目の指輪には「PQR」という文字列が 1 個含まれており， 3 個目の指輪には「PQR」という文字列が含まれていない．そのため「PQR」という文字列が含まれている指輪の数は 2 個となる．

問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。


s=input()
print(sum(len(2*input().split(s))>1 for _ in range(int(input()))))


lista=[]
t=0
ch=0
e=0
d=0
tflag=1
while True:
    try:
        lista.append(list(map(int,input().split())))
    except:
        break;

def func01(a,b,c):
    global t
    global ch
    global e
    global d
    global tflag
    if a+b>c:
        t+=1
        if a**2+b**2==c**2:
            ch+=1
        elif a**2+b**2>c**2:
            e+=1
        elif a**2+b**2<c**2:
            d+=1
    else:
        tflag=0

i=0
for i in range(len(lista)):
    if len(lista)==i:
        break
    x=sorted(lista[i])
    func01(x[0],x[1],x[2])
    if tflag==0:
        break
    i+=1
print(t,ch,e,d)

tri = {} # 1: normal, chokkaku, eikaku donkaku
for i in range(4) :
    tri[i + 1] = 0

while(True) :
    l = sorted(map(int, input().split()), reverse=True)
    a, b, c = l[0], l[1], l[2]

    if a >= b + c :
        break
    else :
        if b ** 2 + c ** 2 == a ** 2:
            tri[1] += 1
        elif b ** 2 + c ** 2 > a ** 2:
            tri[2] += 1
        else :
            tri[3] += 1

print(sum(tri.values()), tri[1], tri[2], tri[3])

問題1

　三角形の形は辺の長さで決まる．
順番に３つの正整数が与えられたとき，
辺の長さがそれらの値と一致する三角形が存在するかどうかを調べ，
存在するなら鋭角三角形，直角三角形，鈍角三角形のいずれかを判定し，
次の入力へ進む．
三角形が存在しないとき，
それまでに入力された，三角形，直角三角形，鋭角三角形，鈍角三角形の
個数を空白で区切って出力し，
それ以降の入力は無視して終了する．
入力の中には必ず三角形が存在しないようなものがある
と仮定してよい.
入力の行数は判らないが各行には３つの正整数が空白で区切って書かれている．
ただし，各整数は100 以下とする.

出力ファイルにおいては，
出力の最後の行にも改行コードを入れること．

入出力例

入力例１

3 4 5
2 1 2
6 3 4
1 1 1
1 2 3

<h3出力例１

4 1 2 1

入力例２

3 4 5
2 1 2
6 3 4
1 2 3
1 1 1

出力例２

3 1 1 1

問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。


lista=[]
t=0
ch=0
e=0
d=0
while True:
    try:
        lista.append(list(map(int,input().split())))
    except:
        break;

def func01(a,b,c):
    global t
    global ch
    global e
    global d
    if a+b>c:
        t+=1
        if a**2+b**2==c**2:
            ch+=1
        elif a**2+b**2>c**2:
            e+=1
        elif a**2+b**2<c**2:
            d+=1
for i in range(len(lista)):
    x=sorted(lista[i])
    func01(x[0],x[1],x[2])
print(t,ch,e,d)


'''
  2xy + x + y = z
  (2x + 1) (2y + 1) = 2z + 1
  x' * y' = z'
  check z' for prime number.
'''

prime = dict()
prime_nums = list()

MAXIMUM = 2**16
def get_prime():
    for i in range(2, MAXIMUM):
        if prime.get(i, True):
            prime_nums.append(i)
            for j in range(i * 2, MAXIMUM, i):
                prime[j] = False

def check(x):
    x = 2*x + 1
    for prime in prime_nums:
        if prime **2 > x:
            break
        if x % prime == 0:
            return False
    return True

get_prime()
n = int(input())
count = 0
for _ in range(n):
    if check(int(input())):
        count += 1
print(count)

a=0
for _ in range(int(input())):
    n=int(input())
    for i in range(1,int(n**0.5)+1):
        if (n-i)%(2*i+1)==0:break
    else:a+=1
print(a)

問題 4

　IOI 不動産ではマンションの賃貸を行なっている．
この会社が取り扱うマンションの部屋は 1LDK で，
下図のように面積が 2xy+x+y になっている．
ただし， x, y は正整数である．

　IOI 不動産のカタログにはマンションの面積が昇順に（狭いものから順番に）書かれているが，この中にいくつか間違い（ありえない面積のもの）が混じっていることがわかった．

　カタログ（入力ファイル）は N+1 行で，最初の行に部屋数が書かれていて，
続く N 行に，１行に１部屋ずつ面積が昇順に書かれている．
ただし，
部屋数は 100,000 以下，
面積は (2の31乗)-1 = 2,147,483,647 以下である．
５つの入力データのうち３つまでは，
部屋数 1000 以下，面積 30000 以下である．

　間違っている行数（ありえない部屋の数）を出力しなさい．

　出力ファイルにおいては，
出力の最後の行にも改行コードを入れること．

入出力例

入力例

10
4
7
9
10
12
13
16
17
19
20

出力例

2

問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。


while True:
    try:
        n, r = map(int, input().split())
        cc = list(map(int, input().split()))
        card = [v for v in range(n)]
        for c in cc:
            A, B, C = card[n//2:], card[:n//2], []
            while len(A) or len(B):
                C += A[:c]
                del A[:c]
                C += B[:c]
                del B[:c]
            card = C
        print(C[-1])
    except: break

import sys
lines=[]
for line in sys.stdin:
    line= line.rstrip()
    lines.append(line)

for i in range(len(lines)//2):
    N,R=map(int,lines[2*i].split())
    ops=list(map(int,lines[2*i+1].split()))
    cards=[i for i in range(N)]
    for c in ops:
        deck_a=cards[N//2:N]
        deck_b=cards[0:N//2]
        deck_c=cards[0:0]
        while len(deck_a)>0 or len(deck_b)>0:
            d=deck_a[0:c]
            deck_a=deck_a[c:]
            deck_c+=d

            d=deck_b[0:c]
            deck_b=deck_b[c:]
            deck_c+=d
        cards=deck_c
    print(cards[-1])

Problem I: Riffle Shuffle

 There are a number of ways to shuffle a deck of cards.  Riffle shuffle is one such example.  The following is how to perform riffle shuffle.

  There is a deck of n cards.  First, we divide it into two decks; deck A which consists of the top half of it and deck B of the bottom half.  Deck A will have one more card when n is odd.

  Next, c cards are pulled from bottom of deck A and are stacked on deck C, which is empty initially.  Then c cards are pulled from bottom of deck B and stacked on deck C, likewise.  This operation is repeated until deck A and B become empty.  When the number of cards of deck A(B) is less than c, all cards are pulled.
  Finally we obtain shuffled deck C.  See an example below:

  - A single riffle operation where n = 9, c = 3

    for given deck [0 1 2 3 4 5 6 7 8]  (right is top)

    - Step 0
    deck A [4 5 6 7 8]
    deck B [0 1 2 3]
    deck C []

    - Step 1
    deck A [7 8]
    deck B [0 1 2 3]
    deck C [4 5 6]

    - Step 2
    deck A [7 8]
    deck B [3]
    deck C [4 5 6 0 1 2]

    - Step 3
    deck A []
    deck B [3]
    deck C [4 5 6 0 1 2 7 8]

    - Step 4
    deck A []
    deck B []
    deck C [4 5 6 0 1 2 7 8 3]

    shuffled deck [4 5 6 0 1 2 7 8 3]

  This operation, called riffle operation, is repeated several times.

  Write a program that simulates Riffle shuffle and answer which card will be finally placed on the top of the deck.

Input

 The input consists of multiple data sets. Each data set starts with a line containing two positive integers n(1 ≤ n ≤ 50) and r(1 ≤ r ≤ 50); n and r are the number of cards in the deck and the number of riffle operations, respectively.

  r more positive integers follow, each of which represents a riffle operation. These riffle operations are performed in the listed order.  Each integer represents c, which is explained above.

  The end of the input is indicated by EOF. The number of data sets is less than 100.

Output

 For each data set in the input, your program should print the number of the top card after the shuffle.  Assume that at the beginning the cards are numbered from 0 to n-1, from the bottom to the top.  Each number should be written in a sparate line without any superfluous characters such as leading or following spaces.

Sample Input

9 1
3
9 4
1 2 3 4

Output for the Sample Input

3
0


while True:
    try:
        n, r = map(int, input().split())
        c = list(map(int, input().split()))
        card = [v for v in range(n)]
        A, B, C = card[n//2:], card[:n//2], []
        for k, v in zip(c, range(r)):
            if v % 2 == 0:
                C += A[:k]
                del A[:k]
            else:
                C += B[:k]
                del B[:k]
    except: break


while True:
    n,r = map(int,input().split())
    if n==0 and r==0:
        break
    cut = [i for i in range(1,n+1)][::-1]
    for i in range(r):
        p,c = map(int,input().split())
        cut = cut[p-1:p+c-1] + cut[:p-1] + cut[p+c-1:]
    print(cut[0])

Problem A: Hanafuda Shuffle

There are a number of ways to shuffle a deck of cards.   Hanafuda
shuffling for Japanese card game 'Hanafuda' is one such example.
The following is how to perform Hanafuda shuffling.

There is a deck of n cards. Starting from the p-th card
from the top of the deck, c cards are pulled out
and put on the top of the deck, as shown in Figure 1.
This operation, called a cutting operation, is repeated.

Write a program that simulates Hanafuda shuffling and answers which
card will be finally placed on the top of the deck.

  Figure 1: Cutting operation

Input

The input consists of multiple data sets.
Each data set starts with a line containing two positive integers n
(1 <= n <= 50) and r (1 <= r <= 50); n and
 r are the number of cards in the deck and the number of cutting
operations, respectively.

 There are r more lines in the data set, each of which
 represents a cutting operation. These cutting operations
are performed in the listed order.
Each line contains two positive integers p and c
(p + c <= n + 1).
Starting from the p-th card from the top of the deck, c
cards should be pulled out and put on the top.

The end of the input is indicated by a line which contains two zeros.

Each input line contains exactly two integers separated by a space
character.
There are no other characters in the line.

Output

For each data set in the input, your program
should write the number of the top card after the shuffle.
Assume that at the beginning the cards
are numbered from 1 to n, from the bottom to the top.
Each number should be written in a separate line
without any superfluous characters such as leading or following spaces.

Sample Input

5 2
3 1
3 1
10 3
1 10
10 1
8 3
0 0

Output for the Sample Input

4
4


while True:
	n, r = map(int, input().split())
	if (n, r) == (0, 0):
		break
	cards = list(range(1, n+1))[::-1]
	print(cards)

	for i in range(r):
		p, c = map(int, input().split())
		cards = cards[p-1:p-1+c] + cards[:p-1] + cards[p-1+c:]
	print(cards[0])