submission_id string | problem_id string | status string | code string | input string | output string | problem_description string |
|---|---|---|---|---|---|---|
s034629052 | p00033 | Accepted | # -*- coding:utf-8 -*-
#datas = [1 5 2 6 3 7 8 9 10 4]
#datas = [1 4 2 6 5 3 7 8 9 10]
def dfs(datas, b, c, count):
if len(datas) == count: return 1
if int(datas[count]) > b:
return dfs(datas, int(datas[count]), c, count+1)
if int(datas[count]) > c:
return dfs(datas, b, int(datas[count]), count+1)
return 0
def solve():
b=0
c=0
count = 1
q = dfs(datas, b, c, count)
print("YES") if q==1 else print("NO")
counter = 0
while True:
line = input()
if not " " in line:
nums = line
else:
datas = line.split(" ")
q = solve()
counter += 1
if int(nums) == counter:
break | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s749826275 | p00033 | Accepted | import sys
sys.setrecursionlimit(100000)
def load_balls():
balls = []
LINE_NUM, TOTAL = 0, 0
while True:
line = sys.stdin.readline().strip()
LINE_NUM += 1
if LINE_NUM == 1:
TOTAL = int(line)+1
continue
balls.append([int(i) for i in line.split(" ")])
if LINE_NUM == TOTAL: break
return balls
balls_list = load_balls()
for balls in balls_list:
left, right = [0], [0]
for ball in balls:
if left[-1] < ball: left.append(ball)
elif right[-1] < ball: right.append(ball)
print("YES" if len(left)-1 + len(right)-1 == 10 else "NO") | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s005001771 | p00033 | Accepted | # -*- coding:utf-8 -*-
def dfs(datas, b, c, count):
if len(datas) == count: return 1
if int(datas[count]) > b:
return dfs(datas, int(datas[count]), c, count+1)
if int(datas[count]) > c:
return dfs(datas, b, int(datas[count]), count+1)
return 0
def solve():
b=0
c=0
count = 1
q = dfs(datas, b, c, count)
if q==1:
print("YES")
elif q==0:
print("NO")
counter = 0
line = input()
if not " " in line:
nums = line
while True:
line = input()
datas = line.split(" ")
q = solve()
counter += 1
if int(nums) == counter:
break | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s646130290 | p00033 | Accepted | # -*- coding:utf-8 -*-
def dfs(datas, b, c, count):
if len(data) == count: return 1
p = int(data[count])
if p > b:
q = dfs(data, p, c, count+1)
if q==1:return 1
if p > c:
q = dfs(data, b, p, count+1)
if q==1:return 1
return 0
def solve():
b=0
c=0
count = 0
q = dfs(data, b, c, count)
if q==1:
print("YES")
elif q==0:
print("NO")
counter = 0
line = input()
if not " " in line:
nums = line
while True:
line = input()
data = line.split(" ")
q = solve()
counter += 1
if int(nums) == counter:
break | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s070948095 | p00033 | Accepted | N = input()
inputs = [map(int, raw_input().split(' ')) for i in range(N)]
for xs in inputs:
a, b = 0, 0
for x in xs:
if min(a,b) > x:
print 'NO'
break
else:
if (a>b and x>a) or (b>x):
a=x
else:
b=x
if x == xs[-1]:
print 'YES' | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s093222593 | p00033 | Accepted | n = int(input())
for i in range(n):
l = list(map(int, input().split()))
x = y = z = 0
for j in l:
if j > y:
y = j
elif j > z:
z = j
else:
x = 1
print(["YES", "NO"][x]) | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s282080369 | p00033 | Accepted | N = int(input())
for n in range(N):
str = input().split()
list = []
for i in str:
list.append(int(i))
b = []
c = []
ans = True
for a in list:
bLen = len(b)
cLen = len(c)
bLast = bLen - 1 if bLen > 0 else 0
cLast = cLen - 1 if cLen > 0 else 0
if bLen == 0 or b[bLast] < a:
b.append(a)
continue
if b[bLast] > a:
if cLen == 0 or c[cLast] < a:
c.append(a)
continue
else:
ans = False
break
print('YES' if ans is True else 'NO') | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s973856057 | p00033 | Accepted | 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") | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s204411834 | p00033 | Accepted | N = int(input())
for i in range(N):
a = [int(n) for n in input().split()]
b = []
c = []
jurge = "YES"
for n in a:
if len(b) == 0\
or b[len(b)-1] < n:
b.append(n)
elif len(c) == 0\
or c[len(c)-1] < n:
c.append(n)
else:
print("NO")
jurge = "NO"
break
if jurge == "YES":
print("YES") | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s908470572 | p00033 | Accepted | BALL_NUM = 10
def main():
n = int(input())
while n > 0:
balls = list(map(int, input().split()))
if dfs(balls, 0, 0):
print("YES")
else:
print("NO")
n -= 1
def dfs(balls, b, c):
if len(balls) == 1:
if balls[0] > b or balls[0] > c:
return True
else:
return False
# ????????????b?????\????????´???
if balls[0] > b and dfs(balls[1:], balls[0], c):
return True
# ????????????c?????\????????´???
if balls[0] > c and dfs(balls[1:], b, balls[0]):
return True
return False
if __name__ == '__main__':
main() | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s908352814 | p00033 | Accepted | # Aizu Problem 0033: Ball
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
N = int(input())
for n in range(N):
balls = [int(_) for _ in input().split()][::-1]
left, right = [0], [0]
fail = False
while len(balls) > 0:
ball = balls.pop()
if ball > left[-1]:
left.append(ball)
elif ball > right[-1]:
right.append(ball)
else:
fail = True
break
print("YES" if not fail else "NO") | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s136147104 | p00033 | Accepted | N = int(input())
for testCase in range(N):
A = list(map(int, input().split()))
ok = False
for i in range(2 ** 10):
x = []
y = []
for j in range(10):
if i & (1 << j):
x.append(A[j])
else:
y.append(A[j])
if x == sorted(x) and y == sorted(y):
ok = True
if ok:
print('YES')
else:
print('NO') | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s079878070 | p00033 | Accepted | def dfs(i, b, c):
if i == 11:
return (b == sorted(b) and c == sorted(c))
if dfs(i + 1, b + [balls[i - 1]], c):
return True
if dfs(i + 1, b, c + [balls[i - 1]]):
return True
return False
if __name__ == '__main__':
N = int(input())
for i in range(N):
balls = list(map(int, input().split()))
if dfs(1, [], []):
print("YES")
else:
print("NO") | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s750707839 | p00033 | Accepted | n = int(input())
for i in range(n):
a = list(map(int, input().split()))
b,c = 0,0
for i in range(len(a)):
if b < a[i]:
b = a[i]
continue
if c < a[i]:
c = a[i]
continue
print("NO")
break
else:
print("YES") | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s659675862 | p00033 | Accepted | def ball(nums):
b, c = 0, 0
for i in range(len(nums)):
if b < nums[i]:
b = nums[i]
continue
if c < nums[i]:
c = nums[i]
continue
return "NO"
return "YES"
N = int(input())
for _ in range(N):
a = list(map(int, input().split()))
print(ball(a)) | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s284587623 | p00033 | Accepted | n = int(input())
for i in range(n):
balls = list(map(int, input().split()))
b = c = 0
for ball in balls:
if b < ball:
b = ball
elif c < ball:
c = ball
else:
print('NO')
break
else:
print('YES') | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s630669262 | p00033 | Accepted | for n in range(int(input())):
A = [int(i) for i in input().split()]
B = [0]
C = [0]
for a in A:
if a > B[-1] and a > C[-1]:
if a - B[-1] <= a - C[-1]:
B.append(a)
else:
C.append(a)
elif a > B[-1] and a < C[-1]:
B.append(a)
elif a > C[-1]:
C.append(a)
else:
print("NO")
break
if len(B) + len(C) == 12:
print("YES") | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s228434992 | p00033 | Accepted | def main():
n = int(input())
for i in range(n):
Ball = map(int,input().split())
l = r = 0
for value in Ball:
if value > r:
r = value
elif value > l:
l = value
else:
print("NO")
r = -777
break
if r < l:
r,l = l,r
if r == -777:
continue
else:
print("YES")
if __name__ == '__main__':
main()
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s343027878 | p00033 | Accepted | n = int(input())
for i in range(n):
b = list(map(int, input().split()))
c_r = [-1]
c_l = [-1]
for j in range(10):
if c_r[-1] < b[j]:
c_r.append(b[j])
elif c_l[-1] < b[j]:
c_l.append(b[j])
else:
print("NO")
break
else:
print("YES")
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s736454082 | p00033 | Accepted | 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)
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s422583632 | p00033 | Accepted | for _ in[0]*int(input()):
a=list(map(int,input().split()))
b=[a[0]];c=[0]
for e in a[1:]:
if e>b[-1]:b+=[e]
elif e>c[-1]:c+=[e]
else:print('NO');break
else:print('YES')
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s514005898 | p00033 | Accepted | 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')
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s245535669 | p00033 | Accepted | 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])
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s113656054 | p00033 | Accepted | 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")
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s515754927 | p00033 | Accepted | 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")
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s056017488 | p00033 | Accepted | 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')
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s798137394 | p00033 | Accepted | 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()
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s037733786 | p00033 | Accepted | 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)
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s976774013 | p00033 | Accepted | 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]
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s316937564 | p00033 | Accepted | #数列に対し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()
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s253314556 | p00033 | Accepted | # 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')
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s238246428 | p00033 | Accepted | 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")
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s701346601 | p00033 | Accepted | 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')
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s601391745 | p00033 | Accepted | 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" | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s377682948 | p00033 | Accepted | 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' | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s665827933 | p00033 | Accepted | 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) | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s094278202 | p00033 | Accepted | 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) | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s608889715 | p00033 | Accepted | 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) | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s814705661 | p00033 | Accepted | 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' | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s314796218 | p00033 | Accepted |
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) | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s151521743 | p00033 | Accepted | 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" | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s516488163 | p00033 | Accepted | 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' | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s528203069 | p00033 | Accepted | 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" | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s192314905 | p00033 | Accepted | 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" | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s771684192 | p00033 | Accepted | 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" | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s084116988 | p00033 | Accepted | # -*- 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() | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s452788946 | p00033 | Accepted | 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" | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s059412911 | p00033 | Accepted | 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" | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s132231767 | p00033 | Accepted | 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" | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s866967751 | p00033 | Accepted | 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)] | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s982733111 | p00033 | Accepted | 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 | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s481952254 | p00033 | Accepted | 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" | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s962228573 | p00033 | Accepted | 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" | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s483464286 | p00033 | Accepted | 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' | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s420909763 | p00033 | Accepted |
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"
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s878795451 | p00033 | Accepted | 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"
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s504759578 | p00033 | Accepted | 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' | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s670019036 | p00033 | Accepted | 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') | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s864606439 | p00033 | Accepted | 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")
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s805874996 | p00033 | Accepted | 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")
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s747448527 | p00033 | Accepted | 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)
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s521343990 | p00033 | Accepted |
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")
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s151340105 | p00033 | Accepted | 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")
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s699130636 | p00033 | Accepted | # 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')
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s083132304 | p00033 | Accepted | 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)
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s789859758 | p00033 | Accepted | 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')
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s674581119 | p00033 | Accepted | 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()
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s622556242 | p00033 | Accepted |
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)
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s641946763 | p00033 | Accepted | 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()
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s205701317 | p00033 | Accepted | 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)
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s650839909 | p00033 | Accepted | 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")
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s389917543 | p00033 | Accepted | 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()
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s832452671 | p00033 | Accepted | import heapq
from collections import deque
from enum import Enum
import sys
import math
from _heapq import heappush, heappop
import copy
from test.support import _MemoryWatchdog
BIG_NUM = 2000000000
HUGE_NUM = 99999999999999999
MOD = 1000000007
EPS = 0.000000001
sys.setrecursionlimit(100000)
NUM = 10
POW = [1]*(NUM+1)
for i in range(1,NUM+1):
POW[i] = POW[i-1]*2
N = int(input())
for _ in range(N):
table = list(map(int,input().split()))
FLG = False
for state in range(POW[NUM]):
A = []
B = []
for i in range(NUM):
if state & POW[i] != 0:
A.append(table[i])
else:
B.append(table[i])
tmpFLG = True
for i in range(len(A)-1):
if A[i] >= A[i+1]:
tmpFLG = False
break
if tmpFLG == False:
continue
for i in range(len(B)-1):
if B[i] >= B[i+1]:
tmpFLG = False
break
if tmpFLG == True:
FLG = True
break
if FLG == True:
print("YES")
else:
print("NO")
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s663547772 | p00033 | Accepted | 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)
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s131130818 | p00033 | Accepted | 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")
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s547129956 | p00033 | Accepted | # 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')
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s972780767 | p00033 | Accepted | 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)
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s779315008 | p00033 | Accepted | 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
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s351068468 | p00033 | Accepted | 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")
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s479909844 | p00033 | Accepted | 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")
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s033358227 | p00033 | Accepted | 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()
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s109428365 | p00033 | Accepted | 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')
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s264116427 | p00033 | Accepted | 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])
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s512510685 | p00033 | Accepted |
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")
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s798752940 | p00033 | Accepted | 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
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s803720624 | p00033 | Accepted | 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'
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s673795987 | p00033 | Accepted | 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])
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s575611110 | p00033 | Accepted | 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")
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s332488338 | p00033 | Accepted | 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")
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s031335431 | p00033 | Accepted | 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")
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s748883149 | p00033 | Accepted | 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')
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s638656429 | p00033 | Accepted | 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")
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s124949956 | p00033 | Accepted | 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")
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s868416697 | p00033 | Accepted | 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")
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s572231537 | p00033 | Accepted | 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()
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s705164688 | p00033 | Runtime Error | n=int(input())
for i in range(n):
a=list(map(int,input().aplit()))
b,c=0,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")
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s916574763 | p00033 | Runtime Error | def s(a):
for i in a:
if i > b:
b = i
elif i > c:
c = i
else:
return False
return True
for n in range(int(raw_input())):
print "YES" if s(map(int,raw_input().split())) else "NO" | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s252067620 | p00033 | Runtime Error | #!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
import itertools
input()
lis = list(itertools.product([False,True],repeat=10))
for s in sys.stdin:
d = map( int, s.split() )
flag = False
for e in lis:
lis_r = []
lis_l = []
for i in range(10):
if e[i]:
lis_r.append(d[i])
else:
lis_l.append(d[i])
f_r = sorted(lis_r)
f_l = sorted(lis_l)
if f_r == lis_r and f_l == lis_l:
flag = True
break
if flag:
print "YES"
else:
print "NO" | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s684455558 | p00033 | Runtime Error | #!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
import itertools
input()
lis = list(itertools.product([False,True],repeat=10))
for s in sys.stdin:
d = map( int, s.split() )
flag = False
for e in lis:
lis_r = []
lis_l = []
for i in range(10):
if e[i]:
lis_r.append(d[i])
else:
lis_l.append(d[i])
f_r = sorted(lis_r)
f_l = sorted(lis_l)
if f_r == lis_r and f_l == lis_l:
flag = True
break
if flag:
print "YES"
else:
print "NO" | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
s389571816 | p00033 | Runtime Error | #!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
import itertools
input()
lis = list(itertools.product([False,True],repeat=10))
for s in sys.stdin:
d = map( int, s.split() )
flag = False
for e in lis:
l = [ d[i] if e[i] else -d[i] for i in xrange(10) ]
m = [ [ e for e in l if e > 0 ],[ -e for e in l if e < 0 ]]
n = 0
for e in m:
n += sum([ 1 if e[i] > e[i+1] else 0 for i in range(len(e)-1)])
if not n:
print "YES"
break
if n:
print "NO" | 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
|
<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>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.