submission_id string | problem_id string | status string | code string | input string | output string | problem_description string |
|---|---|---|---|---|---|---|
s423189164 | p00037 | Accepted | 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 | 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
|
<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>
|
s712001245 | p00037 | Accepted | 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 | 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
|
<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>
|
s608696548 | p00037 | Accepted | 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))
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
|
<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>
|
s368601599 | p00037 | Accepted | 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()
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
|
<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>
|
s123028500 | p00037 | Accepted | 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)
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
|
<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>
|
s009540119 | p00037 | Accepted | 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:])
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
|
<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>
|
s772532405 | p00037 | Accepted | 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()
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
|
<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>
|
s807652175 | p00037 | Runtime Error | import sys
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 (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_result()
if mapp[position[tate]][position[yoko]] == 1:
result.append(direction)
kyoto(position, direction)
elif mapp[position[tate]][position[yoko]] == 0:
return
def kyoto(position, direction):
if direction == 'R':
#????????????????´¢
check_position = position[tate], position[yoko]+1
direction = 'R'
xxx(check_position, direction)
#????????????????´¢
check_position = position[tate]-1, position[yoko]+1
direction = 'U'
xxx(check_position, direction)
#????????????????´¢
check_position = position[tate]+1, position[yoko]+1
direction = 'D'
xxx(check_position, direction)
elif direction == 'U':
#????????????????´¢
check_position = position[tate]-2, position[yoko]
direction = 'U'
xxx(check_position, direction)
#????????????????´¢
check_position = position[tate]-1, position[yoko]-1
direction = 'L'
xxx(check_position, direction)
#????????????????´¢
check_position = position[tate]-1, position[yoko]
direction = 'R'
xxx(check_position, direction)
elif direction == 'L':
#????????????????´¢
check_position = position[tate], position[yoko]-1
direction = 'L'
xxx(check_position, direction)
#????????????????´¢
check_position = position[tate]+1, position[yoko]
direction = 'D'
xxx(check_position, direction)
#????????????????´¢
check_position = position[tate]-1, position[yoko]
direction = 'U'
xxx(check_position, direction)
elif direction == 'D':
#????????????????´¢
check_position = position[tate]+2, position[yoko]
direction = 'D'
xxx(check_position, direction)
#????????????????´¢
check_position = position[tate]+1, position[yoko]
direction = 'R'
xxx(check_position, direction)
#????????????????´¢
check_position = position[tate]+1, position[yoko]-1
direction = 'L'
xxx(check_position, direction)
def print_result():
print ''.join(result)
sys.exit()
mapp = []
for i in range(9):
mapp.append([int(char) for char in raw_input()])
tate = 0
yoko = 1
result = []
xxx((0,0), 'R') | 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
|
<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>
|
s999878550 | p00037 | Runtime Error | import sys
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 (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_result()
if mapp[position[tate]][position[yoko]] == 1:
result.append(direction)
kyoto(position, direction)
elif mapp[position[tate]][position[yoko]] == 0:
return
def kyoto(position, direction):
if direction == 'R':
#????????????????´¢
check_position = position[tate]-1, position[yoko]+1
direction = 'U'
xxx(check_position, direction)
#????????????????´¢
check_position = position[tate], position[yoko]+1
direction = 'R'
xxx(check_position, direction)
#????????????????´¢
check_position = position[tate]+1, position[yoko]+1
direction = 'D'
xxx(check_position, direction)
#????????????????´¢
check_position = position[tate], position[yoko]
direction = 'L'
xxx(check_position, direction)
elif direction == 'U':
#????????????????´¢
check_position = position[tate]-1, position[yoko]-1
direction = 'L'
xxx(check_position, direction)
#????????????????´¢
check_position = position[tate]-2, position[yoko]
direction = 'U'
xxx(check_position, direction)
#????????????????´¢
check_position = position[tate]-1, position[yoko]
direction = 'R'
xxx(check_position, direction)
#????????????????´¢
check_position = position[tate], position[yoko]
direction = 'D'
xxx(check_position, direction)
elif direction == 'L':
#????????????????´¢
check_position = position[tate]+1, position[yoko]
direction = 'D'
xxx(check_position, direction)
#????????????????´¢
check_position = position[tate], position[yoko]-1
direction = 'L'
xxx(check_position, direction)
#????????????????´¢
check_position = position[tate]-1, position[yoko]
direction = 'U'
xxx(check_position, direction)
#????????????????´¢
check_position = position[tate], position[yoko]
direction = 'R'
xxx(check_position, direction)
elif direction == 'D':
#????????????????´¢
check_position = position[tate]+1, position[yoko]
direction = 'R'
xxx(check_position, direction)
#????????????????´¢
check_position = position[tate]+2, position[yoko]
direction = 'D'
xxx(check_position, direction)
#????????????????´¢
check_position = position[tate]+1, position[yoko]-1
direction = 'L'
xxx(check_position, direction)
#????????????????´¢
check_position = position[tate], position[yoko]
direction = 'U'
xxx(check_position, direction)
def print_result():
print ''.join(result)
sys.exit()
mapp = []
for i in range(9):
mapp.append([int(char) for char in raw_input()])
tate = 0
yoko = 1
result = []
xxx((0,0), 'R') | 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
|
<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>
|
s350714342 | p00037 | Runtime Error | 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 (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
if mapp[position[tate]][position[yoko]] == 1:
result.append(direction)
if kyoto(position, direction): return True
elif mapp[position[tate]][position[yoko]] == 0:
return
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
while True:
try:
mapp = []
for i in range(9):
mapp.append([int(char) for char in raw_input()])
tate = 0
yoko = 1
result = []
xxx((0,0), 'R')
except EOFError:
break | 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
|
<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>
|
s308970999 | p00037 | Runtime Error | dist = ['R','D','L','U']
dict = [(1,0),(0,1),(-1,0),(0,-1)]
result = ''
sell = [[False]*13]*2
for i in xrange(9):
l = [False,False]
s = raw_input()
if len(s) == 4:
for j in s:
l.append(False)
l.append(bool(int(j)))
l += [False] * 3
else:
for j in s:
l.append(bool(int(j)))
l.append(False)
l += [False] * 2
sell.append(l)
sell += [[False]*13]*2
my = (2,2,0)
while(True):
if sell[my[0]+dict[my[2]][0],my[1]+dict[my[2]][1]]:
my = (my[0]+dict[my[2]][0]*2,my[1]+dict[my[2]][1]*2,my[2])
if my[0] == 2 and my[1] == 2:
break
else:
result += dist[my[2]]
else:
my = (my[0],my[1],(my[2]+1)%4)
print result | 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
|
<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>
|
s846098170 | p00037 | Runtime Error |
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_backt(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)
#grid.show()
walker = Walker(grid, 1, 1)
path = []
while True:
path.append(walker.walk())
if (walker.x, walker.y) == (1,1):
break
print ''.join(path) | 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
|
<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>
|
s550513000 | p00037 | WA: Presentation Error | 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
| 1111
00001
0110
01011
0010
01111
0010
01001
0111
| RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
|
<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>
|
s924563761 | p00038 | Wrong Answer | def poker(a,b,c,d,e):
x = [a,b,c,d,e]
x.sort()
if x[1]==x[4] or x[0]==x[3]:
print "fourcard"
elif x[0]==x[2] and x[3]==x[4]:
print "fullhouse"
elif x[0]==x[1] and x[2]==x[4]:
print "fullhouse"
elif x[0]==x[2] or x[2]==x[4]:
print "threecard"
elif x[0]==x[1] and x[2]==x[3]:
print "twopair"
elif x[1]==x[2] and x[3]==x[4]:
print "twopair"
elif x[0]==x[1] and x[3]==x[4]:
print "twopair"
elif x[0]==x[1] or x[1]==x[2] or x[2]==x[3] or x[3]==x[4]:
print "onepair"
elif x[0]==x[1]-1==x[2]-2==x[3]-3==x[4]-4 or x[0]==x[1]-9==x[2]-10==x[3]-11==x[4]-12:
print "straight"
else :
print "none" | 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
|
<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>
|
s591511158 | p00038 | Wrong Answer | 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 "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 | 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
|
<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>
|
s681227495 | p00038 | Wrong Answer | 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:
if card_lis == [10,11,12,13,1] or card_lis == [1,2,3,4,5]:
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'
while True:
try:
card_lis = [int(char) for char in raw_input().split(',')]
heaven()
except EOFError:
break | 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
|
<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>
|
s525230469 | p00038 | Wrong Answer | 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:
if card_lis == [10,11,12,13,1] or card_lis == [1,2,3,4,5]:
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 line in sys.stdin.readlines():
card_lis = [int(char) for char in line.split(',')]
heaven() | 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
|
<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>
|
s573958471 | p00038 | Wrong Answer | def heaven(card_lis):
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, card_lis)
def suicide(result_dic, card_lis):
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:
if card_lis == [10,11,12,13,1] or card_lis == [1,2,3,4,5]:
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'
card_lis_lis = []
while True:
try:
card_lis_lis.append([int(char) for char in raw_input().split(',')])
except EOFError:
for card_lis in card_lis_lis:
heaven(card_lis)
break | 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
|
<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>
|
s662397479 | p00038 | Wrong Answer | 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:
if card_lis == [10,11,12,13,1] or card_lis == [1,2,3,4,5]:
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'
card_lis_lis = []
while True:
try:
card_lis = [int(char) for char in raw_input().split(',')]
heaven()
except:
break | 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
|
<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>
|
s736497482 | p00038 | Wrong Answer | 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:
if card_lis == [10,11,12,13,1] or card_lis == [1,2,3,4,5]:
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() | 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
|
<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>
|
s724560730 | p00038 | Wrong Answer | 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:
if card_lis == [10,11,12,13,1] or card_lis == [1,2,3,4,5] or card_lis == [11,12,10,1,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() | 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
|
<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>
|
s606945799 | p00038 | Wrong Answer | 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:
if card_lis == [10,11,12,13,1]:
print 'straight'
else:
card_lis.sort()
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() | 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
|
<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>
|
s783685512 | p00038 | Wrong Answer | 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
for e in x:
for e2 in x:
if e == e2:
count += 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") | 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
|
<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>
|
s425213011 | p00038 | Wrong Answer | while 1:
try:
l=map(int,raw_input().split(','))
l.sort()
if l.count(l[0])==4 or l.count(l[4])==4:
print 'four card'
elif (l.count(l[0])==2 and l.count(l[4])==3) or (l.count(l[0])==3 and l.count(l[4])==2):
print 'full house'
elif l[0]==(l[1]-1)==(l[2]-2)==(l[3]-3)==(l[4]-4):
print 'straight'
elif l.count(l[0])==3 or l.count(l[4])==3:
print 'three card'
elif l.count(l[1])==2 and l.count(l[3])==2:
print 'two pair'
elif len(set(l)):
print 'one pair'
else:
print 'null'
except:
break | 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
|
<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>
|
s523651059 | p00038 | Wrong Answer | while 1:
try:
l=map(int,raw_input().split(','))
l.sort()
if l.count(l[0])==4 or l.count(l[4])==4:
print 'four card'
elif (l.count(l[0])==2 and l.count(l[4])==3) or (l.count(l[0])==3 and l.count(l[4])==2):
print 'full house'
elif l[0]==(l[1]-1)==(l[2]-2)==(l[3]-3)==(l[4]-4):
print 'straight'
elif l.count(l[0])==3 or l.count(l[4])==3:
print 'three card'
elif l.count(l[1])==2 and l.count(l[3])==2:
print 'two pair'
elif len(set(l))==4:
print 'one pair'
else:
print 'null'
except:
break | 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
|
<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>
|
s736086312 | p00038 | Wrong Answer | while 1:
try:
l=map(int,raw_input().split(','))
l.sort()
if l.count(l[0])==4 or l.count(l[4])==4:
print 'four card'
elif (l.count(l[0])==2 and l.count(l[4])==3) or (l.count(l[0])==3 and l.count(l[4])==2):
print 'full house'
elif l[0]==(l[1]-1)==(l[2]-2)==(l[3]-3)==(l[4]-4):
print 'straight'
elif l.count(l[2])==3:
print 'three card'
elif l.count(l[1])==2 and l.count(l[3])==2:
print 'two pair'
elif len(set(l))==4:
print 'one pair'
else:
print 'null'
except:
break | 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
|
<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>
|
s092887595 | p00038 | Wrong Answer | def function(a,b,c,d,e):
A=[a,b,c,d,e]
A.sort()
#4card
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] and A[2]==A[3]==A[4]) or (A[0]==A[1]==A[2] and A[3]==A[4]):
print("full house")
#straight A?????????
elif A[0]==1 and A[1]==10 and A[2]==11 and A[3]==12 and A[4]==13:
print("straight")
#straight A???????????????
elif A[0]==A[1]-1==A[2]-2==A[3]-3==A[4]-4:
print("straight")
#threee
elif A[0]==A[1]==A[2] or A[1]==A[2]==A[3] or A[2]==A[3]==A[4]:
print("threee card")
elif (A[0]==A[1] and A[2]==A[3]) 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")
else:
print("null")
while True:
try:
a,b,c,d,e=map(float,input().split(','))
function(a,b,c,d,e)
except EOFError:
break | 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
|
<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>
|
s289262470 | p00038 | Wrong Answer | def function(a,b,c,d,e):
A=[a,b,c,d,e]
A.sort()
#4card
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] and A[2]==A[3]==A[4]) or (A[0]==A[1]==A[2] and A[3]==A[4]):
print("full house")
#straight A?????????
elif A[0]==1 and A[1]==10 and A[2]==11 and A[3]==12 and A[4]==13:
print("straight")
#straight A???????????????
elif A[0]==A[1]-1==A[2]-2==A[3]-3==A[4]-4:
print("straight")
#threee
elif A[0]==A[1]==A[2] or A[1]==A[2]==A[3] or A[2]==A[3]==A[4]:
print("three card")
elif (A[0]==A[1] and A[2]==A[3]) 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")
else:
print("null")
while True:
try:
a,b,c,d,e=map(float,input().split(','))
function(a,b,c,d,e)
except EOFError:
break | 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
|
<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>
|
s712007119 | p00038 | Wrong Answer | def function(a,b,c,d,e):
A=[a,b,c,d,e]
A.sort()
#4card
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] and A[2]==A[3]==A[4]) or (A[0]==A[1]==A[2] and A[3]==A[4]):
print("full house")
#straight A?????????
elif A[0]==1 and A[1]==10 and A[2]==11 and A[3]==12 and A[4]==13:
print("straight")
#straight A???????????????
elif A[0]==A[1]-1==A[2]-2==A[3]-3==A[4]-4:
print("straight")
#threee
elif A[0]==A[1]==A[2] or A[1]==A[2]==A[3] or A[2]==A[3]==A[4]:
print("three card")
elif (A[0]==A[1] and A[2]==A[3]) 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")
else:
print("null")
while True:
try:
a,b,c,d,e=map(int,input().split(','))
function(a,b,c,d,e)
except EOFError:
break | 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
|
<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>
|
s591455721 | p00038 | Wrong Answer | 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[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 | 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
|
<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>
|
s605183089 | p00038 | Wrong Answer | def function(a,b,c,d,e):
A=[a,b,c,d,e]
A.sort()
print(A)
#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 | 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
|
<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>
|
s294410067 | p00038 | Wrong Answer | #encoding=utf-8
import sys
tako = [1,2,3,4,5,6,7,8,9,10,11,12,13,1]
for line in sys.stdin:
count1, count2, count3, flag = 0, 0, [], 0
line = line[:-1]
num = map(int, line.split(","))
for i in xrange(4):
for j in xrange(i + 1,5):
if num[i] == num[j] and num[j] != 0:
count1 += 1
num[j] = 0
count3.append(count1)
count1 = 0
if sum(count3) == 1:
print "one pair"
elif count3.count(1) == 2:
print "two pair"
elif count3.count(1) != count3.count(2):
print "three card"
elif count3.count(1) == count3.count(2) == 1:
print "hull house"
elif count3.count(3) == 1:
print "four card"
elif sum(count3) == 0:
for i in xrange(13):
if sorted(tako[i:i+5]) == sorted(num):
print "straigth"
flag = 1
break
if flag != 1:
print "null"
flag = 0 | 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
|
<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>
|
s755010253 | p00038 | Wrong Answer | #encoding=utf-8
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 pair"
elif flag[0] < 1 or flag[1] < 1:
print "null"
if __name__ == "__main__":
inp()
| 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
|
<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>
|
s360888582 | p00038 | Wrong Answer | # -*- 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:
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] | 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
|
<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>
|
s212177909 | p00038 | Wrong Answer | # -*- coding: utf-8 -*-
def is_four_card(d):
return 4 in d.values()
def is_full_house(d):
return 3 in d.values() and 2 in d.values()
def is_straight(d):
flag = [False, 0]
for i in d.values():
if flag[0] == True and flag[1] == 5:
return True
if i == 1:
flag[0] = True
flag[1] += 1
return False
def is_three_card(d):
return 3 in d.values()
def is_two_pair(d):
return list(d.values()).count(2) == 2
def is_one_pair(d):
return list(d.values()).count(2) == 1
def judge(d):
if is_four_card(d):
print('four card')
elif is_full_house(d):
print('full house')
elif is_straight(d):
print('straight')
elif is_three_card(d):
print('three card')
elif is_two_pair(d):
print('two pair')
elif is_one_pair(d):
print('one pair')
else:
print('null')
def solve(cards):
d = {k: 0 for k in range(1, 14)}
for card in cards:
d[card] += 1
judge(d)
_input = [int(e) for e in input().split(",")]
solve(_input) | 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
|
<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>
|
s210748643 | p00038 | Wrong Answer | # -*- coding: utf-8 -*-
def is_four_card(d):
return 4 in d.values()
def is_full_house(d):
return 3 in d.values() and 2 in d.values()
def is_straight(d):
flag = False
times = 0
for i in d.values():
if flag and times == 5:
return True
elif flag and times == 4:
_values = list(d.values())
return _values[0] == 1 and _values[1] == 0
if i == 1:
flag = True
times += 1
return False
def is_three_card(d):
return 3 in d.values()
def is_two_pair(d):
return list(d.values()).count(2) == 2
def is_one_pair(d):
return list(d.values()).count(2) == 1
def judge(d):
if is_four_card(d):
print('four card')
elif is_full_house(d):
print('full house')
elif is_straight(d):
print('straight')
elif is_three_card(d):
print('three card')
elif is_two_pair(d):
print('two pair')
elif is_one_pair(d):
print('one pair')
else:
print('null')
def solve(cards):
d = {k: 0 for k in range(1, 14)}
for card in cards:
d[card] += 1
judge(d)
# _input = '11,12,13,1,2'
_input = input()
_cards = [int(e) for e in _input.split(",")]
solve(_cards) | 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
|
<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>
|
s311223143 | p00038 | Wrong Answer | from collections import Counter
def is_strait(_cnt):
f = 0
for i in range(1, 14):
if _cnt[(i % 13) + 1] == 1:
f += 1
if f == 5:
return True
elif f > 0 or _cnt[(i % 13) + 1] > 1:
return False
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 | 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
|
<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>
|
s593140559 | p00038 | Wrong Answer | from collections import Counter
def is_strait(_cnt):
f = 0
for i in range(1, 14):
if _cnt[(i % 13) + 1] == 1:
f += 1
if f == 5:
return True
elif f > 0 or _cnt[(i % 13) + 1] > 1:
return False
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 | 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
|
<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>
|
s829404291 | p00038 | Wrong Answer | import fileinput
from collections import Counter
for line in fileinput.input():
if line == "\n":
break
else:
card = [c for c in line.rstrip().split(",")]
card_num = [int(c) for c in line.rstrip().split(",")]
card_sort = sorted(card_num)
counter = Counter(card)
card_type = counter.most_common()
if card_type[0][1] == 4:
print("four card")
elif card_type[0][1] == 3:
if card_type[1][1] == 2:
print("full house")
else:
print("three card")
elif card_type[0][1] == 2:
if card_type[1][1] == 2:
print("two pair")
else:
print("one pair")
elif card_sort == [1, 10, 11, 12, 13]:
print("straight")
else:
for i in range(1, 5):
if card_sort[0] + i == card_sort[i]:
f = "ok"
else:
f = "no"
break
if f == "ok":
print("straight")
else:
print("nule") | 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
|
<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>
|
s782088187 | p00038 | Wrong Answer | from itertools import permutations
def inini(_card):
for i in range(len(_card)):
_card[i] = 0
def main():
while True:
try:
card = 14*[0]
inini(card)
number = list(map(int,input().split(',')))
for v in number:
card[v] += 1
one_pair = 0
tree_card = 0
four_card = 0
flag = 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
if one_pair == 1 and tree_card ==1:
print('full house')
flag = 777
elif one_pair == 1:
print('one pair')
flag = 777
elif one_pair == 2:
print('two pair')
flag = 777
elif tree_card == 1:
print('tree card')
flag = 777
elif four_card == 1:
print('four card')
flag = 777
straight = [[1,2,3,4,5],[2,3,4,5,6],[3,4,5,6,7],[4,5,6,7,8],[5,6,7,8,9],[6,7,8,9,10],[7,8,9,10,11],[8,9,10,11,12],[9,10,11,12,13],[10,11,12,13,1]]
for s_list in straight:
number.sort()
if number[0] == 1 and number[4] == 13:
number.append(1)
number.pop(0)
if number == s_list:
print('straight')
flag = 777
break
if flag == 0:
print('null')
except EOFError:
break
if __name__ == '__main__':
main()
| 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
|
<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>
|
s906977203 | p00038 | Wrong Answer | 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
flag = 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
if one_pair == 1 and tree_card ==1:
print('full house')
flag = 777
elif one_pair == 1:
print('one pair')
flag = 777
elif one_pair == 2:
print('two pair')
flag = 777
elif tree_card == 1:
print('tree card')
flag = 777
elif four_card == 1:
print('four card')
flag = 777
straight = [[1,2,3,4,5],[2,3,4,5,6],[3,4,5,6,7],[4,5,6,7,8],[5,6,7,8,9],[6,7,8,9,10],[7,8,9,10,11],[8,9,10,11,12],[9,10,11,12,13],[10,11,12,13,1]]
for s_list in straight:
number.sort()
if number[0] == 1 and number[4] == 13:
number.append(1)
number.pop(0)
if number == s_list:
print('straight')
flag = 777
break
if flag == 0:
print('null')
if __name__ == '__main__':
main()
| 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
|
<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>
|
s317193541 | p00038 | Wrong Answer | import sys
for e in sys.stdin:
c=[list(map(int,e.split(','))).count(i+1)for i in range(13)];d=c+c
print('four card'if 4 in c else'full house'if 2 in c else'three card'if 3 in c else'two pair'if c.count(2)-1 else'one pair'if 2 in c else'straight'if sum([1]*5==d[i:i+5]for i in range(10)) else'null')
| 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
|
<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>
|
s149559940 | p00038 | Wrong Answer | while 1:
try: p=sorted(list(map(int,input().split(','))))
except: break
if (p[0] == p[3]) or (p[1] == p[4]):
print('four card')
elif p[0] == p[2] or p[1] == p[3] or p[2] == p[4]:
print('three card')
elif (p[0] == p[1] == p[2] and p[3] == p[4]) or (p[0] == [1] and p[2] == p[3] == p[4]):
print('full house')
elif (p[0] == p[1] and p[2] == p[3]) or (p[1] == p[2] and p[3] == p[4]):
print('two pair')
elif p[0] == p[1] or p[1] == p[2] or p[3] == p[4]:
print('one pair')
elif (p[0] == p[1]-1) and (p[1] == p[2]-1) and (p[2] == p[3]-1) and (p[3] == p[4]-1) and (p[4] == p[3]+1):
print('straight')
else:
print('null')
| 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
|
<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>
|
s818461222 | p00038 | Wrong Answer | while 1:
try: p=sorted(list(map(int,input().split(','))))
except: break
if (p[0] == p[3]) or (p[1] == p[4]):
print('four card')
elif p[0] == p[2] or p[1] == p[3] or p[2] == p[4]:
print('three card')
elif (p[0] == p[1] == p[2] and p[3] == p[4]) or (p[0] == [1] and p[2] == p[3] == p[4]):
print('full house')
elif (p[0] == p[1] and p[2] == p[3]) or (p[1] == p[2] and p[3] == p[4]):
print('two pair')
elif p[0] == p[1] or p[1] == p[2] or p[3] == p[4]:
print('one pair')
elif (p[0] == p[1]-1) and (p[1] == p[2]-1) and (p[2] == p[3]-1) and (p[3] == p[4]-1) and (p[4] == p[3]+1):
print('straight')
elif p[0] == 1 and p[1] == 10 and p[2] == 11 and p[3] == 12 and p[4] == 13:
print('straight')
else:
print('null')
| 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
|
<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>
|
s962412691 | p00038 | Wrong Answer | while 1:
try: p=sorted(list(map(int,input().split(','))))
except: break
if (p[0] == p[3]) or (p[1] == p[4]):
print('four card')
elif p[0] == p[2] or p[1] == p[3] or p[2] == p[4]:
print('three card')
elif (p[0] == p[1] == p[2] and p[3] == p[4]) or (p[0] == [1] and p[2] == p[3] == p[4]):
print('full house')
elif (p[0] == p[1] and p[2] == p[3]) or (p[1] == p[2] and p[3] == p[4]):
print('two pair')
elif p[0] == p[1] or p[1] == p[2] or p[3] == p[4]:
print('one pair')
elif p[0] == p[1]-1 and p[1] == p[2]-1 and p[2] == p[3]-1 and p[3] == p[4]-1 and p[4] == p[3]+1:
print('straight')
elif p[0] == 1 and p[1] == 10 and p[2] == 11 and p[3] == 12 and p[4] == 13:
print('straight')
else:
print('null')
| 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
|
<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>
|
s212349090 | p00038 | Wrong Answer | while 1:
try: p=sorted(list(map(int,input().split(','))))
except: break
if (p[0] == p[3]) or (p[1] == p[4]):
print('four card')
elif p[0] == p[2] or p[1] == p[3] or p[2] == p[4]:
print('three card')
elif (p[0] == p[1] == p[2] and p[3] == p[4]) or (p[0] == [1] and p[2] == p[3] == p[4]):
print('full house')
elif (p[0] == p[1] and p[2] == p[3]) or (p[1] == p[2] and p[3] == p[4]):
print('two pair')
elif p[0] == p[1] or p[1] == p[2] or p[2] == p[3] or p[3] == p[4]:
print('one pair')
elif p[0] == p[1]-1 and p[1] == p[2]-1 and p[2] == p[3]-1 and p[3] == p[4]-1 and p[4] == p[3]+1:
print('straight')
elif p[0] == 1 and p[1] == 10 and p[2] == 11 and p[3] == 12 and p[4] == 13:
print('straight')
else:
print('null')
| 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
|
<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>
|
s814192567 | p00038 | Wrong Answer | while 1:
try: p=sorted(list(map(int,input().split(','))))
except: break
if (p[0] == p[3]) or (p[1] == p[4]):
print('four card')
elif p[0] == p[2] or p[1] == p[3] or p[2] == p[4]:
print('three card')
elif (p[0] == p[2] and p[3] == p[4]) or (p[0] == p[1] and p[2] == p[4]):
print('full house')
elif (p[0] == p[1] and p[2] == p[3]) or (p[1] == p[2] and p[3] == p[4]):
print('two pair')
elif p[0] == p[1] or p[1] == p[2] or p[2] == p[3] or p[3] == p[4]:
print('one pair')
elif p[0] == p[1]-1 and p[1] == p[2]-1 and p[2] == p[3]-1 and p[3] == p[4]-1 and p[4] == p[3]+1:
print('straight')
elif p[0] == 1 and p[1] == 10 and p[2] == 11 and p[3] == 12 and p[4] == 13:
print('straight')
else:
print('null')
| 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
|
<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>
|
s881960312 | p00038 | Wrong Answer | while 1:
try: p=sorted(list(map(int,input().split(','))))
except: break
if (p[0] == p[2] and p[3] == p[4]) or (p[0] == p[1] and p[2] == p[4]):
print('full house')
elif p[0] == p[2] or p[1] == p[3] or p[2] == p[4]:
print('three card')
elif (p[0] == p[1] and p[2] == p[3]) or (p[1] == p[2] and p[3] == p[4]):
print('two pair')
elif (p[0] == p[3]) or (p[1] == p[4]):
print('four card')
elif p[0] == p[1] or p[1] == p[2] or p[2] == p[3] or p[3] == p[4]:
print('one pair')
elif (p[0] == p[1]-1 and p[1] == p[2]-1 and p[2] == p[3]-1 and p[3] == p[4]-1 and p[4] == p[3]+1) or (p[0] == 1 and p[1] == 10 and p[2] == 11 and p[3] == 12 and p[4] == 13):
print('straight')
else:
print('null')
| 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
|
<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>
|
s622705535 | p00038 | Wrong Answer | 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]==i:
print("straight")
s=True
if not s:
print("null")
| 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
|
<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>
|
s720526820 | p00038 | Wrong Answer | 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 'four card'
else:
if nums.count(2) == 2: print 'two pair'
elif nums.count(2) == 1: print 'one pair'
else:
hands2 = str(nums[12])
for val in nums: hand2 += str(val)
if '11111' in hands2: print 'straight'
else: print 'null'
except: break | 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
|
<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>
|
s641002791 | p00038 | Wrong Answer | 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 'four 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 | 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
|
<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>
|
s674763593 | p00038 | Wrong Answer | while True:
try:
hand = map(int, raw_input().split(","))
kind = list(set(hand))
rank =[]
for card in kind:
rank.append(hand.count(kind))
rank.sort()
rank.reverse()
if rank[0] == 4:
print "four card"
elif rank[0] == 3:
if rank[1] == 2:
print "hull 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:
print "straight"
else:
print "null"
except:
break | 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
|
<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>
|
s343433457 | p00038 | Wrong Answer | 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 "hull 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 | 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
|
<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>
|
s685224454 | p00038 | Accepted | 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
| 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
|
<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>
|
s524587750 | p00038 | Accepted | 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" | 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
|
<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>
|
s596595801 | p00038 | Accepted | 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 | 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
|
<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>
|
s510109411 | p00038 | Accepted | #!/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" | 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
|
<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>
|
s469384682 | p00038 | Accepted | 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') | 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
|
<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>
|
s812552225 | p00038 | Accepted | 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") | 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
|
<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>
|
s979883139 | p00038 | Accepted | 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 | 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
|
<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>
|
s028531585 | p00038 | Accepted | 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() | 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
|
<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>
|
s203896905 | p00038 | Accepted | 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") | 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
|
<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>
|
s550145540 | p00038 | Accepted | 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] | 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
|
<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>
|
s048928859 | p00038 | Accepted | 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') | 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
|
<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>
|
s123950695 | p00038 | Accepted | 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 | 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
|
<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>
|
s634391996 | p00038 | Accepted | 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 | 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
|
<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>
|
s640366106 | p00038 | Accepted | 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 | 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
|
<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>
|
s778282915 | p00038 | Accepted | 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()
| 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
|
<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>
|
s533885760 | p00038 | Accepted | # -*- 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] | 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
|
<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>
|
s468260245 | p00038 | Accepted | 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)) | 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
|
<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>
|
s471218610 | p00038 | Accepted | 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 | 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
|
<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>
|
s179621227 | p00038 | Accepted | 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') | 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
|
<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>
|
s717023054 | p00038 | Accepted | 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") | 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
|
<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>
|
s435131819 | p00038 | Accepted | 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 | 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
|
<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>
|
s930762150 | p00038 | Accepted | 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) | 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
|
<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>
|
s602691939 | p00038 | Accepted | 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 | 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
|
<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>
|
s867667442 | p00038 | Accepted | 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]) | 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
|
<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>
|
s458697213 | p00038 | Accepted | 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]) | 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
|
<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>
|
s294910688 | p00038 | Accepted | 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 | 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
|
<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>
|
s136188129 | p00038 | Accepted | 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') | 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
|
<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>
|
s891403099 | p00038 | Accepted | 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 | 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
|
<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>
|
s011202627 | p00038 | Accepted | # -*- 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') | 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
|
<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>
|
s402391592 | p00038 | Accepted | 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 | 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
|
<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>
|
s119669377 | p00038 | Accepted | # 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)) | 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
|
<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>
|
s423717568 | p00038 | Accepted | 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 | 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
|
<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>
|
s831566959 | p00038 | Accepted | 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()
| 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
|
<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>
|
s604111606 | p00038 | Accepted | 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
| 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
|
<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>
|
s813549428 | p00038 | Accepted | 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)
| 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
|
<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>
|
s483076683 | p00038 | Accepted | 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)
| 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
|
<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>
|
s298394377 | p00038 | Accepted | 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])
| 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
|
<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>
|
s116072706 | p00038 | Accepted | 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])
| 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
|
<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>
|
s811968088 | p00038 | Accepted | 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])
| 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
|
<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>
|
s261863709 | p00038 | Accepted | 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])
| 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
|
<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>
|
s751224510 | p00038 | Accepted | 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()
| 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
|
<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>
|
s545397756 | p00038 | Accepted | 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")
| 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
|
<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>
|
s806382734 | p00038 | Accepted | # 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])))
| 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
|
<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>
|
s449310547 | p00038 | Accepted | 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()
| 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
|
<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>
|
s226333437 | p00038 | Accepted | 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] | 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
|
<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>
|
s941402797 | p00038 | Accepted | 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] | 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
|
<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>
|
s785394758 | p00038 | Accepted | 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] | 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
|
<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>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.