s_id stringlengths 10 10 | p_id stringlengths 6 6 | u_id stringlengths 10 10 | date stringlengths 10 10 | language stringclasses 1 value | original_language stringclasses 11 values | filename_ext stringclasses 1 value | status stringclasses 1 value | cpu_time int64 0 100 | memory stringlengths 4 6 | code_size int64 15 14.7k | code stringlengths 15 14.7k | problem_id stringlengths 6 6 | problem_description stringlengths 358 9.83k | input stringlengths 2 4.87k | output stringclasses 807 values | __index_level_0__ int64 1.1k 1.22M |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
s803331348 | p00032 | u800408401 | 1561355045 | Python | Python3 | py | Accepted | 20 | 5592 | 172 | s=0
h=0
while True:
try:
a,b,c =map(int,input().split(","))
except:break
if a**2+b**2==c**2:
s = s+1
elif a==b:
h = h+1
print(s)
print(h)
| p00032 |
<H1>プラスティック板</H1>
<p>
機械に辺・対角線の長さのデータを入力し、プラスティック板の型抜きをしている工場があります。この工場では、サイズは様々ですが、平行四辺形の型のみを切り出しています。あなたは、切り出される平行四辺形のうち、長方形とひし形の製造個数を数えるように上司から命じられました。
</p>
<p>
「機械に入力するデータ」を読み込んで、長方形とひし形の製造個数を出力するプログラムを作成してください。
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_plastic"></center>
<br/>
<H2>Input</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<var>a<sub>1</sub></var>,<var>b<sub>1</sub></var>,<var>c<sub>1</sub></var>
<var>a<sub>2</sub></var>,<var>b<sub>2</sub></var>,<var>c<sub>2</sub></var>
:
</pre>
<p>
機械に入力するデータが複数行に与えられます。<var>i</var> 行目に <var>i</var> 番目の平行四辺形の隣り合う２辺の長さを表す整数 <var>a<sub>i</sub></var>, <var>b<sub>i</sub></var> と対角線の長さを表す整数 <var>c<sub>i</sub></var> がカンマ区切りで与えられます (1 ≤ <var>a<sub>i</sub>, b<sub>i</sub>, c<sub>i</sub></var> ≤ 1000, <var>a<sub>i</sub> + b<sub>i</sub></var> > <var>c<sub>i</sub></var>)。データの数は 100 件を超えません。
</p>
<H2>Output</H2>
<p>
１行目に長方形の製造個数、２行目ひし形の製造個数を出力します。
</p>
<H2>Sample Input</H2>
<pre>
3,4,5
5,5,8
4,4,4
5,4,3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1
2
</pre>
| 3,4,5
5,5,8
4,4,4
5,4,3
| 1
2
| 9,002 |
s558266087 | p00032 | u467711590 | 1561354394 | Python | Python3 | py | Accepted | 20 | 5596 | 192 | rect = 0
hish = 0
try:
while True:
a, b, c =map(int, input().split(","))
if a*a + b*b == c*c:
rect += 1
if a == b:
hish += 1
except:
pass
print(rect)
print(hish)
| p00032 |
<H1>プラスティック板</H1>
<p>
機械に辺・対角線の長さのデータを入力し、プラスティック板の型抜きをしている工場があります。この工場では、サイズは様々ですが、平行四辺形の型のみを切り出しています。あなたは、切り出される平行四辺形のうち、長方形とひし形の製造個数を数えるように上司から命じられました。
</p>
<p>
「機械に入力するデータ」を読み込んで、長方形とひし形の製造個数を出力するプログラムを作成してください。
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_plastic"></center>
<br/>
<H2>Input</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<var>a<sub>1</sub></var>,<var>b<sub>1</sub></var>,<var>c<sub>1</sub></var>
<var>a<sub>2</sub></var>,<var>b<sub>2</sub></var>,<var>c<sub>2</sub></var>
:
</pre>
<p>
機械に入力するデータが複数行に与えられます。<var>i</var> 行目に <var>i</var> 番目の平行四辺形の隣り合う２辺の長さを表す整数 <var>a<sub>i</sub></var>, <var>b<sub>i</sub></var> と対角線の長さを表す整数 <var>c<sub>i</sub></var> がカンマ区切りで与えられます (1 ≤ <var>a<sub>i</sub>, b<sub>i</sub>, c<sub>i</sub></var> ≤ 1000, <var>a<sub>i</sub> + b<sub>i</sub></var> > <var>c<sub>i</sub></var>)。データの数は 100 件を超えません。
</p>
<H2>Output</H2>
<p>
１行目に長方形の製造個数、２行目ひし形の製造個数を出力します。
</p>
<H2>Sample Input</H2>
<pre>
3,4,5
5,5,8
4,4,4
5,4,3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1
2
</pre>
| 3,4,5
5,5,8
4,4,4
5,4,3
| 1
2
| 9,003 |
s473980166 | p00032 | u015712946 | 1561353490 | Python | Python3 | py | Accepted | 20 | 5572 | 223 | rect = 0
hish = 0
try:
while True:
a, b, c = map(float, input().split(","))
if a*a + b*b == c*c:
rect += 1
if a == b:
hish += 1
except:
pass
print(rect)
print(hish)
| p00032 |
<H1>プラスティック板</H1>
<p>
機械に辺・対角線の長さのデータを入力し、プラスティック板の型抜きをしている工場があります。この工場では、サイズは様々ですが、平行四辺形の型のみを切り出しています。あなたは、切り出される平行四辺形のうち、長方形とひし形の製造個数を数えるように上司から命じられました。
</p>
<p>
「機械に入力するデータ」を読み込んで、長方形とひし形の製造個数を出力するプログラムを作成してください。
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_plastic"></center>
<br/>
<H2>Input</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<var>a<sub>1</sub></var>,<var>b<sub>1</sub></var>,<var>c<sub>1</sub></var>
<var>a<sub>2</sub></var>,<var>b<sub>2</sub></var>,<var>c<sub>2</sub></var>
:
</pre>
<p>
機械に入力するデータが複数行に与えられます。<var>i</var> 行目に <var>i</var> 番目の平行四辺形の隣り合う２辺の長さを表す整数 <var>a<sub>i</sub></var>, <var>b<sub>i</sub></var> と対角線の長さを表す整数 <var>c<sub>i</sub></var> がカンマ区切りで与えられます (1 ≤ <var>a<sub>i</sub>, b<sub>i</sub>, c<sub>i</sub></var> ≤ 1000, <var>a<sub>i</sub> + b<sub>i</sub></var> > <var>c<sub>i</sub></var>)。データの数は 100 件を超えません。
</p>
<H2>Output</H2>
<p>
１行目に長方形の製造個数、２行目ひし形の製造個数を出力します。
</p>
<H2>Sample Input</H2>
<pre>
3,4,5
5,5,8
4,4,4
5,4,3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1
2
</pre>
| 3,4,5
5,5,8
4,4,4
5,4,3
| 1
2
| 9,004 |
s871437686 | p00032 | u037441960 | 1561353480 | Python | Python3 | py | Accepted | 20 | 5600 | 226 | X = 0
Y = 0
while True :
try :
a, b, c = map(int, input().split(","))
if(c ** 2 == a ** 2 + b ** 2) :
X += 1
elif(a == b) :
Y += 1
else :
pass
except :
print(X)
print(Y)
break
| p00032 |
<H1>プラスティック板</H1>
<p>
機械に辺・対角線の長さのデータを入力し、プラスティック板の型抜きをしている工場があります。この工場では、サイズは様々ですが、平行四辺形の型のみを切り出しています。あなたは、切り出される平行四辺形のうち、長方形とひし形の製造個数を数えるように上司から命じられました。
</p>
<p>
「機械に入力するデータ」を読み込んで、長方形とひし形の製造個数を出力するプログラムを作成してください。
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_plastic"></center>
<br/>
<H2>Input</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<var>a<sub>1</sub></var>,<var>b<sub>1</sub></var>,<var>c<sub>1</sub></var>
<var>a<sub>2</sub></var>,<var>b<sub>2</sub></var>,<var>c<sub>2</sub></var>
:
</pre>
<p>
機械に入力するデータが複数行に与えられます。<var>i</var> 行目に <var>i</var> 番目の平行四辺形の隣り合う２辺の長さを表す整数 <var>a<sub>i</sub></var>, <var>b<sub>i</sub></var> と対角線の長さを表す整数 <var>c<sub>i</sub></var> がカンマ区切りで与えられます (1 ≤ <var>a<sub>i</sub>, b<sub>i</sub>, c<sub>i</sub></var> ≤ 1000, <var>a<sub>i</sub> + b<sub>i</sub></var> > <var>c<sub>i</sub></var>)。データの数は 100 件を超えません。
</p>
<H2>Output</H2>
<p>
１行目に長方形の製造個数、２行目ひし形の製造個数を出力します。
</p>
<H2>Sample Input</H2>
<pre>
3,4,5
5,5,8
4,4,4
5,4,3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1
2
</pre>
| 3,4,5
5,5,8
4,4,4
5,4,3
| 1
2
| 9,005 |
s262026684 | p00032 | u506537276 | 1561353351 | Python | Python3 | py | Accepted | 20 | 5592 | 185 | rec = 0
dia = 0
while True:
try:
a, b, c = map(int, input().split(","))
except:
break
if a**2 + b**2 == c**2:
rec += 1
if a == b:
dia += 1
print(rec)
print(dia)
| p00032 |
<H1>プラスティック板</H1>
<p>
機械に辺・対角線の長さのデータを入力し、プラスティック板の型抜きをしている工場があります。この工場では、サイズは様々ですが、平行四辺形の型のみを切り出しています。あなたは、切り出される平行四辺形のうち、長方形とひし形の製造個数を数えるように上司から命じられました。
</p>
<p>
「機械に入力するデータ」を読み込んで、長方形とひし形の製造個数を出力するプログラムを作成してください。
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_plastic"></center>
<br/>
<H2>Input</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<var>a<sub>1</sub></var>,<var>b<sub>1</sub></var>,<var>c<sub>1</sub></var>
<var>a<sub>2</sub></var>,<var>b<sub>2</sub></var>,<var>c<sub>2</sub></var>
:
</pre>
<p>
機械に入力するデータが複数行に与えられます。<var>i</var> 行目に <var>i</var> 番目の平行四辺形の隣り合う２辺の長さを表す整数 <var>a<sub>i</sub></var>, <var>b<sub>i</sub></var> と対角線の長さを表す整数 <var>c<sub>i</sub></var> がカンマ区切りで与えられます (1 ≤ <var>a<sub>i</sub>, b<sub>i</sub>, c<sub>i</sub></var> ≤ 1000, <var>a<sub>i</sub> + b<sub>i</sub></var> > <var>c<sub>i</sub></var>)。データの数は 100 件を超えません。
</p>
<H2>Output</H2>
<p>
１行目に長方形の製造個数、２行目ひし形の製造個数を出力します。
</p>
<H2>Sample Input</H2>
<pre>
3,4,5
5,5,8
4,4,4
5,4,3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1
2
</pre>
| 3,4,5
5,5,8
4,4,4
5,4,3
| 1
2
| 9,006 |
s727742007 | p00032 | u990228206 | 1553236904 | Python | Python3 | py | Accepted | 20 | 5596 | 191 | square=0
rhombus=0
while 1:
try:
a,b,c=map(int,input().split(","))
if a==b:rhombus+=1
elif a**2+b**2==c**2:square+=1
except:break
print(square)
print(rhombus)
| p00032 |
<H1>プラスティック板</H1>
<p>
機械に辺・対角線の長さのデータを入力し、プラスティック板の型抜きをしている工場があります。この工場では、サイズは様々ですが、平行四辺形の型のみを切り出しています。あなたは、切り出される平行四辺形のうち、長方形とひし形の製造個数を数えるように上司から命じられました。
</p>
<p>
「機械に入力するデータ」を読み込んで、長方形とひし形の製造個数を出力するプログラムを作成してください。
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_plastic"></center>
<br/>
<H2>Input</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<var>a<sub>1</sub></var>,<var>b<sub>1</sub></var>,<var>c<sub>1</sub></var>
<var>a<sub>2</sub></var>,<var>b<sub>2</sub></var>,<var>c<sub>2</sub></var>
:
</pre>
<p>
機械に入力するデータが複数行に与えられます。<var>i</var> 行目に <var>i</var> 番目の平行四辺形の隣り合う２辺の長さを表す整数 <var>a<sub>i</sub></var>, <var>b<sub>i</sub></var> と対角線の長さを表す整数 <var>c<sub>i</sub></var> がカンマ区切りで与えられます (1 ≤ <var>a<sub>i</sub>, b<sub>i</sub>, c<sub>i</sub></var> ≤ 1000, <var>a<sub>i</sub> + b<sub>i</sub></var> > <var>c<sub>i</sub></var>)。データの数は 100 件を超えません。
</p>
<H2>Output</H2>
<p>
１行目に長方形の製造個数、２行目ひし形の製造個数を出力します。
</p>
<H2>Sample Input</H2>
<pre>
3,4,5
5,5,8
4,4,4
5,4,3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1
2
</pre>
| 3,4,5
5,5,8
4,4,4
5,4,3
| 1
2
| 9,007 |
s020864288 | p00032 | u563075864 | 1543122151 | Python | Python3 | py | Accepted | 20 | 5624 | 276 | rec = 0
rod = 0
E = 10**-10
while(1):
try:
a,b,c = [int(i) for i in input().split(",")]
if abs(c**2 - (a**2+b**2)) < E:
rec += 1
elif a == b:
rod += 1
except EOFError:
print(rec)
print(rod)
break
| p00032 |
<H1>プラスティック板</H1>
<p>
機械に辺・対角線の長さのデータを入力し、プラスティック板の型抜きをしている工場があります。この工場では、サイズは様々ですが、平行四辺形の型のみを切り出しています。あなたは、切り出される平行四辺形のうち、長方形とひし形の製造個数を数えるように上司から命じられました。
</p>
<p>
「機械に入力するデータ」を読み込んで、長方形とひし形の製造個数を出力するプログラムを作成してください。
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_plastic"></center>
<br/>
<H2>Input</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<var>a<sub>1</sub></var>,<var>b<sub>1</sub></var>,<var>c<sub>1</sub></var>
<var>a<sub>2</sub></var>,<var>b<sub>2</sub></var>,<var>c<sub>2</sub></var>
:
</pre>
<p>
機械に入力するデータが複数行に与えられます。<var>i</var> 行目に <var>i</var> 番目の平行四辺形の隣り合う２辺の長さを表す整数 <var>a<sub>i</sub></var>, <var>b<sub>i</sub></var> と対角線の長さを表す整数 <var>c<sub>i</sub></var> がカンマ区切りで与えられます (1 ≤ <var>a<sub>i</sub>, b<sub>i</sub>, c<sub>i</sub></var> ≤ 1000, <var>a<sub>i</sub> + b<sub>i</sub></var> > <var>c<sub>i</sub></var>)。データの数は 100 件を超えません。
</p>
<H2>Output</H2>
<p>
１行目に長方形の製造個数、２行目ひし形の製造個数を出力します。
</p>
<H2>Sample Input</H2>
<pre>
3,4,5
5,5,8
4,4,4
5,4,3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1
2
</pre>
| 3,4,5
5,5,8
4,4,4
5,4,3
| 1
2
| 9,008 |
s921276643 | p00032 | u717526540 | 1541728794 | Python | Python3 | py | Accepted | 20 | 5596 | 212 | rec = 0
dia = 0
while 1:
try:
a, b, c = map(int, input().split(","))
except:
break
if a**2 + b**2 == c**2:
rec += 1
elif a == b:
dia += 1
print(rec)
print(dia)
| p00032 |
<H1>プラスティック板</H1>
<p>
機械に辺・対角線の長さのデータを入力し、プラスティック板の型抜きをしている工場があります。この工場では、サイズは様々ですが、平行四辺形の型のみを切り出しています。あなたは、切り出される平行四辺形のうち、長方形とひし形の製造個数を数えるように上司から命じられました。
</p>
<p>
「機械に入力するデータ」を読み込んで、長方形とひし形の製造個数を出力するプログラムを作成してください。
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_plastic"></center>
<br/>
<H2>Input</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<var>a<sub>1</sub></var>,<var>b<sub>1</sub></var>,<var>c<sub>1</sub></var>
<var>a<sub>2</sub></var>,<var>b<sub>2</sub></var>,<var>c<sub>2</sub></var>
:
</pre>
<p>
機械に入力するデータが複数行に与えられます。<var>i</var> 行目に <var>i</var> 番目の平行四辺形の隣り合う２辺の長さを表す整数 <var>a<sub>i</sub></var>, <var>b<sub>i</sub></var> と対角線の長さを表す整数 <var>c<sub>i</sub></var> がカンマ区切りで与えられます (1 ≤ <var>a<sub>i</sub>, b<sub>i</sub>, c<sub>i</sub></var> ≤ 1000, <var>a<sub>i</sub> + b<sub>i</sub></var> > <var>c<sub>i</sub></var>)。データの数は 100 件を超えません。
</p>
<H2>Output</H2>
<p>
１行目に長方形の製造個数、２行目ひし形の製造個数を出力します。
</p>
<H2>Sample Input</H2>
<pre>
3,4,5
5,5,8
4,4,4
5,4,3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1
2
</pre>
| 3,4,5
5,5,8
4,4,4
5,4,3
| 1
2
| 9,009 |
s214877340 | p00032 | u319725914 | 1534689606 | Python | Python3 | py | Accepted | 20 | 5600 | 243 | from sys import stdin
na = 0
nb = 0
while(True):
try:
a,b,c = map(int,stdin.readline().split(","))
if a**2+b**2==c**2:
na += 1
if a==b:
nb += 1
except:
break
print(na)
print(nb)
| p00032 |
<H1>プラスティック板</H1>
<p>
機械に辺・対角線の長さのデータを入力し、プラスティック板の型抜きをしている工場があります。この工場では、サイズは様々ですが、平行四辺形の型のみを切り出しています。あなたは、切り出される平行四辺形のうち、長方形とひし形の製造個数を数えるように上司から命じられました。
</p>
<p>
「機械に入力するデータ」を読み込んで、長方形とひし形の製造個数を出力するプログラムを作成してください。
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_plastic"></center>
<br/>
<H2>Input</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<var>a<sub>1</sub></var>,<var>b<sub>1</sub></var>,<var>c<sub>1</sub></var>
<var>a<sub>2</sub></var>,<var>b<sub>2</sub></var>,<var>c<sub>2</sub></var>
:
</pre>
<p>
機械に入力するデータが複数行に与えられます。<var>i</var> 行目に <var>i</var> 番目の平行四辺形の隣り合う２辺の長さを表す整数 <var>a<sub>i</sub></var>, <var>b<sub>i</sub></var> と対角線の長さを表す整数 <var>c<sub>i</sub></var> がカンマ区切りで与えられます (1 ≤ <var>a<sub>i</sub>, b<sub>i</sub>, c<sub>i</sub></var> ≤ 1000, <var>a<sub>i</sub> + b<sub>i</sub></var> > <var>c<sub>i</sub></var>)。データの数は 100 件を超えません。
</p>
<H2>Output</H2>
<p>
１行目に長方形の製造個数、２行目ひし形の製造個数を出力します。
</p>
<H2>Sample Input</H2>
<pre>
3,4,5
5,5,8
4,4,4
5,4,3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1
2
</pre>
| 3,4,5
5,5,8
4,4,4
5,4,3
| 1
2
| 9,010 |
s651665313 | p00032 | u539753516 | 1534074313 | Python | Python3 | py | Accepted | 20 | 5592 | 157 | import sys
n0=n1=0
for l in sys.stdin:
a,b,c=map(int,l.split(","))
if a*a+b*b-c*c==0:
n0+=1
elif a==b:
n1+=1
print(n0)
print(n1)
| p00032 |
<H1>プラスティック板</H1>
<p>
機械に辺・対角線の長さのデータを入力し、プラスティック板の型抜きをしている工場があります。この工場では、サイズは様々ですが、平行四辺形の型のみを切り出しています。あなたは、切り出される平行四辺形のうち、長方形とひし形の製造個数を数えるように上司から命じられました。
</p>
<p>
「機械に入力するデータ」を読み込んで、長方形とひし形の製造個数を出力するプログラムを作成してください。
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_plastic"></center>
<br/>
<H2>Input</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<var>a<sub>1</sub></var>,<var>b<sub>1</sub></var>,<var>c<sub>1</sub></var>
<var>a<sub>2</sub></var>,<var>b<sub>2</sub></var>,<var>c<sub>2</sub></var>
:
</pre>
<p>
機械に入力するデータが複数行に与えられます。<var>i</var> 行目に <var>i</var> 番目の平行四辺形の隣り合う２辺の長さを表す整数 <var>a<sub>i</sub></var>, <var>b<sub>i</sub></var> と対角線の長さを表す整数 <var>c<sub>i</sub></var> がカンマ区切りで与えられます (1 ≤ <var>a<sub>i</sub>, b<sub>i</sub>, c<sub>i</sub></var> ≤ 1000, <var>a<sub>i</sub> + b<sub>i</sub></var> > <var>c<sub>i</sub></var>)。データの数は 100 件を超えません。
</p>
<H2>Output</H2>
<p>
１行目に長方形の製造個数、２行目ひし形の製造個数を出力します。
</p>
<H2>Sample Input</H2>
<pre>
3,4,5
5,5,8
4,4,4
5,4,3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1
2
</pre>
| 3,4,5
5,5,8
4,4,4
5,4,3
| 1
2
| 9,011 |
s206496472 | p00032 | u079141094 | 1517805262 | Python | Python3 | py | Accepted | 20 | 5596 | 323 | import sys
def solve():
num_rect, num_rhom = 0, 0
for line in sys.stdin:
a, b, c = map(int, line.split(','))
if c ** 2 == a ** 2 + b ** 2:
num_rect += 1
elif a == b:
num_rhom += 1
print(num_rect)
print(num_rhom)
if __name__ == "__main__":
solve()
| p00032 |
<H1>プラスティック板</H1>
<p>
機械に辺・対角線の長さのデータを入力し、プラスティック板の型抜きをしている工場があります。この工場では、サイズは様々ですが、平行四辺形の型のみを切り出しています。あなたは、切り出される平行四辺形のうち、長方形とひし形の製造個数を数えるように上司から命じられました。
</p>
<p>
「機械に入力するデータ」を読み込んで、長方形とひし形の製造個数を出力するプログラムを作成してください。
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_plastic"></center>
<br/>
<H2>Input</H2>
<p>
入力は以下の形式で与えられます。
</p>
<pre>
<var>a<sub>1</sub></var>,<var>b<sub>1</sub></var>,<var>c<sub>1</sub></var>
<var>a<sub>2</sub></var>,<var>b<sub>2</sub></var>,<var>c<sub>2</sub></var>
:
</pre>
<p>
機械に入力するデータが複数行に与えられます。<var>i</var> 行目に <var>i</var> 番目の平行四辺形の隣り合う２辺の長さを表す整数 <var>a<sub>i</sub></var>, <var>b<sub>i</sub></var> と対角線の長さを表す整数 <var>c<sub>i</sub></var> がカンマ区切りで与えられます (1 ≤ <var>a<sub>i</sub>, b<sub>i</sub>, c<sub>i</sub></var> ≤ 1000, <var>a<sub>i</sub> + b<sub>i</sub></var> > <var>c<sub>i</sub></var>)。データの数は 100 件を超えません。
</p>
<H2>Output</H2>
<p>
１行目に長方形の製造個数、２行目ひし形の製造個数を出力します。
</p>
<H2>Sample Input</H2>
<pre>
3,4,5
5,5,8
4,4,4
5,4,3
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1
2
</pre>
| 3,4,5
5,5,8
4,4,4
5,4,3
| 1
2
| 9,012 |
s707778222 | p00033 | u471400255 | 1531028138 | Python | Python3 | py | Accepted | 20 | 5600 | 348 | 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")
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,013 |
s082288167 | p00033 | u319725914 | 1534743600 | Python | Python3 | py | Accepted | 20 | 5588 | 277 | 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")
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,014 |
s646930519 | p00033 | u525366883 | 1535682910 | Python | Python | py | Accepted | 0 | 4632 | 304 | 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"
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,015 |
s637668726 | p00033 | u647694976 | 1556534288 | Python | Python3 | py | Accepted | 20 | 5592 | 231 | 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")
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,016 |
s648166186 | p00033 | u633068244 | 1414861383 | Python | Python | py | Accepted | 30 | 4216 | 238 | 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" | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,017 |
s470918690 | p00033 | u633068244 | 1414861563 | Python | Python | py | Accepted | 30 | 4208 | 216 | 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" | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,018 |
s408062430 | p00033 | u633068244 | 1414861582 | Python | Python | py | Accepted | 30 | 4216 | 216 | 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" | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,019 |
s148184105 | p00033 | u633068244 | 1414861857 | Python | Python | py | Accepted | 10 | 4200 | 208 | 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" | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,020 |
s866550064 | p00033 | u633068244 | 1414862042 | Python | Python | py | Accepted | 10 | 4200 | 177 | 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" | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,021 |
s638256988 | p00033 | u506132575 | 1416620212 | Python | Python | py | Accepted | 20 | 4196 | 263 | #!/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" | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,022 |
s530493760 | p00033 | u567380442 | 1422705082 | Python | Python3 | py | Accepted | 30 | 6720 | 563 | 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') | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,023 |
s776608562 | p00033 | u744114948 | 1426068491 | Python | Python3 | py | Accepted | 30 | 6724 | 400 | #!/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" ) | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,024 |
s175494828 | p00033 | u744114948 | 1426068499 | Python | Python3 | py | Accepted | 30 | 6720 | 400 | #!/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" ) | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,025 |
s847158374 | p00033 | u540744789 | 1426576239 | Python | Python | py | Accepted | 10 | 4224 | 591 | 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" | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,026 |
s037174932 | p00033 | u873482706 | 1434673589 | Python | Python | py | Accepted | 10 | 4228 | 512 | 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() | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,027 |
s475996097 | p00033 | u379956761 | 1435562607 | Python | Python3 | py | Accepted | 30 | 6724 | 436 | 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") | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,028 |
s952908778 | p00033 | u338932851 | 1437117750 | Python | Python | py | Accepted | 10 | 4220 | 375 | 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" | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,029 |
s019818940 | p00033 | u775586391 | 1448355574 | Python | Python3 | py | Accepted | 50 | 7592 | 401 | 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 | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,030 |
s880114295 | p00033 | u140201022 | 1448384500 | Python | Python | py | Accepted | 10 | 6296 | 260 | 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' | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,031 |
s443977138 | p00033 | u766163292 | 1449918125 | Python | Python3 | py | Accepted | 40 | 7880 | 601 | #!/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() | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,032 |
s138139281 | p00033 | u560214129 | 1450513519 | Python | Python3 | py | Accepted | 20 | 7748 | 736 | 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") | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,033 |
s732589529 | p00033 | u560214129 | 1450516475 | Python | Python3 | py | Accepted | 50 | 7672 | 736 | 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") | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,034 |
s928103771 | p00033 | u529386725 | 1452708769 | Python | Python | py | Accepted | 10 | 6436 | 294 | 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" | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,035 |
s847843828 | p00033 | u075836834 | 1459376499 | Python | Python3 | py | Accepted | 30 | 7684 | 880 | 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) | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,036 |
s992432483 | p00033 | u148101999 | 1459405065 | Python | Python | py | Accepted | 10 | 6392 | 293 | #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" | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,037 |
s241115620 | p00033 | u966364923 | 1459781140 | Python | Python3 | py | Accepted | 20 | 7520 | 388 | 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') | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,038 |
s116698889 | p00033 | u130979865 | 1460813746 | Python | Python | py | Accepted | 10 | 6376 | 374 | # -*- 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" | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,039 |
s466548495 | p00033 | u650459696 | 1463410333 | Python | Python3 | py | Accepted | 20 | 7560 | 332 | 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') | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,040 |
s192629263 | p00033 | u894114233 | 1464864656 | Python | Python | py | Accepted | 10 | 6336 | 438 | 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') | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,041 |
s452572034 | p00033 | u203261375 | 1466256042 | Python | Python3 | py | Accepted | 20 | 7648 | 393 | 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") | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,042 |
s022037555 | p00033 | u766477342 | 1468722690 | Python | Python3 | py | Accepted | 20 | 7512 | 230 | 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) | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,043 |
s832721409 | p00033 | u896025703 | 1469760642 | Python | Python3 | py | Accepted | 30 | 7604 | 371 | 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) | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,044 |
s422651608 | p00033 | u146816547 | 1470721296 | Python | Python | py | Accepted | 10 | 6276 | 370 | 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" | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,045 |
s707215402 | p00033 | u146816547 | 1470742663 | Python | Python | py | Accepted | 10 | 6296 | 322 | 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" | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,046 |
s944913357 | p00033 | u981364540 | 1470898664 | Python | Python3 | py | Accepted | 40 | 7660 | 354 | 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') | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,047 |
s307627588 | p00033 | u358919705 | 1471996427 | Python | Python3 | py | Accepted | 20 | 7584 | 314 | 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') | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,048 |
s038277847 | p00033 | u379499530 | 1473215874 | Python | Python | py | Accepted | 20 | 6372 | 247 | 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' | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,049 |
s780606954 | p00033 | u379499530 | 1473217451 | Python | Python | py | Accepted | 10 | 6324 | 223 | 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' | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,050 |
s744002645 | p00033 | u379499530 | 1473217874 | Python | Python | py | Accepted | 10 | 6400 | 217 | 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' | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,051 |
s593466427 | p00033 | u300946041 | 1474698428 | Python | Python3 | py | Accepted | 20 | 7712 | 558 | # -*- 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)) | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,052 |
s430854421 | p00033 | u469154576 | 1479047625 | Python | Python | py | Accepted | 10 | 6236 | 287 | 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" | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,053 |
s717425111 | p00033 | u922871577 | 1479447308 | Python | Python | py | Accepted | 10 | 6336 | 381 | 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' | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,054 |
s574094972 | p00033 | u364509382 | 1479836938 | Python | Python3 | py | Accepted | 40 | 7684 | 576 |
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") | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,055 |
s168454338 | p00033 | u301729341 | 1481175363 | Python | Python3 | py | Accepted | 20 | 7496 | 721 | 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") | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,056 |
s149908940 | p00033 | u777299405 | 1481180536 | Python | Python3 | py | Accepted | 30 | 7472 | 379 | 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") | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,057 |
s104997914 | p00033 | u811733736 | 1481725451 | Python | Python3 | py | Accepted | 30 | 7780 | 2,728 | # 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)) | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,058 |
s602199448 | p00033 | u087002048 | 1482048697 | Python | Python3 | py | Accepted | 20 | 7712 | 797 | 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') | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,059 |
s334962012 | p00033 | u661290476 | 1482443018 | Python | Python3 | py | Accepted | 20 | 7608 | 310 | 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") | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,060 |
s138127475 | p00033 | u661290476 | 1482443136 | Python | Python3 | py | Accepted | 20 | 7660 | 296 | 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") | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,061 |
s088723729 | p00033 | u661290476 | 1482454045 | Python | Python3 | py | Accepted | 20 | 7620 | 346 | 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 | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,062 |
s960627281 | p00033 | u546285759 | 1482992316 | Python | Python3 | py | Accepted | 20 | 7596 | 368 | 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") | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,063 |
s997945426 | p00033 | u711765449 | 1484831088 | Python | Python3 | py | Accepted | 30 | 7680 | 403 | 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]) | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,064 |
s993544627 | p00033 | u078042885 | 1485965683 | Python | Python3 | py | Accepted | 20 | 7592 | 164 | 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]) | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,065 |
s538793827 | p00033 | u252414452 | 1486642011 | Python | Python | py | Accepted | 10 | 6256 | 323 | 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" | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,066 |
s123033605 | p00033 | u901080241 | 1491634924 | Python | Python3 | py | Accepted | 20 | 7532 | 315 | 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") | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,067 |
s033575313 | p00033 | u462831976 | 1492786168 | Python | Python3 | py | Accepted | 20 | 7592 | 614 | # -*- 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') | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,068 |
s976944736 | p00033 | u577311000 | 1493717517 | Python | Python3 | py | Accepted | 30 | 7616 | 570 | # -*- 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
""" | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,069 |
s327773651 | p00033 | u577311000 | 1493718490 | Python | Python3 | py | Accepted | 20 | 7584 | 732 | # -*- 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
""" | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,070 |
s075460074 | p00033 | u577311000 | 1493718569 | Python | Python3 | py | Accepted | 20 | 7656 | 756 | # -*- 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
""" | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,071 |
s176391442 | p00033 | u577311000 | 1493718796 | Python | Python3 | py | Accepted | 20 | 7676 | 756 | # -*- 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
""" | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,072 |
s003008987 | p00033 | u940389926 | 1493720226 | Python | Python3 | py | Accepted | 20 | 7600 | 856 | 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() | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,073 |
s337093243 | p00033 | u940389926 | 1493720275 | Python | Python3 | py | Accepted | 20 | 7588 | 856 | 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() | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,074 |
s894989502 | p00033 | u945345165 | 1493721591 | Python | Python3 | py | Accepted | 30 | 7756 | 1,154 | 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() | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,075 |
s769551422 | p00033 | u945345165 | 1493722174 | Python | Python3 | py | Accepted | 20 | 7732 | 973 | 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 | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,076 |
s129267686 | p00033 | u945345165 | 1493722750 | Python | Python3 | py | Accepted | 30 | 7588 | 914 | 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) | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,077 |
s242259518 | p00033 | u945345165 | 1493723036 | Python | Python3 | py | Accepted | 30 | 7632 | 776 | 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) | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,078 |
s404947421 | p00033 | u945345165 | 1493724065 | Python | Python3 | py | Accepted | 30 | 7648 | 568 | 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) | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,079 |
s740827901 | p00033 | u945345165 | 1493724299 | Python | Python3 | py | Accepted | 30 | 7616 | 568 | 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) | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,080 |
s034629052 | p00033 | u284851373 | 1493725155 | Python | Python3 | py | Accepted | 20 | 7536 | 673 | # -*- coding:utf-8 -*-
#datas = [1 5 2 6 3 7 8 9 10 4]
#datas = [1 4 2 6 5 3 7 8 9 10]
def dfs(datas, b, c, count):
if len(datas) == count: return 1
if int(datas[count]) > b:
return dfs(datas, int(datas[count]), c, count+1)
if int(datas[count]) > c:
return dfs(datas, b, int(datas[count]), count+1)
return 0
def solve():
b=0
c=0
count = 1
q = dfs(datas, b, c, count)
print("YES") if q==1 else print("NO")
counter = 0
while True:
line = input()
if not " " in line:
nums = line
else:
datas = line.split(" ")
q = solve()
counter += 1
if int(nums) == counter:
break | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,081 |
s034515552 | p00033 | u945345165 | 1493725376 | Python | Python3 | py | Accepted | 20 | 7616 | 568 | 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) | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,082 |
s749826275 | p00033 | u940389926 | 1493727479 | Python | Python3 | py | Accepted | 30 | 7620 | 550 | import sys
sys.setrecursionlimit(100000)
def load_balls():
balls = []
LINE_NUM, TOTAL = 0, 0
while True:
line = sys.stdin.readline().strip()
LINE_NUM += 1
if LINE_NUM == 1:
TOTAL = int(line)+1
continue
balls.append([int(i) for i in line.split(" ")])
if LINE_NUM == TOTAL: break
return balls
balls_list = load_balls()
for balls in balls_list:
left, right = [0], [0]
for ball in balls:
if left[-1] < ball: left.append(ball)
elif right[-1] < ball: right.append(ball)
print("YES" if len(left)-1 + len(right)-1 == 10 else "NO") | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,083 |
s005001771 | p00033 | u284851373 | 1493732464 | Python | Python3 | py | Accepted | 30 | 7660 | 620 | # -*- coding:utf-8 -*-
def dfs(datas, b, c, count):
if len(datas) == count: return 1
if int(datas[count]) > b:
return dfs(datas, int(datas[count]), c, count+1)
if int(datas[count]) > c:
return dfs(datas, b, int(datas[count]), count+1)
return 0
def solve():
b=0
c=0
count = 1
q = dfs(datas, b, c, count)
if q==1:
print("YES")
elif q==0:
print("NO")
counter = 0
line = input()
if not " " in line:
nums = line
while True:
line = input()
datas = line.split(" ")
q = solve()
counter += 1
if int(nums) == counter:
break | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,084 |
s646130290 | p00033 | u284851373 | 1493733582 | Python | Python3 | py | Accepted | 30 | 7636 | 620 | # -*- coding:utf-8 -*-
def dfs(datas, b, c, count):
if len(data) == count: return 1
p = int(data[count])
if p > b:
q = dfs(data, p, c, count+1)
if q==1:return 1
if p > c:
q = dfs(data, b, p, count+1)
if q==1:return 1
return 0
def solve():
b=0
c=0
count = 0
q = dfs(data, b, c, count)
if q==1:
print("YES")
elif q==0:
print("NO")
counter = 0
line = input()
if not " " in line:
nums = line
while True:
line = input()
data = line.split(" ")
q = solve()
counter += 1
if int(nums) == counter:
break | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,085 |
s070948095 | p00033 | u898097781 | 1495433386 | Python | Python | py | Accepted | 10 | 6308 | 349 | N = input()
inputs = [map(int, raw_input().split(' ')) for i in range(N)]
for xs in inputs:
a, b = 0, 0
for x in xs:
if min(a,b) > x:
print 'NO'
break
else:
if (a>b and x>a) or (b>x):
a=x
else:
b=x
if x == xs[-1]:
print 'YES' | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,086 |
s093222593 | p00033 | u905313459 | 1496481353 | Python | Python3 | py | Accepted | 30 | 7648 | 243 | n = int(input())
for i in range(n):
l = list(map(int, input().split()))
x = y = z = 0
for j in l:
if j > y:
y = j
elif j > z:
z = j
else:
x = 1
print(["YES", "NO"][x]) | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,087 |
s282080369 | p00033 | u786299861 | 1501513732 | Python | Python3 | py | Accepted | 30 | 7564 | 473 | N = int(input())
for n in range(N):
str = input().split()
list = []
for i in str:
list.append(int(i))
b = []
c = []
ans = True
for a in list:
bLen = len(b)
cLen = len(c)
bLast = bLen - 1 if bLen > 0 else 0
cLast = cLen - 1 if cLen > 0 else 0
if bLen == 0 or b[bLast] < a:
b.append(a)
continue
if b[bLast] > a:
if cLen == 0 or c[cLast] < a:
c.append(a)
continue
else:
ans = False
break
print('YES' if ans is True else 'NO') | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,088 |
s973856057 | p00033 | u546285759 | 1502847754 | Python | Python3 | py | Accepted | 20 | 7668 | 318 | n = int(input())
for _ in range(n):
data = list(map(int, input().split()))
B, C = 0, 0
flag = True
for d in data:
if B < d:
B = d
elif C < d:
C = d
else:
print("NO")
flag = False
break
if flag:
print("YES") | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,089 |
s204411834 | p00033 | u821624310 | 1502886089 | Python | Python3 | py | Accepted | 30 | 7624 | 412 | N = int(input())
for i in range(N):
a = [int(n) for n in input().split()]
b = []
c = []
jurge = "YES"
for n in a:
if len(b) == 0\
or b[len(b)-1] < n:
b.append(n)
elif len(c) == 0\
or c[len(c)-1] < n:
c.append(n)
else:
print("NO")
jurge = "NO"
break
if jurge == "YES":
print("YES") | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,090 |
s908470572 | p00033 | u510797278 | 1504450502 | Python | Python3 | py | Accepted | 30 | 7628 | 656 | BALL_NUM = 10
def main():
n = int(input())
while n > 0:
balls = list(map(int, input().split()))
if dfs(balls, 0, 0):
print("YES")
else:
print("NO")
n -= 1
def dfs(balls, b, c):
if len(balls) == 1:
if balls[0] > b or balls[0] > c:
return True
else:
return False
# ????????????b?????\????????´???
if balls[0] > b and dfs(balls[1:], balls[0], c):
return True
# ????????????c?????\????????´???
if balls[0] > c and dfs(balls[1:], b, balls[0]):
return True
return False
if __name__ == '__main__':
main() | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,091 |
s908352814 | p00033 | u957021183 | 1504851126 | Python | Python3 | py | Accepted | 30 | 7676 | 562 | # Aizu Problem 0033: Ball
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
N = int(input())
for n in range(N):
balls = [int(_) for _ in input().split()][::-1]
left, right = [0], [0]
fail = False
while len(balls) > 0:
ball = balls.pop()
if ball > left[-1]:
left.append(ball)
elif ball > right[-1]:
right.append(ball)
else:
fail = True
break
print("YES" if not fail else "NO") | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,092 |
s079878070 | p00033 | u695154284 | 1505396186 | Python | Python3 | py | Accepted | 50 | 7608 | 439 | def dfs(i, b, c):
if i == 11:
return (b == sorted(b) and c == sorted(c))
if dfs(i + 1, b + [balls[i - 1]], c):
return True
if dfs(i + 1, b, c + [balls[i - 1]]):
return True
return False
if __name__ == '__main__':
N = int(input())
for i in range(N):
balls = list(map(int, input().split()))
if dfs(1, [], []):
print("YES")
else:
print("NO") | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,093 |
s750707839 | p00033 | u845643816 | 1512297473 | Python | Python3 | py | Accepted | 20 | 5600 | 308 | n = int(input())
for i in range(n):
a = list(map(int, input().split()))
b,c = 0,0
for i in range(len(a)):
if b < a[i]:
b = a[i]
continue
if c < a[i]:
c = a[i]
continue
print("NO")
break
else:
print("YES") | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,094 |
s659675862 | p00033 | u845643816 | 1512298086 | Python | Python3 | py | Accepted | 20 | 5592 | 334 | def ball(nums):
b, c = 0, 0
for i in range(len(nums)):
if b < nums[i]:
b = nums[i]
continue
if c < nums[i]:
c = nums[i]
continue
return "NO"
return "YES"
N = int(input())
for _ in range(N):
a = list(map(int, input().split()))
print(ball(a)) | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,095 |
s284587623 | p00033 | u236679854 | 1512773130 | Python | Python3 | py | Accepted | 20 | 5584 | 289 | n = int(input())
for i in range(n):
balls = list(map(int, input().split()))
b = c = 0
for ball in balls:
if b < ball:
b = ball
elif c < ball:
c = ball
else:
print('NO')
break
else:
print('YES') | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,096 |
s630669262 | p00033 | u028347703 | 1514706210 | Python | Python3 | py | Accepted | 20 | 5596 | 395 | for n in range(int(input())):
A = [int(i) for i in input().split()]
B = [0]
C = [0]
for a in A:
if a > B[-1] and a > C[-1]:
if a - B[-1] <= a - C[-1]:
B.append(a)
else:
C.append(a)
elif a > B[-1] and a < C[-1]:
B.append(a)
elif a > C[-1]:
C.append(a)
else:
print("NO")
break
if len(B) + len(C) == 12:
print("YES") | p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,097 |
s228434992 | p00033 | u600263347 | 1515854415 | Python | Python3 | py | Accepted | 20 | 5592 | 523 | 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()
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,098 |
s343027878 | p00033 | u024715419 | 1516347050 | Python | Python3 | py | Accepted | 20 | 5592 | 332 | n = int(input())
for i in range(n):
b = list(map(int, input().split()))
c_r = [-1]
c_l = [-1]
for j in range(10):
if c_r[-1] < b[j]:
c_r.append(b[j])
elif c_l[-1] < b[j]:
c_l.append(b[j])
else:
print("NO")
break
else:
print("YES")
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,099 |
s736454082 | p00033 | u043254318 | 1517595491 | Python | Python3 | py | Accepted | 20 | 5600 | 277 | N = int(input())
for l in range(N):
A = [int(i) for i in input().split()]
B = 0
C = 0
ans = "YES"
for i in range(10):
if A[i] > B:
B = A[i]
elif A[i] > C:
C = A[i]
else:
ans = "NO"
print(ans)
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,100 |
s422583632 | p00033 | u150984829 | 1517972539 | Python | Python3 | py | Accepted | 20 | 5592 | 179 | for _ in[0]*int(input()):
a=list(map(int,input().split()))
b=[a[0]];c=[0]
for e in a[1:]:
if e>b[-1]:b+=[e]
elif e>c[-1]:c+=[e]
else:print('NO');break
else:print('YES')
| p00033 |
<H1>玉</H1>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ball">
</center>
<br/>
<p>
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
</p>
<p>
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 <var>N</var> が与えられます。つづいて、<var>N</var> 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<span>YES</span> または <span>NO</span> を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
</pre>
| 2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
| YES
NO
| 9,101 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.