s_id stringlengths 10 10 | p_id stringlengths 6 6 | u_id stringlengths 10 10 | date stringlengths 10 10 | language stringclasses 1 value | original_language stringclasses 11 values | filename_ext stringclasses 1 value | status stringclasses 1 value | cpu_time int64 0 100 | memory stringlengths 4 6 | code_size int64 15 14.7k | code stringlengths 15 14.7k | problem_id stringlengths 6 6 | problem_description stringlengths 358 9.83k | input stringlengths 2 4.87k | output stringclasses 807 values | __index_level_0__ int64 1.1k 1.22M |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
s514005898 | p00033 | u150984829 | 1517972700 | Python | Python3 | py | Accepted | 20 | 5592 | 141 | for _ in[0]*int(input()):
b=c=0
for e in map(int,input().split()):
if e>b:b=e
elif e>c:c=e
else:print('NO');break
else:print('YES')
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,102 |
s245535669 | p00033 | u150984829 | 1517972800 | Python | Python3 | py | Accepted | 20 | 5592 | 134 | for _ in[0]*int(input()):
b=c=f=0
for e in map(int,input().split()):
if e>b:b=e
elif e>c:c=e
else:f=1
print(['YES','NO'][f])
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,103 |
s113656054 | p00033 | u299798926 | 1518180372 | Python | Python3 | py | Accepted | 20 | 5596 | 319 | n = int(input())
for _ in range(n):
data = list(map(int, input().split()))
B, C = 0, 0
flag = True
for d in data:
if B < d:
B = d
elif C < d:
C = d
else:
print("NO")
flag = False
break
if flag:
print("YES")
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,104 |
s515754927 | p00033 | u299798926 | 1518180689 | Python | Python3 | py | Accepted | 20 | 5592 | 212 | x=int(input())
for _ in range(x):
num=list(map(int,input().split()))
b,c=0,0
flag=True
for i in num:
if b<i:
b=i
elif c<i:
c=i
else:
print("NO")
flag=False
break
if flag:
print("YES")
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,105 |
s056017488 | p00033 | u553148578 | 1523867327 | Python | Python3 | py | Accepted | 20 | 5588 | 178 | for i in range(int(input())):
a=b=c=0
for j in map(int,input().split()):
if j > b:
b=j
elif j > c:
c=j
else:
a=1
if a==0:
print('YES')
else:
print('NO')
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,106 |
s798137394 | p00033 | u434470018 | 1524819174 | Python | Python | py | Accepted | 10 | 4660 | 513 | def solution():
n = input()
data = []
for _ in range(n):
data.append([int(val) for val in raw_input().split()])
for i in range(n):
ans = True
l = 0
r = 0
for j in range(10):
if data[i][j] > l:
l = data[i][j]
elif data[i][j] > r:
r = data[i][j]
else:
ans = False
break
if ans:
print 'YES'
else:
print 'NO'
solution()
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,107 |
s037733786 | p00033 | u306037418 | 1525947693 | Python | Python3 | py | Accepted | 50 | 5600 | 492 | n = int(input())
def bi(ball, i, x, y):
# print(i, len(x), len(y))
if i != 10:
x2, y2 = x + [ball[i]], y + [ball[i]]
bi(ball, i + 1, x2, y)
bi(ball, i + 1, x, y2)
else:
nx = x[:]
ny = y[:]
x.sort(), y.sort()
if nx == x and ny == y:
global ans
ans = 'YES'
# print(nx, ny)
for i in range(n):
ans = 'NO'
ball = list(map(int, input().split()))
bi(ball, 0, [], [])
print(ans)
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,108 |
s976774013 | p00033 | u136916346 | 1527414321 | Python | Python3 | py | Accepted | 20 | 5600 | 368 | def bl(l):
b=[]
c=[]
for (i,j) in enumerate(l):
if(i==0):b.extend([j])
elif(j>b[-1]):b.extend([j])
elif(c and j>c[-1] and j<b[-1]):c.extend([j])
elif(not c):c.extend([j])
else:return 0
return 1
l=[list(map(int,input().split())) for i in range(int(input()))]
[print("YES") if bl(i) else print("NO") for i in l]
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,109 |
s316937564 | p00033 | u352394527 | 1527484243 | Python | Python3 | py | Accepted | 20 | 5588 | 600 | #数列に対しy/nの判定をする
def solve(balls):
#B, Cの一番上の数(ただし常にB <= Cを保つ)
last_b = last_c = 0
while balls:
new = balls.pop(0)
#new <= last_b <= last_c --> 不可能
if new <= last_b:
print("NO")
return
#last_b < new <= last_c --> Bを更新
elif new <= last_c:
last_b = new
#last_b < last_c < new --> Cを更新
else:
last_c = new
print("YES")
return
def main():
n = int(input())
for _ in range(n):
balls = list(map(int, input().split()))
solve(balls)
main()
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,110 |
s253314556 | p00033 | u847467233 | 1529128497 | Python | Python3 | py | Accepted | 20 | 5596 | 261 | # AOJ 0033 Ball
# Python3 2018.6.16 bal4u
n = int(input())
for i in range(n):
a = list(map(int, input().split()))
b = c = 0
yes = True
for j in range(10):
if a[j] > b: b = a[j]
elif a[j] > c: c = a[j]
else: yes = False
print('YES' if yes else 'NO')
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,111 |
s238246428 | p00033 | u011621222 | 1530002403 | Python | Python3 | py | Accepted | 30 | 5608 | 531 | def int_input():
return list(map(int, input().split()))
def is_sorted(l):
return all(l[i] <= l[i + 1] for i in range(len(l) - 1))
def dfs(arr, i, a, b):
if i == 10:
return is_sorted(a) and is_sorted(b)
na = a + [arr[i]]
nb = b + [arr[i]]
return any([
dfs(arr, i + 1, na, b) if is_sorted(na) else False,
dfs(arr, i + 1, a, nb) if is_sorted(nb) else False])
n = int(input())
for _ in range(n):
raw = int_input()
print("YES" if dfs(raw, 0, list(), list()) else "NO")
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,112 |
s701346601 | p00033 | u019169314 | 1530683345 | Python | Python3 | py | Accepted | 20 | 5588 | 422 | n = int(input())
for i in range(n):
b = list()
c = list()
a = list(map(int, input().split()))
# print(a)
b.append(a.pop(0))
for _ in range(9):
a0 = a.pop(0)
if b[-1] < a0:
b.append(a0)
elif len(c)==0 or c[-1]<a0:
c.append(a0)
else:
a.append(a0)
print('NO')
break
if len(a)==0:
print('YES')
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,113 |
s601391745 | p00033 | u647766105 | 1355760877 | Python | Python | py | Accepted | 10 | 5736 | 322 | for i in xrange(input()):
head1,head2=0,0
frag=True
for a in map(int,raw_input().split()):
if head1>a and head2>a:
frag=False
break
if head1<a and head1 > head2 or head2>a:
head1=a
else:
head2=a
if frag:print "YES"
else:print "NO" | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,114 |
s377682948 | p00033 | u419407022 | 1356287943 | Python | Python | py | Accepted | 10 | 4244 | 476 | def dfs(al,bl,cl):
if(len(al) == 0):
return True
else:
if(al[0] > bl[-1]):
b = dfs(al[1:], bl+al[0:1], cl)
if(b):
return True
if(al[0] > cl[-1]):
b = dfs(al[1:], bl, cl+al[0:1])
if(b):
return True
return False
for i in xrange(int(raw_input())):
if(dfs([int(j) for j in raw_input().split()],[-1],[-1])):
print 'YES'
else:
print 'NO' | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,115 |
s665827933 | p00033 | u865312527 | 1359541175 | Python | Python | py | Accepted | 10 | 4232 | 483 | def solve(balls):
B,C=[],[]
B.append(balls[0])
for ball in balls[1:]:
if B[-1]<ball:
B.append(ball)
else:
if len(C)==0: C.append(ball)
else:
if C[-1]<ball:
C.append(ball)
else:
return "NO"
return "YES"
if __name__=='__main__':
N=int(raw_input())
for i in range(N):
balls=map(int,raw_input().split())
print solve(balls) | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,116 |
s094278202 | p00033 | u865312527 | 1359541352 | Python | Python | py | Accepted | 10 | 4228 | 366 | def solve(balls):
B,C=balls[0],0
for ball in balls[1:]:
if B<ball:
B=ball
else:
if C<ball:
C=ball
else:
return "NO"
return "YES"
if __name__=='__main__':
N=int(raw_input())
for i in range(N):
balls=map(int,raw_input().split())
print solve(balls) | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,117 |
s608889715 | p00033 | u782850731 | 1362324057 | Python | Python | py | Accepted | 10 | 4244 | 461 | from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
for _ in xrange(int(stdin.readline())):
result = 'YES'
b = c = 0
for a in (int(s) for s in stdin.readline().split()):
if b < a:
b = a
elif c < a:
c = a
if b < c:
b, c = c, b
else:
result = 'NO'
break
print(result) | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,118 |
s814705661 | p00033 | u282635979 | 1363800798 | Python | Python | py | Accepted | 10 | 4252 | 328 | N = input() + 1
for val in range(1,N):
c = 0
x = map(int,raw_input().split(' '))
a = x[0]
b = 0
for n in range(1,10):
if b > a:
e = a
d = b
a = d
b = e
else:
pass
if a < x[n]:
a = x[n]
elif a > x[n] and b < x[n]:
b = x[n]
elif x[n] < b:
c += 1
if c == 0:
print 'YES'
else:
print 'NO' | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,119 |
s314796218 | p00033 | u542421762 | 1368281725 | Python | Python | py | Accepted | 10 | 4244 | 535 |
import sys
def fill_balls(a):
b = [0]
c = [0]
for ball in a:
if b[-1] == 0:
b.append(ball)
elif b[-1] < ball and c[-1] < ball:
if b[-1] < c[-1]:
c.append(ball)
else:
b.append(ball)
elif b[-1] < ball:
b.append(ball)
elif c[-1] < ball:
c.append(ball)
else:
return 'NO'
return 'YES'
for i in range(input()):
a = map(int, raw_input().split(' '))
print fill_balls(a) | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,120 |
s151521743 | p00033 | u147801965 | 1375079750 | Python | Python | py | Accepted | 10 | 4248 | 435 | for i in range(input()):
q,w=[0],[0]
flag=0
_L=map(int,raw_input().split())
q.append(_L[0])
for j in _L[1:]:
if q[-1] > w[-1]:
if q[-1] < j: q.append(j)
elif w[-1] < j: w.append(j)
else:
flag=1
break
if q[-1] < w[-1]:
if w[-1] < j: w.append(j)
elif q[-1] < j: q.append(j)
else:
flag=1
break
print "YES" if flag==0 else "NO" | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,121 |
s516488163 | p00033 | u813384600 | 1380552632 | Python | Python | py | Accepted | 20 | 4224 | 289 | def f(ball):
b, c = 0, 0
for a in ball:
if a > b:
b = a
elif a > c:
c = a
else:
return False
return True
n = int(raw_input())
for i in range(n):
a = map(int, raw_input().split())
print 'YES' if f(a) else 'NO' | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,122 |
s528203069 | p00033 | u912237403 | 1382276341 | Python | Python | py | Accepted | 20 | 4200 | 231 | n=input()
for i in range(n):
dt=map(int, raw_input().split())
a1=0
a2=0
for e in dt:
if e>a1: a1=e
elif e>a2: a2=e
else:
print "NO"
break
else:
print "YES" | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,123 |
s192314905 | p00033 | u912237403 | 1382276913 | Python | Python | py | Accepted | 10 | 4204 | 236 | def f(x):
a,b=0,0
for e in x:
if e>a: a=e
elif e>b: b=e
else: return False
return True
n=input()
for i in range(n):
dt=map(int, raw_input().split())
if f(dt): print "YES"
else: print "NO" | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,124 |
s771684192 | p00033 | u912237403 | 1382277190 | Python | Python | py | Accepted | 10 | 4208 | 224 | def f(x):
a,b=0,0
for e in x:
if e>a: a=e
elif e>b: b=e
else: return False
return True
n=input()
for i in range(n):
dt=map(int, raw_input().split())
print "YES" if f(dt) else "NO" | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,125 |
s084116988 | p00033 | u523886269 | 1382450652 | Python | Python | py | Accepted | 40 | 4476 | 1,219 | # -*- coding: utf-8 -*-
def check_one(balls, partition):
l_head = 0
r_head = 0
for i in xrange(10):
ball = balls[i]
# 左に入る場合
if partition[i] == 1:
if l_head > ball:
# NG
return False
else:
# OK
l_head = ball
# 右に入る場合
else:
if r_head > ball:
# NG
return False
else:
# OK
r_head = ball
# 最後まで return False しなかった
return True
def generate_partitions():
total = []
for i in xrange(2**10):
bin = [0] * 10
for b in xrange(10):
bin[b] = i >> b & 1
total.append(bin)
return total
def check_total(balls, total):
for p in total:
if check_one(balls, p):
return True
return False
def main():
num_data_set = int(raw_input())
for i in xrange(num_data_set):
balls = map(int, raw_input().strip().split())
total = generate_partitions()
if check_total(balls, total):
print 'YES'
else:
print 'NO'
main() | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,126 |
s452788946 | p00033 | u633068244 | 1393407440 | Python | Python | py | Accepted | 10 | 4228 | 425 | n = int(raw_input())
for i in range(n):
ball = map(int, raw_input().split())
a = [ball[0]]
b = []
flag = 0
for j in range(1,10):
if ball[j] > a[len(a)-1]:
a.append(ball[j])
else:
b.append(ball[j])
if len(b) > 1 and b[len(b)-2] > b[len(b)-1]:
print "NO"
flag = 1
break
if flag == 0:
print "YES" | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,127 |
s059412911 | p00033 | u633068244 | 1393577367 | Python | Python | py | Accepted | 10 | 4204 | 313 | def check(x):
a, b = 0, 0
for ball in x:
if a < ball:
a = ball
elif b < ball:
b = ball
else:
return False
return True
n = int(raw_input())
for i in range(n):
all = map(int, raw_input().split())
print "YES" if check(all) else "NO" | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,128 |
s132231767 | p00033 | u633068244 | 1393577650 | Python | Python | py | Accepted | 10 | 4204 | 291 | def d(x):
b, c = 0, 0
for a in x:
if b < a:
b = a
elif c < a:
c = a
else:
return False
return True
n = int(raw_input())
for i in range(n):
all = map(int, raw_input().split())
print "YES" if d(all) else "NO" | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,129 |
s866967751 | p00033 | u912237403 | 1394323659 | Python | Python | py | Accepted | 20 | 4212 | 212 | def f(x):
a,b=0,0
for e in x:
if e>a: a=e
elif e>b: b=e
else: return 0
return 1
n=input()
for i in range(n):
D = map(int, raw_input().split())
print ["NO","YES"][f(D)] | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,130 |
s982733111 | p00033 | u912237403 | 1394323687 | Python | Python | py | Accepted | 10 | 4212 | 222 | def f(x):
a,b=0,0
for e in x:
if e>a: a=e
elif e>b: b=e
else: return 0
return 1
n=input()
for i in range(n):
D = map(int, raw_input().split())
s = ["NO","YES"][f(D)]
print s | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,131 |
s481952254 | p00033 | u193025715 | 1396094133 | Python | Python | py | Accepted | 10 | 4248 | 508 | for i in range(input()):
balls = map(int, raw_input().split())
a = [balls.pop(0)]
b = [0]
flag = 0
while len(balls) > 0:
gapa = balls[0] - a[-1]
gapb = balls[0] - b[-1]
if gapa < gapb:
if gapa > 0:
a.append(balls.pop(0))
elif gapb > 0:
b.append(balls.pop(0))
else:
flag = 1
elif gapb < gapa:
if gapb > 0:
b.append(balls.pop(0))
elif gapa > 0:
a.append(balls.pop(0))
else:
flag = 1
if flag == 1:
print "NO"
break
if len(balls) == 0: print "YES" | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,132 |
s962228573 | p00033 | u491763171 | 1396404751 | Python | Python | py | Accepted | 20 | 4208 | 301 | for i in range(input()):
L = map(int, raw_input().split())
L1, L2 = [], []
for x in L:
if not L1 or L1[-1] < x:
L1.append(x)
elif not L2 or L2[-1] < x:
L2.append(x)
else:
print "NO"
break
else:
print "YES" | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,133 |
s483464286 | p00033 | u246033265 | 1396624176 | Python | Python | py | Accepted | 20 | 4208 | 295 | def f(b):
a = [0, 0]
for p in b:
if p > a[1]:
a[1] = p
elif p > a[0]:
a[0] = p
else:
return False
a.sort()
return True
for i in range(int(raw_input())):
print 'YES' if f(map(int, raw_input().split())) else 'NO' | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,134 |
s420909763 | p00033 | u063091489 | 1399647506 | Python | Python | py | Accepted | 20 | 4232 | 519 |
N = int(raw_input())
for c in range(N):
B = [0]
C = [0]
def dfs(depth):
if depth == 10:
return True
res = False
if B[-1] < A[depth]:
B.append(A[depth])
res |= dfs(depth+1)
del B[-1]
if C[-1] < A[depth]:
C.append(A[depth])
res |= dfs(depth+1)
del C[-1]
return res
A = map(int, raw_input().split(" "))
print "YES" if dfs(0) else "NO"
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,135 |
s878795451 | p00033 | u063091489 | 1399648149 | Python | Python | py | Accepted | 10 | 4220 | 346 | N = int(raw_input())
def dfs(depth, l, r):
if depth == 10:
return True
res = False
if l < A[depth]:
res |= dfs(depth+1, A[depth], r)
if r < A[depth]:
res |= dfs(depth+1, l, A[depth])
return res
for c in range(N):
A = map(int, raw_input().split(" "))
print "YES" if dfs(0, 0, 0) else "NO"
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,136 |
s504759578 | p00033 | u708217907 | 1400404335 | Python | Python | py | Accepted | 10 | 4224 | 366 | n = int(raw_input())
for i in range(n):
left, right = [], []
arr = map(int, raw_input().split(' '))
for a in arr:
if len(left) == 0 or left[len(left)-1] < a:
left.append(a)
elif len(right) == 0 or right[len(right)-1] < a:
right.append(a)
else:
break
if len(arr) == len(left) + len(right):
print 'YES'
else:
print 'NO' | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,137 |
s670019036 | p00033 | u436634575 | 1401171785 | Python | Python3 | py | Accepted | 30 | 6720 | 483 | def check(a):
b = [a[0]]
c = [0]
for i in range(1, len(a)):
x = a[i]
if x < b[-1] and x < c[-1]:
return False
elif b[-1] < x < c[-1]:
b.append(x)
elif c[-1] < x < b[-1]:
c.append(x)
elif b[-1] > c[-1]:
b.append(x)
else:
c.append(x)
return True
n = int(input())
for i in range(n):
a = list(map(int, input().split()))
print('YES' if check(a) else 'NO') | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,138 |
s864606439 | p00033 | u593595530 | 1597670228 | Python | Python3 | py | Accepted | 20 | 5592 | 474 | n = int(input())
for i in range(n):
a = list(map(int, input().split()))
b = 0
c = 0
for j in range(10):
if a[j] > b:
if a[j] > c:
if a[j] - b < a[j] - c:
b = a[j]
else:
c = a[j]
else:
b = a[j]
elif a[j] > c:
c = a[j]
else:
print("NO")
break
if j == 9:
print("YES")
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,139 |
s805874996 | p00033 | u617272666 | 1597509224 | Python | Python3 | py | Accepted | 20 | 5600 | 733 | N = int(input())
for i in range(N):
tmp = [int(x) for x in input().split()]
B = 0
C = 0
flg = 0
for i in tmp:
if B >= C:
if B < i :
B = i
continue
else:
if C < i :
C = i
continue
else:
flg = 1
break
else:
if C < i :
C = i
continue
else:
if B < i :
C = i
continue
else:
flg = 1
break
if flg != 1:
print("YES")
else:
print("NO")
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,140 |
s747448527 | p00033 | u747915832 | 1597148043 | Python | Python3 | py | Accepted | 30 | 5588 | 283 | N = int(input())
for i in range(N):
Ball = list(map(int, input().split()))
B = 0
C = 0
x = 'YES'
for j in range(10):
if B < Ball[j]:
B = Ball[j]
elif C < Ball[j]:
C = Ball[j]
else:
x = 'NO'
print(x)
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,141 |
s521343990 | p00033 | u290304811 | 1596191519 | Python | Python3 | py | Accepted | 20 | 5596 | 285 |
n = int(input())
for i in range(n):
tmp = list(map(int,input().split()))
a,b,cnt = 0,0,0
for j in range(10):
if a<tmp[j]: a = tmp[j]
elif b<tmp[j]: b = tmp[j]
else: cnt += 1
if cnt==0: print("YES")
else: print("NO")
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,142 |
s151340105 | p00033 | u838993229 | 1595851145 | Python | Python3 | py | Accepted | 20 | 5588 | 259 | N = int(input())
for i in range(N):
B = C = 0
yes = True
a = list(map(int,input().split()))
for j in range(10):
if a[j] > B:
B = a[j]
elif a[j] > C:
C = a[j]
else:
yes = False
print("YES" if yes else "NO")
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,143 |
s699130636 | p00033 | u956438347 | 1595849701 | Python | Python3 | py | Accepted | 20 | 5596 | 262 | # AOJ 0033 Ball
# Python3 2018.6.16 bal4u
n = int(input())
for i in range(n):
a = list(map(int, input().split()))
b = c = 0
yes = True
for j in range(10):
if a[j] > b: b = a[j]
elif a[j] > c: c = a[j]
else: yes = False
print('YES' if yes else 'NO')
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,144 |
s083132304 | p00033 | u511292942 | 1595830041 | Python | Python3 | py | Accepted | 20 | 5596 | 276 | n = int(input())
for l in range(n):
a = [int(i) for i in input().split()]
b = 0
c = 0
ans = "YES"
for i in range(10):
if a[i] > b:
b= a[i]
elif a[i] > c:
c = a[i]
else:
ans = "NO"
print(ans)
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,145 |
s789859758 | p00033 | u187074069 | 1595465123 | Python | Python3 | py | Accepted | 30 | 5592 | 316 | N = int(input())
for i in range(N):
lst = list(map(int, input().split()))
B = 0
C = 0
r = 0
for j in lst:
if B < j:
B = j
elif C < j:
C = j
else:
r = 1
break
if r:
print('NO')
else:
print('YES')
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,146 |
s674581119 | p00033 | u817076074 | 1592402767 | Python | Python3 | py | Accepted | 20 | 5608 | 776 | import sys
sys.setrecursionlimit(10 ** 8)
def Z(): return int(input())
def ZZ(): return [int(_) for _ in input().split()]
def main():
n = Z()
for _ in range(n):
A = ZZ()
done = [False] * 10
def dfs(i, a):
if done[i]:
if i+1 < 10: dfs(i+1, a)
else: return
else:
if a < A[i]:
done[i] = True
if i+1 < 10: dfs(i+1, A[i])
else:
if i+1 < 10: dfs(i+1, a)
cc = 0
for i in range(10):
if done[i]: continue
cc += 1
done[i] = True
dfs(i, A[i])
print('YES' if cc <= 2 else 'NO')
return
if __name__ == '__main__':
main()
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,147 |
s622556242 | p00033 | u322428339 | 1589616497 | Python | Python3 | py | Accepted | 20 | 5592 | 843 |
N = int(input())
for i in range(N):
x = input()
y = x.split(' ')
a = []
b = []
text='YES'
for j in range(10):
number = int(y[j])
aNum = 0
bNum = 0
if a != [] :
aNum = a[-1]
if b != [] :
bNum = b[-1]
if(aNum > bNum):
if(aNum < number):
a.append(number)
else:
if(bNum < number):
b.append(number)
else:
text = 'NO'
break
else:
if(bNum < number):
b.append(number)
else:
if(aNum < number):
a.append(number)
else:
text = 'NO'
break
# print(a)
# print(b)
print(text)
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,148 |
s641946763 | p00033 | u260980560 | 1589611601 | Python | Python3 | py | Accepted | 30 | 5632 | 606 | from itertools import product
import sys
readline = sys.stdin.readline
write = sys.stdout.write
def solve():
*B, = map(int, readline().split())
N = 10
for p in product([0, 1], repeat = N):
p1 = p2 = 0
ok = 1
for b, e in zip(B, p):
if e:
if not p1 < b:
break
p1 = b
else:
if not p2 < b:
break
p2 = b
else:
write("YES\n")
break
else:
write("NO\n")
T = int(readline())
for i in range(T):
solve()
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,149 |
s205701317 | p00033 | u630911389 | 1588128062 | Python | Python3 | py | Accepted | 30 | 5600 | 522 | n = int(input())
for i in range(0,n):
a = b = 0
arr = list(int(x) for x in input().split())
ans = "YES"
for j in range(0,10):
if arr[j] < a and arr[j] < b:
ans = "NO"
break
else:
if a > b:
if a < arr[j]:
a = arr[j]
else :
b = arr[j]
else:
if b < arr[j]:
b = arr[j]
else:
a = arr[j];
print(ans)
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,150 |
s650839909 | p00033 | u814278309 | 1588071499 | Python | Python3 | py | Accepted | 20 | 5596 | 262 | n = int(input())
for i in range(n):
a = list(map(int,input().split()))
b = 0
c = 0
x = 0
for j in range(10):
if b < a[j]:
b = a[j]
elif c < a[j]:
c = a[j]
else:
x += 1
if x == 0:
print("YES")
else:
print("NO")
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,151 |
s389917543 | p00033 | u110740299 | 1582125048 | Python | Python3 | py | Accepted | 60 | 5596 | 607 | def check(ary):
for i in range(1, len(ary)):
if ary[i] < ary[i - 1]:
return False
return True
def dfs(a, b, c, i):
if len(b) + len(c) == 10:
return check(b) and check(c)
added_b = b[:]
added_c = c[:]
added_b.append(a[i])
added_c.append(a[i])
return dfs(a, added_b, c, i + 1) or dfs(a, b, added_c, i + 1)
def main():
n = int(input())
for i in range(n):
datasets = [int(i) for i in input().split(' ')]
result = dfs(datasets, [], [], 0)
print('YES' if result else 'NO')
if __name__ == '__main__':
main()
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,152 |
s663547772 | p00033 | u041846875 | 1575603353 | Python | Python3 | py | Accepted | 20 | 5596 | 433 | n = int(input())
for j in range(n):
nums = list(map(int, input().split()))
b = [0]
c = []
ans = "YES"
for i in range(10):
if nums[i] > b[-1]:
b.append(nums[i])
else:
c.append(nums[i])
if len(c) > 1:
x = c[0]
for i in range(1, len(c)):
if x > c[i]:
ans = "NO"
else:
x = c[i]
print(ans)
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,153 |
s131130818 | p00033 | u053061421 | 1575549593 | Python | Python3 | py | Accepted | 20 | 5588 | 475 | n = int(input())
for i in range(n):
a = list(map(int, input().split()))
b = 0
c = 0
for j in range(10):
if a[j] > b:
if a[j] > c:
if a[j] - b < a[j] - c:
b = a[j]
else:
c = a[j]
else:
b = a[j]
elif a[j] > c:
c = a[j]
else:
print("NO")
break
if j == 9:
print("YES")
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,154 |
s547129956 | p00033 | u236679854 | 1575029405 | Python | Python3 | py | Accepted | 20 | 5588 | 309 | # AOJ 0033
N = int(input())
for i in range(N):
balls = list(map(int, input().split()))
b = 0
c = 0
for ball in balls:
if b < ball:
b = ball
elif c < ball:
c = ball
else:
print('NO')
break
else:
print('YES')
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,155 |
s972780767 | p00033 | u813197825 | 1572449214 | Python | Python3 | py | Accepted | 30 | 5600 | 401 | n = int(input())
for i in range(n):
B = 0
C = 0
A = [int(i) for i in input().split()]
ans = 'YES'
for v in A:
if B > v and C > v:
ans = 'NO'
break
elif B < v and C < v:
if B > C:
B = v
else:
C = v
elif B < v:
B = v
else:
C = v
print(ans)
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,156 |
s779315008 | p00033 | u606731189 | 1571301316 | Python | Python3 | py | Accepted | 20 | 5608 | 898 | n=int(input())
i=1
while i<=n:
ball=list(map(int,input().split()))
left=[0]
right=[0]
m=0
while True:
#終了条件
if m==10:
print("YES")
#print("left",left,"right",right)
break
#noの条件
if ball[m]<left[len(left)-1] and ball[m]<right[len(right)-1]:
print("NO")
#print("left",left,"right",right,"ball",ball[m])
break
#左側に入れるか右側に入れるかの条件
if ball[m]>left[len(left)-1] and ball[m]>right[len(right)-1]:
if left[len(left)-1]>right[len(right)-1]:
left.append(ball[m])
else:
right.append(ball[m])
elif ball[m]>left[len(left)-1]:
left.append(ball[m])
else:
right.append(ball[m])
m+=1
i+=1
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,157 |
s351068468 | p00033 | u625806423 | 1569031689 | Python | Python3 | py | Accepted | 20 | 5592 | 251 | n = int(input())
for _ in range(n):
a = list(map(int,input().split()))
b = 0
c = 0
for i in range(10):
if a[i] > b:
b = a[i]
elif a[i] > c:
c = a[i]
else:
print("NO")
break
if i == 9:
print("YES")
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,158 |
s479909844 | p00033 | u824708460 | 1566316161 | Python | Python3 | py | Accepted | 20 | 5592 | 307 | n = int(input())
for i in range(n):
l = list(map(int, input().split()))
b, c, flag = 0, 0, 0
for seq in l:
if seq > b:
b = seq
elif seq > c:
c = seq
else:
flag = 1
if flag == 0:
print("YES")
else:
print("NO")
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,159 |
s033358227 | p00033 | u072053884 | 1563367490 | Python | Python3 | py | Accepted | 20 | 5644 | 410 | def solve():
from sys import stdin
f_i = stdin
N = int(f_i.readline())
from itertools import combinations
ans = []
for m in (map(int, f_i.readline().split()) for i in range(N)):
for a, b, c in combinations(m, 3):
if a > b > c:
ans.append('NO')
break
else:
ans.append('YES')
print('\n'.join(ans))
solve()
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,160 |
s109428365 | p00033 | u595265835 | 1563261796 | Python | Python3 | py | Accepted | 20 | 5592 | 251 | n = int(input())
for i in range(n):
a = list(map(int, input().split()))
b = c = 0
yes = True
for j in range(10):
if a[j] > b: b = a[j]
elif a[j] > c: c = a[j]
else: yes = False
print('YES' if yes else 'NO')
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,161 |
s264116427 | p00033 | u264450287 | 1561960237 | Python | Python3 | py | Accepted | 20 | 5600 | 416 | N=int(input())
answer=[]
for i in range(N):
A=list(map(int,input().split()))
B=[-1 for i in range(10)]
C=[-1 for i in range(10)]
B[0]=A[0]
C[0]=0
for i in range(1,10):
if B[i-1]<A[i]:
B[i]=A[i]
C[i]=C[i-1]
elif C[i-1]<A[i]:
C[i]=A[i]
B[i]=B[i-1]
else:
answer.append("NO")
break
if i==9:
answer.append("YES")
for i in range(N):
print(answer[i])
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,162 |
s512510685 | p00033 | u548252256 | 1561467389 | Python | Python3 | py | Accepted | 20 | 5592 | 338 |
if __name__ == '__main__':
n = int(input())
for i in range(n):
A = list(map(int,input().split()))
tmp1 = [0]
tmp2 = [0]
Flg = True
for j in A:
if tmp1[-1] < j:
tmp1.append(j)
else:
if tmp2[-1] < j:
tmp2.append(j)
else:
Flg = False
break
if Flg:
print("YES")
else:
print("NO")
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,163 |
s798752940 | p00033 | u506537276 | 1560317054 | Python | Python3 | py | Accepted | 20 | 5592 | 533 | flag = False
def dfs(a, b, c, i):
if i == 10:
# print("OK")
global flag
flag = True
return
else:
if a[i] > b:
# print("b:",a[i], i)
dfs(a, a[i], c, i + 1)
else:
pass
if a[i] > c:
# print("c:", a[i], i)
dfs(a, b, a[i], i + 1)
else:
pass
if a[i] < b and a[i] < c:
return
n = int(input())
for i in range(n):
a = list(map(int, input().split()))
dfs(a, 0, 0, 0)
if flag == True:
print("YES")
else:
print("NO")
flag = False
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,164 |
s803720624 | p00033 | u406093358 | 1555547666 | Python | Python | py | Accepted | 0 | 4660 | 372 | N = int(raw_input())
for i in range(0, N):
ball = map(int, raw_input().split())
stack = [[1, ball[0], 0]]
flag = False
while stack != []:
now = stack.pop(-1)
if now[0] == 10:
flag = True
break
b = ball[now[0]]
if now[1] < b: stack.append([now[0]+1, b, now[2]])
if now[2] < b: stack.append([now[0]+1, now[1], b])
if flag: print 'YES'
else: print 'NO'
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,165 |
s673795987 | p00033 | u990228206 | 1553237482 | Python | Python3 | py | Accepted | 20 | 5596 | 284 | n=int(input())
for i in range(n):
ball=list(map(int,input().split()))
b=0
c=0
flag=0
for j in ball:
if b>j and c>j:
flag=1
break
elif b>j or j-c<j-b:
c=j
else:
b=j
print('YNEOS'[flag::2])
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,166 |
s575611110 | p00033 | u563075864 | 1543202647 | Python | Python3 | py | Accepted | 20 | 5600 | 481 | num = int(input())
for _ in range(num):
n = [int(i) for i in input().split()]
b = 0
able = 1
for j in range(10):
if j == 0:
a = n[0]
else:
if n[j] < a:
if n[j] < b:
print("NO")
able = 0
break
else:
b = n[j]
else:
a = n[j]
if able == 1:
print("YES")
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,167 |
s332488338 | p00033 | u067299340 | 1542354133 | Python | Python3 | py | Accepted | 20 | 5600 | 528 | def balling(balls, left, right):
if len(balls) == 0:
return True
elif balls[0] <= left and balls[0] <= right:
return False
else:
complete = False
if balls[0] > left:
complete = balling(balls[1:], balls[0], right)
if not complete and balls[0] > right:
complete = balling(balls[1:], left, balls[0])
return complete
for _ in range(int(input())):
balls = [int(x) for x in input().split()]
print("YES" if balling(balls, 0, 0) else "NO")
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,168 |
s031335431 | p00033 | u717526540 | 1541729193 | Python | Python3 | py | Accepted | 20 | 5592 | 479 | n = int(input())
for _ in range(n):
balllist = list(map(int, input().split()))
leftlist = []
rightlist = []
for i, ball in enumerate(balllist):
if i == 0:
leftlist.append(ball)
continue
if leftlist[-1] < ball:
leftlist.append(ball)
elif rightlist == [] or rightlist[-1] < ball:
rightlist.append(ball)
else:
print("NO")
break
else:
print("YES")
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,169 |
s748883149 | p00033 | u219940997 | 1538183802 | Python | Python3 | py | Accepted | 20 | 5600 | 312 | N = int(input())
for _ in range(N):
A = list(map(int, input().split()))
b, c = 0, 0
flag = True
for a in A:
if b < a:
b = a
elif c < a:
c = a
else:
print('NO')
flag = False
break
if flag:
print('YES')
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,170 |
s638656429 | p00033 | u101341113 | 1534567297 | Python | Python3 | py | Accepted | 30 | 5600 | 424 | n = int(input())
a = [[0 for i in range(10)] for j in range(n)]
for i in range(n):
a[i] = list(map(int, input().split()))
for i in range(n):
l = 0
r = 0
f = 1
for j in range(10):
if l>=r and l<a[i][j]:
l = a[i][j]
elif r<a[i][j]:
r = a[i][j]
else:
f = 0
break
if f == 1:
print("YES")
else:
print("NO")
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,171 |
s124949956 | p00033 | u632958781 | 1533619701 | Python | Python3 | py | Accepted | 20 | 5640 | 447 | import bisect
def LIS(seq):
r = [seq[0]]
for n in seq[1:]:
if n > r[-1]:
r.append(n)
else:
idx = bisect.bisect_left(r, n)
r[idx] = n
return r
N = int(input())
for _ in range(N):
seq = list(map(int, input().split()))
left = set(LIS(seq))
remain = [n for n in seq if n not in left]
right = LIS(remain)
print("YES" if len(left) + len(right) == len(seq) else "NO")
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,172 |
s868416697 | p00033 | u454636644 | 1525948704 | Python | Python3 | py | Accepted | 20 | 5596 | 384 | n = int(input())
for i in range(n):
balls = list(map(int, input().split()))
b, c = 0, 0
flag = 0
for ball in balls:
if b == 0:
b = ball
elif b < ball:
b = ball
elif c > ball:
flag = 1
break
else:
c = ball
if flag == 0:
print('YES')
else:
print("NO")
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,173 |
s572231537 | p00033 | u079141094 | 1517979156 | Python | Python3 | py | Accepted | 20 | 5596 | 453 | def solve():
N = int(input())
for _ in range(N):
balls = list(map(int, input().split()))
lefts, rights = [0], [0]
for ball in balls:
if lefts[-1] < ball:
lefts.append(ball)
elif rights[-1] < ball:
rights.append(ball)
else:
print('NO')
break
else:
print('YES')
if __name__ == "__main__":
solve()
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,174 |
s820880043 | p00034 | u471400255 | 1531029468 | Python | Python3 | py | Accepted | 20 | 5608 | 353 | import sys
for line in sys.stdin:
po = [int(i) for i in line.split(",")]
l = [0]
for i in range(10):
l.append(l[-1] + po[i])
v1,v2 = po[10:]
t = l[-1] / (v1+v2)
for i in range(10):
if l[i] < v1*t < l[i+1]:
print(i+1)
break
elif l[i] == v1*t:
print(i)
break
| p00034 |
<H1>鉄道路線</H1>
<p>
複線（上りと下りが別の線路になっていてどこででもすれ違える）の鉄道路線があります。この路線には終端駅を含めて11 の駅があり、それぞれの駅と駅の間は図で示す区間番号で呼ばれています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_railway">
</center>
<br/>
<p>
この路線の両方の終端駅から列車が同時に出発して、途中で停まらずに走ります。各区間の長さと2 本の列車の速度を読み込んで、それぞれの場合について列車がすれ違う区間の番号を出力するプログラムを作成してください。ただし、ちょうど駅のところですれ違う場合は、両側の区間番号のうち小さいほうの数字を出力します。また、列車の長さ、駅の長さは無視できるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられる。各データセットは以下のような形式で与えられる。
</p>
<pre>
<var>l<sub>1</sub></var>,<var>l<sub>2</sub></var>,<var>l<sub>3</sub></var>,<var>l<sub>4</sub></var>,<var>l<sub>5</sub></var>,<var>l<sub>6</sub></var>,<var>l<sub>7</sub></var>,<var>l<sub>8</sub></var>,<var>l<sub>9</sub></var>,<var>l<sub>10</sub></var>,<var>v<sub>1</sub></var>,<var>v<sub>2</sub></var>
</pre>
<p>
<var>l<sub>i</sub></var> (1 ≤ <var>l<sub>i</sub></var> ≤ 2,000) は区間 <var>i</var> の長さ(km)を表す整数である。<var>v<sub>1</sub></var> は区間 1 側の終端駅を出発した列車の速度(km/h)、<var>v<sub>2</sub></var> は区間 10 側の終端駅を出発した列車の速度(km/h)を表す整数である (1 ≤ <var>v<sub>1</sub></var>, <var>v<sub>2</sub></var> ≤ 2,000)。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>Output</H2>
<p>
データセットごとに、列車がすれちがう区間の番号を１行に出力する。
</p>
<H2>Sample Input</H2>
<pre>
1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
7
6
</pre>
| 1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
| 4
7
6
| 9,175 |
s605510422 | p00034 | u319725914 | 1534744626 | Python | Python3 | py | Accepted | 20 | 5644 | 277 | from sys import stdin
import bisect
while(True):
try:
*ls,v1,v2 = list(map(int,stdin.readline().split(",")))
rs = [sum(ls[:i+1]) for i in range(len(ls))]
idx = bisect.bisect_left(rs,rs[-1]*v1/(v1+v2))
print(idx+1)
except:
break
| p00034 |
<H1>鉄道路線</H1>
<p>
複線（上りと下りが別の線路になっていてどこででもすれ違える）の鉄道路線があります。この路線には終端駅を含めて11 の駅があり、それぞれの駅と駅の間は図で示す区間番号で呼ばれています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_railway">
</center>
<br/>
<p>
この路線の両方の終端駅から列車が同時に出発して、途中で停まらずに走ります。各区間の長さと2 本の列車の速度を読み込んで、それぞれの場合について列車がすれ違う区間の番号を出力するプログラムを作成してください。ただし、ちょうど駅のところですれ違う場合は、両側の区間番号のうち小さいほうの数字を出力します。また、列車の長さ、駅の長さは無視できるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられる。各データセットは以下のような形式で与えられる。
</p>
<pre>
<var>l<sub>1</sub></var>,<var>l<sub>2</sub></var>,<var>l<sub>3</sub></var>,<var>l<sub>4</sub></var>,<var>l<sub>5</sub></var>,<var>l<sub>6</sub></var>,<var>l<sub>7</sub></var>,<var>l<sub>8</sub></var>,<var>l<sub>9</sub></var>,<var>l<sub>10</sub></var>,<var>v<sub>1</sub></var>,<var>v<sub>2</sub></var>
</pre>
<p>
<var>l<sub>i</sub></var> (1 ≤ <var>l<sub>i</sub></var> ≤ 2,000) は区間 <var>i</var> の長さ(km)を表す整数である。<var>v<sub>1</sub></var> は区間 1 側の終端駅を出発した列車の速度(km/h)、<var>v<sub>2</sub></var> は区間 10 側の終端駅を出発した列車の速度(km/h)を表す整数である (1 ≤ <var>v<sub>1</sub></var>, <var>v<sub>2</sub></var> ≤ 2,000)。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>Output</H2>
<p>
データセットごとに、列車がすれちがう区間の番号を１行に出力する。
</p>
<H2>Sample Input</H2>
<pre>
1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
7
6
</pre>
| 1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
| 4
7
6
| 9,176 |
s813435049 | p00034 | u525366883 | 1535687927 | Python | Python | py | Accepted | 10 | 4652 | 296 | while True:
try:
l = map(int, raw_input().split(","))
v1 = l.pop(10)
v2 = l.pop(10)
p = v1*float(sum(l))/(v1+v2)
for i in range(10):
p -= l[i]
if p <= 0:
print i+1
break
except:
break
| p00034 |
<H1>鉄道路線</H1>
<p>
複線（上りと下りが別の線路になっていてどこででもすれ違える）の鉄道路線があります。この路線には終端駅を含めて11 の駅があり、それぞれの駅と駅の間は図で示す区間番号で呼ばれています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_railway">
</center>
<br/>
<p>
この路線の両方の終端駅から列車が同時に出発して、途中で停まらずに走ります。各区間の長さと2 本の列車の速度を読み込んで、それぞれの場合について列車がすれ違う区間の番号を出力するプログラムを作成してください。ただし、ちょうど駅のところですれ違う場合は、両側の区間番号のうち小さいほうの数字を出力します。また、列車の長さ、駅の長さは無視できるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられる。各データセットは以下のような形式で与えられる。
</p>
<pre>
<var>l<sub>1</sub></var>,<var>l<sub>2</sub></var>,<var>l<sub>3</sub></var>,<var>l<sub>4</sub></var>,<var>l<sub>5</sub></var>,<var>l<sub>6</sub></var>,<var>l<sub>7</sub></var>,<var>l<sub>8</sub></var>,<var>l<sub>9</sub></var>,<var>l<sub>10</sub></var>,<var>v<sub>1</sub></var>,<var>v<sub>2</sub></var>
</pre>
<p>
<var>l<sub>i</sub></var> (1 ≤ <var>l<sub>i</sub></var> ≤ 2,000) は区間 <var>i</var> の長さ(km)を表す整数である。<var>v<sub>1</sub></var> は区間 1 側の終端駅を出発した列車の速度(km/h)、<var>v<sub>2</sub></var> は区間 10 側の終端駅を出発した列車の速度(km/h)を表す整数である (1 ≤ <var>v<sub>1</sub></var>, <var>v<sub>2</sub></var> ≤ 2,000)。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>Output</H2>
<p>
データセットごとに、列車がすれちがう区間の番号を１行に出力する。
</p>
<H2>Sample Input</H2>
<pre>
1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
7
6
</pre>
| 1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
| 4
7
6
| 9,177 |
s631620990 | p00034 | u647694976 | 1556618345 | Python | Python3 | py | Accepted | 20 | 5600 | 448 | while True:
try:
l1,l2,l3,l4,l5,l6,l7,l8,l9,l10,v1,v2=map(int,input().split(","))
kyo=0
for i in l1,l2,l3,l4,l5,l6,l7,l8,l9,l10:
kyo +=i
v=v1+v2
x=kyo/v
ans=v1*x
flag=0
for j in l1,l2,l3,l4,l5,l6,l7,l8,l9,l10,0:
if ans>0:
ans -=j
flag +=1
else:
print(flag)
break
except:break
| p00034 |
<H1>鉄道路線</H1>
<p>
複線（上りと下りが別の線路になっていてどこででもすれ違える）の鉄道路線があります。この路線には終端駅を含めて11 の駅があり、それぞれの駅と駅の間は図で示す区間番号で呼ばれています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_railway">
</center>
<br/>
<p>
この路線の両方の終端駅から列車が同時に出発して、途中で停まらずに走ります。各区間の長さと2 本の列車の速度を読み込んで、それぞれの場合について列車がすれ違う区間の番号を出力するプログラムを作成してください。ただし、ちょうど駅のところですれ違う場合は、両側の区間番号のうち小さいほうの数字を出力します。また、列車の長さ、駅の長さは無視できるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられる。各データセットは以下のような形式で与えられる。
</p>
<pre>
<var>l<sub>1</sub></var>,<var>l<sub>2</sub></var>,<var>l<sub>3</sub></var>,<var>l<sub>4</sub></var>,<var>l<sub>5</sub></var>,<var>l<sub>6</sub></var>,<var>l<sub>7</sub></var>,<var>l<sub>8</sub></var>,<var>l<sub>9</sub></var>,<var>l<sub>10</sub></var>,<var>v<sub>1</sub></var>,<var>v<sub>2</sub></var>
</pre>
<p>
<var>l<sub>i</sub></var> (1 ≤ <var>l<sub>i</sub></var> ≤ 2,000) は区間 <var>i</var> の長さ(km)を表す整数である。<var>v<sub>1</sub></var> は区間 1 側の終端駅を出発した列車の速度(km/h)、<var>v<sub>2</sub></var> は区間 10 側の終端駅を出発した列車の速度(km/h)を表す整数である (1 ≤ <var>v<sub>1</sub></var>, <var>v<sub>2</sub></var> ≤ 2,000)。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>Output</H2>
<p>
データセットごとに、列車がすれちがう区間の番号を１行に出力する。
</p>
<H2>Sample Input</H2>
<pre>
1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
7
6
</pre>
| 1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
| 4
7
6
| 9,178 |
s162613450 | p00034 | u193025715 | 1408271275 | Python | Python3 | py | Accepted | 30 | 6736 | 298 | while True:
try:
n = list(map(int, input().split(',')))
v2, v1 = n.pop(), n.pop()
dist = sum(n) * (v1 / (v1 + v2))
total = 0
ans = 0
while total < dist:
total += n[ans]
ans += 1
print(ans)
except:
break | p00034 |
<H1>鉄道路線</H1>
<p>
複線（上りと下りが別の線路になっていてどこででもすれ違える）の鉄道路線があります。この路線には終端駅を含めて11 の駅があり、それぞれの駅と駅の間は図で示す区間番号で呼ばれています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_railway">
</center>
<br/>
<p>
この路線の両方の終端駅から列車が同時に出発して、途中で停まらずに走ります。各区間の長さと2 本の列車の速度を読み込んで、それぞれの場合について列車がすれ違う区間の番号を出力するプログラムを作成してください。ただし、ちょうど駅のところですれ違う場合は、両側の区間番号のうち小さいほうの数字を出力します。また、列車の長さ、駅の長さは無視できるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられる。各データセットは以下のような形式で与えられる。
</p>
<pre>
<var>l<sub>1</sub></var>,<var>l<sub>2</sub></var>,<var>l<sub>3</sub></var>,<var>l<sub>4</sub></var>,<var>l<sub>5</sub></var>,<var>l<sub>6</sub></var>,<var>l<sub>7</sub></var>,<var>l<sub>8</sub></var>,<var>l<sub>9</sub></var>,<var>l<sub>10</sub></var>,<var>v<sub>1</sub></var>,<var>v<sub>2</sub></var>
</pre>
<p>
<var>l<sub>i</sub></var> (1 ≤ <var>l<sub>i</sub></var> ≤ 2,000) は区間 <var>i</var> の長さ(km)を表す整数である。<var>v<sub>1</sub></var> は区間 1 側の終端駅を出発した列車の速度(km/h)、<var>v<sub>2</sub></var> は区間 10 側の終端駅を出発した列車の速度(km/h)を表す整数である (1 ≤ <var>v<sub>1</sub></var>, <var>v<sub>2</sub></var> ≤ 2,000)。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>Output</H2>
<p>
データセットごとに、列車がすれちがう区間の番号を１行に出力する。
</p>
<H2>Sample Input</H2>
<pre>
1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
7
6
</pre>
| 1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
| 4
7
6
| 9,179 |
s341910836 | p00034 | u733620181 | 1410227103 | Python | Python | py | Accepted | 10 | 4228 | 306 | while True:
try:
line = map(int, raw_input().split(","))
except:
break
sum = 0
rail = []
for x in line[0:10]:
sum += x
rail.append(sum)
cross = sum * (line[10] * 1.0 / (line[10] + line[11]))
for i, length in enumerate(rail):
if cross <= length:
print i+1
break | p00034 |
<H1>鉄道路線</H1>
<p>
複線（上りと下りが別の線路になっていてどこででもすれ違える）の鉄道路線があります。この路線には終端駅を含めて11 の駅があり、それぞれの駅と駅の間は図で示す区間番号で呼ばれています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_railway">
</center>
<br/>
<p>
この路線の両方の終端駅から列車が同時に出発して、途中で停まらずに走ります。各区間の長さと2 本の列車の速度を読み込んで、それぞれの場合について列車がすれ違う区間の番号を出力するプログラムを作成してください。ただし、ちょうど駅のところですれ違う場合は、両側の区間番号のうち小さいほうの数字を出力します。また、列車の長さ、駅の長さは無視できるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられる。各データセットは以下のような形式で与えられる。
</p>
<pre>
<var>l<sub>1</sub></var>,<var>l<sub>2</sub></var>,<var>l<sub>3</sub></var>,<var>l<sub>4</sub></var>,<var>l<sub>5</sub></var>,<var>l<sub>6</sub></var>,<var>l<sub>7</sub></var>,<var>l<sub>8</sub></var>,<var>l<sub>9</sub></var>,<var>l<sub>10</sub></var>,<var>v<sub>1</sub></var>,<var>v<sub>2</sub></var>
</pre>
<p>
<var>l<sub>i</sub></var> (1 ≤ <var>l<sub>i</sub></var> ≤ 2,000) は区間 <var>i</var> の長さ(km)を表す整数である。<var>v<sub>1</sub></var> は区間 1 側の終端駅を出発した列車の速度(km/h)、<var>v<sub>2</sub></var> は区間 10 側の終端駅を出発した列車の速度(km/h)を表す整数である (1 ≤ <var>v<sub>1</sub></var>, <var>v<sub>2</sub></var> ≤ 2,000)。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>Output</H2>
<p>
データセットごとに、列車がすれちがう区間の番号を１行に出力する。
</p>
<H2>Sample Input</H2>
<pre>
1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
7
6
</pre>
| 1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
| 4
7
6
| 9,180 |
s714194360 | p00034 | u506132575 | 1416656188 | Python | Python | py | Accepted | 20 | 4220 | 255 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
for s in sys.stdin:
d = map(float, s.split(","))
dl,v1,v2 = d[:-2],d[-2],d[-1]
L = sum(dl)
x = L/(1+v2/v1)
m = 0
for i in range(len(dl)):
m += dl[i]
if m >= x: print i+1; break | p00034 |
<H1>鉄道路線</H1>
<p>
複線（上りと下りが別の線路になっていてどこででもすれ違える）の鉄道路線があります。この路線には終端駅を含めて11 の駅があり、それぞれの駅と駅の間は図で示す区間番号で呼ばれています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_railway">
</center>
<br/>
<p>
この路線の両方の終端駅から列車が同時に出発して、途中で停まらずに走ります。各区間の長さと2 本の列車の速度を読み込んで、それぞれの場合について列車がすれ違う区間の番号を出力するプログラムを作成してください。ただし、ちょうど駅のところですれ違う場合は、両側の区間番号のうち小さいほうの数字を出力します。また、列車の長さ、駅の長さは無視できるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられる。各データセットは以下のような形式で与えられる。
</p>
<pre>
<var>l<sub>1</sub></var>,<var>l<sub>2</sub></var>,<var>l<sub>3</sub></var>,<var>l<sub>4</sub></var>,<var>l<sub>5</sub></var>,<var>l<sub>6</sub></var>,<var>l<sub>7</sub></var>,<var>l<sub>8</sub></var>,<var>l<sub>9</sub></var>,<var>l<sub>10</sub></var>,<var>v<sub>1</sub></var>,<var>v<sub>2</sub></var>
</pre>
<p>
<var>l<sub>i</sub></var> (1 ≤ <var>l<sub>i</sub></var> ≤ 2,000) は区間 <var>i</var> の長さ(km)を表す整数である。<var>v<sub>1</sub></var> は区間 1 側の終端駅を出発した列車の速度(km/h)、<var>v<sub>2</sub></var> は区間 10 側の終端駅を出発した列車の速度(km/h)を表す整数である (1 ≤ <var>v<sub>1</sub></var>, <var>v<sub>2</sub></var> ≤ 2,000)。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>Output</H2>
<p>
データセットごとに、列車がすれちがう区間の番号を１行に出力する。
</p>
<H2>Sample Input</H2>
<pre>
1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
7
6
</pre>
| 1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
| 4
7
6
| 9,181 |
s712996418 | p00034 | u567380442 | 1423049953 | Python | Python3 | py | Accepted | 40 | 6732 | 320 | import sys
f = sys.stdin
for line in f:
line = list(map(int, line.split(',')))
l = line[:10]
v1, v2 = line[10:]
for i in range(1, len(l)):
l[i] += l[i - 1]
t = l[-1] / (v1 + v2)
dist = v1 * t
for i in range(len(l)):
if l[i] >= dist:
print(i + 1)
break | p00034 |
<H1>鉄道路線</H1>
<p>
複線（上りと下りが別の線路になっていてどこででもすれ違える）の鉄道路線があります。この路線には終端駅を含めて11 の駅があり、それぞれの駅と駅の間は図で示す区間番号で呼ばれています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_railway">
</center>
<br/>
<p>
この路線の両方の終端駅から列車が同時に出発して、途中で停まらずに走ります。各区間の長さと2 本の列車の速度を読み込んで、それぞれの場合について列車がすれ違う区間の番号を出力するプログラムを作成してください。ただし、ちょうど駅のところですれ違う場合は、両側の区間番号のうち小さいほうの数字を出力します。また、列車の長さ、駅の長さは無視できるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられる。各データセットは以下のような形式で与えられる。
</p>
<pre>
<var>l<sub>1</sub></var>,<var>l<sub>2</sub></var>,<var>l<sub>3</sub></var>,<var>l<sub>4</sub></var>,<var>l<sub>5</sub></var>,<var>l<sub>6</sub></var>,<var>l<sub>7</sub></var>,<var>l<sub>8</sub></var>,<var>l<sub>9</sub></var>,<var>l<sub>10</sub></var>,<var>v<sub>1</sub></var>,<var>v<sub>2</sub></var>
</pre>
<p>
<var>l<sub>i</sub></var> (1 ≤ <var>l<sub>i</sub></var> ≤ 2,000) は区間 <var>i</var> の長さ(km)を表す整数である。<var>v<sub>1</sub></var> は区間 1 側の終端駅を出発した列車の速度(km/h)、<var>v<sub>2</sub></var> は区間 10 側の終端駅を出発した列車の速度(km/h)を表す整数である (1 ≤ <var>v<sub>1</sub></var>, <var>v<sub>2</sub></var> ≤ 2,000)。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>Output</H2>
<p>
データセットごとに、列車がすれちがう区間の番号を１行に出力する。
</p>
<H2>Sample Input</H2>
<pre>
1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
7
6
</pre>
| 1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
| 4
7
6
| 9,182 |
s556131274 | p00034 | u540744789 | 1426577549 | Python | Python | py | Accepted | 10 | 4204 | 309 | import sys
for dataset in sys.stdin:
dataset=map(int,dataset.split(","))
v2=dataset.pop()
v1=dataset.pop()
L=sum(dataset)
s=L/float(v1+v2)
cross=v1*s
banti=0
for i in dataset:
banti+=1
cross-=i
if cross<=0:
print banti
break | p00034 |
<H1>鉄道路線</H1>
<p>
複線（上りと下りが別の線路になっていてどこででもすれ違える）の鉄道路線があります。この路線には終端駅を含めて11 の駅があり、それぞれの駅と駅の間は図で示す区間番号で呼ばれています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_railway">
</center>
<br/>
<p>
この路線の両方の終端駅から列車が同時に出発して、途中で停まらずに走ります。各区間の長さと2 本の列車の速度を読み込んで、それぞれの場合について列車がすれ違う区間の番号を出力するプログラムを作成してください。ただし、ちょうど駅のところですれ違う場合は、両側の区間番号のうち小さいほうの数字を出力します。また、列車の長さ、駅の長さは無視できるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられる。各データセットは以下のような形式で与えられる。
</p>
<pre>
<var>l<sub>1</sub></var>,<var>l<sub>2</sub></var>,<var>l<sub>3</sub></var>,<var>l<sub>4</sub></var>,<var>l<sub>5</sub></var>,<var>l<sub>6</sub></var>,<var>l<sub>7</sub></var>,<var>l<sub>8</sub></var>,<var>l<sub>9</sub></var>,<var>l<sub>10</sub></var>,<var>v<sub>1</sub></var>,<var>v<sub>2</sub></var>
</pre>
<p>
<var>l<sub>i</sub></var> (1 ≤ <var>l<sub>i</sub></var> ≤ 2,000) は区間 <var>i</var> の長さ(km)を表す整数である。<var>v<sub>1</sub></var> は区間 1 側の終端駅を出発した列車の速度(km/h)、<var>v<sub>2</sub></var> は区間 10 側の終端駅を出発した列車の速度(km/h)を表す整数である (1 ≤ <var>v<sub>1</sub></var>, <var>v<sub>2</sub></var> ≤ 2,000)。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>Output</H2>
<p>
データセットごとに、列車がすれちがう区間の番号を１行に出力する。
</p>
<H2>Sample Input</H2>
<pre>
1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
7
6
</pre>
| 1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
| 4
7
6
| 9,183 |
s697432501 | p00034 | u873482706 | 1434675518 | Python | Python | py | Accepted | 20 | 4220 | 460 | def tokyo():
t = float(sum(station_lis)) / (v1 + v2)
x = v1 * t
total = 0
for index, length in enumerate(station_lis):
total += length
if x <= total:
print index+1
break
while True:
try:
input_line = [int(char) for char in raw_input().split(',')]
station_lis = input_line[:10]
v1 = input_line[-2]
v2 = input_line[-1]
tokyo()
except EOFError:
break | p00034 |
<H1>鉄道路線</H1>
<p>
複線（上りと下りが別の線路になっていてどこででもすれ違える）の鉄道路線があります。この路線には終端駅を含めて11 の駅があり、それぞれの駅と駅の間は図で示す区間番号で呼ばれています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_railway">
</center>
<br/>
<p>
この路線の両方の終端駅から列車が同時に出発して、途中で停まらずに走ります。各区間の長さと2 本の列車の速度を読み込んで、それぞれの場合について列車がすれ違う区間の番号を出力するプログラムを作成してください。ただし、ちょうど駅のところですれ違う場合は、両側の区間番号のうち小さいほうの数字を出力します。また、列車の長さ、駅の長さは無視できるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられる。各データセットは以下のような形式で与えられる。
</p>
<pre>
<var>l<sub>1</sub></var>,<var>l<sub>2</sub></var>,<var>l<sub>3</sub></var>,<var>l<sub>4</sub></var>,<var>l<sub>5</sub></var>,<var>l<sub>6</sub></var>,<var>l<sub>7</sub></var>,<var>l<sub>8</sub></var>,<var>l<sub>9</sub></var>,<var>l<sub>10</sub></var>,<var>v<sub>1</sub></var>,<var>v<sub>2</sub></var>
</pre>
<p>
<var>l<sub>i</sub></var> (1 ≤ <var>l<sub>i</sub></var> ≤ 2,000) は区間 <var>i</var> の長さ(km)を表す整数である。<var>v<sub>1</sub></var> は区間 1 側の終端駅を出発した列車の速度(km/h)、<var>v<sub>2</sub></var> は区間 10 側の終端駅を出発した列車の速度(km/h)を表す整数である (1 ≤ <var>v<sub>1</sub></var>, <var>v<sub>2</sub></var> ≤ 2,000)。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>Output</H2>
<p>
データセットごとに、列車がすれちがう区間の番号を１行に出力する。
</p>
<H2>Sample Input</H2>
<pre>
1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
7
6
</pre>
| 1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
| 4
7
6
| 9,184 |
s051958626 | p00034 | u621997536 | 1435396248 | Python | Python3 | py | Accepted | 30 | 6732 | 272 | import sys
for line in sys.stdin:
ll = list(map(int, line.split(',')))
s = ll[:10]
v1, v2 = ll[10], ll[11]
p = sum(s) / (v1 + v2) * v1
ss = 0
for i, l in enumerate(s):
ss += l
if ss >= p:
print(i + 1)
break | p00034 |
<H1>鉄道路線</H1>
<p>
複線（上りと下りが別の線路になっていてどこででもすれ違える）の鉄道路線があります。この路線には終端駅を含めて11 の駅があり、それぞれの駅と駅の間は図で示す区間番号で呼ばれています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_railway">
</center>
<br/>
<p>
この路線の両方の終端駅から列車が同時に出発して、途中で停まらずに走ります。各区間の長さと2 本の列車の速度を読み込んで、それぞれの場合について列車がすれ違う区間の番号を出力するプログラムを作成してください。ただし、ちょうど駅のところですれ違う場合は、両側の区間番号のうち小さいほうの数字を出力します。また、列車の長さ、駅の長さは無視できるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられる。各データセットは以下のような形式で与えられる。
</p>
<pre>
<var>l<sub>1</sub></var>,<var>l<sub>2</sub></var>,<var>l<sub>3</sub></var>,<var>l<sub>4</sub></var>,<var>l<sub>5</sub></var>,<var>l<sub>6</sub></var>,<var>l<sub>7</sub></var>,<var>l<sub>8</sub></var>,<var>l<sub>9</sub></var>,<var>l<sub>10</sub></var>,<var>v<sub>1</sub></var>,<var>v<sub>2</sub></var>
</pre>
<p>
<var>l<sub>i</sub></var> (1 ≤ <var>l<sub>i</sub></var> ≤ 2,000) は区間 <var>i</var> の長さ(km)を表す整数である。<var>v<sub>1</sub></var> は区間 1 側の終端駅を出発した列車の速度(km/h)、<var>v<sub>2</sub></var> は区間 10 側の終端駅を出発した列車の速度(km/h)を表す整数である (1 ≤ <var>v<sub>1</sub></var>, <var>v<sub>2</sub></var> ≤ 2,000)。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>Output</H2>
<p>
データセットごとに、列車がすれちがう区間の番号を１行に出力する。
</p>
<H2>Sample Input</H2>
<pre>
1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
7
6
</pre>
| 1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
| 4
7
6
| 9,185 |
s626107277 | p00034 | u379956761 | 1435565018 | Python | Python3 | py | Accepted | 30 | 6732 | 289 | import sys
for s in sys.stdin:
data = list(map(int, s.split(',')))
dis = data[:10]
v1, v2 = data[10], data[11]
for i in range(1, len(dis)):
dis[i] += dis[i-1]
time = dis[-1] / (v1+v2)
meetDis = v1 * time
for i in range(len(dis)):
if dis[i] >= meetDis:
print(i+1)
break | p00034 |
<H1>鉄道路線</H1>
<p>
複線（上りと下りが別の線路になっていてどこででもすれ違える）の鉄道路線があります。この路線には終端駅を含めて11 の駅があり、それぞれの駅と駅の間は図で示す区間番号で呼ばれています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_railway">
</center>
<br/>
<p>
この路線の両方の終端駅から列車が同時に出発して、途中で停まらずに走ります。各区間の長さと2 本の列車の速度を読み込んで、それぞれの場合について列車がすれ違う区間の番号を出力するプログラムを作成してください。ただし、ちょうど駅のところですれ違う場合は、両側の区間番号のうち小さいほうの数字を出力します。また、列車の長さ、駅の長さは無視できるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられる。各データセットは以下のような形式で与えられる。
</p>
<pre>
<var>l<sub>1</sub></var>,<var>l<sub>2</sub></var>,<var>l<sub>3</sub></var>,<var>l<sub>4</sub></var>,<var>l<sub>5</sub></var>,<var>l<sub>6</sub></var>,<var>l<sub>7</sub></var>,<var>l<sub>8</sub></var>,<var>l<sub>9</sub></var>,<var>l<sub>10</sub></var>,<var>v<sub>1</sub></var>,<var>v<sub>2</sub></var>
</pre>
<p>
<var>l<sub>i</sub></var> (1 ≤ <var>l<sub>i</sub></var> ≤ 2,000) は区間 <var>i</var> の長さ(km)を表す整数である。<var>v<sub>1</sub></var> は区間 1 側の終端駅を出発した列車の速度(km/h)、<var>v<sub>2</sub></var> は区間 10 側の終端駅を出発した列車の速度(km/h)を表す整数である (1 ≤ <var>v<sub>1</sub></var>, <var>v<sub>2</sub></var> ≤ 2,000)。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>Output</H2>
<p>
データセットごとに、列車がすれちがう区間の番号を１行に出力する。
</p>
<H2>Sample Input</H2>
<pre>
1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
7
6
</pre>
| 1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
| 4
7
6
| 9,186 |
s897854322 | p00034 | u775586391 | 1448356274 | Python | Python3 | py | Accepted | 20 | 7664 | 237 | import sys
for line in sys.stdin.readlines():
l = [int(i) for i in line.split(',')]
v2 = l.pop()
v1 = l.pop()
d = sum(l) * v1 / (v1+v2)
a = 0
c = 0
for i in l:
a += i
c += 1
if d <= a:
print(c)
break | p00034 |
<H1>鉄道路線</H1>
<p>
複線（上りと下りが別の線路になっていてどこででもすれ違える）の鉄道路線があります。この路線には終端駅を含めて11 の駅があり、それぞれの駅と駅の間は図で示す区間番号で呼ばれています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_railway">
</center>
<br/>
<p>
この路線の両方の終端駅から列車が同時に出発して、途中で停まらずに走ります。各区間の長さと2 本の列車の速度を読み込んで、それぞれの場合について列車がすれ違う区間の番号を出力するプログラムを作成してください。ただし、ちょうど駅のところですれ違う場合は、両側の区間番号のうち小さいほうの数字を出力します。また、列車の長さ、駅の長さは無視できるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられる。各データセットは以下のような形式で与えられる。
</p>
<pre>
<var>l<sub>1</sub></var>,<var>l<sub>2</sub></var>,<var>l<sub>3</sub></var>,<var>l<sub>4</sub></var>,<var>l<sub>5</sub></var>,<var>l<sub>6</sub></var>,<var>l<sub>7</sub></var>,<var>l<sub>8</sub></var>,<var>l<sub>9</sub></var>,<var>l<sub>10</sub></var>,<var>v<sub>1</sub></var>,<var>v<sub>2</sub></var>
</pre>
<p>
<var>l<sub>i</sub></var> (1 ≤ <var>l<sub>i</sub></var> ≤ 2,000) は区間 <var>i</var> の長さ(km)を表す整数である。<var>v<sub>1</sub></var> は区間 1 側の終端駅を出発した列車の速度(km/h)、<var>v<sub>2</sub></var> は区間 10 側の終端駅を出発した列車の速度(km/h)を表す整数である (1 ≤ <var>v<sub>1</sub></var>, <var>v<sub>2</sub></var> ≤ 2,000)。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>Output</H2>
<p>
データセットごとに、列車がすれちがう区間の番号を１行に出力する。
</p>
<H2>Sample Input</H2>
<pre>
1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
7
6
</pre>
| 1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
| 4
7
6
| 9,187 |
s309877081 | p00034 | u140201022 | 1448385546 | Python | Python | py | Accepted | 10 | 6344 | 276 | while 1:
try:
l=map(int,raw_input().split(','))
v2=l.pop()
v1=l.pop()
p=v1*float(sum(l))/(v1+v2)
for i in range(10):
p-=l[i]
if p<=0:
print i+1
break
except:
break | p00034 |
<H1>鉄道路線</H1>
<p>
複線（上りと下りが別の線路になっていてどこででもすれ違える）の鉄道路線があります。この路線には終端駅を含めて11 の駅があり、それぞれの駅と駅の間は図で示す区間番号で呼ばれています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_railway">
</center>
<br/>
<p>
この路線の両方の終端駅から列車が同時に出発して、途中で停まらずに走ります。各区間の長さと2 本の列車の速度を読み込んで、それぞれの場合について列車がすれ違う区間の番号を出力するプログラムを作成してください。ただし、ちょうど駅のところですれ違う場合は、両側の区間番号のうち小さいほうの数字を出力します。また、列車の長さ、駅の長さは無視できるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられる。各データセットは以下のような形式で与えられる。
</p>
<pre>
<var>l<sub>1</sub></var>,<var>l<sub>2</sub></var>,<var>l<sub>3</sub></var>,<var>l<sub>4</sub></var>,<var>l<sub>5</sub></var>,<var>l<sub>6</sub></var>,<var>l<sub>7</sub></var>,<var>l<sub>8</sub></var>,<var>l<sub>9</sub></var>,<var>l<sub>10</sub></var>,<var>v<sub>1</sub></var>,<var>v<sub>2</sub></var>
</pre>
<p>
<var>l<sub>i</sub></var> (1 ≤ <var>l<sub>i</sub></var> ≤ 2,000) は区間 <var>i</var> の長さ(km)を表す整数である。<var>v<sub>1</sub></var> は区間 1 側の終端駅を出発した列車の速度(km/h)、<var>v<sub>2</sub></var> は区間 10 側の終端駅を出発した列車の速度(km/h)を表す整数である (1 ≤ <var>v<sub>1</sub></var>, <var>v<sub>2</sub></var> ≤ 2,000)。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>Output</H2>
<p>
データセットごとに、列車がすれちがう区間の番号を１行に出力する。
</p>
<H2>Sample Input</H2>
<pre>
1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
7
6
</pre>
| 1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
| 4
7
6
| 9,188 |
s611417847 | p00034 | u461370825 | 1449747398 | Python | Python | py | Accepted | 10 | 6420 | 315 | from math import *
PI = 3.1415926535898
while True:
try:
rd = map(float, raw_input().strip().split(','))
v1 = rd[10]
v2 = rd[11]
rd = rd[:-2]
total = 0
for x in rd:
total += x
t = total / (v1+v2) * v1
pas = 0
i = 0
while pas < t:
pas += rd[i]
i += 1
print i
except EOFError:
break | p00034 |
<H1>鉄道路線</H1>
<p>
複線（上りと下りが別の線路になっていてどこででもすれ違える）の鉄道路線があります。この路線には終端駅を含めて11 の駅があり、それぞれの駅と駅の間は図で示す区間番号で呼ばれています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_railway">
</center>
<br/>
<p>
この路線の両方の終端駅から列車が同時に出発して、途中で停まらずに走ります。各区間の長さと2 本の列車の速度を読み込んで、それぞれの場合について列車がすれ違う区間の番号を出力するプログラムを作成してください。ただし、ちょうど駅のところですれ違う場合は、両側の区間番号のうち小さいほうの数字を出力します。また、列車の長さ、駅の長さは無視できるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられる。各データセットは以下のような形式で与えられる。
</p>
<pre>
<var>l<sub>1</sub></var>,<var>l<sub>2</sub></var>,<var>l<sub>3</sub></var>,<var>l<sub>4</sub></var>,<var>l<sub>5</sub></var>,<var>l<sub>6</sub></var>,<var>l<sub>7</sub></var>,<var>l<sub>8</sub></var>,<var>l<sub>9</sub></var>,<var>l<sub>10</sub></var>,<var>v<sub>1</sub></var>,<var>v<sub>2</sub></var>
</pre>
<p>
<var>l<sub>i</sub></var> (1 ≤ <var>l<sub>i</sub></var> ≤ 2,000) は区間 <var>i</var> の長さ(km)を表す整数である。<var>v<sub>1</sub></var> は区間 1 側の終端駅を出発した列車の速度(km/h)、<var>v<sub>2</sub></var> は区間 10 側の終端駅を出発した列車の速度(km/h)を表す整数である (1 ≤ <var>v<sub>1</sub></var>, <var>v<sub>2</sub></var> ≤ 2,000)。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>Output</H2>
<p>
データセットごとに、列車がすれちがう区間の番号を１行に出力する。
</p>
<H2>Sample Input</H2>
<pre>
1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
7
6
</pre>
| 1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
| 4
7
6
| 9,189 |
s088256545 | p00034 | u766163292 | 1451796728 | Python | Python3 | py | Accepted | 20 | 7496 | 496 | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
import array
import sys
def solve(ls, v1, v2):
lsum = sum(ls)
d1 = v1 * lsum / (v1 + v2)
d = 0.0
for i in range(len(ls)):
d += ls[i]
if d >= d1:
break
else:
continue
return i + 1
if __name__ == "__main__":
for line in sys.stdin:
vals = array.array("d", map(float, line.split(",")))
ls = vals[:10]
v1, v2 = vals[-2:]
print(solve(ls, v1, v2)) | p00034 |
<H1>鉄道路線</H1>
<p>
複線（上りと下りが別の線路になっていてどこででもすれ違える）の鉄道路線があります。この路線には終端駅を含めて11 の駅があり、それぞれの駅と駅の間は図で示す区間番号で呼ばれています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_railway">
</center>
<br/>
<p>
この路線の両方の終端駅から列車が同時に出発して、途中で停まらずに走ります。各区間の長さと2 本の列車の速度を読み込んで、それぞれの場合について列車がすれ違う区間の番号を出力するプログラムを作成してください。ただし、ちょうど駅のところですれ違う場合は、両側の区間番号のうち小さいほうの数字を出力します。また、列車の長さ、駅の長さは無視できるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられる。各データセットは以下のような形式で与えられる。
</p>
<pre>
<var>l<sub>1</sub></var>,<var>l<sub>2</sub></var>,<var>l<sub>3</sub></var>,<var>l<sub>4</sub></var>,<var>l<sub>5</sub></var>,<var>l<sub>6</sub></var>,<var>l<sub>7</sub></var>,<var>l<sub>8</sub></var>,<var>l<sub>9</sub></var>,<var>l<sub>10</sub></var>,<var>v<sub>1</sub></var>,<var>v<sub>2</sub></var>
</pre>
<p>
<var>l<sub>i</sub></var> (1 ≤ <var>l<sub>i</sub></var> ≤ 2,000) は区間 <var>i</var> の長さ(km)を表す整数である。<var>v<sub>1</sub></var> は区間 1 側の終端駅を出発した列車の速度(km/h)、<var>v<sub>2</sub></var> は区間 10 側の終端駅を出発した列車の速度(km/h)を表す整数である (1 ≤ <var>v<sub>1</sub></var>, <var>v<sub>2</sub></var> ≤ 2,000)。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>Output</H2>
<p>
データセットごとに、列車がすれちがう区間の番号を１行に出力する。
</p>
<H2>Sample Input</H2>
<pre>
1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
7
6
</pre>
| 1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
| 4
7
6
| 9,190 |
s950939926 | p00034 | u316203371 | 1455456799 | Python | Python | py | Accepted | 10 | 6312 | 256 | import sys
for line in sys.stdin:
s = map(int, line.split(','))
l = s[0:10]
v1 = s[10]
v2 = s[11]
d = 1.0*sum(l)*v1/(v1+v2)
t = 0
for i in xrange(10):
t += l[i]
if t >= d:
print i+1
break | p00034 |
<H1>鉄道路線</H1>
<p>
複線（上りと下りが別の線路になっていてどこででもすれ違える）の鉄道路線があります。この路線には終端駅を含めて11 の駅があり、それぞれの駅と駅の間は図で示す区間番号で呼ばれています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_railway">
</center>
<br/>
<p>
この路線の両方の終端駅から列車が同時に出発して、途中で停まらずに走ります。各区間の長さと2 本の列車の速度を読み込んで、それぞれの場合について列車がすれ違う区間の番号を出力するプログラムを作成してください。ただし、ちょうど駅のところですれ違う場合は、両側の区間番号のうち小さいほうの数字を出力します。また、列車の長さ、駅の長さは無視できるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられる。各データセットは以下のような形式で与えられる。
</p>
<pre>
<var>l<sub>1</sub></var>,<var>l<sub>2</sub></var>,<var>l<sub>3</sub></var>,<var>l<sub>4</sub></var>,<var>l<sub>5</sub></var>,<var>l<sub>6</sub></var>,<var>l<sub>7</sub></var>,<var>l<sub>8</sub></var>,<var>l<sub>9</sub></var>,<var>l<sub>10</sub></var>,<var>v<sub>1</sub></var>,<var>v<sub>2</sub></var>
</pre>
<p>
<var>l<sub>i</sub></var> (1 ≤ <var>l<sub>i</sub></var> ≤ 2,000) は区間 <var>i</var> の長さ(km)を表す整数である。<var>v<sub>1</sub></var> は区間 1 側の終端駅を出発した列車の速度(km/h)、<var>v<sub>2</sub></var> は区間 10 側の終端駅を出発した列車の速度(km/h)を表す整数である (1 ≤ <var>v<sub>1</sub></var>, <var>v<sub>2</sub></var> ≤ 2,000)。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>Output</H2>
<p>
データセットごとに、列車がすれちがう区間の番号を１行に出力する。
</p>
<H2>Sample Input</H2>
<pre>
1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
7
6
</pre>
| 1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
| 4
7
6
| 9,191 |
s904459746 | p00034 | u148101999 | 1459406952 | Python | Python | py | Accepted | 10 | 6304 | 328 | #encoding=utf-8
import sys
for i in sys.stdin:
ans, num = 0.0, []
num = map(int, i.split(","))
x, y = float(num[10]), float(num[11])
del num[10:12]
# print sum(num)*(x/(x+y)), sum(num)*(y/(x+y))
for i in xrange(10):
ans += num[i]
# print i,ans, sum(num)*(x/(x+y))
if ans >= (sum(num)*(x/(x+y))):
break
print i + 1 | p00034 |
<H1>鉄道路線</H1>
<p>
複線（上りと下りが別の線路になっていてどこででもすれ違える）の鉄道路線があります。この路線には終端駅を含めて11 の駅があり、それぞれの駅と駅の間は図で示す区間番号で呼ばれています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_railway">
</center>
<br/>
<p>
この路線の両方の終端駅から列車が同時に出発して、途中で停まらずに走ります。各区間の長さと2 本の列車の速度を読み込んで、それぞれの場合について列車がすれ違う区間の番号を出力するプログラムを作成してください。ただし、ちょうど駅のところですれ違う場合は、両側の区間番号のうち小さいほうの数字を出力します。また、列車の長さ、駅の長さは無視できるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられる。各データセットは以下のような形式で与えられる。
</p>
<pre>
<var>l<sub>1</sub></var>,<var>l<sub>2</sub></var>,<var>l<sub>3</sub></var>,<var>l<sub>4</sub></var>,<var>l<sub>5</sub></var>,<var>l<sub>6</sub></var>,<var>l<sub>7</sub></var>,<var>l<sub>8</sub></var>,<var>l<sub>9</sub></var>,<var>l<sub>10</sub></var>,<var>v<sub>1</sub></var>,<var>v<sub>2</sub></var>
</pre>
<p>
<var>l<sub>i</sub></var> (1 ≤ <var>l<sub>i</sub></var> ≤ 2,000) は区間 <var>i</var> の長さ(km)を表す整数である。<var>v<sub>1</sub></var> は区間 1 側の終端駅を出発した列車の速度(km/h)、<var>v<sub>2</sub></var> は区間 10 側の終端駅を出発した列車の速度(km/h)を表す整数である (1 ≤ <var>v<sub>1</sub></var>, <var>v<sub>2</sub></var> ≤ 2,000)。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>Output</H2>
<p>
データセットごとに、列車がすれちがう区間の番号を１行に出力する。
</p>
<H2>Sample Input</H2>
<pre>
1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
7
6
</pre>
| 1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
| 4
7
6
| 9,192 |
s441829862 | p00034 | u130979865 | 1460885394 | Python | Python | py | Accepted | 20 | 7716 | 288 | # -*- coding: utf-8 -*-
import sys
from decimal import *
for line in sys.stdin:
L = map(int, line.split(','))
v1 = L.pop(10)
v2 = L.pop(10)
sum_L = sum(L)
t = float(sum_L)*float(v1)/float(v1+v2)
i = 0
while t > 0:
t -= L[i]
i += 1
print i | p00034 |
<H1>鉄道路線</H1>
<p>
複線（上りと下りが別の線路になっていてどこででもすれ違える）の鉄道路線があります。この路線には終端駅を含めて11 の駅があり、それぞれの駅と駅の間は図で示す区間番号で呼ばれています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_railway">
</center>
<br/>
<p>
この路線の両方の終端駅から列車が同時に出発して、途中で停まらずに走ります。各区間の長さと2 本の列車の速度を読み込んで、それぞれの場合について列車がすれ違う区間の番号を出力するプログラムを作成してください。ただし、ちょうど駅のところですれ違う場合は、両側の区間番号のうち小さいほうの数字を出力します。また、列車の長さ、駅の長さは無視できるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられる。各データセットは以下のような形式で与えられる。
</p>
<pre>
<var>l<sub>1</sub></var>,<var>l<sub>2</sub></var>,<var>l<sub>3</sub></var>,<var>l<sub>4</sub></var>,<var>l<sub>5</sub></var>,<var>l<sub>6</sub></var>,<var>l<sub>7</sub></var>,<var>l<sub>8</sub></var>,<var>l<sub>9</sub></var>,<var>l<sub>10</sub></var>,<var>v<sub>1</sub></var>,<var>v<sub>2</sub></var>
</pre>
<p>
<var>l<sub>i</sub></var> (1 ≤ <var>l<sub>i</sub></var> ≤ 2,000) は区間 <var>i</var> の長さ(km)を表す整数である。<var>v<sub>1</sub></var> は区間 1 側の終端駅を出発した列車の速度(km/h)、<var>v<sub>2</sub></var> は区間 10 側の終端駅を出発した列車の速度(km/h)を表す整数である (1 ≤ <var>v<sub>1</sub></var>, <var>v<sub>2</sub></var> ≤ 2,000)。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>Output</H2>
<p>
データセットごとに、列車がすれちがう区間の番号を１行に出力する。
</p>
<H2>Sample Input</H2>
<pre>
1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
7
6
</pre>
| 1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
| 4
7
6
| 9,193 |
s303430268 | p00034 | u572790226 | 1460892484 | Python | Python3 | py | Accepted | 20 | 7556 | 256 | import sys
ds = sys.stdin.readlines()
for d in ds:
L = list(map(int, d.split(',')))
l = sum(L[:-2])
t = l/(L[-1] + L[-2])
x = t * L[-2]
for i in range(10):
x = x - L[i]
if x <= 0:
print(i+1)
break | p00034 |
<H1>鉄道路線</H1>
<p>
複線（上りと下りが別の線路になっていてどこででもすれ違える）の鉄道路線があります。この路線には終端駅を含めて11 の駅があり、それぞれの駅と駅の間は図で示す区間番号で呼ばれています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_railway">
</center>
<br/>
<p>
この路線の両方の終端駅から列車が同時に出発して、途中で停まらずに走ります。各区間の長さと2 本の列車の速度を読み込んで、それぞれの場合について列車がすれ違う区間の番号を出力するプログラムを作成してください。ただし、ちょうど駅のところですれ違う場合は、両側の区間番号のうち小さいほうの数字を出力します。また、列車の長さ、駅の長さは無視できるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられる。各データセットは以下のような形式で与えられる。
</p>
<pre>
<var>l<sub>1</sub></var>,<var>l<sub>2</sub></var>,<var>l<sub>3</sub></var>,<var>l<sub>4</sub></var>,<var>l<sub>5</sub></var>,<var>l<sub>6</sub></var>,<var>l<sub>7</sub></var>,<var>l<sub>8</sub></var>,<var>l<sub>9</sub></var>,<var>l<sub>10</sub></var>,<var>v<sub>1</sub></var>,<var>v<sub>2</sub></var>
</pre>
<p>
<var>l<sub>i</sub></var> (1 ≤ <var>l<sub>i</sub></var> ≤ 2,000) は区間 <var>i</var> の長さ(km)を表す整数である。<var>v<sub>1</sub></var> は区間 1 側の終端駅を出発した列車の速度(km/h)、<var>v<sub>2</sub></var> は区間 10 側の終端駅を出発した列車の速度(km/h)を表す整数である (1 ≤ <var>v<sub>1</sub></var>, <var>v<sub>2</sub></var> ≤ 2,000)。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>Output</H2>
<p>
データセットごとに、列車がすれちがう区間の番号を１行に出力する。
</p>
<H2>Sample Input</H2>
<pre>
1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
7
6
</pre>
| 1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
| 4
7
6
| 9,194 |
s067927799 | p00034 | u650459696 | 1466772122 | Python | Python3 | py | Accepted | 20 | 7660 | 224 | while True:
try:
l = list(map(int, input().split(',')))
except:
break
d = sum(l[:10]) * l[10] / (l[10] + l[11])
for i in range(1,11):
if sum(l[:i]) >= d:
break
print(i) | p00034 |
<H1>鉄道路線</H1>
<p>
複線（上りと下りが別の線路になっていてどこででもすれ違える）の鉄道路線があります。この路線には終端駅を含めて11 の駅があり、それぞれの駅と駅の間は図で示す区間番号で呼ばれています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_railway">
</center>
<br/>
<p>
この路線の両方の終端駅から列車が同時に出発して、途中で停まらずに走ります。各区間の長さと2 本の列車の速度を読み込んで、それぞれの場合について列車がすれ違う区間の番号を出力するプログラムを作成してください。ただし、ちょうど駅のところですれ違う場合は、両側の区間番号のうち小さいほうの数字を出力します。また、列車の長さ、駅の長さは無視できるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられる。各データセットは以下のような形式で与えられる。
</p>
<pre>
<var>l<sub>1</sub></var>,<var>l<sub>2</sub></var>,<var>l<sub>3</sub></var>,<var>l<sub>4</sub></var>,<var>l<sub>5</sub></var>,<var>l<sub>6</sub></var>,<var>l<sub>7</sub></var>,<var>l<sub>8</sub></var>,<var>l<sub>9</sub></var>,<var>l<sub>10</sub></var>,<var>v<sub>1</sub></var>,<var>v<sub>2</sub></var>
</pre>
<p>
<var>l<sub>i</sub></var> (1 ≤ <var>l<sub>i</sub></var> ≤ 2,000) は区間 <var>i</var> の長さ(km)を表す整数である。<var>v<sub>1</sub></var> は区間 1 側の終端駅を出発した列車の速度(km/h)、<var>v<sub>2</sub></var> は区間 10 側の終端駅を出発した列車の速度(km/h)を表す整数である (1 ≤ <var>v<sub>1</sub></var>, <var>v<sub>2</sub></var> ≤ 2,000)。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>Output</H2>
<p>
データセットごとに、列車がすれちがう区間の番号を１行に出力する。
</p>
<H2>Sample Input</H2>
<pre>
1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
7
6
</pre>
| 1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
| 4
7
6
| 9,195 |
s377959018 | p00034 | u766477342 | 1468808407 | Python | Python3 | py | Accepted | 20 | 7576 | 311 | try:
while 1:
lv = list(map(int, input().split(',')))
l = lv[:-2]
v1, v2 = lv[-2:]
s = sum(l) / (v1 + v2) * v1
spam = 0
for i in range(10):
spam += l[i]
if spam >= s:
print(i + 1)
break
except:
pass | p00034 |
<H1>鉄道路線</H1>
<p>
複線（上りと下りが別の線路になっていてどこででもすれ違える）の鉄道路線があります。この路線には終端駅を含めて11 の駅があり、それぞれの駅と駅の間は図で示す区間番号で呼ばれています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_railway">
</center>
<br/>
<p>
この路線の両方の終端駅から列車が同時に出発して、途中で停まらずに走ります。各区間の長さと2 本の列車の速度を読み込んで、それぞれの場合について列車がすれ違う区間の番号を出力するプログラムを作成してください。ただし、ちょうど駅のところですれ違う場合は、両側の区間番号のうち小さいほうの数字を出力します。また、列車の長さ、駅の長さは無視できるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられる。各データセットは以下のような形式で与えられる。
</p>
<pre>
<var>l<sub>1</sub></var>,<var>l<sub>2</sub></var>,<var>l<sub>3</sub></var>,<var>l<sub>4</sub></var>,<var>l<sub>5</sub></var>,<var>l<sub>6</sub></var>,<var>l<sub>7</sub></var>,<var>l<sub>8</sub></var>,<var>l<sub>9</sub></var>,<var>l<sub>10</sub></var>,<var>v<sub>1</sub></var>,<var>v<sub>2</sub></var>
</pre>
<p>
<var>l<sub>i</sub></var> (1 ≤ <var>l<sub>i</sub></var> ≤ 2,000) は区間 <var>i</var> の長さ(km)を表す整数である。<var>v<sub>1</sub></var> は区間 1 側の終端駅を出発した列車の速度(km/h)、<var>v<sub>2</sub></var> は区間 10 側の終端駅を出発した列車の速度(km/h)を表す整数である (1 ≤ <var>v<sub>1</sub></var>, <var>v<sub>2</sub></var> ≤ 2,000)。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>Output</H2>
<p>
データセットごとに、列車がすれちがう区間の番号を１行に出力する。
</p>
<H2>Sample Input</H2>
<pre>
1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
7
6
</pre>
| 1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
| 4
7
6
| 9,196 |
s090185256 | p00034 | u203261375 | 1468815151 | Python | Python3 | py | Accepted | 30 | 7724 | 299 | while True:
try:
s = list(map(int, input().split(',')))
except:
break
arrL = [s[i] for i in range(10)]
v1, v2 = s[10], s[11]
l = sum(arrL) * (v1 / (v1 + v2))
total = 0
ans = 0
while total < l:
total += arrL[ans]
ans += 1
print(ans) | p00034 |
<H1>鉄道路線</H1>
<p>
複線（上りと下りが別の線路になっていてどこででもすれ違える）の鉄道路線があります。この路線には終端駅を含めて11 の駅があり、それぞれの駅と駅の間は図で示す区間番号で呼ばれています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_railway">
</center>
<br/>
<p>
この路線の両方の終端駅から列車が同時に出発して、途中で停まらずに走ります。各区間の長さと2 本の列車の速度を読み込んで、それぞれの場合について列車がすれ違う区間の番号を出力するプログラムを作成してください。ただし、ちょうど駅のところですれ違う場合は、両側の区間番号のうち小さいほうの数字を出力します。また、列車の長さ、駅の長さは無視できるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられる。各データセットは以下のような形式で与えられる。
</p>
<pre>
<var>l<sub>1</sub></var>,<var>l<sub>2</sub></var>,<var>l<sub>3</sub></var>,<var>l<sub>4</sub></var>,<var>l<sub>5</sub></var>,<var>l<sub>6</sub></var>,<var>l<sub>7</sub></var>,<var>l<sub>8</sub></var>,<var>l<sub>9</sub></var>,<var>l<sub>10</sub></var>,<var>v<sub>1</sub></var>,<var>v<sub>2</sub></var>
</pre>
<p>
<var>l<sub>i</sub></var> (1 ≤ <var>l<sub>i</sub></var> ≤ 2,000) は区間 <var>i</var> の長さ(km)を表す整数である。<var>v<sub>1</sub></var> は区間 1 側の終端駅を出発した列車の速度(km/h)、<var>v<sub>2</sub></var> は区間 10 側の終端駅を出発した列車の速度(km/h)を表す整数である (1 ≤ <var>v<sub>1</sub></var>, <var>v<sub>2</sub></var> ≤ 2,000)。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>Output</H2>
<p>
データセットごとに、列車がすれちがう区間の番号を１行に出力する。
</p>
<H2>Sample Input</H2>
<pre>
1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
7
6
</pre>
| 1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
| 4
7
6
| 9,197 |
s404841495 | p00034 | u896025703 | 1469763540 | Python | Python3 | py | Accepted | 30 | 7556 | 243 | import sys
for line in sys.stdin:
l = list(map(int, line.split(',')))
v1, v2 = l[10], l[11]
sumlen = sum(l[:10])
x = v1 * sumlen / (v1 + v2)
temp_len = 0
for i in range(10):
temp_len += l[i]
if x <= temp_len:
print(i + 1)
break | p00034 |
<H1>鉄道路線</H1>
<p>
複線（上りと下りが別の線路になっていてどこででもすれ違える）の鉄道路線があります。この路線には終端駅を含めて11 の駅があり、それぞれの駅と駅の間は図で示す区間番号で呼ばれています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_railway">
</center>
<br/>
<p>
この路線の両方の終端駅から列車が同時に出発して、途中で停まらずに走ります。各区間の長さと2 本の列車の速度を読み込んで、それぞれの場合について列車がすれ違う区間の番号を出力するプログラムを作成してください。ただし、ちょうど駅のところですれ違う場合は、両側の区間番号のうち小さいほうの数字を出力します。また、列車の長さ、駅の長さは無視できるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられる。各データセットは以下のような形式で与えられる。
</p>
<pre>
<var>l<sub>1</sub></var>,<var>l<sub>2</sub></var>,<var>l<sub>3</sub></var>,<var>l<sub>4</sub></var>,<var>l<sub>5</sub></var>,<var>l<sub>6</sub></var>,<var>l<sub>7</sub></var>,<var>l<sub>8</sub></var>,<var>l<sub>9</sub></var>,<var>l<sub>10</sub></var>,<var>v<sub>1</sub></var>,<var>v<sub>2</sub></var>
</pre>
<p>
<var>l<sub>i</sub></var> (1 ≤ <var>l<sub>i</sub></var> ≤ 2,000) は区間 <var>i</var> の長さ(km)を表す整数である。<var>v<sub>1</sub></var> は区間 1 側の終端駅を出発した列車の速度(km/h)、<var>v<sub>2</sub></var> は区間 10 側の終端駅を出発した列車の速度(km/h)を表す整数である (1 ≤ <var>v<sub>1</sub></var>, <var>v<sub>2</sub></var> ≤ 2,000)。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>Output</H2>
<p>
データセットごとに、列車がすれちがう区間の番号を１行に出力する。
</p>
<H2>Sample Input</H2>
<pre>
1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
7
6
</pre>
| 1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
| 4
7
6
| 9,198 |
s194005464 | p00034 | u358919705 | 1472055263 | Python | Python3 | py | Accepted | 40 | 7656 | 340 | while True:
try:
line = input()
l = list(map(int, line.split(',')))[0:10]
v1, v2 = list(map(int, line.split(',')))[10:12]
except:
break
l = list(map(lambda x: x / sum(l), l))
x = v1 / (v1 + v2)
for i in range(10):
if x <= sum(l[:i + 1]):
print(i + 1)
break | p00034 |
<H1>鉄道路線</H1>
<p>
複線（上りと下りが別の線路になっていてどこででもすれ違える）の鉄道路線があります。この路線には終端駅を含めて11 の駅があり、それぞれの駅と駅の間は図で示す区間番号で呼ばれています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_railway">
</center>
<br/>
<p>
この路線の両方の終端駅から列車が同時に出発して、途中で停まらずに走ります。各区間の長さと2 本の列車の速度を読み込んで、それぞれの場合について列車がすれ違う区間の番号を出力するプログラムを作成してください。ただし、ちょうど駅のところですれ違う場合は、両側の区間番号のうち小さいほうの数字を出力します。また、列車の長さ、駅の長さは無視できるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられる。各データセットは以下のような形式で与えられる。
</p>
<pre>
<var>l<sub>1</sub></var>,<var>l<sub>2</sub></var>,<var>l<sub>3</sub></var>,<var>l<sub>4</sub></var>,<var>l<sub>5</sub></var>,<var>l<sub>6</sub></var>,<var>l<sub>7</sub></var>,<var>l<sub>8</sub></var>,<var>l<sub>9</sub></var>,<var>l<sub>10</sub></var>,<var>v<sub>1</sub></var>,<var>v<sub>2</sub></var>
</pre>
<p>
<var>l<sub>i</sub></var> (1 ≤ <var>l<sub>i</sub></var> ≤ 2,000) は区間 <var>i</var> の長さ(km)を表す整数である。<var>v<sub>1</sub></var> は区間 1 側の終端駅を出発した列車の速度(km/h)、<var>v<sub>2</sub></var> は区間 10 側の終端駅を出発した列車の速度(km/h)を表す整数である (1 ≤ <var>v<sub>1</sub></var>, <var>v<sub>2</sub></var> ≤ 2,000)。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>Output</H2>
<p>
データセットごとに、列車がすれちがう区間の番号を１行に出力する。
</p>
<H2>Sample Input</H2>
<pre>
1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
7
6
</pre>
| 1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
| 4
7
6
| 9,199 |
s354889029 | p00034 | u379499530 | 1473227684 | Python | Python | py | Accepted | 10 | 6344 | 319 | while 1:
try:
ds = map(int, raw_input().split(','))
d = [sum(ds[:i + 1]) for i in xrange(10)]
t = sum(ds[:10]) / float(ds[10] + ds[11])
s = ds[10] * t
for i, j in enumerate(d):
if j >= s:
print i + 1
break
except:
break | p00034 |
<H1>鉄道路線</H1>
<p>
複線（上りと下りが別の線路になっていてどこででもすれ違える）の鉄道路線があります。この路線には終端駅を含めて11 の駅があり、それぞれの駅と駅の間は図で示す区間番号で呼ばれています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_railway">
</center>
<br/>
<p>
この路線の両方の終端駅から列車が同時に出発して、途中で停まらずに走ります。各区間の長さと2 本の列車の速度を読み込んで、それぞれの場合について列車がすれ違う区間の番号を出力するプログラムを作成してください。ただし、ちょうど駅のところですれ違う場合は、両側の区間番号のうち小さいほうの数字を出力します。また、列車の長さ、駅の長さは無視できるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられる。各データセットは以下のような形式で与えられる。
</p>
<pre>
<var>l<sub>1</sub></var>,<var>l<sub>2</sub></var>,<var>l<sub>3</sub></var>,<var>l<sub>4</sub></var>,<var>l<sub>5</sub></var>,<var>l<sub>6</sub></var>,<var>l<sub>7</sub></var>,<var>l<sub>8</sub></var>,<var>l<sub>9</sub></var>,<var>l<sub>10</sub></var>,<var>v<sub>1</sub></var>,<var>v<sub>2</sub></var>
</pre>
<p>
<var>l<sub>i</sub></var> (1 ≤ <var>l<sub>i</sub></var> ≤ 2,000) は区間 <var>i</var> の長さ(km)を表す整数である。<var>v<sub>1</sub></var> は区間 1 側の終端駅を出発した列車の速度(km/h)、<var>v<sub>2</sub></var> は区間 10 側の終端駅を出発した列車の速度(km/h)を表す整数である (1 ≤ <var>v<sub>1</sub></var>, <var>v<sub>2</sub></var> ≤ 2,000)。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>Output</H2>
<p>
データセットごとに、列車がすれちがう区間の番号を１行に出力する。
</p>
<H2>Sample Input</H2>
<pre>
1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
7
6
</pre>
| 1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
| 4
7
6
| 9,200 |
s967173917 | p00034 | u469154576 | 1479087707 | Python | Python | py | Accepted | 10 | 6436 | 216 | import sys
for line in sys.stdin:
#while True:
# line=raw_input()
l=map(int,line.split(","))
dis=l[10]/float(l[10]+l[11])*sum(l[:10])
suml=0
for i in xrange(10):
suml+=l[i]
if dis<=suml:
print i+1
break | p00034 |
<H1>鉄道路線</H1>
<p>
複線（上りと下りが別の線路になっていてどこででもすれ違える）の鉄道路線があります。この路線には終端駅を含めて11 の駅があり、それぞれの駅と駅の間は図で示す区間番号で呼ばれています。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_railway">
</center>
<br/>
<p>
この路線の両方の終端駅から列車が同時に出発して、途中で停まらずに走ります。各区間の長さと2 本の列車の速度を読み込んで、それぞれの場合について列車がすれ違う区間の番号を出力するプログラムを作成してください。ただし、ちょうど駅のところですれ違う場合は、両側の区間番号のうち小さいほうの数字を出力します。また、列車の長さ、駅の長さは無視できるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられる。各データセットは以下のような形式で与えられる。
</p>
<pre>
<var>l<sub>1</sub></var>,<var>l<sub>2</sub></var>,<var>l<sub>3</sub></var>,<var>l<sub>4</sub></var>,<var>l<sub>5</sub></var>,<var>l<sub>6</sub></var>,<var>l<sub>7</sub></var>,<var>l<sub>8</sub></var>,<var>l<sub>9</sub></var>,<var>l<sub>10</sub></var>,<var>v<sub>1</sub></var>,<var>v<sub>2</sub></var>
</pre>
<p>
<var>l<sub>i</sub></var> (1 ≤ <var>l<sub>i</sub></var> ≤ 2,000) は区間 <var>i</var> の長さ(km)を表す整数である。<var>v<sub>1</sub></var> は区間 1 側の終端駅を出発した列車の速度(km/h)、<var>v<sub>2</sub></var> は区間 10 側の終端駅を出発した列車の速度(km/h)を表す整数である (1 ≤ <var>v<sub>1</sub></var>, <var>v<sub>2</sub></var> ≤ 2,000)。
</p>
<p>
データセットの数は 50 を超えない。
</p>
<H2>Output</H2>
<p>
データセットごとに、列車がすれちがう区間の番号を１行に出力する。
</p>
<H2>Sample Input</H2>
<pre>
1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
</pre>
<H2>Output for the Sample Input</H2>
<pre>
4
7
6
</pre>
| 1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
| 4
7
6
| 9,201 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.