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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
s160239193 | p00037 | u873482706 | 1435308793 | Python | Python | py | Accepted | 10 | 4468 | 3,752 | #coding: utf-8
def xxx(position, direction):
if direction == 'R' or direction == 'L':
if not (0 <= position[tate] <= 8 and 0 <= position[yoko] <= 3):
return
elif direction == 'U' or direction == 'D':
if not (1 <= position[tate] <= 7 and 0 <= position[yoko] <= 4):
return
if mapp[position[tate]][position[yoko]] == 0:
return
if (position[tate] == 0 and position[yoko] == 0) and direction == 'L' or \
(position[tate] == 1 and position[yoko] == 0) and direction == 'U':
result.append(direction)
print ''.join(result)
return True
elif mapp[position[tate]][position[yoko]] == 1:
result.append(direction)
if kyoto(position, direction): return True
def kyoto(position, direction):
if direction == 'R':
#????????????????´¢
check_position = position[tate]-1, position[yoko]+1
direction = 'U'
if xxx(check_position, direction): return True
#????????????????´¢
check_position = position[tate], position[yoko]+1
direction = 'R'
if xxx(check_position, direction): return True
#????????????????´¢
check_position = position[tate]+1, position[yoko]+1
direction = 'D'
if xxx(check_position, direction): return True
#????????????????´¢
check_position = position[tate], position[yoko]
direction = 'L'
if xxx(check_position, direction): return True
elif direction == 'U':
#????????????????´¢
check_position = position[tate]-1, position[yoko]-1
direction = 'L'
if xxx(check_position, direction): return True
#????????????????´¢
check_position = position[tate]-2, position[yoko]
direction = 'U'
if xxx(check_position, direction): return True
#????????????????´¢
check_position = position[tate]-1, position[yoko]
direction = 'R'
if xxx(check_position, direction): return True
#????????????????´¢
check_position = position[tate], position[yoko]
direction = 'D'
if xxx(check_position, direction): return True
elif direction == 'L':
#????????????????´¢
check_position = position[tate]+1, position[yoko]
direction = 'D'
if xxx(check_position, direction): return True
#????????????????´¢
check_position = position[tate], position[yoko]-1
direction = 'L'
if xxx(check_position, direction): return True
#????????????????´¢
check_position = position[tate]-1, position[yoko]
direction = 'U'
if xxx(check_position, direction): return True
#????????????????´¢
check_position = position[tate], position[yoko]
direction = 'R'
if xxx(check_position, direction): return True
elif direction == 'D':
#????????????????´¢
check_position = position[tate]+1, position[yoko]
direction = 'R'
if xxx(check_position, direction): return True
#????????????????´¢
check_position = position[tate]+2, position[yoko]
direction = 'D'
if xxx(check_position, direction): return True
#????????????????´¢
check_position = position[tate]+1, position[yoko]-1
direction = 'L'
if xxx(check_position, direction): return True
#????????????????´¢
check_position = position[tate], position[yoko]
direction = 'U'
if xxx(check_position, direction): return True
if __name__ == '__main__':
mapp = []
for i in range(9):
mapp.append([int(char) for char in raw_input()])
tate = 0
yoko = 1
result = []
xxx((0,0), 'R') | p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,402 |
s481522383 | p00037 | u379956761 | 1436098277 | Python | Python3 | py | Accepted | 30 | 6780 | 1,050 | import sys
loc = [3, 1]
def print_dir(h):
if h == 0:
print('R', end='')
elif h == 1:
print('D', end='')
elif h == 2:
print('L', end='')
elif h == 3:
print('U', end='')
dir = [[1, 0], [0, 1], [-1, 0], [0, -1]]
hand = 3
board = [[0 for _ in range(11)] for _ in range(11)]
for i, line in enumerate(sys.stdin):
for j, c in enumerate(line.strip()):
board[i+1][1 + (i+1)%2 + j*2] = int(c)
print("R", end='')
while loc != [1, 1]:
for i in range(4):
if board[loc[1]+dir[(hand+i)%4][1]][loc[0]+dir[(hand+i)%4][0]] == 1:
loc[0] += dir[(hand+i)%4][0]*2
loc[1] += dir[(hand+i)%4][1]*2
if i == 1:
print_dir((hand+1)%4)
elif i == 2:
print_dir((hand+2)%4)
hand = (hand+1)%4
elif i == 3:
print_dir((hand+3)%4)
hand = (hand+2)%4
elif i == 0:
print_dir(hand%4)
hand = (hand+3)%4
break
print() | p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,403 |
s048107920 | p00037 | u140201022 | 1449562287 | Python | Python | py | Accepted | 10 | 6368 | 599 | def wall(grid,x,y,d):
if d==0:
return x<4 and grid[y*2][x]=='1'
if d==1:
return y<4 and grid[y*2+1][x]=='1'
if d==2:
return x>0 and grid[y*2][x-1]=='1'
if d==3:
return y>0 and grid[y*2-1][x]=='1'
def move(x,y,d):
if d==0:
return x+1,y,'R'
if d==1:
return x,y+1,'D'
if d==2:
return x-1,y,'L'
if d==3:
return x,y-1,'U'
ans=''
x=y=d=0
grid=[raw_input() for i in range(9)]
while x or y or d < 2:
d=(d+3)%4
while not wall(grid,x,y,d):
d=(d+1)%4
x,y,c=move(x,y,d)
ans=ans+c
print ans | p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,404 |
s353957049 | p00037 | u148101999 | 1460089587 | Python | Python | py | Accepted | 10 | 6280 | 697 | import sys
grid=[line.strip() for line in sys.stdin.readlines()]
xgrid=["0"+grid[i]+"0" for i in xrange(9) if i%2==0]
ygrid=[grid[i] for i in xrange(9) if i%2==1]
ygrid.insert(5,"0"*5)
ygrid.insert(0,"0"*5)
graph=[[None]*5 for i in xrange(5)]
for y in xrange(5):
for x in xrange(5):
graph[y][x]=[ygrid[y][x],xgrid[y][x+1],ygrid[y+1][x],xgrid[y][x]]
nx,ny,dir=0,0,1
di=["U","R","D","L",]
dx=[0,1,0,-1]
dy=[-1,0,1,0]
log=[]
while True:
for i in xrange(4):
if graph[ny][nx][(dir+3)%4]=="1":
dir=(dir+3)%4
log.append(di[dir])
nx,ny=nx+dx[dir],ny+dy[dir]
break
dir=(dir+1)%4
if nx==0 and ny==0:break
print "".join(log) | p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,405 |
s625779063 | p00037 | u130979865 | 1461450050 | Python | Python | py | Accepted | 10 | 6296 | 1,669 | # -*- coding: utf-8 -*-
road_h = [[0 for i in range(6)] for j in range(7)] #?¨??????????
road_v = [[0 for i in range(7)] for j in range(6)] #????????????
ax = ay = 1
ad_list = ['L', 'R', 'U', 'D']
for i in range(9):
line = str(raw_input())
if i % 2 == 0:
for j in range(4):
if line[j] == '1':
road_h[1+i/2][1+j] += 1
else:
for j in range(5):
if line[j] == '1':
road_v[1+i/2][1+j] += 1
ad = 1
ax += 1
ans = 'R'
while True:
if ax == 1 and ay == 1:
break
if ad == 0: #?????????
if road_v[ay][ax]:
ay += 1
ad = 3
elif road_h[ay][ax-1]:
ax -= 1
elif road_v[ay-1][ax]:
ay -= 1
ad = 2
else:
ax += 1
ad = 1
elif ad == 1: #?????????
if road_v[ay-1][ax]:
ay -= 1
ad = 2
elif road_h[ay][ax]:
ax += 1
elif road_v[ay][ax]:
ay += 1
ad = 3
else:
ax -= 1
ad = 0
elif ad == 2: #?????????
if road_h[ay][ax-1]:
ax -= 1
ad = 0
elif road_v[ay-1][ax]:
ay -= 1
elif road_h[ay][ax]:
ax += 1
ad = 1
else:
ay += 1
ad = 3
elif ad == 3: #?????????
if road_h[ay][ax]:
ax += 1
ad = 1
elif road_v[ay][ax]:
ay += 1
elif road_h[ay][ax-1]:
ax -= 1
ad = 0
else:
ay -= 1
ad = 2
ans = ans + ad_list[ad]
print ans | p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,406 |
s605587584 | p00037 | u766477342 | 1469857846 | Python | Python3 | py | Accepted | 20 | 7556 | 1,034 | import sys
n = [input() for i in range(9)]
path = [[0 for i in range(5)] for j in range(5)]
for i, v in enumerate([a[1] for a in enumerate(n) if a[0] % 2 == 0]):
for j in range(4):
if v[j] == '1':
path[i][j] += 1
path[i][j+1] += 2
for i, v in enumerate([a[1] for a in enumerate(n) if a[0] % 2 != 0]):
for j in range(5):
if v[j] == '1':
path[i][j] += 4
path[i+1][j] += 8
dur = {'R':(1, 0, 1),
'L':(2, 0, -1),
'U':(8, -1, 0),
'D':(4, 1, 0)}
dur_next = {'R':('U','R','D','L'),
'L':('D','L','U','R'),
'U':('L','U','R','D'),
'D':('R','D','L','U')}
def walk():
global cx, cy
cx = dur[d][2] + cx
cy = dur[d][1] + cy
def next_D():
global cx,cy,d,dur
for nd in dur_next[d]:
if path[cy][cx] & dur[nd][0]:
d = nd
break
cx = cy = 0
d = 'R'
log = []
while 1:
log.append(d)
walk()
if cx == cy == 0:
break
next_D()
print(''.join(log)) | p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,407 |
s618746368 | p00037 | u358919705 | 1472064301 | Python | Python3 | py | Accepted | 20 | 7800 | 715 | def idx_to_wxy(x, y, idx):
return (2 * x + 1 + (idx % 2) * (2 - idx), 2 * y + 1 + (1 - idx % 2) * (1 - idx))
ws = [[0]*11 for _ in range(11)]
for i in range(1, 10):
if i % 2:
ws[i][2], ws[i][4], ws[i][6], ws[i][8] = map(int, list(input()))
else:
ws[i][1], ws[i][3], ws[i][5], ws[i][7], ws[i][9] = map(int, list(input()))
x = y = 0
ds = list('RDLU')
d = 'R'
while True:
print(d, end='')
idx = ds.index(d)
x += (idx % 2) * (2 - idx)
y += (1 - idx % 2) * (1 - idx)
if x == y == 0:
break
for i in range(-1, 3):
if ws[idx_to_wxy(x, y, (idx + i) % 4)[0]][idx_to_wxy(x, y, (idx + i) % 4)[1]]:
d = ds[(idx + i) % 4]
break
print('') | p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,408 |
s971668572 | p00037 | u650459696 | 1477712944 | Python | Python3 | py | Accepted | 20 | 7672 | 885 | import sys
point = [[[0 for i in range(4)] for j in range(5)] for k in range(5)]
raw = 0
for line in sys.stdin:
way = list(map(int, line.strip()))
if len(way) == 4:
for col in range(4):
if way[col] == 1:
point[raw][col][1] = point[raw][col + 1][3] = 1
elif len(way) == 5:
for col in range(5):
if way[col] == 1:
point[raw][col][2] = point[raw + 1][col][0] = 1
raw += 1
dict = {0:"U", 1:"R", 2:"D", 3:"L"}
cold = [0, 1, 0, -1]
rawd = [-1, 0, 1, 0]
raw = 0
col = 0
nowd = 1
ans = ""
while True:
for dirc in [(x - 1) % 4 for x in range(nowd, nowd + 4)]:
if point[raw][col][dirc] == 1:
ans += dict[dirc]
raw += rawd[dirc]
col += cold[dirc]
nowd = dirc
break
if raw == 0 and col == 0:
break
print(ans) | p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,409 |
s787404304 | p00037 | u901080241 | 1491710137 | Python | Python3 | py | Accepted | 30 | 7484 | 1,459 | def is_wall(x1,y1,x2,y2):
if x1<0 or 4<x1 or y1<0 or 4<y1 or x2<0 or 4<x2 or y2<0 or 4<y2:
return False
elif x1 == x2:
if y1>y2: y1,y2 = y2,y1
if y2-y1 != 1: return False
return (walls[y1*2+1][x1] == "1")
elif y1 == y2:
if x1>x2: x1,x2 = x2,x1
if x2-x1 != 1: return False
return (walls[y1*2][x1] == "1")
else: return False
def nextmove(x,y):
lastmove = moves[-1]
if lastmove == 3: lastmove = -1
if lastmove < -1: lastmove += 4
if is_wall(x,y,x+direction[lastmove+1][1],y+direction[lastmove+1][2]):
return lastmove+1,x+direction[lastmove+1][1],y+direction[lastmove+1][2]
if is_wall(x,y,x+direction[lastmove][1],y+direction[lastmove][2]):
return lastmove,x+direction[lastmove][1],y+direction[lastmove][2]
if is_wall(x,y,x+direction[lastmove-1][1],y+direction[lastmove-1][2]):
return lastmove-1,x+direction[lastmove-1][1],y+direction[lastmove-1][2]
if is_wall(x,y,x+direction[lastmove-2][1],y+direction[lastmove-2][2]):
return lastmove-2,x+direction[lastmove-2][1],y+direction[lastmove-2][2]
direction = [["R",1,0],["U",0,-1],["L",-1,0],["D",0,1]]
walls = []
moves = [0]
for _ in range(9):
walls.append(input())
lastx = 1
lasty = 0
print("R", end = "")
while True:
move,lastx,lasty = nextmove(lastx, lasty)
moves.append(move)
print(direction[move][0], end = "")
if lastx == 0 and lasty == 0: break
print() | p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,410 |
s229709059 | p00037 | u957021183 | 1504859191 | Python | Python3 | py | Accepted | 50 | 7768 | 1,172 | # Aizu Problem 0037: Path on a Grid
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
DIRS = ['R', 'D', 'L', 'U']
DX = [0, 1, 0, -1]
DY = [1, 0, -1, 0]
board = [[[False for _ in range(4)] for __ in range(6)] for ___ in range(6)]
for i in range(9):
l = 4 + i % 2
walls = input().strip()
for j in range(4 + i % 2):
n = int(walls[j])
if n == 1:
if i % 2 == 0:
board[i//2][j+1][1] = True
board[i//2+1][j+1][3] = True
else:
board[i//2+1][j][0] = True
board[i//2+1][j+1][2] = True
out = ""
direc = 0
nx, ny = 0, 1
while True:
if (nx == 1 and ny == 0 and direc == 2) or \
(nx == 0 and ny == 0 and direc == 2):
break
x = nx + DX[direc]
y = ny + DY[direc]
if not board[nx][ny][(direc+1)%4]:
direc = (direc + 1) % 4
nx += DX[direc]
ny += DY[direc]
elif board[nx][ny][direc]:
out += DIRS[direc]
direc = (direc - 1 + 4) % 4
else:
out += DIRS[direc]
nx = x
ny = y
print(out) | p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,411 |
s781289891 | p00037 | u024715419 | 1516953802 | Python | Python3 | py | Accepted | 20 | 5572 | 1,247 | def move(position):
x = position[0]
y = position[1]
d = position[2]
if d == "L":
p = "DLUR"
elif d == "R":
p = "URDL"
elif d == "U":
p = "LURD"
else:
p = "RDLU"
for i in range(4):
if p[i] in grid[y][x]:
d = p[i]
if d == "L":
print("L",end="")
x -= 1
break
elif d == "R":
print("R",end="")
x += 1
break
elif d == "U":
print("U",end="")
y -= 1
break
else:
print("D",end="")
y += 1
break
return [x, y, d]
pos = [1,1,"R"]
grid = [["" for i in range(6)] for j in range(6)]
for i in range(9):
inp = input()
if i%2 == 0:
for j in range(4):
if inp[j] == "1":
grid[i//2 + 1][j + 1] += "R"
grid[i//2 + 1][j + 2] += "L"
else:
for j in range(5):
if inp[j] == "1":
grid[i//2 + 1][j + 1] += "D"
grid[i//2 + 2][j + 1] += "U"
while True:
pos = move(pos)
if pos[0] == 1 and pos[1] == 1:
break
print("")
| p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,412 |
s756654050 | p00037 | u150984829 | 1518103354 | Python | Python3 | py | Accepted | 30 | 5604 | 384 | g=[[0]*5 for _ in[0]*5]
for i in range(9):
e=input()
for j in range(4+i%2):
if int(e[j]):
if i%2:g[i//2][j]+=4;g[i//2+1][j]+=1
else:r=g[i//2];r[j]+=2;r[j+1]+=8
y,x,k=0,1,1
a='1'
while 1:
k=k%4+2
for _ in[0]*4:
k+=1
if g[y][x]&int(2**(k%4)):a+=str(k%4);break
if k%2:x+=[1,-1][(k%4)>1]
else:y+=[-1,1][(k%4)>0]
if x+y==0:break
print(''.join('URDL'[int(c)]for c in a))
| p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,413 |
s110782169 | p00037 | u150984829 | 1518103382 | Python | Python3 | py | Accepted | 20 | 5612 | 384 | g=[[0]*5 for _ in[0]*5]
for i in range(9):
e=input()
for j in range(4+i%2):
if int(e[j]):
if i%2:g[i//2][j]+=4;g[i//2+1][j]+=1
else:r=g[i//2];r[j]+=2;r[j+1]+=8
y,x=0,1
k=1
a='1'
while 1:
k=k%4+2
for _ in[0]*4:
k+=1
if g[y][x]&int(2**(k%4)):a+=str(k%4);break
if k%2:x+=[1,-1][(k%4)>1]
else:y+=[-1,1][(k%4)>0]
if x+y==0:break
print(''.join('URDL'[int(c)]for c in a))
| p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,414 |
s396517023 | p00037 | u150984829 | 1518103565 | Python | Python3 | py | Accepted | 20 | 5608 | 381 | g=[[0]*5 for _ in[0]*5]
for i in range(9):
e=input()
for j in range(4+i%2):
if int(e[j]):
if i%2:g[i//2][j]+=4;g[i//2+1][j]+=1
else:r=g[i//2];r[j]+=2;r[j+1]+=8
y,x=0,1
k=1
a='1'
while 1:
k+=2
for _ in[0]*4:
k+=1
if g[y][x]&int(2**(k%4)):a+=str(k%4);break
if k%2:x+=[1,-1][(k%4)>1]
else:y+=[-1,1][(k%4)>0]
if x+y==0:break
print(''.join('URDL'[int(c)]for c in a))
| p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,415 |
s091245006 | p00037 | u133119785 | 1519477031 | Python | Python3 | py | Accepted | 20 | 5584 | 3,010 | class Board:
def __init__(self,m):
self.m = m
self.x = 0
self.y = 0
self.d = 'e'
def dir(self):
return self.d
def is_origin(self):
return (self.x==0) and (self.y==0)
def north_is_wall(self):
if self.y == 0:
return False
else:
if self.m[2*self.y-1][self.x] == '1':
return True
else:
return False
def east_is_wall(self):
if self.x == 4:
return False
elif m[2*self.y][self.x] == '1':
return True
else:
return False
def west_is_wall(self):
if self.x == 0:
return False
elif m[2*self.y][self.x-1] == '1':
return True
else:
return False
def south_is_wall(self):
# print("x={},y={}".format(self.x,self.y))
if self.y == 4:
return False
elif self.m[2*self.y+1][self.x] == '1':
return True
else:
return False
def go_north(self):
if self.y == 0:
raise "invalid"
else:
self.y -= 1
self.d = 'n'
print("U",end="")
def go_south(self):
if self.y == 5:
raise "invalid"
else:
self.y += 1
self.d = 's'
print("D",end="")
def go_east(self):
if self.x == 4:
raise "go_east"
else:
self.x += 1
self.d = 'e'
print("R",end="")
def go_west(self):
if self.x == 0:
raise "go_west"
else:
self.x -= 1
self.d = 'w'
print("L",end="")
def run(m):
b = Board(m)
init = True
while True:
d = b.dir()
if d == 'e':
if b.north_is_wall():
b.go_north()
elif b.east_is_wall():
b.go_east()
elif b.south_is_wall():
b.go_south()
else:
b.go_west()
elif d == 's':
if b.east_is_wall():
b.go_east()
elif b.south_is_wall():
b.go_south()
elif b.west_is_wall():
b.go_west()
else:
b.go_north()
elif d == 'w':
if b.south_is_wall():
b.go_south()
elif b.west_is_wall():
b.go_west()
elif b.north_is_wall():
b.go_north()
else:
b.go_east()
elif d == 'n':
if b.west_is_wall():
b.go_west()
elif b.north_is_wall():
b.go_north()
elif b.east_is_wall():
b.go_east()
else:
b.go_south()
if (not init) and b.is_origin():
print()
break
init = False
m = []
for _ in range(9):
m.append(list(input()))
run(m)
| p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,416 |
s475101386 | p00037 | u150984829 | 1524993988 | Python | Python3 | py | Accepted | 20 | 5612 | 373 | g=[[0]*5 for _ in[0]*5]
for i in range(9):
e=input()
for j in range(4+i%2):
if int(e[j]):
if i%2:g[i//2][j]+=4;g[i//2+1][j]+=1
else:r=g[i//2];r[j]+=2;r[j+1]+=8
y,x=0,1
k=1
a=[1]
while 1:
k+=2
for _ in[0]*4:
k+=1
if g[y][x]&int(2**(k%4)):a+=[k%4];break
if k%2:x+=[1,-1][(k%4)>1]
else:y+=[-1,1][(k%4)>0]
if x+y==0:break
print(''.join('URDL'[c]for c in a))
| p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,417 |
s741180886 | p00037 | u150984829 | 1525320465 | Python | Python3 | py | Accepted | 20 | 5604 | 369 | g=[[0]*5 for _ in[0]*5]
for i in range(9):
e=input()
for j in range(4+i%2):
if int(e[j]):
if i%2:g[i//2][j]+=4;g[i//2+1][j]+=1
else:r=g[i//2];r[j]+=2;r[j+1]+=8
y,x=0,1
k=1
a=[1]
while 1:
k+=2
for _ in[0]*4:
k+=1
if g[y][x]&int(2**(k%4)):a+=[k%4];break
if k%2:x+=1-2*((k%4)>1)
else:y+=2*((k%4)>0)-1
if x+y==0:break
print(''.join('URDL'[c]for c in a))
| p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,418 |
s997694967 | p00037 | u150984829 | 1525320557 | Python | Python3 | py | Accepted | 20 | 5612 | 368 | g=[[0]*5 for _ in[0]*5]
for i in range(9):
e=input()
for j in range(4+i%2):
if int(e[j]):
if i%2:g[i//2][j]+=4;g[i//2+1][j]+=1
else:r=g[i//2];r[j]+=2;r[j+1]+=8
y,x=0,1
k=1
a=[1]
while 1:
k+=2
for _ in[0]*4:
k+=1
if g[y][x]&int(2**(k%4)):a+=[k%4];break
if k%2:x+=1-2*((k%4)>1)
else:y+=2*((k%4)>0)-1
if x+y<1:break
print(''.join('URDL'[c]for c in a))
| p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,419 |
s075151408 | p00037 | u847467233 | 1530052141 | Python | Python3 | py | Accepted | 20 | 5580 | 763 | # AOJ 0037: Path on a Grid
# Python3 2018.6.27 bal4u
next = [[1,2,4,8],[4,8,1,2],[8,1,2,4],[2,4,8,1]]
tbl = [[0 for c in range(5)] for r in range(5)]
def move(k):
global r, c, last, ans
if k == 1:
r -= 1
last = 2
ans += 'U'
elif k == 2:
c += 1
last = 0
ans += 'R'
elif k == 4:
r += 1
last = 3
ans += 'D'
else:
c -= 1
last = 1
ans += 'L'
for i in range(9):
a = input()
r = i >> 1
if i & 1:
for c in range(5):
if a[c] == '1':
tbl[r ][c] |= 4
tbl[r+1][c] |= 1
else:
for c in range(4):
if a[c] == '1':
tbl[r][c ] |= 2
tbl[r][c+1] |= 8
ans = ""
r, c, last = 0, 0, 0
while True:
for i in range(4):
if tbl[r][c] & next[last][i]:
move(next[last][i])
break;
if r == 0 and c == 0: break
print(ans)
| p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,420 |
s416403663 | p00037 | u197615397 | 1530368113 | Python | Python3 | py | Accepted | 20 | 5576 | 1,278 | class Coordinate(object):
def __init__(self):
self.path = [None, None, None, None]
class Maze(object):
def __init__(self):
self.a = [[Coordinate() for _ in [0]*5] for _ in [0]*5]
def get_room(self, x, y):
return self.a[y][x]
def set_path(self, pos1, pos2):
dir1, dir2 = (0, 2) if pos1[1] == pos2[1] else (1, 3)
self.get_room(*pos1).path[dir1] = pos2
self.get_room(*pos2).path[dir2] = pos1
def solve(self):
result, x, y, direction = "R", 1, 0, 0
direction_sign = "RDLU"
while not(x == 0 and y == 0):
current = self.get_room(x, y)
if current.path[(direction-1)%4]:
direction = (direction-1)%4
elif current.path[direction]:
pass
elif current.path[(direction+1)%4]:
direction = (direction+1)%4
else:
direction = (direction+2)%4
x, y = current.path[direction]
result += direction_sign[direction]
return result
maze = Maze()
for i in range(9):
y = i//2
dx, dy = (1, 0) if i%2 == 0 else (0, 1)
for x, c in enumerate(input()):
if c == "1":
maze.set_path((x, y), (x+dx, y+dy))
print(maze.solve())
| p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,421 |
s831435897 | p00037 | u647766105 | 1356177298 | Python | Python | py | Accepted | 20 | 23000 | 711 | import sys
grid=[line.strip() for line in sys.stdin.readlines()]
xgrid=["0"+grid[i]+"0" for i in xrange(9) if i%2==0]
ygrid=[grid[i] for i in xrange(9) if i%2==1]
ygrid.insert(5,"0"*5)
ygrid.insert(0,"0"*5)
graph=[[None]*5 for i in xrange(5)]
for y in xrange(5):
for x in xrange(5):
graph[y][x]=[ygrid[y][x],xgrid[y][x+1],ygrid[y+1][x],xgrid[y][x]]
nx,ny,dir=0,0,1
DIRECTION=["U","R","D","L",]
dx=[0,1,0,-1]
dy=[-1,0,1,0]
log=[]
while True:
for i in xrange(4):
if graph[ny][nx][(dir+3)%4]=="1":
dir=(dir+3)%4
log.append(DIRECTION[dir])
nx,ny=nx+dx[dir],ny+dy[dir]
break
dir=(dir+1)%4
if nx==0 and ny==0:break
print "".join(log) | p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,422 |
s457658573 | p00037 | u459861655 | 1356309984 | Python | Python | py | Accepted | 10 | 4312 | 1,435 | import sys
def read_inputs():
inputs = []
for i in range(9):
try:
inputs.append(raw_input())
except EOFError:
sys.exit()
return inputs
def create_routes(inputs):
for y, line in enumerate(inputs):
for x, c in enumerate(list(line)):
if c == '1':
if y % 2 == 0:
dots[y/2][x]["R"] = 1
dots[y/2][x+1]["L"] = 1
else:
dots[y/2][x]["D"] = 1
dots[y/2+1][x]["U"] = 1
def move_person(dots):
ret, current = "", "R"
x, y = 0, 0
def find(indexs):
dic = ("R", "D", "L", "U",)
for i in indexs:
if dots[y][x][dic[i]]:
return dic[i]
return ""
while True:
ret += current
if current == "R":
x += 1
current = find([3, 0, 1, 2])
elif current == "D":
y += 1
current = find([0, 1, 2, 3])
elif current == "L":
x -= 1
current = find([1, 2, 3, 0])
elif current == "U":
y -= 1
current = find([2, 3, 0, 1])
else:
print "wrong data"
if x == 0 and y == 0:
break
return ret
dots = [[{'U': 0, 'D': 0, 'L': 0, 'R': 0} for i in range(5)] for j in range(5)]
inputs = read_inputs()
create_routes(inputs)
print move_person(dots) | p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,423 |
s788567534 | p00037 | u246394513 | 1362165449 | Python | Python | py | Accepted | 10 | 4260 | 639 | def wall(d, x, y, z):
if z == 0: return x < 4 and d[y * 2][x] == '1'
if z == 1: return y < 4 and d[y * 2 + 1][x] == '1'
if z == 2: return x > 0 and d[y * 2][x - 1] == '1'
if z == 3: return y > 0 and d[y * 2 - 1][x] == '1'
def move(x, y, z):
if z == 0: return (x + 1, y, 'R')
if z == 1: return (x, y + 1, 'D')
if z == 2: return (x - 1, y, 'L')
if z == 3: return (x, y - 1, 'U')
d = []
p = ""
x = y = z = 0
for i in range(9):
d.append(raw_input())
while x != 0 or y != 0 or z < 2:
z = (z + 3) % 4
while not wall(d, x, y, z):
z = (z + 1) % 4
(x, y, c) = move(x, y, z)
p += c
print p | p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,424 |
s681749983 | p00037 | u542421762 | 1368333680 | Python | Python | py | Accepted | 20 | 4544 | 4,436 |
import sys
class Grid:
def __init__(self, lines):
lines = map((lambda line: list(line)), lines)
l = []
for i in range(len(lines)):
if i % 2 == 0:
l.append(intersperse2(lines[i], '+'))
else:
l.append(intersperse(lines[i], 'x'))
l.insert(0, ['0','x','0','x','0','x','0','x','0'])
l.append(['0','x','0','x','0','x','0','x','0'])
l = map(lambda x: self._outer(x), l)
self.grid = l
def show(self):
for l in self.grid:
print l
return self
def _outer(self, lis):
if lis[0] == '0' or lis[0] == '1':
lis.insert(0, 'x')
else:
lis.insert(0, '0')
if lis[-1] == '0' or lis[-1] == '1':
lis.append('x')
else:
lis.append('0')
return lis
class Walker:
def __init__(self, grid, x, y):
self.grid = grid
self.x = x
self.y = y
self.dir = 'R'
def walk(self):
if self.left() == '1':
return self.to_left()
elif self.ahead() == '1':
return self.to_ahead()
elif self.right() == '1':
return self.to_right()
else:
return self.to_back()
def left(self):
x = self.x
y = self.y
d = self.dir
if d == 'R':
return self.grid.grid[y-1][x]
elif d == 'L':
return self.grid.grid[y+1][x]
elif d == 'U':
return self.grid.grid[y][x-1]
else: # d == 'D'
return self.grid.grid[y][x+1]
def ahead(self):
x = self.x
y = self.y
d = self.dir
if d == 'R':
return self.grid.grid[y][x+1]
elif d == 'L':
return self.grid.grid[y][x-1]
elif d == 'U':
return self.grid.grid[y-1][x]
else: # d == 'D'
return self.grid.grid[y+1][x]
def right(self):
x = self.x
y = self.y
d = self.dir
if d == 'R':
return self.grid.grid[y+1][x]
elif d == 'L':
return self.grid.grid[y-1][x]
elif d == 'U':
return self.grid.grid[y][x+1]
else: # d == 'D'
return self.grid.grid[y][x-1]
def to_left(self):
d = self.dir
if d == 'R':
self.y -= 2
self.dir = 'U'
return 'U'
elif d == 'L':
self.y += 2
self.dir = 'D'
return 'D'
elif d == 'U':
self.x -= 2
self.dir = 'L'
return 'L'
else: # d == 'D'
self.x += 2
self.dir = 'R'
return 'R'
def to_ahead(self):
d = self.dir
if d == 'R':
self.x += 2
return 'R'
elif d == 'L':
self.x -= 2
return 'L'
elif d == 'U':
self.y -= 2
return 'U'
else: # d == 'D'
self.y += 2
return 'D'
def to_right(self):
d = self.dir
if d == 'R':
self.y += 2
self.dir = 'D'
return 'D'
elif d == 'L':
self.y -= 2
self.dir = 'U'
return 'U'
elif d == 'U':
self.x += 2
self.dir = 'R'
return 'R'
else: # d == 'D'
self.x -= 2
self.dir = 'L'
return 'L'
def to_back(self):
d = self.dir
if d == 'R':
self.x -= 2
self.dir = 'L'
return 'L'
elif d == 'L':
self.x += 2
self.dir = 'R'
return 'R'
elif d == 'U':
self.y += 2
self.dir = 'D'
return 'D'
else: # d == 'D'
self.y -= 2
self.dir = 'U'
return 'U'
def intersperse(lis, s):
r = []
for a in lis:
r.append(a)
r.append(s)
r.pop()
return r
def intersperse2(lis, s):
r = []
for a in lis:
r.append(s)
r.append(a)
r.append(s)
return r
lines = sys.stdin.readlines()
lines = map(lambda x: x.rstrip("\r\n"), lines)
grid = Grid(lines)
walker = Walker(grid, 1, 1)
path = []
while True:
path.append(walker.walk())
if (walker.x, walker.y) == (1,1):
break
print ''.join(path) | p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,425 |
s637512599 | p00037 | u104911888 | 1370999167 | Python | Python | py | Accepted | 10 | 4260 | 549 | def wall(grid,x,y,d):
if d==0: return x<4 and grid[y*2][x]=='1'
if d==1: return y<4 and grid[y*2+1][x]=='1'
if d==2: return x>0 and grid[y*2][x-1]=='1'
if d==3: return y>0 and grid[y*2-1][x]=='1'
def move(x,y,d):
if d==0: return (x+1,y,'R')
if d==1: return (x,y+1,'D')
if d==2: return (x-1,y,'L')
if d==3: return (x,y-1,'U')
path=""
x=y=d=0
grid=[raw_input() for i in range(9)]
while x!=0 or y!=0 or d<2:
d=(d+3)%4
while not wall(grid,x,y,d):
d=(d+1)%4
(x,y,c)=move(x,y,d)
path+=c
print path | p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,426 |
s159389318 | p00037 | u782850731 | 1381152095 | Python | Python | py | Accepted | 20 | 4456 | 2,372 | #!/usr/bin/env python
from __future__ import division, print_function
from sys import stdin, exit
def make_destination(wx, wy):
data = [[] for _ in range(5)]
x1 = wx[0]
y1 = wy[0]
append = data[0].append
append(('R' if x1[0] == '1' else '.') +
('D' if y1[0] == '1' else '.') + '..')
for i in range(3):
append(('R' if x1[i+1] == '1' else '.') +
('D' if y1[i+1] == '1' else '.') +
('L' if x1[i] == '1' else '.') + '.')
append('.' + ('D' if y1[4] == '1' else '.') +
('L' if x1[3] == '1' else '.') + '.')
for j in range(1, 4):
y0 = y1
x1 = wx[j]
y1 = wy[j]
append = data[j].append
append(('R' if x1[0] == '1' else '.') +
('D' if y1[0] == '1' else '.') + '.' +
('U' if y0[0] == '1' else '.'))
for i in range(3):
append(('R' if x1[i+1] == '1' else '.') +
('D' if y1[i+1] == '1' else '.') +
('L' if x1[i] == '1' else '.') +
('U' if y0[i+1] == '1' else '.'))
append('.' + ('D' if y1[4] == '1' else '.') +
('L' if x1[3] == '1' else '.') +
('U' if y0[4] == '1' else '.'))
y0 = y1
x1 = wx[4]
append = data[4].append
append(('R' if x1[0] == '1' else '.') + '..' +
('U' if y0[0] == '1' else '.'))
for i in range(3):
append(('R' if x1[i+1] == '1' else '.') + '.' +
('L' if x1[i] == '1' else '.') +
('U' if y0[i+1] == '1' else '.'))
append('..' + ('L' if x1[3] == '1' else '.') +
('U' if y0[4] == '1' else '.'))
return data
def walk(data):
destination = {'R': (1, 0), 'D': (0, 1), 'L': (-1, 0), 'U': (0, -1)}
permutation = {'R': (3, 0, 1, 2), 'D': (0, 1, 2, 3),
'L': (1, 2, 3, 0), 'U': (2, 3, 0, 1)}
print('R', end='')
x = 1
y = 0
move = 'R'
while x != 0 or y != 0:
ways = data[y][x]
for per in permutation[move]:
m = ways[per]
dest = destination.get(m)
if dest is not None:
break
x += dest[0]
y += dest[1]
move = m
print(move, end='')
print()
def main():
wall = stdin.read().split()
walk(make_destination(wall[::2], wall[1::2]))
exit(0)
main() | p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,427 |
s184673950 | p00037 | u912237403 | 1383401878 | Python | Python | py | Accepted | 10 | 4360 | 1,525 | wx=[]
wy=[]
def readdata():
it=0
x=[]
y=[]
while True:
try: tmp = map(int,raw_input())
except:
return x,y
if it%2==0:
x.append(tmp)
else:
y.append(tmp)
it +=1
def nextpath(p, dir0):
tmp = ispath(p, (dir0+3)%4)
if tmp!=[]: return tmp
tmp = ispath(p, dir0)
if tmp!=[]: return tmp
tmp = ispath(p, (dir0+1)%4)
if tmp!=[]: return tmp
tmp = ispath(p, (dir0+2)%4)
if tmp!=[]: return tmp
return tmp
def ispath(p,dir1):
y,x = p
if dir1==0:
if y>0 and wy[y-1][x]==1: return [-1,0]
else: return []
elif dir1==1:
if x<len(wx[0]) and wx[y][x]==1: return [0,1]
else: return []
elif dir1==2:
if y<len(wy[0])-1 and wy[y][x]==1: return [1,0]
else: return []
elif dir1==3:
if x>0 and wx[y][x-1]==1: return [0,-1]
else: return []
return []
def f0037():
p =[0,0]
direction = 1
msg = []
while True:
dp = nextpath(p, direction)
p[0] += dp[0]
p[1] += dp[1]
if dp == [0,1]:
direction = 1
msg.append("R")
elif dp == [0,-1]:
direction = 3
msg.append("L")
elif dp == [1,0]:
direction = 2
msg.append("D")
elif dp == [-1,0]:
direction = 0
msg.append("U")
if p==[0,0]: break
return msg
wx, wy = readdata()
msg = f0037()
print "".join(msg) | p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,428 |
s605459127 | p00037 | u912237403 | 1383434134 | Python | Python | py | Accepted | 20 | 4300 | 865 | wx=[]
wy=[]
def readdata():
z=[]
try:
while True:
z.append(raw_input())
except: return z
def nextpath(p, dir0):
for e in [3,0,1,2]:
dp = ispath(p, (dir0+e)%4)
if dp!=[]: break
return dp
def ispath(p, dir1):
y,x = p
dp = []
if dir1==0 and y>0 and wy[y-1][x]=="1": dp= 0
elif dir1==1 and x<len(wx[0]) and wx[y][x] =="1": dp = 1
elif dir1==2 and y<len(wy[0])-1 and wy[y][x] =="1": dp = 2
elif dir1==3 and x>0 and wx[y][x-1]=="1": dp = 3
return dp
def f0037():
p =[0,0]
dp = 1
msg = []
while True:
dp = nextpath(p, dp)
p[0]+=[-1,0,1,0][dp]
p[1]+=[0,1,0,-1][dp]
msg.append("URDL"[dp])
if p==[0,0]: break
return msg
z = readdata()
wx = z[0::2]
wy = z[1::2]
msg = f0037()
print "".join(msg) | p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,429 |
s846591592 | p00037 | u912237403 | 1383442676 | Python | Python | py | Accepted | 10 | 4288 | 795 | wx=[]
wy=[]
def readdata():
z=[]
try:
while True:
z.append(raw_input())
except: return z
def nextpath(p,dir0):
for e in [3,0,1,2]:
d = (dir0+e)%4
if ispath(p,d): return d
return None
def ispath(p,d):
y,x = p
f=""
try:
if d==0 and y>0: f = wy[y-1][x]
elif d==1 and x<len(wy): f = wx[y][x]
elif d==2 and y<len(wx): f = wy[y][x]
elif d==3 and x>0: f = wx[y][x-1]
except: pass
return f=="1"
def f0037():
p =[0,0]
dp = 1
msg = []
while True:
dp = nextpath(p, dp)
p[0] += [-1,0,1,0][dp]
p[1] += [0,1,0,-1][dp]
msg.append("URDL"[dp])
if p==[0,0]: break
return "".join(msg)
z = readdata()
wx = z[0::2]
wy = z[1::2]
print f0037() | p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,430 |
s116676012 | p00037 | u912237403 | 1394377349 | Python | Python | py | Accepted | 10 | 4280 | 584 | import sys
wx=[]
wy=[]
def readdata():
global wx,wy
i=1
A="0"
wx=[""]
wy=[""]
for s in sys.stdin:
s=s[:-1]
if i: wx.append(A+s+A)
else: wy.append(A+s)
i=1-i
wx[0]=A*len(wx[1])
z=A*len(wy[1])
wy[0]=z
wy.append(z)
return
readdata()
y = 1
x = 1
d = 1
msg = ""
while 1:
A=[3,0,1,2,3,0,1][d:d+4]
wall=[wy[y-1][x],wx[y][x],wy[y][x],wx[y][x-1]]
for e in A:
if wall[e]=="1": break
d = e
y += [-1,0,1,0][d]
x += [0,1,0,-1][d]
msg += "URDL"[d]
if [x,y]==[1,1]: break
print msg | p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,431 |
s319247515 | p00037 | u912237403 | 1394377540 | Python | Python | py | Accepted | 10 | 4280 | 474 | import sys
wx=[]
wy=[]
i=1
A="0"
wx=[A]
wy=[A]
for s in sys.stdin:
s=s[:-1]
if i: wx.append(A+s+A)
else: wy.append(A+s)
i=1-i
wx[0]=A*len(wx[1])
z=A*len(wy[1])
wy[0]=z
wy.append(z)
y = 1
x = 1
d = 1
msg = ""
while 1:
A=[3,0,1,2,3,0,1][d:d+4]
wall=[wy[y-1][x],wx[y][x],wy[y][x],wx[y][x-1]]
for e in A:
if wall[e]=="1": break
d = e
y += [-1,0,1,0][d]
x += [0,1,0,-1][d]
msg += "URDL"[d]
if [x,y]==[1,1]: break
print msg | p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,432 |
s423189164 | p00037 | u633068244 | 1396009403 | Python | Python | py | Accepted | 10 | 4260 | 601 | def wall(grid,x,y,d):
#(0,1,2,3) => (R,D,L,U)
if d == 0: return x < 4 and grid[y*2][x] == '1'
if d == 1: return y < 4 and grid[y*2+1][x] == '1'
if d == 2: return x > 0 and grid[y*2][x-1] == '1'
if d == 3: return y > 0 and grid[y*2-1][x] == '1'
def move(x,y,d):
if d == 0: return x+1,y,'R'
if d == 1: return x,y+1,'D'
if d == 2: return x-1,y,'L'
if d == 3: return x,y-1,'U'
ans = ""
x=y=d=0
grid=[raw_input() for i in range(9)]
while x or y or d < 2:
d = (d+3)%4
while not wall(grid,x,y,d):
d = (d+1)%4
x,y,c = move(x,y,d)
ans += c
print ans | p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,433 |
s712001245 | p00037 | u246033265 | 1396688036 | Python | Python | py | Accepted | 10 | 4252 | 513 | dx, dy, s = [1, 0, -1, 0], [0, 1, 0, -1], 'RDLU'
def f(x, y, d):
x -= int(d == 2)
y = y * 2 + dy[d]
if not(0 <= y < len(a) and 0 <= x < len(a[y])):
return False
return a[y][x] == '1'
a = [raw_input() for i in range(9)]
x = y = d = 0
t = ''
while True:
x += dx[d]
y += dy[d]
t += s[d]
if x == 0 and y == 0:
break
for i in [(d + j + 3) % 4 for j in range(3)]:
if f(x, y, i):
d = i
break
else:
d = (d + 2) % 4
print t | p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,434 |
s608696548 | p00037 | u187074069 | 1595662741 | Python | Python3 | py | Accepted | 20 | 5572 | 956 | mat = [['0', '0', '0', '0', '0']]
for i in range(9):
if i%2 ==0:
tmpc = '0' + input() + '0'
else:
tmpc = input()
mat.append(list(tmpc))
mat.append(['0', '0', '0', '0', '0'])
pos = [0,1]
move = ['R']
while True:
mdict = {'U': [2*pos[0], pos[1]], 'R': [2*pos[0]+1, pos[1]+1], 'D': [2*pos[0]+2, pos[1]], 'L': [2*pos[0]+1, pos[1]]}
if move[-1] == 'R':
belst = ['U', 'R', 'D', 'L']
elif move[-1] == 'D':
belst = ['R', 'D', 'L', 'U']
elif move[-1] == 'L':
belst = ['D', 'L', 'U', 'R']
else:
belst = ['L', 'U', 'R', 'D']
for i in belst:
if mat[mdict[i][0]][mdict[i][1]] == '1':
be = i
break
if be == 'U':
pos[0] -= 1
elif be == 'R':
pos[1] += 1
elif be == 'D':
pos[0] += 1
else:
pos[1] -= 1
move.append(be)
if pos == [0, 0]:
break
print(''.join(move))
| p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,435 |
s368601599 | p00037 | u260980560 | 1589696825 | Python | Python3 | py | Accepted | 20 | 5580 | 912 | import sys
readline = sys.stdin.readline
write = sys.stdout.write
def solve():
N = 5
MP = [[[0]*4 for i in range(N)] for j in range(N)]
dd = ((-1, 0), (0, -1), (1, 0), (0, 1))
ds = "LURD"
for i in range(N):
s = readline().strip()
for j in range(N-1):
if s[j] == '1':
MP[i][j][2] = MP[i][j+1][0] = 1
if i < 4:
s = readline().strip()
for j in range(N):
if s[j] == '1':
MP[i][j][3] = MP[i+1][j][1] = 1
x = 1; y = 0; cd = 2
de = [3, 0, 1, 2]
ans = [2]
while not x == y == 0:
e = MP[y][x]
for d in de:
if e[cd + d - 4]:
cd = (cd + d) % 4
ans.append(cd)
dx, dy = dd[cd]
x += dx; y += dy
break
write("".join(map(ds.__getitem__, ans)))
write("\n")
solve()
| p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,436 |
s123028500 | p00037 | u630911389 | 1585660654 | Python | Python3 | py | Accepted | 20 | 5572 | 786 | table = [input() for i in range(9)]
def isWall(x,y,dir):
# 右
if dir == 0:
return x < 4 and table[y][x] == '1'
# 下
elif dir == 1:
return y < 8 and table[y + 1][x] == '1'
# 左
elif dir == 2:
return x > 0 and table[y][x - 1] == '1'
# 上
elif dir == 3:
return y > 0 and table[y - 1][x] == '1'
ans = ""
x = y = dir = 0
while 1:
# 正面の壁
dir = (dir + 3) % 4
while not isWall(x,y,dir):
# 伝う壁
dir = (dir + 1) % 4
# 移動
if dir == 0:
x += 1
ans += 'R'
elif dir == 1:
y += 2
ans += 'D'
elif dir == 2:
x -= 1
ans += 'L'
elif dir == 3:
y -= 2
ans += 'U'
if x == 0 and y == 0:
break
print(ans)
| p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,437 |
s009540119 | p00037 | u563075864 | 1543423404 | Python | Python3 | py | Accepted | 20 | 5628 | 2,179 | path = [[[] for i in range(5)] for i in range(5)]
for i in range(9):
if i%2 == 0:
a = [int(i) for i in list(input())]
for j in range(4):
if a[j] == 1:
path[int(i/2)][j].append("R")
path[int(i/2)][j+1].append("L")
else:
a = [int(i) for i in list(input())]
for j in range(5):
if a[j] == 1:
path[int(i/2)][j].append("D")
path[int(i/2)+1][j].append("U")
prev = "R"
p = "R"
x = 0
y = 0
while(1):
if prev == "R":
if "U" in path[x][y]:
x -= 1
prev = "U"
p += "U"
elif "R" in path[x][y]:
y += 1
prev = "R"
p += "R"
elif "D" in path[x][y]:
x += 1
prev = "D"
p += "D"
elif "L" in path[x][y]:
y -= 1
prev = "L"
p += "L"
elif prev == "L":
if "D" in path[x][y]:
x += 1
prev = "D"
p += "D"
elif "L" in path[x][y]:
y -= 1
prev = "L"
p += "L"
elif "U" in path[x][y]:
x -= 1
prev = "U"
p += "U"
elif "R" in path[x][y]:
y += 1
prev = "R"
p += "R"
elif prev == "U":
if "L" in path[x][y]:
y -= 1
prev = "L"
p += "L"
elif "U" in path[x][y]:
x -= 1
prev = "U"
p += "U"
elif "R" in path[x][y]:
y += 1
prev = "R"
p += "R"
elif "D" in path[x][y]:
x += 1
prev = "D"
p += "D"
elif prev == "D":
if "R" in path[x][y]:
y += 1
prev = "R"
p += "R"
elif "D" in path[x][y]:
x += 1
prev = "D"
p += "D"
elif "L" in path[x][y]:
y -= 1
prev = "L"
p += "L"
elif "U" in path[x][y]:
x -= 1
prev = "U"
p += "U"
if x == 0 and y == 0:
break
print(p[1:])
| p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,438 |
s772532405 | p00037 | u079141094 | 1518353581 | Python | Python3 | py | Accepted | 20 | 5616 | 1,328 | def solve():
pipes = [[0 for _ in range(6)]]
pipes.extend([list(map(int, '0{0}0'.format(input()))) for _ in range(9)])
pipes.extend([[0 for _ in range(6)]])
last_dirction = 2
x, y = 1, 1
while True:
next_direction = (last_dirction - 1) % 4
while True:
if next_direction == 0:
nx, ny = x, 2*y - 2
if pipes[ny][nx] == 1:
print('U', end='')
x, y = x, y - 1
break
elif next_direction == 1:
nx, ny = x, 2*y - 1
if pipes[ny][nx] == 1:
print('R', end='')
x, y = x + 1, y
break
elif next_direction == 2:
nx, ny = x, 2*y
if pipes[ny][nx] == 1:
print('D', end='')
x, y = x, y + 1
break
else:
nx, ny = x - 1, 2*y - 1
if pipes[ny][nx] == 1:
print('L', end='')
x, y = x - 1, y
break
next_direction = (next_direction + 1) % 4
last_dirction = next_direction
if x == 1 and y == 1:
print()
break
if __name__ == "__main__":
solve()
| p00037 |
<H1>格子上の経路</H1>
<p>
上から見ると図 1 のような形の格子状の広場があります。この格子の各辺に「壁」があるかないかを 0 と 1 の並びで表します。点 A に立って壁に右手をつき、壁に右手をついたまま、矢印の方向に歩き続けて再び点 A に戻ってくるまでの経路を出力するプログラムを作成してください。
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid1">
</t></tr>
</table>
<table>
<tr><th>
図1
</th></tr>
</table>
</center>
<br/>
<H2>Input</H2>
<p>
入力は９行からなり、以下の図 2 に示すように、壁がある場合を 1、ない場合を 0 として、以下の形式で与えられます。
<br><br>
1 行目は一番上の横線の壁の有無を左から 0 と 1 で表した文字列<br>
2 行目はその下の縦線の壁の有無を左から0 と1 で表した文字列<br>
3 行目は上から2 本目の横線の壁の有無を左から0 と1 で表した文字列<br>
...<br>
9 行目は一番下の横線の壁の有無を左から0 と1 で表した文字列<br>
</p>
<center>
<table>
<tr><th>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_pathOnGrid2">
</th></tr>
<tr><th>
図2 (壁あるところを太線で表しています) (対応する数字のならび)
</th></tr>
</table>
</center>
<br/>
<p>
ただし、図１の太線に示すように、点 A から右に 1 区画分は必ず壁があるものとします。すなわち、1 行目の 1 文字目は常に 1 です。
</p>
<H2>Output</H2>
<p>
「図の左方向に一区画分進む」を '<span>L</span>'、「図の右方向に一区画分進む」を '<span>R</span>'、「図の上方向に一区画分進む」を '<span>U</span>'、「図の下方向に一区画分進む」を '<span>D</span>' で表わし、進む順に '<span>L</span>', '<span>R</span>', '<span>U</span>', '<span>D</span>' を１行に並べて出力します。
</p>
<H2>Sample Input</H2>
<pre>
1111
00001
0110
01011
0010
01111
0010
01001
0111
</pre>
<H2>Output for the Sample Input</H2>
<pre>
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
</pre>
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
| 9,439 |
s685224454 | p00038 | u319725914 | 1534845333 | Python | Python3 | py | Accepted | 30 | 6000 | 582 | from collections import Counter
ans = ["null","one pair","two pair","three card","straight","full house","four card"]
straits = [[i,i+1,i+2,i+3,i+4]for i in range(1,10)]
straits.append([1,10,11,12,13])
while(True):
try:
l = sorted(list(map(int,input().split(","))))
v = sorted(list(Counter(l).values()))
p = 0
if v == [1,1,1,2]: p = 1
elif v == [1,2,2]: p = 2
elif v == [1,1,3]: p = 3
elif l in straits: p = 4
elif v == [2,3]: p = 5
elif v == [1,4]: p = 6
print(ans[p])
except:
break
| p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,440 |
s524587750 | p00038 | u858885710 | 1404028723 | Python | Python | py | Accepted | 10 | 4284 | 999 | hand = None
def find(trg, start = 0):
count = 0
m = -1
mm = 0
for i in range(start, 5):
if m == hand[i]:
count += 1
else:
if count == trg:
mm = i
break
m = hand[i]
count = 1
if count == trg:
mm = i
return mm
while True:
try:
hand = map( int, raw_input().split(',') )
except EOFError:
break
hand.sort()
if find(4):
print "four card"
elif find(3) and find(2) and find(3) != find(2):
print "full house"
elif (hand[1] - hand[0]) * (hand[2] - hand[1]) * (hand[3] - hand[2]) * (hand[4] - hand[3]) == 1 or (hand[0] == 1 and hand[1] == 10 and hand[2] == 11 and hand[3] == 12 and hand[4] == 13):
print "straight"
elif find(3):
print "three card"
elif find(2)*find(2,2) and find(2) != find(2, 2):
print "two pair"
elif find(2):
print "one pair"
else:
print "null" | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,441 |
s596595801 | p00038 | u193025715 | 1408272446 | Python | Python3 | py | Accepted | 30 | 6740 | 1,093 | while True:
try:
cards = list(map(int, input().split(',')))
cards.sort()
if len(set(cards)) == 5:
c = cards[0]
if cards == [c, c+1, c+2, c+3, c+4]:
print("straight")
elif cards == [1,10,11,12,13]:
print("straight")
else:
print("null")
else:
if len(set(cards)) == 2:
t = cards.count(cards[0])
if t == 1 or t == 4:
print("four card")
else:
print("full house")
elif len(set(cards)) == 3:
flag = True
i = 0
while flag:
c = cards[i]
if cards.count(c) == 3:
print("three card")
flag = False
if cards.count(c) == 2:
print("two pair")
flag = False
i += 1
else:
print("one pair")
except:
break | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,442 |
s510109411 | p00038 | u506132575 | 1416667338 | Python | Python | py | Accepted | 20 | 4628 | 1,032 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
import collections
def is_four_card(cards):
return cards.most_common(1)[0][-1] == 4
def is_full_house(cards):
return cards.most_common(1)[0][-1] == 3 and cards.most_common(2)[-1][-1] == 2
def is_straight(cards):
if cards[0] == 1 and cards[1:] == [10,11,12,13]: return True
return cards == range(cards[0],cards[0]+5)
def is_three_card(cards):
return cards.most_common(1)[0][-1] == 3
def is_two_pair(cards):
return cards.most_common(2)[0][-1] == 2 and cards.most_common(2)[1][-1] == 2
def is_one_pair(cards):
return cards.most_common(1)[0][-1] == 2
for s in sys.stdin:
d = map(int,s.split(","))
d.sort()
dc = collections.Counter(d)
if is_four_card(dc): print "four card" ; continue
if is_full_house(dc): print "full house" ; continue
if is_straight(d): print "straight" ; continue
if is_three_card(dc): print "three card" ; continue
if is_two_pair(dc): print "two pair" ; continue
if is_one_pair(dc): print "one pair" ; continue
print "null" | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,443 |
s469384682 | p00038 | u567380442 | 1424676546 | Python | Python3 | py | Accepted | 30 | 6752 | 724 | import sys
f = sys.stdin
for line in f:
c = sorted(list(map(int, line.strip().split(','))))
if c[0] == c[3] or c[1] == c[4]:
print('four card')
elif (c[0] == c[2] and c[3] == c[4]) or (c[0] == c[1] and c[2] == c[4]):
print('full house')
elif c[0] == c[2] or c[1] == c[3] or c[2] == c[4]:
print('three card')
else:
cnt = 0
for i in range(4):
if c[i] == c[i + 1]:
cnt += 1
if cnt == 2:
print('two pair')
elif cnt == 1:
print('one pair')
elif c == [1,10,11,12,13] or c[0] == c[1] - 1 == c[2] - 2 == c[3] - 3 == c[4] - 4:
print('straight')
else:
print('null') | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,444 |
s812552225 | p00038 | u744114948 | 1426077032 | Python | Python3 | py | Accepted | 30 | 6724 | 581 | def s(n):
sum=0
for i in range(14):
if n[i] == 1 : sum+=i
if sum % 5 == 0 or sum == 47: return True
return False
while True:
try:
l=map(int, input().split(","))
except:
break
n=[0]*14
for i in l:
n[i]+=1
if 4 in n:
print("four card")
elif 3 in n and 2 in n:
print("full house")
elif 3 in n:
print("three card")
elif 2 == n.count(2):
print("two pair")
elif 2 in n:
print("one pair")
elif s(n):
print("straight")
else:
print("null") | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,445 |
s979883139 | p00038 | u540744789 | 1426780157 | Python | Python | py | Accepted | 20 | 4232 | 751 | def yaku(card):
table=[0]*13
for i in range(5):
table[card[i]-1]+=1
if table.count(4)!=0:
return "four card"
elif table.count(3)!=0:
if table.count(2)!=0:
return "full house"
else:
return "three card"
elif table.count(2)!=0:
if table.count(2)==2:
return "two pair"
else:
return "one pair"
else:
if ",".join(map(str,card)) in "1,2,3,4,5,6,7,8,9,10,11,12,13" or\
",".join(map(str,card)) in "1,10,11,12,13":
return "straight"
else:
return "null"
while True:
try:
card=map(int,raw_input().split(","))
card.sort()
print yaku(card)
except:
break | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,446 |
s028531585 | p00038 | u873482706 | 1434811308 | Python | Python | py | Accepted | 20 | 4264 | 1,402 | import sys
def heaven():
result_dic = {}
check_num_lis = []
for i in range(5):
check_num = card_lis[0]
if not check_num in check_num_lis:
for card in card_lis[1:]:
if card == check_num:
if not card in result_dic:
result_dic[card] = 2
else:
result_dic[card] = result_dic[card] + 1
check_num_lis.append(check_num)
card_lis.append(check_num)
del card_lis[0]
suicide(result_dic)
def suicide(result_dic):
result = result_dic.values()
result.sort()
if result == [2]:
print 'one pair'
elif result == [2,2]:
print 'two pair'
elif result == [3]:
print 'three card'
elif result == [4]:
print 'four card'
elif result == [2,3]:
print 'full house'
elif not result:
card_lis.sort()
if card_lis == [1,10,11,12,13]:
print 'straight'
else:
check_num = card_lis[0]
for card in card_lis:
if card == check_num:
check_num = card + 1
else:
print 'null'
break
else:
print 'straight'
for input_line in sys.stdin:
card_lis = [int(char) for char in input_line.split(',')]
heaven() | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,447 |
s203896905 | p00038 | u379956761 | 1443343439 | Python | Python3 | py | Accepted | 30 | 7748 | 1,350 | import sys
def is_onepair(x):
for i in range(4):
if x.count(x[i]) == 2:
return True
return False
def is_twopair(x):
count = 0
i = 0
x.sort()
while i < 5:
if x.count(x[i]) == 2:
i += 2
count += 1
else:
i += 1
if count == 2:
return True
return False
def is_threecard(x):
for i in range(3):
if x.count(x[i]) == 3:
return True
return False
def is_straight(x):
x.sort()
if x[0] == 1 and x[1:] == [10, 11, 12, 13]:
return True
for i in range(4):
if x[i]+1 != x[i+1]:
return False
return True
def is_fullhouse(x):
if is_threecard(x) and is_onepair(x):
return True
return False
def is_fourcard(x):
for i in range(2):
if x.count(x[i]) == 4:
return True
return False
for line in sys.stdin.readlines():
hand = list(map(int, line.split(',')))
if is_fourcard(hand):
print("four card")
elif is_fullhouse(hand):
print("full house")
elif is_straight(hand):
print("straight")
elif is_threecard(hand):
print("three card")
elif is_twopair(hand):
print("two pair")
elif is_onepair(hand):
print("one pair")
else:
print("null") | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,448 |
s550145540 | p00038 | u489809100 | 1446563668 | Python | Python | py | Accepted | 10 | 6472 | 628 | pair = [["null","one pair","two pair"],["three card","full house"]]
while True:
try:
card = map(int,raw_input().split(","))
except EOFError:
break
hand = [0,0,0,0,0,0,0,0,0,0,0,0,0]
one = 0
three= 0
four = 0
straight = 0
for i in range(0, 5):
hand[card[i] - 1] += 1
for i in range(0, 13):
if hand[i] == 2:
one += 1
elif hand[i] == 3:
three += 1
elif hand[i] == 4:
four = 1
if hand[i] == 1:
straight += 1
elif straight != 5:
straight = 0
if straight == 4 and hand[0] == 1 or straight == 5:
print "straight"
elif four == 1:
print "four card"
else:
print pair[three][one] | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,449 |
s048928859 | p00038 | u775586391 | 1448534597 | Python | Python3 | py | Accepted | 30 | 7624 | 422 | import sys
for line in sys.stdin.readlines():
l = [int(i) for i in line.split(',')]
l.sort()
n =sum([l.count(i) for i in l])
if n == 17:
print('four card')
elif n == 13:
print('full house')
elif n == 11:
print('three card')
elif n == 9:
print('two pair')
elif n == 7:
print('one pair')
elif max(l)-min(l)==4 or (l[1] == 10 and l[0]==1):
print('straight')
else:
print('null') | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,450 |
s123950695 | p00038 | u140201022 | 1448734052 | Python | Python | py | Accepted | 10 | 6476 | 577 | while 1:
try:
l=map(int,raw_input().split(','))
l.sort()
if l.count(l[2])==4:
print 'four card'
elif len(set(l))==2:
print 'full house'
elif l[0]==(l[1]-1)==(l[2]-2)==(l[3]-3)==(l[4]-4) or (l[0]+9)==(l[1])==(l[2]-1)==(l[3]-2)==(l[4]-3):
print 'straight'
elif l.count(l[2])==3:
print 'three card'
elif len(set(l))==3:
print 'two pair'
elif len(set(l))==4:
print 'one pair'
else:
print 'null'
except:
break | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,451 |
s634391996 | p00038 | u075836834 | 1459332221 | Python | Python3 | py | Accepted | 20 | 7820 | 778 | def function(a,b,c,d,e):
A=[a,b,c,d,e]
A.sort()
#4card
if A[0]==A[3] or A[1]==A[4]:
print("four card")
#Full house
elif (A[0]==A[1] and A[2]==A[4]) or (A[0]==A[2] and A[3]==A[4]):
print("full house")
#three card
elif A[0]==A[2] or A[1]==A[3] or A[2]==A[4]:
print("three card")
elif (A[0]==A[1] and A[2]==A[3]) or (A[0]==A[1] and A[3]==A[4]) or (A[1]==A[2] and A[3]==A[4]):
print("two pair")
elif A[0]==A[1] or A[1]==A[2] or A[2]==A[3] or A[3]==A[4]:
print("one pair")
#straight A?????????
elif A==[1,10,11,12,13]:
print("straight")
#straight A???????????????
elif A[0]==A[1]-1==A[2]-2==A[3]-3==A[4]-4:
print("straight")
else:
print("null")
while True:
try:
a,b,c,d,e=map(int,input().split(','))
function(a,b,c,d,e)
except EOFError:
break | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,452 |
s640366106 | p00038 | u075836834 | 1459332336 | Python | Python3 | py | Accepted | 30 | 7752 | 694 | def function(a,b,c,d,e):
A=[a,b,c,d,e]
A.sort()
if A[0]==A[3] or A[1]==A[4]:
print("four card")
elif (A[0]==A[1] and A[2]==A[4]) or (A[0]==A[2] and A[3]==A[4]):
print("full house")
elif A[0]==A[2] or A[1]==A[3] or A[2]==A[4]:
print("three card")
elif (A[0]==A[1] and A[2]==A[3]) or (A[0]==A[1] and A[3]==A[4]) or (A[1]==A[2] and A[3]==A[4]):
print("two pair")
elif A[0]==A[1] or A[1]==A[2] or A[2]==A[3] or A[3]==A[4]:
print("one pair")
elif A==[1,10,11,12,13]:
print("straight")
elif A[0]==A[1]-1==A[2]-2==A[3]-3==A[4]-4:
print("straight")
else:
print("null")
while True:
try:
a,b,c,d,e=map(int,input().split(','))
function(a,b,c,d,e)
except EOFError:
break | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,453 |
s778282915 | p00038 | u148101999 | 1460006097 | Python | Python | py | Accepted | 10 | 6324 | 1,130 | import sys
def inp():
word = []
for line in sys.stdin:
word = map(int, line.split(","))
syori(sorted(word))
def syori(word):
flag = [0,0]
if sum(word[1:5]) == 46:
word.append(int(word[0]))
del word[0]
if word == [10,11,12,13,1]:
print "straight"
else:
for j in xrange(1,14):
if word.count(j) == 2:
flag[0] += 1
elif word.count(j) == 3:
flag[1] += 1
elif word.count(j) == 4:
print "four card"
flag = [10,10]
break
elif word[0] + 2 == word[1] + 1 == word[2] == word[3] - 1 == word[4] - 2:
print "straight"
flag = [10,10]
break
if flag[0] == flag[1] == 1:
print "full house"
elif flag[0] == 1:
print "one pair"
elif flag[0] == 2:
print "two pair"
elif flag[1] == 1:
print "three card"
elif flag[0] < 1 or flag[1] < 1:
print "null"
if __name__ == "__main__":
inp()
| p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,454 |
s533885760 | p00038 | u130979865 | 1461149040 | Python | Python | py | Accepted | 10 | 6380 | 1,073 | # -*- coding: utf-8 -*-
import sys
poker = ["0", "null", "one pair", "two pair", "three card", "straight", "full house", "four card"]
for line in sys.stdin:
H = map(int, line.split(','))
H.sort()
if H[0] == H[1] == H[2] == H[3] or H[1] == H[2] == H[3] == H[4]:
print poker[7]
elif H[0] == H[1] or H[1] == H[2] or H[2] == H[3] or H[3] == H[4]:
if H[0] == H[1] == H[2] or H[1] == H[2] == H[3] or H[2] == H[3] == H[4]:
if H[0] == H[1] and H[2] == H[3] == H[4] or H[0] == H[1] == H[2] and H[3] == H[4]:
print poker[6]
else:
print poker[4]
else:
if H[0] == H[1] and H[2] == H[3] or H[0] == H[1] and H[3] == H[4] or H[1] == H[2] and H[3] == H[4]:
print poker[3]
else:
print poker[2]
else:
if H[0] == 1 and H[4] == 13:
H[0] += 13
H.sort()
if H[0]+1 == H[1] and H[1]+1 == H[2] and H[2]+1 == H[3] and H[3]+1 == H[4]:
print poker[5]
else:
print poker[1] | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,455 |
s468260245 | p00038 | u896025703 | 1469766138 | Python | Python3 | py | Accepted | 30 | 7892 | 521 | import sys
from collections import Counter
straight = [list(range(i, i+5)) for i in range(1, 10)] + [[1,10,11,12,13]]
def hantei(hand):
l = sorted(Counter(hand).values(), reverse=True)
if l[0] == 4: return "four card"
if l[0] == 3 and l[1] == 2: return "full house"
if hand in straight: return "straight"
if l[0] == 3: return "three card"
if l[0] == l[1] == 2: return "two pair"
if l[0] == 2: return "one pair"
return "null"
for line in sys.stdin:
hand = sorted(map(int, line.split(',')))
print(hantei(hand)) | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,456 |
s471218610 | p00038 | u766477342 | 1469864430 | Python | Python3 | py | Accepted | 30 | 8008 | 783 | from collections import Counter
def is_strait(_cnt):
f = 0
for i in range(14):
if _cnt[(i % 13) + 1] == 1:
f += 1
if f == 5:
return True
else:
f = 0
return False
try:
while 1:
cnt = Counter(map(int,input().split(',')))
mc = cnt.most_common(2)
if mc[0][1] == 4:
print('four card')
elif mc[0][1] == 3 and mc[1][1] == 2:
print('full house')
elif mc[0][1] == 3:
print('three card')
elif mc[0][1] == mc[1][1] == 2:
print('two pair')
elif mc[0][1] == 2:
print('one pair')
elif is_strait(cnt):
print('straight')
else:
print('null')
except:
pass | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,457 |
s179621227 | p00038 | u358919705 | 1472065958 | Python | Python3 | py | Accepted | 20 | 7712 | 819 | while True:
try:
cards = list(map(int, input().split(',')))
except:
break
cards.sort()
if cards.count(cards[2]) == 4:
print('four card')
elif cards.count(cards[2]) == 3:
if cards[0] == cards[1] and cards[3] == cards[4]:
print('full house')
else:
print('three card')
elif (cards[1] < cards[2] < cards[3] < cards[4]) and cards[4] - cards[1] == 3\
and (cards[0] == cards[4] - 4 or cards[0] == cards[4] - 12):
print('straight')
elif (cards[0] == cards[1] and (cards[2] == cards[3] or cards[3] == cards[4]))\
or (cards[1] == cards[2] and cards[3] == cards[4]):
print('two pair')
elif max(cards.count(cards[i]) for i in range(5)) == 2:
print('one pair')
else:
print('null') | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,458 |
s717023054 | p00038 | u650459696 | 1479483691 | Python | Python3 | py | Accepted | 30 | 7916 | 731 | from collections import Counter
while True:
try:
card = list(map(int, input().split(",")))
except:
break
counter = Counter(card)
mc = counter.most_common()
if len(mc) == 2:
if mc[0][1] == 4:
print("four card")
else:
print("full house")
elif len(mc) == 3:
if mc[0][1] == 3:
print("three card")
else:
print("two pair")
elif len(mc) == 4:
print("one pair")
else:
t = sorted([mc[i][0] for i in range(len(mc))])
if t[4]-t[3] == t[3]-t[2] == t[2]-t[1] and \
(t[1]-t[0] or (t[0] == 1 and t[4] == 13)):
print("straight")
else:
print("null") | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,459 |
s435131819 | p00038 | u301729341 | 1481278764 | Python | Python3 | py | Accepted | 20 | 7492 | 981 | while True:
try:
Size = []
Card_Lis = list(map(int,input().split(",")))
Card_Lis.sort()
for tag in sorted(set(Card_Lis), key=Card_Lis.index):
Size.append(Card_Lis.count(tag))
Size.sort()
if max(Size) == 4:
print("four card")
elif Size == [2,3]:
print("full house")
elif max(Size) == 3:
print("three card")
elif Size == [1,2,2]:
print("two pair")
elif max(Size) == 2:
print("one pair")
elif max(Size) == 1:
if Card_Lis[0] == 1:
if Card_Lis == [1,2,3,4,5] or Card_Lis == [1,10,11,12,13]:
print("straight")
else:
print("null")
elif Card_Lis[0] + 4 == Card_Lis[4]:
print("straight")
else:
print("null")
except EOFError:
break | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,460 |
s930762150 | p00038 | u811733736 | 1481781668 | Python | Python3 | py | Accepted | 30 | 7908 | 1,850 | import sys
from collections import Counter
class Poker(object):
def __init__(self, cards):
# ?????????????????????????????????????????§?????????(??????)???????????????
self.cards = cards[:]
self.cards.sort(reverse=True)
def evaluate_hand(self):
""" ???????????????????????????????????????????????????
????????????????????\??????????????????????????????????????§?????????????????\???????????¬????????????????????\???????????????????????¬????????????????????\?????±????????????
- null
- one pair
- two pair
- three card
- straight
- full house
- four card
"""
if (self.cards[0] == self.cards[1]+1 == self.cards[2]+2 == self.cards[3]+3 == self.cards[4]+4) or \
(self.cards[0] == 13 and self.cards[1] == 12 and self.cards[2] == 11 and self.cards[3] == 10 and self.cards[4] ==1):
return 'straight'
else:
c = Counter(self.cards)
hand = c.most_common() # ????????°?????????????????°????????????????????????(???: ????????????)?????????????????????????????????
if hand[0][1] == 4:
return 'four card'
elif hand[0][1] == 3 and hand[1][1] == 2:
return 'full house'
elif hand[0][1] == 3:
return 'three card'
elif hand[0][1] == 2 and hand[1][1] == 2:
return 'two pair'
elif hand[0][1] == 2:
return 'one pair'
else:
return 'null'
if __name__ == '__main__':
# ??????????????\???
for line in sys.stdin:
cards = [int(x) for x in line.strip().split(',')]
# ??????????????????
p1 = Poker(cards)
result = p1.evaluate_hand()
# ???????????¨???
print(result) | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,461 |
s602691939 | p00038 | u711765449 | 1484971783 | Python | Python3 | py | Accepted | 20 | 7660 | 924 | def hand(card):
m = 0
n = [0]*13
val = 0
for i in range(13):
n[i] = card.count(str(i+1))
for i in range(13):
if n[i] == 4:
return 'four card'
for i in range(13):
if n[i] == 3:
for j in range(13):
if n[j] == 2:
return 'full house'
return 'three card'
for i in range(13):
if n[i] == 2:
for j in range(i+1,13):
if n[j] == 2:
return 'two pair'
return 'one pair'
for i in range(len(card)):
card[i] = int(card[i])
card.sort()
if card == [1,10,11,12,13]:
return 'straight'
for i in range(4):
if card[4-i] - card[4-i-1] != 1:
return 'null'
return 'straight'
while True:
try:
card = input().split(',')
print(hand(card))
except:
break | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,462 |
s867667442 | p00038 | u546285759 | 1486372898 | Python | Python3 | py | Accepted | 30 | 7788 | 717 | def isstraight(cs):
if 1 in cs:
if cs==[1,2,3,4,5] or cs==[1,10,11,12,13]:
return True
else:
return False
else:
for i in range(len(cs)-1):
if cs[i+1]!=cs[i]+1:
return False
return True
while 1:
try:
c= list(map(int, input().split(',')))
except:
break
l= [c.count(i) for i in set(c)]
ans= {7: "four card", 6: "full house", 5: "straight", 4: "three card", 3: "two pair", 2: "one pair", 1: "null"}
if len(set(c))==5:
v= 5 if isstraight(sorted(c)) else 1
else:
v= 7 if 4 in l else(6 if 3 in l and 2 in l else(4 if 3 in l else(3 if l.count(2)==2 else 2)))
print(ans[v]) | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,463 |
s458697213 | p00038 | u078042885 | 1486509843 | Python | Python3 | py | Accepted | 20 | 7588 | 323 | while 1:
try:n=sorted(map(int,input().split(',')))
except:break
c=sum(n.count(x) for x in n)
if c==17:c=3
elif c in [13,11,9,7]:c-=5
elif max(n)-min(n)==4 or (n[1] == 10 and n[0]==1):c=1
else:c=0
print(['null','straight','one pair','four card','two pair','','three card','','full house'][c]) | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,464 |
s294910688 | p00038 | u032662562 | 1487124885 | Python | Python3 | py | Accepted | 30 | 7656 | 886 | import re
chars = {'10':'D', '11':'J', '12':'Q', '13':'K'}
while True:
try:
f = sorted(map(int, input().strip().split(',')))
g = list(map(str,f.copy()))
for i in chars.keys():
while i in g:
g[g.index(i)] = chars[i]
h = ''.join(g)
if re.search(r'(.)\1\1\1', h):
print('four card')
elif re.search(r'(.)\1\1(.)\2', h) or re.search(r'(.)\1(.)\2\2', h):
print('full house')
elif (f[1]==f[0]+1 and f[2]==f[0]+2 and f[3]==f[0]+3 and f[4]==f[0]+4) or h=='1DJQK':
print('straight')
elif re.search(r'(.)\1\1', h):
print('three card')
elif re.search(r'(.)\1.?(.)\2', h):
print('two pair')
elif re.search(r'(.)\1', h):
print('one pair')
else:
print('null')
except EOFError:
break | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,465 |
s136188129 | p00038 | u964040941 | 1489950500 | Python | Python3 | py | Accepted | 30 | 7592 | 1,567 | N = 13
while True:
try:
A = list(map(int,input().split(',')))
except EOFError:
break
flag = False
for i in range(1,N + 1):
if A.count(i) == 4:
flag = True
print('four card')
break
if flag:
continue
for i in range(1,N + 1):
for j in range(1,N + 1):
if i == j:
continue
if A.count(i) == 3 and A.count(j) == 2:
flag = True
print('full house')
break
if flag:
break
if flag:
continue
for i in range(1,11):
cnt = 0
for j in range(0,5):
if i + j == 14:
cnt += A.count(1) > 0
else:
cnt += A.count(i + j) > 0
if cnt == 5:
flag = True
print('straight')
break
if flag:
continue
for i in range(1,N + 1):
if A.count(i) == 3:
flag = True
print('three card')
break
if flag:
continue
for i in range(1,N + 1):
for j in range(1,N + 1):
if i == j:
continue
if A.count(i) == 2 and A.count(j) == 2:
flag = True
print('two pair')
break
if flag:
break
if flag:
continue
for i in range(1,N + 1):
if A.count(i) == 2:
flag = True
print('one pair')
break
if flag:
continue
print('null') | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,466 |
s891403099 | p00038 | u901080241 | 1491710881 | Python | Python3 | py | Accepted | 30 | 7552 | 1,194 | while True:
try:
rawhand = input().split(",")
hand = [0]*14
for card in rawhand:
if card =="A" : hand[1] += 1
elif card =="J" : hand[11] += 1
elif card =="Q" : hand[12] += 1
elif card =="K" : hand[13] += 1
else: hand[int(card)] += 1
pairs = 0
three = False
four = False
minone = 0
for i in range(14):
ranks = hand[i]
if ranks == 1 and minone == 0: minone = i
elif ranks == 2: pairs += 1
elif ranks == 3: three = True
elif ranks == 4: four = True; break
straight = hand[minone]==1 and hand[minone+1]==1 and hand[minone+2]==1 and hand[minone+3]==1 and hand[minone+4]==1
straight = straight or (hand[1]==1 and hand[10]==1 and hand[11]==1 and hand[12]==1 and hand[13]==1)
if four: print("four card")
elif three and pairs == 1: print("full house")
elif straight: print("straight")
elif three: print("three card")
elif pairs == 2: print("two pair")
elif pairs == 1: print("one pair")
else: print("null")
except EOFError:
break | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,467 |
s011202627 | p00038 | u462831976 | 1492874681 | Python | Python3 | py | Accepted | 20 | 7616 | 1,071 | # -*- coding: utf-8 -*-
import sys
import os
for s in sys.stdin:
A = list(map(int, s.split(',')))
A.sort()
#print(A)
if (A[0] == A[1] == A[2] == A[3]) or (A[1] == A[2] == A[3] == A[4]):
print('four card')
# full house
elif (A[0] == A[1] == A[2]) and (A[3] == A[4]):
print('full house')
elif (A[0] == A[1]) and (A[2] == A[3] == A[4]):
print('full house')
# straight
elif A[0] == A[1] - 1 == A[2] - 2 == A[3] - 3 == A[4] - 4:
print('straight')
elif A[1] == 10 and A[2] == 11 and A[3] == 12 and A[4] == 13 and A[0] == 1:
print('straight')
# three card
elif (A[0] == A[1] == A[2]) or (A[1] == A[2] == A[3]) or (A[2] == A[3] == A[4]):
print('three card')
# two pair
elif ((A[0] == A[1]) and (A[2] == A[3])) or ((A[0] == A[1]) and (A[3] == A[4])) or ((A[1] == A[2]) and (A[3] == A[4])):
print('two pair')
# one pair
elif (A[0] == A[1]) or (A[1] == A[2]) or (A[2] == A[3]) or (A[3] == A[4]):
print('one pair')
else:
print('null') | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,468 |
s402391592 | p00038 | u868716420 | 1495919234 | Python | Python3 | py | Accepted | 30 | 7716 | 832 | while True :
try :
temp = [int(_) for _ in input().split(',')]
length = len(set(temp))
if length == 2 :
if temp.count(temp[0]) == 1 or temp.count(temp[0]) == 4 : print('four card')
else : print('full house')
elif length == 3 :
for _ in set(temp) :
if temp.count(_) == 2 :
print('two pair')
break
elif temp.count(_) == 3 :
print('three card')
break
elif length == 4 : print('one pair')
else :
temp.sort(reverse = True)
test = [(temp[0] - _) for _ in range(5)]
if temp == test or temp == [13, 12, 11, 10, 1] : print('straight')
else : print('null')
except :
break | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,469 |
s119669377 | p00038 | u957021183 | 1504859749 | Python | Python3 | py | Accepted | 30 | 7792 | 1,020 | # Aizu Problem 0038: Poker Hand
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
def is_straight(hand):
if hand == [1, 10, 11, 12, 13]:
return True
m = min(hand)
if hand == list(range(m, m + 5)):
return True
return False
def poker_hand(hand):
hand = sorted(hand)
counts = {}
for card in hand:
counts[card] = counts.get(card, 0) + 1
counts = sorted(list(counts.values()))
if counts == [1, 4]:
return "four card"
elif counts == [2, 3]:
return "full house"
elif is_straight(hand):
return "straight"
elif counts == [1, 1, 3]:
return "three card"
elif counts == [1, 2, 2]:
return "two pair"
elif counts == [1, 1, 1, 2]:
return "one pair"
else:
return "null"
while True:
try:
hand = [int(_) for _ in input().split(',')]
except EOFError:
break
print(poker_hand(hand)) | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,470 |
s423717568 | p00038 | u028347703 | 1514704554 | Python | Python3 | py | Accepted | 20 | 5620 | 1,111 | import sys
def checkPairs(cards):
result = {}
for card in cards:
if cards.count(card) >= 2:
result.update({card: cards.count(card)})
keysNum = len(result.keys())
values = list(result.values())
if keysNum == 0:
return "null"
elif keysNum == 2:
if values.count(3) > 0:
return "full house"
else:
return "two pair"
else:
if values.count(4) > 0:
return "four card"
elif values.count(3) > 0:
return "three card"
else:
return "one pair"
def checkStraight(cards):
if cards.count(1) > 0:
if cards[1] == 10 and cards[2] == 11 and cards[3] == 12 and cards[4] == 13:
return True
if cards[0] == cards[1] - 1 and cards[1] == cards[2] - 1 and cards[2] == cards[3] - 1 and cards[3] == cards[4] - 1:
return True
else:
return False
for line in sys.stdin:
try:
cards = [int(i) for i in line.split(',')]
cards.sort()
result = checkPairs(cards)
if result == "full house" or result == "four card":
print(result)
else:
print("straight" if checkStraight(cards) else result)
except:
break | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,471 |
s831566959 | p00038 | u600263347 | 1516256953 | Python | Python3 | py | Accepted | 30 | 5640 | 1,466 | from itertools import permutations
import sys
import os
def inini(_card):
for i in range(len(_card)):
_card[i] = 0
def main():
for s in sys.stdin:
card = 14*[0]
inini(card)
number = list(map(int,s.split(',')))
for v in number:
card[v] += 1
one_pair = 0
tree_card = 0
four_card = 0
for value in sorted(set(number),key=number.index):
if card[value] == 2:
one_pair += 1
elif card[value] == 3:
tree_card += 1
elif card[value] == 4:
four_card += 1
number.sort()
if one_pair == 1 and tree_card ==1:
print('full house')
elif one_pair == 1:
print('one pair')
elif one_pair == 2:
print('two pair')
elif tree_card == 1:
print('three card')
elif four_card == 1:
print('four card')
elif number[0] == number[1]-1 == number[2]-2 == number[3]-3 == number[4]-4:
print('straight')
elif number[0] == 1 and number[1] == 10 and number[2] == 11 and number[3] == 12 and number[4] == 13:
print('straight')
else:
print('null')
if __name__ == '__main__':
main()
| p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,472 |
s604111606 | p00038 | u024715419 | 1517293411 | Python | Python3 | py | Accepted | 20 | 5608 | 783 | straight = [[i for i in range(j,j + 5)] for j in range(1,10)]
straight.append([1,10,11,12,13])
while True:
try:
h = list(map(int, input().split(",")))
h_s = sorted(h)
p = []
for i in range(4):
if h_s[i] != h_s[i + 1]:
p.append(i)
if len(p) == 1:
if p[0] == 0 or p[0] == 3:
print("four card")
else:
print("full house")
elif h_s in straight:
print("straight")
elif len(p) == 2:
if p[0] == 1 or p == [0,2]:
print("two pair")
else:
print("three card")
elif len(p) == 3:
print("one pair")
else:
print("null")
except:
break
| p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,473 |
s813549428 | p00038 | u043254318 | 1517931667 | Python | Python3 | py | Accepted | 20 | 5604 | 1,034 | def get_input():
while True:
try:
yield ''.join(input())
except EOFError:
break
N = list(get_input())
for l in range(len(N)):
table = [0 for i in range(15)]
cards = [int(i) for i in N[l].split(",")]
for i in range(5):
table[cards[i]] += 1
two,three,four,ren = 0,0,0,0
for i in range(15):
if table[i] == 2:
two += 1
elif table[i] == 3:
three += 1
elif table[i] == 4:
four += 1
for i in range(14):
if table[i] == 1 and table[i+1] == 1:
ren += 1
if table[10] == 1 and table[11] == 1 and table[12] == 1 and table[13] == 1 and table[1] == 1:
ren = 4
ans = "null"
if four == 1:
ans = "four card"
elif two == 1 and three == 1:
ans = "full house"
elif ren == 4:
ans = "straight"
elif three == 1:
ans = "three card"
elif two == 2:
ans = "two pair"
elif two == 1:
ans = "one pair"
print(ans)
| p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,474 |
s483076683 | p00038 | u150984829 | 1518107197 | Python | Python3 | py | Accepted | 20 | 5604 | 340 | import sys
for e in sys.stdin:
e=list(map(int,e.split(',')))
c=[e.count(i+1)for i in range(13)];d=c+c
if 4 in c:s='four card'
elif 3 in c:
if 2 in c:s='full house'
else:s='three card'
elif 2 in c:
if c.count(2)-1:s='two pair'
else:s='one pair'
elif sum([1]*5==d[i:i+5]for i in range(10)):s='straight'
else:s='null'
print(s)
| p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,475 |
s298394377 | p00038 | u150984829 | 1518109825 | Python | Python3 | py | Accepted | 20 | 5604 | 224 | import sys
for e in sys.stdin:
e=sorted(map(int,e.split(',')))
n=sum(e.count(s)for s in e)-5
print([['null','straight'][e[4]-e[0]==4 or e[0]*10==e[1]],'one pair','two pair','three card','full house',0,'four card'][n//2])
| p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,476 |
s116072706 | p00038 | u150984829 | 1518109970 | Python | Python3 | py | Accepted | 20 | 5612 | 219 | import sys
for e in sys.stdin:
e=sorted(map(int,e.split(',')))
print([['null','straight'][e[4]-e[0]==4 or e[0]*10==e[1]],'one pair','two pair','three card','full house',0,'four card'][sum(e.count(s)for s in e)//2-2])
| p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,477 |
s811968088 | p00038 | u150984829 | 1518110111 | Python | Python3 | py | Accepted | 20 | 5608 | 218 | import sys
for e in sys.stdin:
e=sorted(map(int,e.split(',')))
print([['null','straight'][e[0]*10==e[1]or e[4]-e[0]==4],'one pair','two pair','three card','full house',0,'four card'][sum(e.count(s)for s in e)//2-2])
| p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,478 |
s261863709 | p00038 | u150984829 | 1518110212 | Python | Python3 | py | Accepted | 20 | 5612 | 215 | import sys
for e in sys.stdin:
e=sorted(map(int,e.split(',')))
print([['null','straight'][e[0]*9<e[1]or e[4]-e[0]<5],'one pair','two pair','three card','full house',0,'four card'][sum(e.count(s)for s in e)//2-2])
| p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,479 |
s781942829 | p00038 | u150984829 | 1518110242 | Python | Python3 | py | Accepted | 20 | 5608 | 215 | import sys
for e in sys.stdin:
e=sorted(map(int,e.split(',')))
print([['null','straight'][e[0]*9<e[1]or e[4]-e[0]<5],'one pair','two pair','three card','full house',0,'four card'][sum(e.count(s)for s in e)//2-2])
| p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,480 |
s751224510 | p00038 | u352394527 | 1527494130 | Python | Python3 | py | Accepted | 30 | 6016 | 915 | from collections import Counter
#カードを引数に取って答えを出力する
def put_ans(cards):
cards.sort()
#10 ~ Aのストレート
if cards == [1, 10, 11, 12, 13]:
print("straight")
return
#それ以外のストレート
for i in range(1,len(cards)):
if cards[i] - cards[i - 1] != 1:
break
else:
print("straight")
return
#result...カードの枚数の降順リスト
result = [t[1] for t in Counter(cards).most_common()]
if result == [1,1,1,1,1]:
print("null")
if result == [2,1,1,1]:
print("one pair")
if result == [2,2,1]:
print("two pair")
if result == [3,1,1]:
print("three card")
if result == [3, 2]:
print("full house")
if result == [4, 1]:
print("four card")
def main():
while True:
try:
cards = list(map(int, input().split(",")))
put_ans(cards)
except EOFError:
break
main()
| p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,481 |
s545397756 | p00038 | u136916346 | 1529221177 | Python | Python3 | py | Accepted | 20 | 5992 | 715 | from collections import Counter
import sys
for t in sys.stdin:
l=sorted(map(int,t[:-1].split(",")))
s=False
p1=Counter(l)
p2=Counter(p1.values())
if 3 in p2 and 2 in p2:
print("full house")
elif 2 in p2:
if p2[2]==1:
print("one pair")
elif p2[2]==2:
print("two pair")
elif 3 in p2:
print("three card")
elif 4 in p2:
print("four card")
else:
for i in range(1,10):
if list(range(i,i+5))==l:
print("straight")
s=True
break
if [1,10,11,12,13]==l:
print("straight")
s=True
if not s:
print("null")
| p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,482 |
s806382734 | p00038 | u847467233 | 1530050224 | Python | Python3 | py | Accepted | 30 | 5992 | 596 | # AOJ 0038: Poker Hand
# Python3 2018.6.27 bal4u
def judge(card, cnt):
nmax = cnt[0][1]
if nmax == 4: return "four card"
if nmax == 3: return "full house" if cnt[1][1] == 2 else "three card"
if nmax == 2: return "two pair" if cnt[1][1] == 2 else "one pair"
if (card[0] == 1 and list(range(10, 14)) == card[1:]) \
or list(range(card[0], card[0]+5)) == card: return "straight"
return "null"
import collections
while True:
try: card = list(map(int, input().split(',')))
except: break
cnt = collections.Counter(card)
print(judge(sorted(card), sorted(cnt.items(), key=lambda x: -x[1])))
| p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,483 |
s449310547 | p00038 | u197615397 | 1530368813 | Python | Python3 | py | Accepted | 20 | 5596 | 648 | try:
while True:
a: list = sorted(map(int, input().split(",")))
if a.count(a[0]) == 4 or a.count(a[1]) == 4:
print("four card")
elif len(set(a)) == 2:
print("full house")
elif (a[0]+4 == a[1]+3 == a[2]+2 == a[3]+1 == a[4] or
a == [1, 10, 11, 12, 13]):
print("straight")
elif max(a.count(a[0]), a.count(a[1]), a.count(a[2])) == 3:
print("three card")
elif len(set(a)) == 3:
print("two pair")
elif len(set(a)) == 4:
print("one pair")
else:
print("null")
except EOFError:
exit()
| p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,484 |
s226333437 | p00038 | u647766105 | 1356181573 | Python | Python | py | Accepted | 10 | 23000 | 596 | import sys
HAND=["null","one pair","two pair","three card","straight","full house","four card"]
for line in sys.stdin.readlines():
cards=sorted(map(int,line.strip().split(",")))
switch=len(set(cards))
ma=cards.count(max(cards,key=lambda c:cards.count(c)))
if switch==4:print HAND[1]
elif switch==3:
if ma==2:print HAND[2]
else:print HAND[3]
elif switch==2:
if ma==4:print HAND[6]
else:print HAND[5]
else:
if cards==[1,10,11,12,13] or len(set([cards[i+1]-cards[i] for i in xrange(4)]))==1:print HAND[4]
else:print HAND[0] | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,485 |
s941402797 | p00038 | u647766105 | 1356181737 | Python | Python | py | Accepted | 20 | 23000 | 581 | import sys
HAND=["null","one pair","two pair","three card","straight","full house","four card"]
for line in sys.stdin.readlines():
cards=sorted(map(int,line.strip().split(",")))
switch=len(set(cards))
ma=max([cards.count(i) for i in cards])
if switch==4:print HAND[1]
elif switch==3:
if ma==2:print HAND[2]
else:print HAND[3]
elif switch==2:
if ma==4:print HAND[6]
else:print HAND[5]
else:
if cards==[1,10,11,12,13] or len(set([cards[i+1]-cards[i] for i in xrange(4)]))==1:print HAND[4]
else:print HAND[0] | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,486 |
s534564612 | p00038 | u647766105 | 1356181837 | Python | Python | py | Accepted | 10 | 23000 | 581 | import sys
HAND=["null","one pair","two pair","three card","straight","full house","four card"]
for line in sys.stdin.readlines():
cards=sorted(map(int,line.strip().split(",")))
switch=len(set(cards))
ma=max([cards.count(i) for i in cards])
if switch==4:print HAND[1]
elif switch==3:
if ma==2:print HAND[2]
else:print HAND[3]
elif switch==2:
if ma==4:print HAND[6]
else:print HAND[5]
else:
if cards==[1,10,11,12,13] or len(set([cards[i+1]-cards[i] for i in xrange(4)]))==1:print HAND[4]
else:print HAND[0] | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,487 |
s785394758 | p00038 | u647766105 | 1356182007 | Python | Python | py | Accepted | 10 | 23000 | 579 | import sys
HAND=["null","one pair","two pair","three card","straight","full house","four card"]
for line in sys.stdin.readlines():
cards=sorted(map(int,line.strip().split(",")))
switch=len(set(cards))
ma=max([cards.count(i) for i in cards])
if switch==4:print HAND[1]
elif switch==3:
if ma==2:print HAND[2]
else:print HAND[3]
elif switch==2:
if ma==4:print HAND[6]
else:print HAND[5]
else:
if cards==[1,10,11,12,13] or [cards[i+1]-cards[i] for i in xrange(4)]==[1,1,1,1]:print HAND[4]
else:print HAND[0] | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,488 |
s542593195 | p00038 | u459861655 | 1356318345 | Python | Python | py | Accepted | 10 | 6560 | 663 | HANDS = {
'one pair': [1,1,1,2],
'two pair': [1,2,2],
'three card': [1,1,3],
'four card': [1,4],
'full house': [2,3],
}
def check(key, value):
for (k, v) in HANDS.iteritems():
if value == v:
return k
if key[-1] - key[0] == 4 or key == [1, 10, 11, 12, 13]:
return 'straight'
else:
return 'null'
while True:
try:
cards = map(int, raw_input().split(','))
m = {}
for n in cards:
if m.has_key(n):
m[n] += 1
else:
m[n] = 1
print check(sorted(m.keys()), sorted(m.values()))
except EOFError:
break | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,489 |
s524135267 | p00038 | u282635979 | 1364030524 | Python | Python | py | Accepted | 10 | 4240 | 519 | while True:
try:
nums = [0 for x in xrange(13)]
hands = map(int,raw_input().split(','))
for val in hands: nums[val-1] += 1
if 4 in nums: print 'four card'
else:
if 3 in nums:
if 2 in nums: print 'full house'
else: print 'three card'
else:
if nums.count(2) == 2: print 'two pair'
elif nums.count(2) == 1: print 'one pair'
else:
hands2 = ''
for val in xrange(14): hands2 += str(nums[val%13])
if '11111' in hands2: print 'straight'
else: print 'null'
except: break | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,490 |
s886179051 | p00038 | u542421762 | 1368355239 | Python | Python | py | Accepted | 20 | 4372 | 1,729 |
import sys
def solv(hand):
if four_card(hand):
return "four card"
elif full_house(hand):
return "full house"
elif straight(hand):
return "straight"
elif three_card(hand):
return "three card"
elif two_pair(hand):
return "two pair"
elif one_pair(hand):
return "one pair"
else:
return "null"
def four_card(hand):
s = set(hand)
if len(s) == 2:
for c in s:
if count(hand, c) == 4:
return True
else:
return False
def full_house(hand):
s = set(hand)
if len(s) == 2:
for c in s:
if count(hand, c) == 3:
return True
else:
return False
def straight(hand):
hand.sort()
if difference_one(hand):
return True
elif difference_one(change_ace(hand)):
return True
else:
return False
def three_card(hand):
s = set(hand)
if len(s) == 3:
for c in s:
if count(hand, c) == 3:
return True
else:
return False
def two_pair(hand):
s = set(hand)
return len(s) == 3
def one_pair(hand):
s = set(hand)
return len(s) == 4
def count(hand, c):
return len(filter(lambda x: x == c, hand))
def difference_one(hand):
r = []
d = reduce(lambda x, y: (add_list(x[0], y-x[1]), y), hand, (r,0))
d[0].pop(0)
return d[0] == [1,1,1,1]
def add_list(lis, x):
lis.append(x)
return lis
def change_ace(hand):
r = []
for c in hand:
if c == 1:
r.append(14)
else:
r.append(c)
r.sort()
return r
for line in sys.stdin:
hand = map(int, line.split(','))
print solv(hand) | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,491 |
s494650784 | p00038 | u782850731 | 1375003889 | Python | Python | py | Accepted | 10 | 4684 | 862 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
from collections import Counter
for line in stdin:
L = sorted([int(s) for s in line.split(',')])
cnt = Counter(L)
length, num = len(cnt), cnt.most_common(1)[0][1]
if length == 4 and num == 2:
print('one pair')
elif length == 3 and num == 2:
print('two pair')
elif length == 3 and num == 3:
print('three card')
elif length == 2 and num == 3:
print('full house')
elif length == 2 and num == 4:
print('four card')
elif L[0] == L[1]-1 == L[2]-2 == L[3]-3 == L[4]-4:
print('straight')
elif L[0] == 1 and L[1]-1 == L[2]-2 == L[3]-3 == L[4]-4:
print('straight')
else:
print('null') | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,492 |
s594355521 | p00038 | u813384600 | 1381311660 | Python | Python | py | Accepted | 10 | 4268 | 693 | import sys
def straight(cards):
aa = range(1,5)
if cards == [1, 10, 11, 12, 13]:
return True
for i in range(1, 10):
if cards == range(i, i+5):
return True
return False
for s in sys.stdin.read().rstrip().split('\n'):
cards = sorted(map(int, s.split(',')))
c = [0]*13
for card in cards:
c[card-1] += 1
if 4 in c:
print 'four card'
elif (3 in c) and (2 in c):
print 'full house'
elif straight(cards):
print 'straight'
elif 3 in c:
print 'three card'
elif c.count(2) == 2:
print 'two pair'
elif c.count(2) == 1:
print 'one pair'
else:
print 'null' | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,493 |
s752541984 | p00038 | u912237403 | 1383516528 | Python | Python | py | Accepted | 20 | 4304 | 973 | def readdata():
x = []
try:
while True:
x.append(map(int,raw_input().split(",")))
except: return x
def checkhand2(hand):
tmp = [(e+11)%13 for e in hand]
x1=sorted(list(set(tmp)))
x2=[]
for e in x1:
x2.append(tmp.count(e))
return x1,x2
def isstraight(x1):
if x1==[0,1,2,3,12]: return True
e = x1[0]
if x1==range(e,e+5): return True
else: return False
def checkhand(hand):
x1,x2 = checkhand2(hand)
x2 = sorted(x2)
prize = 0
if x2==[1,1,1,1,1]:
if isstraight(x1): prize = 4
else: prize = 0
elif x2==[1,1,1,2]: prize = 1
elif x2==[1,2,2]: prize = 2
elif x2==[1,1,3]: prize = 3
elif x2==[2,3]: prize = 5
elif x2==[1,4]: prize = 6
return prize
values=[2,3,4,5,6,7,8,9,10,11,12,13,1]
prize=["null","one pair","two pair","three card",
"straight","full house","four card"]
hands = readdata()
for e in hands:
print prize[checkhand(e)] | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,494 |
s911093993 | p00038 | u912237403 | 1383530501 | Python | Python | py | Accepted | 10 | 4240 | 575 | prize=["null","one pair","two pair","three card",
"straight","full house","four card"]
try:
while True:
hand = map(int,raw_input().split(","))
x = sorted(list(set(hand)))
a = len(x)
b = max([hand.count(e) for e in x])
if b==4: p=6
elif b==3:
if a==2: p=5
else: p=3
elif b==2:
if a==3: p=2
else: p=1
elif b==1:
e = x[0]
if x==[1,10,11,12,13] or x==range(e,e+5): p=4
else: p=0
print prize[p]
except:
pass | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,495 |
s094506768 | p00038 | u912237403 | 1383531356 | Python | Python | py | Accepted | 10 | 4236 | 507 | from sys import stdin
prize=["null","one pair","two pair","three card",
"straight","full house","four card"]
for line in stdin:
hand = map(int,line.split(","))
x = sorted(list(set(hand)))
a = len(x)
b = max([hand.count(e) for e in x])
if b==4: p=6
elif b==3:
if a==2: p=5
else: p=3
elif b==2:
if a==3: p=2
else: p=1
elif b==1:
e = x[0]
if x==[1,10,11,12,13] or x==range(e,e+5): p=4
else: p=0
print prize[p] | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,496 |
s224771062 | p00038 | u633068244 | 1393482130 | Python | Python | py | Accepted | 20 | 4240 | 793 | while True:
try:
hand = map(int, raw_input().split(","))
kind = list(set(hand))
rank =[]
for card in kind:
rank.append(hand.count(card))
rank.sort()
rank.reverse()
if rank[0] == 4:
print "four card"
elif rank[0] == 3:
if rank[1] == 2:
print "full house"
else:
print "three card"
elif rank[0] == 2:
if rank[1] == 2:
print "two pair"
else:
print "one pair"
else:
hand.sort()
if hand[4] - hand[0] == 4 or (hand[0] == 1 and hand[1] == 10):
print "straight"
else:
print "null"
except:
break | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,497 |
s821879037 | p00038 | u633068244 | 1393482804 | Python | Python | py | Accepted | 10 | 4220 | 782 | while True:
try:
hand = sorted(map(int, raw_input().split(",")))
kind = len(set(hand))
ma = max([hand.count(i) for i in hand])
if kind == 4:
print "one pair"
elif kind == 3:
if ma == 2:
print "two pair"
else:
print "three card"
elif kind == 2:
if ma==4:
print "four card"
else:
print "full house"
else:
if hand==[1,10,11,12,13] or hand[4] - hand[0] == 4:
print "straight"
else:
print "null"
except:
break | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,498 |
s018341384 | p00038 | u246033265 | 1396689336 | Python | Python | py | Accepted | 20 | 4228 | 588 | try:
while True:
a = sorted(map(int, raw_input().split(',')))
if a.count(a[2]) == 4:
print 'four card'
elif a.count(a[1]) + a.count(a[-2]) == 5:
print 'full house'
elif a == range(a[0], a[0] + 5) or a == [1, 10, 11, 12, 13]:
print 'straight'
elif a.count(a[2]) == 3:
print 'three card'
elif a.count(a[1]) == 2 and a.count(a[-2]) == 2:
print 'two pair'
elif len(set(a)) == 4:
print 'one pair'
else:
print 'null'
except EOFError:
pass | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,499 |
s949948901 | p00038 | u708217907 | 1398944834 | Python | Python | py | Accepted | 20 | 4228 | 484 | import sys
for s in sys.stdin:
hand = sorted(map(int, s.split(',')))
kind = len(set(hand))
ma = max([hand.count(i) for i in hand])
ans = 'null'
if kind == 4:
ans = 'one pair'
elif kind == 3:
if ma == 2:
ans = 'two pair'
else:
ans = 'three card'
elif kind == 2:
if ma==4:
ans = 'four card'
else:
ans = 'full house'
else:
if hand == [1,10,11,12,13] or (hand[4] - hand[0]) == 4:
ans = 'straight'
print ans | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,500 |
s730152507 | p00038 | u491763171 | 1400483397 | Python | Python | py | Accepted | 20 | 4600 | 885 | from collections import Counter
while 1:
try:
hand = map(int, raw_input().split(','))
except EOFError:
break
count = Counter(hand).most_common()
ret = ''
if count[0][1] >= 4:
ret = 'four card'
elif len(count) >= 2 and count[0][1] == 3 and count[1][1] == 2:
ret = 'full house'
elif len(count) == 5:
sort_hand = sorted(hand)
for i in xrange(4):
if sort_hand[i] + 1 != sort_hand[i + 1]:
break
else:
ret = 'straight'
if sort_hand == [1, 10, 11, 12, 13]:
ret = 'straight'
elif len(count) == 3 and count[0][1] == 3:
ret = 'three card'
elif len(count) == 3 and count[0][1] == count[1][1] == 2:
ret = 'two pair'
elif len(count) == 4:
ret = 'one pair'
if ret:
print ret
else:
print 'null' | p00038 |
<H1>ポーカー</H1>
<p>
ポーカーの手札データを読み込んで、それぞれについてその役を出力するプログラムを作成してください。ただし、この問題では、以下のルールに従います。
</p>
<ul>
<li>ポーカーはトランプ 5 枚で行う競技です。</li>
<li>同じ数字のカードは 5 枚以上ありません。</li>
<li>ジョーカーは無いものとします。</li>
<li>以下のポーカーの役だけを考えるものとします。(番号が大きいほど役が高くなります。)</li>
</ul>
<ol style="margin-left:40px">
<li>役なし(以下に挙げるどれにも当てはまらない)</li>
<li>ワンペア（2 枚の同じ数字のカードが1 組ある）</li>
<li>ツーペア（2 枚の同じ数字のカードが2 組ある）</li>
<li>スリーカード（3 枚の同じ数字のカードが1 組ある）</li>
<li>ストレート（5 枚のカードの数字が連続している）<br>
ただし、A を含むストレートの場合、A で終わる並びもストレートとします。つまり、A を含むストレート
は、A 2 3 4 5 と 10 J Q K A の２種類です。J Q K A 2 などのように、A をまたぐ並び
はストレートではありません。（この場合、「役なし」になります）。
</li>
<li>フルハウス（3 枚の同じ数字のカードが1 組と、残りの2 枚が同じ数字のカード）</li>
<li>フォーカード（4 枚の同じ数字のカードが1 組ある）</li>
</ol>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットは以下の形式で与えられます。
</p>
<pre class=exp>
手札1,手札2,手札3,手札4,手札5
</pre>
<p>
手札は、トランプのJ(ジャック) を11、Q(クイーン) を12、K(キング) を13、A（エース）を 1、その他はそれぞれの数字で表すこととします。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、手札によってできる最も高い役をひとつ出力してください。役の表記については出力例に従ってください。
</p>
<H2>Sample Input</H2>
<pre>
1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
</pre>
<H2>Output for the Sample Input</H2>
<pre>
one pair
two pair
three card
full house
four card
straight
straight
null
</pre>
<p>
3 3 2 3 3 という手札であったときは、two pair ではなく four card です。
</p>
| 1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2
| one pair
two pair
three card
full house
four card
straight
straight
null
| 9,501 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.