submission_id string | problem_id string | status string | code string | input string | output string | problem_description string |
|---|---|---|---|---|---|---|
s524468769 | p00033 | Wrong Answer | import sys
def solve(balls):
ans = distribute(balls, [], [])
if ans is True: print('YES')
else: print("NO")
def distribute(balls, R, L):
if len(balls) != 0:
next = balls[0]
ans = False
#case R
if isMutch(next, R):
neoR = R
neoR.append(next)
ans = distribute(balls[1:], neoR, L)
if isMutch(next, L):
neoL = L
neoL.append(next)
ans =distribute(balls[1:], R, neoL)
if ans: return True
else:
return isOrdered(R) and isOrdered(L)
def isMutch(next, lis):
if len(lis) != 0:
return next >= lis[len(lis)-1]
return True
def isOrdered(lis):
#check both R and L are ordered
checker = sorted(lis)
return checker == lis
limit = 2**11
sys.setrecursionlimit(limit)
line = input()
size = -1;
while True:
if size == -1:
size = int(line)
else:
solve(line.split(' '))
size -= 1
print(size)
if size == 0: break
line = input() | 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>
|
s442457572 | p00033 | Wrong Answer | for _ in range(int(input())) :
b, c = 0, 0
for number, a in enumerate(input().split()) :
a = int(a)
if a < b and a < c :
print('NO')
break
elif b < a and c <= b : b = a
else : c = a
if number == 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>
|
s999842840 | p00033 | Wrong Answer | n = int(input())
for i in range(n):
l = list(map(int, input().split()))
k,c= l[0], 0
for j in l:
if j < k:
c += 1
k = j
if 2 <= c:
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>
|
s864741435 | p00033 | Wrong Answer | n = int(input())
for i in range(n):
l = list(map(int, input().split()))
k , c= l[0], 0
for j in l:
if j < k:
c += 1
else:
c = 0
if 2 <= c:
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>
|
s885118044 | p00033 | Wrong Answer | 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 bLast == 0:
b.append(a)
continue
if b[bLast] > a:
if cLast == 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>
|
s747630032 | p00033 | Wrong Answer | def dfs(i, b, c):
if i == 10:
b_sort = sorted(b)
c_sort = sorted(c)
return (b == b_sort and c == c_sort)
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, [0], [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>
|
s962712983 | p00033 | Wrong Answer | def dfs(i, b, c):
if i == 10:
b_sort = sorted(b)
c_sort = sorted(c)
return (b == b_sort and c == c_sort)
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, [0], [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>
|
s934458067 | p00033 | Wrong Answer | 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):
print(j)
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>
|
s635563074 | p00033 | Wrong Answer | def dfs(i, b, c):
if i == 10:
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>
|
s597017328 | p00033 | Wrong Answer | def dfs(i, b, c):
if i == 11:
print(b)
print(c)
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>
|
s464502502 | p00033 | Wrong Answer | n = int(input())
for i in range(n):
balls = list(map(int, input().split()))
min_ball = balls[0]
count = 0
for ball in balls:
if ball > min_ball:
min_ball = ball
count += 1
if count > 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>
|
s596385580 | p00033 | Wrong Answer | n = int(input())
for i in range(n):
balls = list(map(int, input().split()))
count = 0
first = 0
for i, n in enumerate(balls):
min_ball = 11
for m in balls[i:]:
if m != first and n < m < min_ball:
min_ball = m
if min_ball != 11:
first = min_ball
count += 1
if count == 2:
break
if count == 2:
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>
|
s756878349 | p00033 | Wrong Answer | 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 == -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>
|
s920501457 | p00033 | Wrong Answer | 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>
|
s485035275 | p00033 | Wrong Answer | x=int(input())
for i in range(x):
num=[int(i) for i in input().split()]
b=[]
c=[]
flag=0
b.append(num[0])
c.append(int(0))
for i in range(1,10):
if b[0]<num[i]:
b.append(num[i])
elif c[0]<num[i]:
c.append(num[i])
else:
flag=1
break
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>
|
s495446184 | p00033 | Wrong Answer | x=int(input())
for i in range(x):
num=[int(i) for i in input().split()]
b=[]
c=[]
flag=0
b.append(num[0])
c.append(int(0))
for i in range(1,10):
if b[len(b)-1]<num[i]:
b.append(num[i])
elif c[len(c)-1]<num[i]:
c.append(num[i])
else:
flag=1
break
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>
|
s477228702 | p00033 | Wrong Answer | x=int(input())
for i in range(x):
num=[int(i) for i in input().split()]
b=[]
c=[]
flag=0
b.append(num[0])
c.append(min(num)-1)
for i in range(1,10):
if b[len(b)-1]<num[i]:
b.append(num[i])
elif c[len(c)-1]<num[i]:
c.append(num[i])
else:
flag=1
break
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>
|
s469111898 | p00033 | Wrong Answer | x=int(input())
for i in range(x):
num=[int(i) for i in input().split()]
b,c=0,0
flag=0
for i in num:
if b<i:
b=i
elif c<i:
c=i
else:
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>
|
s874432904 | p00033 | Wrong Answer | x=int(input())
for j in range(x):
num=list(map(int,input().split()))
b,c=0,0
flag=0
for i in num:
if b<i:
b=i
elif c<i:
c=i
else:
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>
|
s812880039 | p00033 | Wrong Answer | x=int(input())
for j in range(x):
num=list(map(int,input().split()))
b,c=0,0
flag=0
for i in num:
if b<i:
b=i
elif c<i:
c=i
else:
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>
|
s521572454 | p00033 | Wrong Answer | x=int(input())
for _ in range(x):
num=list(map(int,input().split()))
b,c=0,0
flag=0
for i in num:
if b<i:
b=i
elif c<i:
c=i
else:
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>
|
s410842613 | p00033 | Wrong Answer | 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>
|
s099875785 | p00033 | Wrong Answer | N = int(input())
for i in range(N):
Ball = list(map(int, input().split()))
cannot = 0
right = 0
left = 0
for j in range(10):
if abs(Ball[j] - right) <= abs(Ball[j] - left) and Ball[j] > right:
right = Ball[j]
elif abs(Ball[j] - right) > abs(Ball[j] - left) and Ball[j] > left:
left = Ball[j]
else:
cannot = 1
break
if cannot == 1: print('NO')
elif cannot == 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>
|
s835264185 | p00033 | Wrong Answer | for i in range(int(input())):
a=b=c=0
for n in map(int,input().split()):
if n>b: n=b
elif n>c: n=c
else: a=1
print(['YES','N'][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>
|
s430734302 | p00033 | Wrong Answer | 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:
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>
|
s584622180 | p00033 | Wrong Answer | def solve(balls):
ans=False
K=len(balls)
for i in range(K):
bi=balls[i]
for j in range(i+1,K):
bj=balls[j]
if bi<bj: continue
ans=False
for l in range(j-1,0,-1):
bl=balls[l]
if bj>bl: ans=True
return "YES" if ans else "NO"
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>
|
s063993704 | p00033 | Wrong Answer | def findMin(balls, bn):
if len(balls)==0: return True
return True if min(balls)<bn else False
def solve(balls):
K=len(balls)
for i in range(K-2):
bc=balls[i]
bn=balls[i+1]
if bc<bn: continue
if not findMin(balls[:i],bn):
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>
|
s893860480 | p00033 | Wrong Answer | N = input() + 1
for val in range(1,N):
x = map(int,raw_input().split(' '))
no_num = []
for l in range(1,10):
GE_num = []
for n in range(0,l):
if x[n] >= x[l]:
GE_num.append('GE')
if len(GE_num) == l:
no_num.append('no')
if len(no_num) <= 2:
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>
|
s075593087 | p00033 | Wrong Answer | N = input() + 1
for val in range(1,N):
x = map(int,raw_input().split(' '))
no_num = []
for l in range(1,10):
GE_num = []
for n in range(0,l):
if x[n] >= x[l]:
GE_num.append('GE')
if len(GE_num) == l:
no_num.append('no')
if len(no_num) <= 2:
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>
|
s378786744 | p00033 | Wrong Answer | N = input() + 1
for val in range(1,N):
x = map(int,raw_input().split(' '))
no_num = []
for l in range(1,10):
GE_num = []
for n in range(0,l):
if x[n] >= x[l]:
GE_num.append('GE')
if len(GE_num) == l:
no_num.append('no')
if len(no_num) <= 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>
|
s180874427 | p00033 | Wrong Answer | N = input() + 1
for val in range(1,N):
x = map(int,raw_input().split(' '))
branch = 1
for l in range(2,10):
lessthan = []
for n in range(0,l):
if x[n] < x[l]:
lessthan.append('<')
if len(lessthan) == 0:
branch += 1
if branch <= 2:
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>
|
s032789353 | p00033 | Wrong Answer | N = input() + 1
for val in range(1,N):
x = map(int,raw_input().split(' '))
branch = 1
for l in range(1,10):
lessthan = []
for n in range(0,l):
if x[n] < x[l]:
lessthan.append('<')
if len(lessthan) == 0:
branch += 1
if branch <= 2:
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>
|
s195152989 | p00033 | Wrong Answer | N = input() + 1
for val in range(1,N):
x = map(int,raw_input().split(' '))
branch = 1
for l in range(1,10):
lessthan = []
for n in range(0,l):
if x[n] < x[l]:
lessthan.append('<')
if lessthan == []:
branch += 1
if branch <= 2:
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>
|
s712578771 | p00033 | Wrong Answer | N = input() + 1
for val in range(1,N):
branches = [[100] for x in range(0,10)]
x = map(int,raw_input().split(' '))
branches[0][0] = x[0]
branch_num = 0
for l in range(1,10):
small_num = 0
for n in range(0,l):
if branches[n][0] < x[l]:
small_num += 1
if small_num == 0:
branches[l][0] = x[l]
for val in range(0,10):
if branches[val][0] != 100:
branch_num += 1
if branch_num <= 2:
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>
|
s872580593 | p00033 | Wrong Answer | 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>
|
s707778222 | p00033 | Accepted | n = int(input())
for i in range(n):
data = [int(i) for i in input().split()]
flag = False
a = [0]
b = [0]
for ball in data:
if ball > a[-1]:
a.append(ball)
elif ball > b[-1]:
b.append(ball)
else:
flag = True
break
print("NO") if flag 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>
|
s082288167 | p00033 | Accepted | from sys import stdin
for _ in range(int(stdin.readline())):
s = list(map(int, stdin.readline().split()))
a = 0
b = 0
for c in s:
if a<c: a=c
elif b<c: b=c
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>
|
s646930519 | p00033 | Accepted | n = int(raw_input())
for i in range(n):
ball = map(int, raw_input().split())
a = [0]
b = [0]
for j in ball:
if a[-1] < j:
a.append(j)
elif b[-1] < j:
b.append(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>
|
s637668726 | p00033 | Accepted | n=int(input())
for i in range(n):
a=list(map(int,input().split()))
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>
|
s648166186 | p00033 | Accepted | def solve(a,i,b,c):
return b == sorted(b) and c == sorted(c) if i == 10 else solve(a,i+1,b+[a[i]],c) or solve(a,i+1,b,c+[a[i]])
for roop in range(int(raw_input())):
print "YES" if solve(map(int,raw_input().split()),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>
|
s470918690 | p00033 | Accepted | def s(a,i,b,c):
return b==sorted(b) and c==sorted(c) if i==10 else s(a,i+1,b+[a[i]],c) or s(a,i+1,b,c+[a[i]])
for roop in range(int(raw_input())):
print "YES" if s(map(int,raw_input().split()),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>
|
s148184105 | p00033 | Accepted | def s(a):
b = c = 0
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>
|
s866550064 | p00033 | Accepted | def s(a):
b=c=0
for i in a:
if i>b:b=i
elif i>c:c=i
else:return 0
return 1
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>
|
s638256988 | p00033 | Accepted | #!/usr/bin/env python
# -*- coding: utf-8 -*-
n = input()
for s in xrange(n):
d = map( int, raw_input().split() )
a = b = 0
flag = True
for e in d:
if a < e: a = e
elif b < e: b = e
else: flag = False
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>
|
s530493760 | p00033 | Accepted | import sys
f = sys.stdin
def cylinder(balls):
cy = []
for ball in balls:
if len(cy) == 0:
pass
elif len(cy) == 1:
if cy[0] < ball:
cy.remove(cy[0])
elif min(ball, *cy) == ball:
return False
elif max(ball, *cy) == ball:
cy.remove(max(cy))
else:
cy.remove(min(cy))
cy.append(ball)
return True
n = int(f.readline())
for _ in range(n):
balls = list(map(int, f.readline().split()))
print('YES' if cylinder(balls) 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>
|
s776608562 | p00033 | Accepted | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Copyright : @Huki_Hara
# Created : 2015-03-11
for _ in range(int(input())):
l=[0]
r=[0]
c=True
n=map(int, input().split())
for i in n:
if l[-1] > i and r[-1] > i:
c=False
break
if l[-1] < i:
l.append(i)
else:
r.append(i)
print("YES" if c 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>
|
s847158374 | p00033 | Accepted | for data in range(input()):
dataset=map(int,raw_input().split(" "))
B,C=0,0
B=dataset.pop(0)
while len(dataset)!=0:
ball = dataset.pop(0)
if ball-B<0 or ball-C<0:
if ball-B<0 and ball-C<0:
print "NO"
dataset.append(0)
break
else:
if ball-B<0:
C=ball
else:
B=ball
else:
if ball-B<ball-C:
B=ball
else:
C=ball
if(len(dataset)==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>
|
s037174932 | p00033 | Accepted | def kyoto():
for ball in ball_lis:
if B[-1] <= C[-1] < ball:
C.append(ball)
elif C[-1] < B[-1] < ball:
B.append(ball)
elif B[-1] < ball < C[-1]:
B.append(ball)
elif C[-1] < ball < B[-1]:
C.append(ball)
else:
print 'NO'
break
else:
print 'YES'
for i in range(int(raw_input())):
ball_lis = [int(char) for char in raw_input().split()]
B = [0]
C = [0]
kyoto() | 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>
|
s475996097 | p00033 | Accepted | import sys
def stackBall(ball):
sB, sC = [0], [0]
for b in ball:
if max(sB[-1], sC[-1]) < b:
if sB[-1] >= sC[-1]:
sB.append(b)
else:
sC.append(b)
elif min(sB[-1], sC[-1]) < b:
if sB[-1] >= sC[-1]:
sC.append(b)
else:
sB.append(b)
else:
return False
return True
n = int(input())
for _ in range(n):
ball = list(map(int, input().split()))
if stackBall(ball):
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>
|
s952908778 | p00033 | Accepted | N = int(raw_input())
def dfs(depth, l, r):
if depth == 10:
return True
if l < A[depth] and dfs(depth+1, A[depth], r):
return True
if r < A[depth] and dfs(depth+1, l, A[depth]):
return True
return False
for c in range(N):
A = map(int, raw_input().split(" "))
if dfs(0, 0, 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>
|
s019818940 | p00033 | Accepted | n = int(input())
while n > 0:
l = [int(i) for i in input().split()]
m1 = [0]
m2 = [0]
for i in l:
M1 = max(m1)
M2 = max(m2)
if i < M1 and i < M2:
print('NO')
break
elif M1 <= i <= M2:
m1.append(i)
elif M2 <= i <= M1:
m2.append(i)
elif M2 <= M1 <= i:
m1.append(i)
elif M1 <= M2 <= i:
m2.append(i)
else:
print('YES')
n -= 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>
|
s880114295 | p00033 | Accepted | def sol(a):
b=c=0
for i in a:
if i>b:
b=i
elif i>c:
c=i
else:
return 0
return 1
n=int(raw_input())
for i in range(n):
l=map(int,raw_input().split())
print 'YES' if sol(l) 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>
|
s443977138 | p00033 | Accepted | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
import collections
def judge(balls):
left_balls = collections.deque([0])
right_balls = collections.deque([0])
while balls:
ball = balls.popleft()
if ball > left_balls[-1]:
left_balls.append(ball)
elif ball > right_balls[-1]:
right_balls.append(ball)
else:
return "NO"
return "YES"
def main():
n = int(input())
for x in range(n):
balls = collections.deque(map(int, input().split()))
print(judge(balls))
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>
|
s138139281 | p00033 | Accepted | a=[]
n=int(input())
for i in range(10):
a.append(-1)
while(n!=0):
n-=1
b=[]
c=[]
a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8],a[9]=map(int,input().split())
for i in range(10):
b.append(-1)
c.append(-1)
j=1
k=0
lenb=0
lenc=0
b[0]=a[0]
for i in range(1,10):
if(a[i]>b[j-1]):
b[j]=a[i]
j+=1
else:
if(k==0):
c[0]=a[i]
k+=1
elif(a[i]>c[k-1]):
c[k]=a[i]
k+=1
for i in range(10):
if(b[i]!=-1):
lenb+=1
if(c[i]!=-1):
lenc+=1
if(len(a)==(lenb+lenc)):
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>
|
s928103771 | p00033 | Accepted | N = input()
for i in xrange(N):
ball = map(int, raw_input().split())
a = [0]
b = [0]
for x in ball:
if a[-1] < x:
a.append(x)
elif b[-1] < x:
b.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>
|
s847843828 | p00033 | Accepted | def solve(A):
B=[]
C=[]
#print(A)
#??????
B.append(A[0])
C.append(0)#?????§??????
for i in range(1,9):
if B[-1]<A[i] and C[-1]>A[i]:
B.append(A[i])
#print("B",B)
#print("C",C)
elif B[-1]>A[i] and C[-1]<A[i]:
C.append(A[i])
#print("B",B)
#print("C",C)
elif B[-1]<A[i] and C[-1]<A[i]:
for j in range(i+1,len(A)):
if A[j]<A[i]:
if B[-1]<C[-1]:
C.append(A[i])
#print("B",B)
#print("C",C)
break
else:
B.append(A[i])
#print("B",B)
#print("C",C)
break
else:
B.append(A[i])
#print("B",B)
#print("C",C)
else:
break
del C[0]
#print("B is ",B)
#print("C is ",C)
if B[-1]<A[-1] or C[-1]<A[-1]:
if len(B)+len(C)==len(A)-1:
print("YES")
else:
print("NO")
else:
print("NO")
n=int(input())
for i in range(n):
A=list(map(int,input().split()))
solve(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>
|
s992432483 | p00033 | Accepted | #encoding=utf-8
x = input()
for i in xrange(x):
num,a,b = [],[0],[0]
num = map(int, raw_input().split())
for i in xrange(10):
if num[i] > a[0]:
a.insert(0,num[i])
elif num[i] > b[0]:
b.insert(0,num[i])
else:
pass
if len(a) + len(b) == 12:
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>
|
s241115620 | p00033 | Accepted | n = int(input())
for i in range(n):
bs = list(map(int, input().split()))
lanes = [0,0]
for j in bs:
if j > lanes[0] and j > lanes[1]:
lanes[lanes.index(max(lanes))] = j
elif j>lanes[0]:
lanes[0] = j
elif j>lanes[1]:
lanes[1] = 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>
|
s116698889 | p00033 | Accepted | # -*- coding: utf-8 -*-
n = int(raw_input())
for i in range(n):
A, B, C = [], [0], [0]
A = map(int, raw_input().split())
for i in range(10):
if A[i] > B[0]:
B.insert(0, A[i])
elif A[i] > C[0]:
C.insert(0, A[i])
else:
break
if len(B) + len(C) == 12:
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>
|
s466548495 | p00033 | Accepted | for _ in range(int(input())):
pipe = [0, 0]
a = list(map(int, input().split()))
for i in a:
if i > max(pipe):
pipe[pipe.index(max(pipe))] = i
elif i > min(pipe):
pipe[pipe.index(min(pipe))] = i
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>
|
s192629263 | p00033 | Accepted | n=input()
for _ in xrange(n):
b=[0]
c=[0]
a=map(int,raw_input().split())
for i in a:
if b[-1]<=c[-1]:
if c[-1]<=i:
c.append(i)
elif b[-1]<=i:
b.append(i)
else:
if b[-1]<=i:
b.append(i)
elif c[-1]<=i:
c.append(i)
if len(b)+len(c)==len(a)+2:
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>
|
s452572034 | p00033 | Accepted | n = int(input())
for i in range(n):
str = input().split()
arr = [int(str[j]) for j in range(len(str))]
b,c = 0,0
flag = True
for i in range(len(arr)):
if b < arr[i]:
b = arr[i]
continue
if c < arr[i]:
c = arr[i]
continue
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>
|
s022037555 | p00033 | Accepted | for i in range(int(input())):
res = "YES"
b = c = 0
for t in map(int,input().split()):
if t > b >= c:
b = t
elif t > c:
c = t
else:
res = "NO"
print(res) | 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>
|
s832721409 | p00033 | Accepted | N = int(input())
for _ in range(N):
balls = list(map(int, input().split()))
left = right = 0
ans = "YES"
for i in range(10):
if min(left, right) > balls[i]:
ans = "NO"
break
if left < right:
if right < balls[i]:
right = balls[i]
else:
left = balls[i]
else:
if left < balls[i]:
left = balls[i]
else:
right = balls[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>
|
s422651608 | p00033 | Accepted | N = int(raw_input())
for i in range(N):
Ball = map(int, raw_input().split())
left, right = [], []
for i in Ball:
if len(left) == 0 or left[len(left) - 1] < i:
left.append(i)
elif len(right) == 0 or right[len(right) - 1] < i:
right.append(i)
else:
break
if len(right) + len(left) == 10:
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>
|
s707215402 | p00033 | Accepted | N = int(raw_input())
for i in range(N):
A = map(int, raw_input().split())
B, C = [], []
B.append(0)
C.append(0)
flag = True
for i in A:
if B[-1] < i:
B.append(i)
elif C[-1] < i:
C.append(i)
else:
flag = False
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>
|
s944913357 | p00033 | Accepted | N = input()
for x in range(int(N)):
B = map(int, input().split())
a = b = 0
for y in B:
if y > a:
a = y
elif y > b:
b = y
else:
print('NO')
a = -1
break
if a < b:
a, b = b, a
if a == -1:
continue
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>
|
s307627588 | p00033 | Accepted | for _ in range(int(input())):
ano = []
balls = list(map(int, input().split()))
i = 0
while balls != sorted(balls):
if balls[i] > balls[i + 1]:
ano.append(balls[i + 1])
del balls[i + 1]
else:
i += 1
print('YES' if ano == sorted(ano) 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>
|
s038277847 | p00033 | Accepted | N = input()
for i in xrange(N):
b, c = [0], [0]
for j in map(int, raw_input().split()):
if b[-1] < j: b.append(j)
elif c[-1] < j: c.append(j)
else: break
else:
print 'YES'
continue
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>
|
s780606954 | p00033 | Accepted | N = input()
for i in xrange(N):
b, c = 0, 0
for j in map(int, raw_input().split()):
if b < j: b = j
elif c < j: c = j
else: break
else:
print 'YES'
continue
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>
|
s744002645 | p00033 | Accepted | for i in xrange(input()):
b, c = 0, 0
for j in map(int, raw_input().split()):
if b < j: b = j
elif c < j: c = j
else: break
else:
print 'YES'
continue
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>
|
s593466427 | p00033 | Accepted | # -*- coding: utf-8 -*-
def ball(nums):
l = []
r = []
for i, num in enumerate(nums):
if i == 0:
l.append(num)
elif l[-1] < num:
l.append(num)
elif len(r) == 0:
r.append(num)
elif r[-1] < num:
r.append(num)
else:
return 'NO'
return 'YES'
N = int(input())
# N = 1
for _ in range(N):
nums = [int(e) for e in input().split()]
# nums = [3, 1, 4, 2, 5, 6, 7, 8, 9, 10]
# nums = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
print(ball(nums)) | 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>
|
s430854421 | p00033 | Accepted | n=input()
for t in xrange(n):
a=map(int,raw_input().split())
pos=range(1,11)
for i in xrange(len(a)):
pos[a[i]-1]=i
left=right=-1
for i in xrange(len(pos)):
if(left<pos[i]):
left=pos[i]
elif(right<pos[i]):
right=pos[i]
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>
|
s717425111 | p00033 | Accepted | import sys
for _ in xrange(input()):
A = map(int, raw_input().split())
x, y = 0, 0
for a in A:
if a > x and a > y:
if x >= y:
x = a
else:
y = a
elif a > x:
x = a
elif a > y:
y = a
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>
|
s574094972 | p00033 | Accepted |
def solve(Balls,Left,Right,i):
if i==len(Balls):#???????????¶
return True
#????????\????????´???
if len(Left)==0 or Left[-1]<Balls[i]:
Left.append(Balls[i])
return solve(Balls,Left,Right,i+1)
#????????\????????´???
if len(Right)==0 or Right[-1]<Balls[i]:
Right.append(Balls[i])
return solve(Balls,Left,Right,i+1)
return False#??\???????????????
if __name__ == "__main__":
n=int(input())
for i in range(n):
Balls = [int(i) for i in input().split()]
Left=[]
Right=[]
i=0
if solve(Balls,Left,Right,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>
|
s168454338 | p00033 | Accepted | n = int(input())
for i in range(n):
Bt = [0]
Ct = [0]
Alis = list(map(int,input().split()))
Bt.append(Alis[0])
for i in range(1,len(Alis)):
if Bt[len(Bt) - 1] < Alis[i] and Ct[len(Ct) - 1] > Alis[i]:
Bt.append(Alis[i])
elif Bt[len(Bt) - 1] > Alis[i] and Ct[len(Ct) - 1] < Alis[i]:
Ct.append(Alis[i])
elif Bt[len(Bt) - 1] > Alis[i] and Ct[len(Ct) - 1] > Alis[i]:
print("NO")
break
else:
if Alis[i] - max(Bt) > Alis[i] - max(Ct):
Ct.append(Alis[i])
elif Alis[i] - max(Ct) > Alis[i] - max(Bt):
Bt.append(Alis[i])
if i == len(Alis) - 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>
|
s149908940 | p00033 | Accepted | n = int(input())
for i in range(n):
left, right = [], []
arr = map(int, input().split())
for a in arr:
if len(left) == 0 or left[-1] < a:
left.append(a)
elif len(right) == 0 or right[-1] < a:
right.append(a)
else:
break
if len(left) + len(right) == 10:
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>
|
s547913071 | p00033 | Accepted | import sys
from itertools import compress
def is_right_order(B, C):
max_val = 0
for b in B:
if b < max_val:
return False
max_val = b
max_val = 0
for c in C:
if c < max_val:
return False
max_val = c
return True
def solve_bf(d):
""" ??????????????§?§£??? """
for i in range(1024):
bin_i = '{0:010b}'.format(i)
bin_i = [int(x) for x in bin_i]
comp = compress(d, bin_i)
B = list(comp)
C = d[:]
for b in B:
C.remove(b)
if is_right_order(B, C):
return True
return False
if __name__ == '__main__':
# ??????????????\???
num = int(input())
data = []
for _ in range(num):
data.append(list(map(int, input().split(' '))))
# ????????????
for d in data:
result = solve_bf(d)
# ???????????¨???
if result:
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>
|
s104997914 | p00033 | Accepted | # import sys
from itertools import compress
# from random import shuffle, seed, random
from time import perf_counter
def is_right_order(B, C):
""" B, C????????§??????????????????????????????(??????)????????§???????????? """
max_val = 0
for b in B:
if b < max_val:
return False
max_val = b
max_val = 0
for c in C:
if c < max_val:
return False
max_val = c
return True
def solve_bf(d):
""" ??????????????§?§£???(??????) """
for i in range(1024): # ????????§??????????????????????????????????????????????????????B?????????C????????????????????????
bin_i = '{0:010b}'.format(i)
bin_i = [int(x) for x in bin_i]
comp = compress(d, bin_i)
B = list(comp)
C = d[:]
for b in B:
C.remove(b)
if is_right_order(B, C): # ???????????????????????????????????§?????¶???????????????????????????????¨???????
return True
return False
def solve_greed(d):
""" ????¬????????????????
????????¨?????????????????????????????\????????????C?????\?????????????????\?????????B?????\?????????
??? ???????????????????????????????????°????????¨???????????????????????¨????????????????????????????????´?????????
"""
used = [False] * 11 # ???????????????????????????????????????????????°?????????????????????index??????????????????used[1]?????????????????????????????§????????????+1????????????
B = [] # ?????\????????????????????\?????????
C = [] # ????????\???????????????????????????????????\?????????
for b in d:
cb = 0
for i in range(1, 11):
if used[i] == False:
cb = i # ?????????????????????????????????????????\????????????cb??¨?????¶
break
if b == cb:
C.append(b)
else:
B.append(b)
used[b] = True # ????????????????????????????????????B?????????C???????????????????????????????????§????????¨?????????
return is_right_order(B, C)
if __name__ == '__main__':
# ??????????????\???
num = int(input())
data = []
for _ in range(num):
data.append(list(map(int, input().split(' '))))
# ???????????¨??????????????????????????????
# for i in range(100):
# t = list(range(1, 11))
# shuffle(t)
# data.append(t)
# start_time = perf_counter()
# ????????????
for d in data:
# print('trying: {0}'.format(d))
#result = solve_bf(d)
result = solve_greed(d)
if result:
print('YES')
else:
print('NO')
# end_time = perf_counter()
# print('elapsed: {0}'.format(end_time - start_time)) | 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>
|
s602199448 | p00033 | Accepted | class Depth_First_Search:
def __init__(self, bolls):
self.bolls = bolls
self.possible = False
def search(self, left, right, remaining):
if len(remaining) == 0:
self.possible = True
else:
boll = remaining[0]
if boll > max(left):
self.search(left+[boll], right, remaining[1:])
if boll > max(right):
self.search(left, right+[boll], remaining[1:])
def run(self):
self.search([-1], [-1], self.bolls)
if __name__ == '__main__':
N = int(input())
for i in range(N):
bolls = list(map(int, input().split(' ')))
DFS = Depth_First_Search(bolls)
DFS.run()
if DFS.possible:
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>
|
s334962012 | p00033 | Accepted | def solve(n,left,right):
if n==0:
return 1
if a[n-1]>left:
return solve(n-1,a[n-1],right)
if a[n-1]>right:
return solve(n-1,left,a[n-1])
return 0
n=int(input())
for _ in range(n):
a=[int(i) for i in input().split()][::-1]
print("YES" if solve(10,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>
|
s138127475 | p00033 | Accepted | def solve(n,left,right):
if n==10:
return 1
if a[n]>left:
return solve(n+1,a[n],right)
if a[n]>right:
return solve(n+1,left,a[n])
return 0
n=int(input())
for _ in range(n):
a=[int(i) for i in input().split()]
print("YES" if solve(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>
|
s088723729 | p00033 | Accepted | ans=0
def solve(n,left,right):
global ans
if n==10:
ans=1
else:
if a[n]>left:
ans=solve(n+1,a[n],right)
if a[n]>right:
ans=solve(n+1,left,a[n])
return ans
n=int(input())
for _ in range(n):
a=[int(i) for i in input().split()]
print("YES" if solve(0,0,0) else "NO")
ans=0 | 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>
|
s960627281 | p00033 | Accepted | N = int(input())
for _ in range(N):
balls = list(map(int, input().split()))
B, C = [0], [0]
ans = 1
for i in range(10):
b = balls[i]
if b > B[-1]:
B.append(b)
else:
if b > C[-1]:
C.append(b)
else:
ans = 0
break
print("YES" if ans 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>
|
s997945426 | p00033 | Accepted | def judge(data):
num = list(map(int,data.split()))
a,b = 0,0
for i in range(10):
if a <= num[i]:
a = num[i]
elif b <= num[i]:
b = num[i]
else:
print('NO')
return 0
print('YES')
return 0
n = int(input())
array = [0]*n
for i in range(n):
array[i] = input()
for i in range(n):
judge(array[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>
|
s993544627 | p00033 | Accepted | for _ in range(int(input())):
a=b=c=0
for x in map(int,input().split()):
if x>b:b=x
elif x>c:c=x
else:a=1
print(['YES','NO'][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>
|
s538793827 | p00033 | Accepted | n = int(raw_input().rstrip())
for i in xrange(n):
a = 0
b = 0
is_ok = True
l = raw_input().rstrip().split(" ")
for e in l:
ball = int(e)
if ball-a <= ball-b and ball-a > 0:
a = ball
elif ball-b > 0:
b = ball
else:
is_ok = False
if is_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>
|
s572575364 | 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>
|
s123033605 | p00033 | Accepted | n = int(input())
for _ in range(n):
balls = list(map(int, input().split()))
b = 0
c = 0
flag = True
for itm in balls:
if b>c: b,c = c,b
if c<itm: c=itm; continue
elif b<itm: b=itm; continue
else: flag = False; 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>
|
s033575313 | p00033 | Accepted | # -*- coding: utf-8 -*-
import sys
import os
N = int(input())
for _ in range(N):
balls = list(map(int, input().split()))
left = right = 0
impossible = False
for ball in balls:
if ball > left and ball > right:
# ?????£????????\?????????
if left < right:
right = ball
else:
left = ball
elif ball > left:
left = ball
elif ball > right:
right = ball
else:
impossible = True
break
if impossible:
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>
|
s976944736 | p00033 | Accepted | # -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**6)
def dfs(balls,B=-1,C=-1,cp=0):
if cp==len(balls): return True
ball = balls[cp]
if B<ball:
is_find = dfs(balls,ball,C,cp+1)
if is_find: return True
if C<ball:
is_find = dfs(balls,B,ball,cp+1)
if is_find: return True
return False
def main():
N = int(input().strip())
for _ in range(N):
balls = list(map(int,input().split(' ')))
is_find = dfs(balls)
if is_find: print('YES')
else: print('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
""" | 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>
|
s327773651 | p00033 | Accepted | # -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**6)
"""
def dfs(balls,B=-1,C=-2,cp=0):
if cp==len(balls): return True
ball = balls[cp]
if B<ball:
is_find = dfs(balls,ball,C,cp+1)
if is_find: return True
if C<ball:
is_find = dfs(balls,B,ball,cp+1)
if is_find: return True
return False
"""
def dfs(balls):
B, C = -2, -1
for ball in balls:
if C<ball:
C = ball
continue
if B<ball:
B = ball
continue
return False
return True
def main():
N = int(input().strip())
for _ in range(N):
balls = list(map(int,input().split(' ')))
is_find = dfs(balls)
if is_find: print('YES')
else: print('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
""" | 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>
|
s075460074 | p00033 | Accepted | # -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**6)
def dfs(balls,B=-1,C=-2,cp=0):
if cp==len(balls): return True
ball = balls[cp]
if B<ball:
is_find = dfs(balls,ball,C,cp+1)
if is_find: return True
if C<ball:
is_find = dfs(balls,B,ball,cp+1)
if is_find: return True
return False
def not_dfs(balls):
B, C = -2, -1
for ball in balls:
if C<ball:
C = ball
continue
if B<ball:
B = ball
continue
return False
return True
def main():
N = int(input().strip())
for _ in range(N):
balls = list(map(int,input().split(' ')))
# is_find = dfs(balls)
is_find = not_dfs(balls)
if is_find: print('YES')
else: print('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
""" | 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>
|
s176391442 | p00033 | Accepted | # -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**6)
def dfs(balls,B=-2,C=-1,cp=0):
if cp==len(balls): return True
ball = balls[cp]
if C<ball:
is_find = dfs(balls,B,ball,cp+1)
if is_find: return True
if B<ball:
is_find = dfs(balls,ball,C,cp+1)
if is_find: return True
return False
def not_dfs(balls):
B, C = -2, -1
for ball in balls:
if C<ball:
C = ball
continue
if B<ball:
B = ball
continue
return False
return True
def main():
N = int(input().strip())
for _ in range(N):
balls = list(map(int,input().split(' ')))
# is_find = dfs(balls)
is_find = not_dfs(balls)
if is_find: print('YES')
else: print('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
""" | 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>
|
s003008987 | p00033 | Accepted | import sys
sys.setrecursionlimit(100000)
def load_balls():
LINE_NUM, TOTAL = 0, 0
balls = []
i = 0
for line in sys.stdin:
line = line.strip()
LINE_NUM += 1
if LINE_NUM == 1:
TOTAL = int(line.strip())
continue
balls.append([int(i) for i in line.split(" ")])
if LINE_NUM == TOTAL+1: break
return balls
class VesselClass:
def __init__(self):
self.tmp = []
self.left = [0]
self.right = [0]
def fill(self, balls:list):
self.tmp = balls
def DFS(self):
if len(self.tmp) == 0: print("YES")
elif self.left[-1] < self.tmp[0]:
self.left.append(self.tmp[0])
self.tmp.pop(0)
self.DFS()
elif self.right[-1] < self.tmp[0]:
self.right.append(self.tmp[0])
self.tmp.pop(0)
self.DFS()
else: print("NO")
balls_list = load_balls()
for balls in balls_list:
Vessel = VesselClass()
Vessel.fill(balls)
Vessel.DFS() | 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>
|
s894989502 | p00033 | Accepted | import sys
def solve(balls):
ans = distribute(balls, [], [])
if ans is True: print('YES')
else: print("NO")
def distribute(balls, R, L):
if len(balls) != 0:
next = balls[0]
ans = False
#case R
if isMutch(next, R):
neoR = R
neoR.append(next)
ans = distribute(balls[1:], neoR, L)
if ans: return True
if isMutch(next, L):
neoL = L
neoL.append(next)
ans =distribute(balls[1:], R, neoL)
if ans: return True
else:
return isOrdered(R) and isOrdered(L)
def isMutch(next, lis):
if len(lis) != 0:
return next >= lis[len(lis)-1]
return True
def isOrdered(lis):
#check both R and L are ordered
checker = sorted(lis)
return checker == lis
limit = 2**11
sys.setrecursionlimit(limit)
line = input()
size = -1;
while True:
if size == -1:
size = int(line)
else:
balls = []
for a in line.split(' '):
balls.append(int(a))
solve(balls)
size -= 1
if size == 0: break
line = input() | 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>
|
s769551422 | p00033 | Accepted | import sys
def solve(balls):
if distribute(balls, [], []): print('YES')
else: print("NO")
def distribute(balls, R, L):
if len(balls) != 0:
next = balls[0]
if isMutch(next, R):
neoR = R
neoR.append(next)
if distribute(balls[1:], neoR, L): return True
if isMutch(next, L):
neoL = L
neoL.append(next)
if distribute(balls[1:], R, neoL): return True
else:
return isOrdered(R) and isOrdered(L)
def isMutch(next, lis):
if len(lis) != 0:
return next >= lis[len(lis)-1]
return True
def isOrdered(lis):
#check both R and L are ordered
checker = sorted(lis)
return checker == lis
limit = 2**11
sys.setrecursionlimit(limit)
size = int(input());
for i in range(0,size):
balls = []
for a in input().split(' '):
balls.append(int(a))
solve(balls)
size -= 1
if size == 0: 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>
|
s129267686 | p00033 | Accepted | import sys
def solve(balls):
if distribute(balls, [], []): print('YES')
else: print("NO")
def distribute(balls, R, L):
if len(balls) != 0:
next = balls[0]
if isMutch(next, R):
neoR = R
neoR.append(next)
if distribute(balls[1:], neoR, L): return True
if isMutch(next, L):
neoL = L
neoL.append(next)
if distribute(balls[1:], R, neoL): return True
else:
return isOrdered(R) and isOrdered(L)
def isMutch(next, lis):
if len(lis) != 0:
return next >= lis[len(lis)-1]
return True
def isOrdered(lis):
#check both R and L are ordered
checker = sorted(lis)
return checker == lis
sys.setrecursionlimit(2**11)
size = int(input());
for i in range(size):
balls = []
for a in input().split(' '):
balls.append(int(a))
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>
|
s242259518 | p00033 | Accepted | import sys
def solve(balls):
if distribute(balls, [], []): print('YES')
else: print('NO')
def distribute(balls, R, L):
if len(balls) != 0:
next = balls[0]
if isMutch(next, R):
neoR = R
neoR.append(next)
if distribute(balls[1:], neoR, L): return True
if isMutch(next, L):
neoL = L
neoL.append(next)
if distribute(balls[1:], R, neoL): return True
else:
return True
def isMutch(next, lis):
if len(lis) != 0:
return next >= lis[len(lis)-1]
return True
sys.setrecursionlimit(2**11)
size = int(input());
for i in range(size):
balls = []
for a in input().split(' '):
balls.append(int(a))
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>
|
s404947421 | p00033 | Accepted | import sys
def solve(balls):
if distribute(balls, 0, 0): print('YES')
else: print('NO')
def distribute(balls, lastR, lastL):
if len(balls) != 0:
next = balls[0]
if next>lastR:
if distribute(balls[1:], next, lastL): return True
if next>lastL:
if distribute(balls[1:], lastR, next): return True
else:
return True
sys.setrecursionlimit(2**11)
size = int(input());
for i in range(size):
balls = []
for a in input().split(' '):
balls.append(int(a))
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>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.