submission_id string | problem_id string | status string | code string | input string | output string | problem_description string |
|---|---|---|---|---|---|---|
s802438537 | p00042 | Runtime Error | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
import itertools
def solve():
cache = dict()
def loop(i, w):
if (i, w) in cache:
return cache[i, w]
if i == N:
return (0, 0)
cache[i, w] = loop(i + 1, w)
if v[i][1] <= w:
t = loop(i + 1, w - v[i][1])
cache[i, w] = max(cache[i, w], (t[0] + v[i][0], t[1] + v[i][1]), key=lambda u: u[0])
return cache[i, w]
return loop(0, W)
for dn in itertools.count(1):
W = int(input())
if W == 0: break
N = int(input())
v = [tuple(map(int, input().split(','))) for _ in range(N)]
optim = solve()
print("Case %d:\n%d\n%d" % (dn, optim[0], optim[1])) | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s573891222 | p00042 | Runtime Error | import itertools
def solve():
cache = {}
def loop(i, w):
if (i, w) in cache:
return cache[i, w]
if i == N:
return (0, 0)
cache[i, w] = loop(i + 1, w)
if v[i][1] <= w:
t = loop(i + 1, w - v[i][1])
cache[i, w] = max(cache[i, w], (t[0] + v[i][0], t[1] + v[i][1]), key=lambda u: u[0])
return cache[i, w]
return loop(0, W)
for dn in itertools.count(1):
W = int(input())
if W == 0: break
N = int(input())
v = [tuple(map(int, input().split(','))) for _ in range(N)]
optim = solve()
print("Case %d:\n%d\n%d" % (dn, optim[0], optim[1])) | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s892533809 | p00042 | Runtime Error | import itertools
def solve(W, N, v):
cache = {}
def loop(i, w):
if (i, w) in cache:
return cache[i, w]
if i == N:
return (0, 0)
cache[i, w] = loop(i + 1, w)
if v[i][1] <= w:
t = loop(i + 1, w - v[i][1])
cache[i, w] = max(cache[i, w], (t[0] + v[i][0], t[1] + v[i][1]), key=lambda u: u[0])
return cache[i, w]
return loop(0, W)
for dn in itertools.count(1):
W = int(input())
if W == 0: break
N = int(input())
v = [tuple(map(int, input().split(','))) for _ in range(N)]
optim = solve(W, N, v)
print("Case %d:\n%d\n%d" % (dn, optim[0], optim[1])) | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s953407805 | p00042 | Runtime Error | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
import itertools
def solve(W, N, v):
cache = [[None for _ in range(W + 1)] for _ in range(N)]
def loop(i, w):
if i == N:
return (0, 0)
if cache[i][w] is not None:
return cache[i][w]
cache[i][w] = loop(i + 1, w)
if v[i][1] <= w:
t = loop(i + 1, w - v[i][1])
cache[i][w] = max(cache[i][w], (t[0] + v[i][0], t[1] + v[i][1]), key=lambda u: u[0])
return cache[i][w]
return loop(0, W)
for dn in itertools.count(1):
W = int(input())
if W == 0: break
N = int(input())
v = [tuple(map(int, input().split(','))) for _ in range(N)]
optim = solve(W, N, v)
print("Case %d:\n%d\n%d" % (dn, optim[0], optim[1])) | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s709644587 | p00042 | Runtime Error | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
import itertools
def solve(W, N, v):
cache = {}
def loop(i, w):
if i == N:
return (0, 0)
if (i, w) in cache:
return cache[i, w]
cache[i, w] = loop(i + 1, w)
if v[i][1] <= w:
t = loop(i + 1, w - v[i][1])
t = (t[0] + v[i][0], t[1] + v[i][1])
if cache[i, w][0] < t[0] or cache[i, w][0] == t[0] and t[1] < cache[i, w][1]:
cache[i, w] = t
return cache[i, w]
return loop(0, W)
for dn in itertools.count(1):
W = int(input())
if W == 0: break
N = int(input())
v = [tuple(map(int, input().split(','))) for _ in range(N)]
optim = solve(W, N, v)
print("Case %d:\n%d\n%d" % (dn, optim[0], optim[1])) | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s630073206 | p00042 | Runtime Error | c=0
for W in iter(input,'0\n'):
c+=1
W=int(W)
dp=[0]*-~W
for _ in[0]*int(input()):
v,w=map(int,input().split(','))
for i in range(W,w-1,-1):
if dp[i]<dp[i-w]+v:dp[i]=dp[i-w]+v
for i in range(W+1):
if dp[W]==dp[i]:print(f'Case {c}:\n{dp[W]}\n{i}');break
| 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s197093521 | p00042 | Runtime Error | case = 0
while True:
W = int(input())
if W == 0:
break
N = int(input())
case += 1
# a list of [itemValue, itemWeight]
items = [list(map(int,input().split(','))) for i in range(N)]
dp = {}
def bestVW(item, capa):
if (item,capa) in dp:
return dp[(item,capa)]
elif item == 0:
bestVWForCapa = items[item] if items[item][1] <= capa else [0,0]
dp[(item,capa)] = bestVWForCapa
return bestVWForCapa
else:
if items[item][1] > capa:
bestVWForCapa = bestVW(item-1, capa)
dp[(item,capa)] = bestVWForCapa
return bestVWForCapa
else:
pickedVW = bestVW(item-1,capa)
notPickedVW = list(map(sum, zip(items[item], bestVW(item-1, capa-items[item][1]))))
bestVWForCapa = pickedVW if pickedVW[0] > notPickedVW[0] else notPickedVW
dp[(item,capa)] = bestVWForCapa
return bestVWForCapa
print('Case ',case, ':', sep='')
print('\n'.join(map(str,bestVW(N-1,W))))
| 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s111525273 | p00042 | Runtime Error | case = 0
while True:
W = int(input())
if W == 0:
break
N = int(input())
case += 1
# a list of [itemValue, itemWeight]
items = [list(map(int,input().split(','))) for i in range(N)]
dp = {}
def bestVW(item, capa):
if (item,capa) in dp:
return dp[(item,capa)]
elif item == 0:
bestVWForCapa = items[item] if items[item][1] <= capa else [0,0]
dp[(item,capa)] = bestVWForCapa
return bestVWForCapa
else:
if items[item][1] > capa:
bestVWForCapa = bestVW(item-1, capa)
dp[(item,capa)] = bestVWForCapa
return bestVWForCapa
else:
pickedVW = bestVW(item-1,capa)
notPickedVW = list(map(sum, zip(items[item], bestVW(item-1, capa-items[item][1]))))
bestVWForCapa = pickedVW if pickedVW[0] > notPickedVW[0] else notPickedVW
dp[(item,capa)] = bestVWForCapa
return bestVWForCapa
msg = 'Case '+case+':\n'
print(msg)
print('\n'.join(map(str,bestVW(N-1,W))))
| 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s497587343 | p00042 | Runtime Error | case = 0
while True:
W = int(input())
if W == 0:
break
N = int(input())
case += 1
# a list of [itemValue, itemWeight]
items = [list(map(int,input().split(','))) for i in range(N)]
dp = {}
def bestVW(item, capa):
if (item,capa) in dp:
return dp[(item,capa)]
elif item == 0:
bestVWForCapa = items[item] if items[item][1] <= capa else [0,0]
dp[(item,capa)] = bestVWForCapa
return bestVWForCapa
else:
if items[item][1] > capa:
bestVWForCapa = bestVW(item-1, capa)
dp[(item,capa)] = bestVWForCapa
return bestVWForCapa
else:
pickedVW = bestVW(item-1,capa)
notPickedVW = list(map(sum, zip(items[item], bestVW(item-1, capa-items[item][1]))))
bestVWForCapa = pickedVW if pickedVW[0] > notPickedVW[0] else notPickedVW
dp[(item,capa)] = bestVWForCapa
return bestVWForCapa
msg = "Case "+str(case)+":"
print(msg)
print('\n'.join(map(str,bestVW(N-1,W))))
| 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s909005656 | p00042 | Runtime Error | case=0
while True:
case+=1
W=input()
if W==0:break
print "Case {}:".format(case)
dp=[0]*1000
w=[0]*1000
v=[0]*1000
n=input()
for i in xrange(n):
v[i],w[i]=map(int,raw_input().strip().split(","))
for i in xrange(n):
for j in xrange(W,-1,-1):
if j+w[i]<=W:
dp[j+w[i]]=max(dp[j+w[i]],dp[j]+v[i])
print max(dp)
print dp.index(max(dp)) | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s466099884 | p00042 | Runtime Error | num=1
maxw=input()
while maxw<>0:
N=input()
ws,ps=[],[]
for i in range(N):
tmp=input()
ws.append(tmp[1])
ps.append(tmp[0])
dp=[[0]*(maxw+1) for i in range(len(ws)+1)]
ret=0
for i in range(len(ws)):
for j in range(maxw+1):
if (j+ws[i])<=maxw:
dp[i+1][j+ws[i]]=max(dp[i+1][j+ws[i]],dp[i][j]+ps[i])
ret=max(dp[i+1][j+ws[i]],ret)
print "Case %d:"%num
print ret
print dp[len(ws)].index(ret)
num+=1
maxw=input() | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s725835884 | p00042 | Runtime Error | num=1
while True:
maxw=input()
if maxw==0:break
N=input()
ws,ps=[0]*N,[0]*N
for i in xrange(N):
ps[i],ws[i]=map(int,raw_input().strip().split(","))
dp=[[0]*(maxw+1) for i in range(len(ws)+1)]
ret=0
for i in range(len(ws)):
for j in range(maxw+1):
if (j+ws[i])<=maxw:
dp[i+1][j+ws[i]]=max(dp[i+1][j+ws[i]],dp[i][j]+ps[i])
ret=max(dp[i+1][j+ws[i]],ret)
print "Case %d:"%num
print ret
print dp[len(ws)].index(ret)
num+=1 | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s339135834 | p00042 | Runtime Error | num=1
while True:
maxw=input()
if maxw==0:break
N=input()
ws,ps=[0]*N,[0]*N
for i in xrange(N):
ps[i],ws[i]=map(int,raw_input().strip().split(","))
dp=[[0]*(maxw+1) for i in range(len(ws)+1)]
ret=0
for i in range(len(ws)):
for j in range(maxw+1):
if (j+ws[i])<=maxw:
dp[i+1][j+ws[i]]=max(dp[i+1][j+ws[i]],dp[i][j]+ps[i])
ret=max(dp[i+1][j+ws[i]],ret)
print "Case {}:".format(num)
print ret
print dp[len(ws)].index(ret)
num+=1 | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s657829285 | p00042 | Runtime Error | num=1
while True:
maxw=input()
if maxw==0:break
N=input()
ws,ps=[0]*N,[0]*N
for i in range(N):
ps[i],ws[i]=map(int,raw_input().strip().split(","))
#dp=[[0]*(maxw+1) for i in range(N+1)]
ret=0
for i in range(N):
for j in range(maxw+1):
if (j+ws[i])<=maxw:
dp[i+1][j+ws[i]]=max(dp[i+1][j+ws[i]],dp[i][j]+ps[i])
ret=max(dp[i+1][j+ws[i]],ret)
print "Case %d:"%num
print ret
print dp[len(ws)].index(ret)
num+=1 | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s401954916 | p00042 | Runtime Error |
import sys
import itertools
class Treasure:
def __init__(self, value, weight):
self.value = value
self.weight = weight
def solv(treasures, w_limit):
comb = t_combinations(treasures)
ts = filter(lambda x: t_sum_weight(x) <= w_limit, comb)
max_value = max(map(lambda x: t_sum_value(x), ts))
ts2 = filter(lambda x: t_sum_value(x) == max_value, ts)
if len(ts2) == 1:
return (ts2[0].value, ts2[0].weight)
else:
rt = rightest(ts2)
return (t_sum_value(rt), t_sum_weight(rt))
def t_combinations(t):
l = len(t)
r = []
for x in range(1, l+1):
for y in itertools.combinations(t, x):
r.append(y)
return r
def t_sum_weight(t):
return sum(map(lambda x: x.weight, t))
def t_sum_value(t):
return sum(map(lambda x: x.value, t))
def rightest(ts):
return reduce(lambda a, b: take_right(a, b), ts)
def take_right(a, b):
if t_sum_weight(a) <= t_sum_weight(b):
return a
else:
return b
case = 0
while True:
weight_limit = int(sys.stdin.readline())
case += 1
if weight_limit == 0:
exit()
n = int(sys.stdin.readline())
treasures = []
for i in range(n):
v, w = map(int, sys.stdin.readline().split(','))
treasures.append(Treasure(v, w))
value, weight = solv(treasures, weight_limit)
print 'Case ' + str(case) + ':'
print value
print weight | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s728223965 | p00042 | Runtime Error |
import sys
import itertools
class Treasure:
def __init__(self, value, weight):
self.value = value
self.weight = weight
def solv(treasures, w_limit):
comb = t_combinations(treasures)
ts = filter(lambda x: t_sum_weight(x) <= w_limit, comb)
max_value = max(map(lambda x: t_sum_value(x), ts))
ts2 = filter(lambda x: t_sum_value(x) == max_value, ts)
if len(ts2) == 1:
return (ts2[0].value, ts2[0].weight)
else:
rt = rightest(ts2)
return (t_sum_value(rt), t_sum_weight(rt))
def t_combinations(t):
l = len(t)
r = []
for x in range(1, l+1):
for y in itertools.combinations(t, x):
r.append(y)
return r
def t_sum_weight(ts):
return sum(map(lambda x: x.weight, ts))
def t_sum_value(ts):
return sum(map(lambda x: x.value, ts))
def rightest(tss):
return reduce(lambda a, b: take_right(a, b), tss)
def take_right(a, b):
if t_sum_weight(a) <= t_sum_weight(b):
return a
else:
return b
case = 0
while True:
weight_limit = int(sys.stdin.readline())
case += 1
if weight_limit == 0:
exit()
n = int(sys.stdin.readline())
treasures = []
for i in range(n):
v, w = map(int, sys.stdin.readline().split(','))
treasures.append(Treasure(v, w))
value, weight = solv(treasures, weight_limit)
print 'Case ' + str(case) + ':'
print value
print weight | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s830414421 | p00042 | Runtime Error | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
from itertools import count, combinations
for case in count(1):
W = int(stdin.readline())
if not W:
break
N = int(stdin.readline())
data = []
for _ in range(N):
data.append([int(s) for s in stdin.readline().split(',')])
total = []
for i in range(1, N+1):
for cmb in combinations(data, i):
tv, tw = 0, 0
for value, weight in cmb:
tv += value
tw += weight
if tw < W:
total.append((tv, tw))
tv, tw = max(total, key=lambda(tv, tw): (tv, -tw))
print('Case {}:\n{}\n{}'.format(case, tv, tw)) | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s799922147 | p00042 | Runtime Error | r = 50001
sqrt = int(math.sqrt(r))
p = [1]*r
p[0] = 0
for i in range(1,sqrt):
if p[i]:
p[2*i+1::i+1] = [0 for x in range(2*i+1,r,i+1)]
while True:
n = int(raw_input())
if n == 0:
break
count = 0
for i in range(n/2):
if p[i] == 1:
m = n - (i+1)
if p[m-1] == 1:
count += 1
print count | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s511089478 | p00042 | Runtime Error | def get():
p,w = map(int, raw_input().split(","))
for i in range(W-w+1,-1,-1):
if bag[i] > 0 and bag[i]+p > bag[i+w]:
bag[i+w] = bag[i]+p
else:
if p > bag[w]: bag[w] = p
return
c = 1
while True:
W = int(raw_input())
if W == 0: break
bag = [0]*(W+1)
N = int(raw_input())
for i in range(N): get()
w_all = max(bag)
money = bag.index(w_all)
print "Case {}:\n{}\n{}".format(c,w_all,money)
c += 1 | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s562709946 | p00042 | Runtime Error | for h in range(1, 10000):
w = int(raw_input())
if w == 0:
break
n = int(raw_input())
a = [map(int, raw_input().split(',')) for i in range(n)]
d = [[None] * 1010 for i in range(1010)]
def f(ix, w):
if ix == n:
return 0, 0
if d[ix][w] is not None:
return d[ix][w]
mx = f(ix + 1, w)
if w >= a[ix][1]:
e = [p + q for p, q in zip(f(ix + 1, w - a[ix][1]), a[ix])]
if mx[0] < e[0] or (mx[0] == e[0] and mx[1] > e[1]):
mx = e
d[ix][w] = mx
return mx
mx = f(0, w)
print 'Case {}:'.format(h)
print mx[0]
print mx[1] | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s387003722 | p00042 | Runtime Error | def mlist(n, *args, **keys):
if args:
return [mlist(*args, **keys) for i in range(n)]
else:
return [keys.get('default')] * n
while True:
w = int(raw_input())
if w == 0: break
n = int(raw_input())
a, b = zip(*[map(int, raw_input().split(',')) for i in range(5)])
c = mlist(1010, 1010)
c[0][0] = 0
for i in range(n):
for j in range(w + 1):
if c[i][j] is None: continue
c[i + 1][j] = max(c[i + 1][j], c[i][j])
if j + b[i] <= w:
c[i + 1][j + b[i]] = max(c[i + 1][j + b[i]], c[i][j] + a[i])
mx = max(c[n])
print mx
print c[n].index(mx) | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s235164523 | p00042 | Runtime Error | #!/bin/env python3
from __future__ import division, print_function
try:
input = raw_input
range = xrange
except NameError:
pass
# 上記のコードはPython2とPython3の違いを一部吸収するためのもの
def main():
value = [0] * 1000
weight = [0] * 1000
casenum = 1
while True:
W = int(input())
if(W == 0):
return
N = int(input())
dp = [[0 for x in range(W+1)] for y in range(N+1)]
for x in range(0, N):
value[x], weight[x] = map(int, input().split(','))
for i in range(0, N):
for w in range(0, W+1):
if w - weight[i] >= 0:
use = dp[i][w - weight[i]] + value[i]
else:
use = 0
unuse = dp[i][w]
dp[i+1][w] = max(use, unuse)
print("Case " + str(casenum) + ":")
for w in range(W+1):
if(dp[N][w] == dp[N][W]):
print(str(dp[N][w]) + "\n" + str(w))
break
casenum += 1
main() | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s669836533 | p00043 | Wrong Answer | import sys
def pokakito(num_line):
if not num_line and flag == 1:
result_lis.append(check_num)
return True
for num in num_line:
if three(num, num_line): return True
if two(num, num_line): return True
if straight(num, num_line): return True
def three(num, num_line):
count = 0
for check in num_line[:3]:
if check == num:
count += 1
else:
if count == 3:
if pokakito(num_line[3:]): return True
def two(num, num_line):
global flag
count = 0
for check in num_line[:2]:
if check == num:
count += 1
else:
if count == 2:
flag += 1
if pokakito(num_line[2:]): return True
flag -= 1
def straight(num, num_line):
num_lis = [num,num+1,num+2]
for i in range(3):
for check in num_lis:
if check < 0 or (not check in num_line):
for i in range(3):
num_lis[i] = num_lis[i]-1
break
else:
for n in num_lis:
index = 0
while num_line:
if num_line[index] == n:
del num_line[index]
break
index += 1
else:
if pokakito(num_line): return True
flag = 0
result_lis = []
check_num = 0
for input_line in sys.stdin:
for i in range(9):
check_num = i+1
input_line = input_line.rstrip()
line = sorted(input_line + str(check_num))
line = ''.join(line)
index = line.find(str(check_num))
if line[index:index+5] == str(check_num)*5:
continue
pokakito([int(char) for char in line])
result = sorted([str(num) for num in result_lis])
flag = 0
else:
if result_lis:
print ' '.join(result)
else:
print 0
else:
flag = 0
result_lis = []
check_num = 0 | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s397375943 | p00043 | Wrong Answer | def Solve(c,s):
if s:
for i in range(9):
if c[i]>4:return False
elif c[i]>=2:
cc=c[:]
cc[i]-=2
if Solve(cc,False):return True
else:
if c.count(0)+c.count(3)==9:return True
else:
for i in range(9):
if c[i]<0:return False
elif c[i]>=1 and i<7:
cc=c[:]
for j in range(3):
cc[i+j]-=1
if Solve(cc,False):return True
_in=""
while True:
ans=[]
try:_in=input()
except EOFError:break
for i in range(9):
l=sorted((_in+str(i+1))[::1])
count=[l.count(str(j+1))for j in range(9)]
if Solve(count,True):ans.append(str(i+1))
print(0 if len(ans)==0 else " ".join(ans)) | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s098050149 | p00043 | Wrong Answer | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0043
"""
import sys
from sys import stdin
input = stdin.readline
def dfs(hand, count):
# ??¢??????n????????£??????????????¨????¢??????????
if count < 1:
return True
for i, n in enumerate(hand):
if n >= 3:
c_hand = hand[:]
c_hand[i] -= 3
res = dfs(c_hand[:], count-1)
if res:
return True
elif n >= 1:
if i > 7:
return False
if hand[i+1] >= 1 and hand[i+2] >= 1:
c_hand = hand[:]
c_hand[i] -= 1
c_hand[i+1] -= 1
c_hand[i+2] -= 1
res = dfs(c_hand[:], count-1)
if res:
return True
else:
return False
return True
def solve(data):
"""
1) ??????1??????????????¨
2) ??¢??????4??????????????¨
3) ????????°??????5?????\??????????????¨
:param data: ??????
:return: ??????????????????
"""
ans = []
# ?????¨?????????l???9??????????????????????????????????????????????????§??????????????????????????????????????§????????°????????????????????°????????????????????????
for tsumo in range(1, 10):
my_hand = data[:]
my_hand.append(tsumo) # ????????????????????°??????1????¶????
remaining = [0] * 10
for n in my_hand:
remaining[n] += 1
if max(remaining) > 4: # ?????????3?¢????
continue
# ?????????1????¢????
for i, n in enumerate(remaining[1:], start=1):
if n >= 2:
c_remaining = remaining[:]
c_remaining[i] -= 2
res = dfs(c_remaining[:], 4)
if res:
ans.append(tsumo)
break
return ans
def main(args):
#hand = '3649596966777'
#data = list(map(int, list(hand)))
for line in sys.stdin:
data = list(map(int, list(line.strip())))
result = solve(data)
if len(result) > 0:
print(*result)
else:
print(0)
if __name__ == '__main__':
main(sys.argv[1:])
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s877944173 | p00043 | Wrong Answer | from collections import deque
try:
while True:
a = list(sorted(map(int, input())))
result = []
for i in range(1, 10):
if a.count(i) == 4:
continue
_a = sorted(a+[i])
dq = deque([(_a, 0)])
while dq:
hand, mentu = dq.popleft()
if mentu == 5:
if not hand:
result.append(i)
break
continue
if hand.count(hand[0]) >= 2:
dq.append((hand[2:], mentu+1))
if hand.count(hand[0]) >= 3:
dq.append((hand[3:], mentu+1))
if hand.count(hand[0]+1) > 0 and hand.count(hand[0]+2) > 0:
_hand = hand[:]
del _hand[0]
del _hand[_hand.index(hand[0]+1)]
del _hand[_hand.index(hand[0]+2)]
dq.append((_hand, mentu+1))
print(" ".join(map(str, result)) if result else 0)
except EOFError as e:
print(e)
exit()
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s976751830 | p00043 | Wrong Answer | def Judge(P,cnt2=0):
for i in range(1,11):
if P[i]==1 or P[i]==4:
P[i],P[i+1],P[i+2]=0,P[i+1]-1,P[i+2]-1
elif P[i]==2:
if cnt2>=1:
return False
P[i]-=2
if Judge(P[:],1):
return True
P[i+1]-=2
P[i+2]-=2
if Judge(P[:]):
return True
elif P[i]==3:
P[i]-=3
if Judge(P[:]):
return True
P[i+1]-=1
P[i+2]-=1
if Judge(P[:]):
return True
elif P[i]<0:
return False
return True
while True:
try:
s=map(int,raw_input())
except EOFError:
break
L=[0]*12
ans=[]
for i in s:
L[i]+=1
for i in range(1,10):
L[i]+=1
if max(L)!=5 and Judge(L[:]):
ans.append(i)
L[i]-=1
print " ".join(map(str,ans)) if len(ans)>0 else 0 | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s706126828 | p00043 | Wrong Answer | def Judge(P,cnt2=0):
for i in range(1,11):
if P[i]==1 or P[i]==4:
P[i],P[i+1],P[i+2]=0,P[i+1]-1,P[i+2]-1
elif P[i]==2:
if cnt2>=1:
return False
P[i]-=2
cnt2=1
if Judge(P[:],cnt2):
return True
P[i+1]-=2
P[i+2]-=2
if Judge(P[:],cnt2):
return True
elif P[i]==3:
P[i]-=3
if Judge(P[:],cnt2):
return True
P[i+1]-=1
P[i+2]-=1
if Judge(P[:],cnt2):
return True
elif P[i]<0:
return False
return True
while True:
try:
s=map(int,raw_input())
except EOFError:
break
L=[0]*12
ans=[]
for i in s:
L[i]+=1
for i in range(1,10):
L[i]+=1
if max(L)!=5 and Judge(L[:]):
ans.append(i)
L[i]-=1
print " ".join(map(str,ans)) if len(ans)>0 else 0 | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s335956867 | p00043 | Wrong Answer | def Judge(P,cnt2=0):
for i in range(1,11):
if P[i]==1:
P[i],P[i+1],P[i+2]=0,P[i+1]-1,P[i+2]-1
elif P[i]==2:
if cnt2>=1:
return False
P[i]-=2
cnt2=1
if Judge(P[:],cnt2):
return True
P[i+1]-=2
P[i+2]-=2
if Judge(P[:],cnt2):
return True
elif P[i]==3:
P[i]-=3
if Judge(P[:],cnt2):
return True
P[i+1]-=1
P[i+2]-=1
if Judge(P[:],cnt2):
return True
elif P[i]==4:
P[i],P[i+1],P[i+2]=0,P[i+1]-1,P[i+2]-1
if Judge(P[:],cnt2):
return True
P[i+1],P[i+2]=P[i+1]-3,P[i+2]-3
if Judge(P[:],cnt2):
return True
elif P[i]<0:
return False
return True
while True:
try:
s=map(int,raw_input())
except EOFError:
break
L=[0]*12
ans=[]
for i in s:
L[i]+=1
for i in range(1,10):
L[i]+=1
if max(L)!=5 and Judge(L[:]):
ans.append(i)
L[i]-=1
print " ".join(map(str,ans)) if len(ans)>0 else 0 | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s356793710 | p00043 | Wrong Answer | def rm_shuntsu(hand):
for hai in set(hand):
if (hai in hand) and (hai+1 in hand) and (hai+2 in hand):
if len(hand) == 3: return True
hand1 = hand[:]
hand1.remove(hai);hand1.remove(hai+1);hand1.remove(hai+2)
return is_hora(hand1)
else: return False
def rm_kotsu(hand):
for hai in set(hand):
if hand.count(hai) >= 3:
if len(hand) == 3: return True
hand1 = hand[:]
hand1.remove(hai);hand1.remove(hai);hand1.remove(hai)
return is_hora(hand1)
else: return False
def is_hora(hand):
return rm_shuntsu(hand) or rm_kotsu(hand)
while True:
try:
hand = map(int, raw_input())
ans = []
for tumo in range(1,10):
hand1 = hand[:]
hand1.append(tumo)
for janto in set(hand1):
if 2 <= hand1.count(janto) <= 4:
hand2 = hand1[:]
hand2.remove(janto);hand2.remove(janto)
if is_hora(hand2):
ans.append(tumo)
break
print " ".join(map(str, sorted(ans))) if len(ans) > 0 else 0
except:
break | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s365264683 | p00043 | Wrong Answer | from collections import Counter
while 1:
try:
puzzle = map(int, raw_input())
except EOFError:
break
ret = []
for i in xrange(1, 10):
for j in xrange(1, 10):
tmp = Counter(puzzle + [i])
if tmp[j] < 2:
continue
tmp[j] -= 2
for k in xrange(1, 10):
if not tmp[k]:
continue
if tmp[k] >= 3:
tmp[k] -= 3
while tmp[k] and tmp[k + 1] and tmp[k + 2]:
tmp[k] -= 1
tmp[k + 1] -= 1
tmp[k + 2] -= 1
if tmp[k]:
break
else:
ret.append(i)
break
if ret:
print ' '.join(map(str, ret))
else:
print 0 | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s144121063 | p00043 | Time Limit Exceeded | def Solve(c,s):
if s:
for i in range(9):
if c[i]>4:return False
elif c[i]>=2:
cc=c[:]
cc[i]-=2
if Solve(cc,False):return True
else:
if c.count(0)+c.count(3)==9:return True
else:
for i in range(9):
if c[i]<0:return False
elif c[i]>=1 and i<7:
cc=c[:]
for j in range(3):
cc[i+j]-=1
if Solve(cc,False):return True
_in=""
while True:
ans=[]
try:_in="9118992346175"
except EOFError:break
for i in range(9):
l=sorted((_in+str(i+1))[::1])
count=[l.count(str(j+1))for j in range(9)]
if Solve(count,True):ans.append(str(i+1))
print(0 if len(ans)==0 else " ".join(ans)) | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s202184149 | p00043 | Time Limit Exceeded | def Solve(c,s):
if s:
if max(c)>4:return False
for i in range(9):
if c[i]>=2:
cc=c[:]
cc[i]-=2
if Solve(cc,False):return True
else:
check=0
for i in range(4):check+=c.count(3*i)
if check==9:return True
else:
for i in range(7):
if c[i]>=1:
cc=c[:]
for j in range(3):
cc[i+j]-=1
if cc[i+j]<0:break
if Solve(cc,False):return True
_in=""
while True:
ans=[]
try:_in="1123345567799"
except EOFError:break
for i in range(9):
l=(_in+str(i+1))[::1]
count=[l.count(str(j+1))for j in range(9)]
if Solve(count,True):ans.append(str(i+1))
print(0 if len(ans)==0 else " ".join(ans)) | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s295447871 | p00043 | Time Limit Exceeded | def Solve(c,s):
if s:
if max(c)>4:return False
for i in range(9):
if c[i]>=2:
cc=c[:]
cc[i]-=2
if Solve(cc,False):return True
else:
check=0
for i in range(4):check+=c.count(3*i)
if check==9:return True
else:
for i in range(7):
if c[i]>=1:
cc=c[:]
for j in range(3):
cc[i+j]-=1
if cc[i+j]<0:break
if Solve(cc,False):return True
_in=""
while True:
ans=[]
try:_in=input()
except EOFError:break
for i in range(9):
l=(_in+str(i+1))[::1]
count=[l.count(str(j+1))for j in range(9)]
if Solve(count,True):ans.append(str(i+1))
print(0 if len(ans)==0 else " ".join(ans)) | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s069337243 | p00043 | Accepted | def is_solved(nums):
keys = set(nums)
for key in keys:
if nums.count(key) >= 2:
tmp = nums[:]
tmp.remove(key)
tmp.remove(key)
for key in keys:
key_count = tmp.count(key)
if key_count == 4:
if key + 1 in tmp and key + 2 in tmp:
for _ in range(4): tmp.remove(key)
tmp.remove(key + 1)
tmp.remove(key + 2)
elif key_count == 3:
for _ in range(3): tmp.remove(key)
elif tmp.count(key + 1) >= key_count and tmp.count(key + 2) >= key_count:
for _ in range(key_count):
tmp.remove(key)
tmp.remove(key + 1)
tmp.remove(key + 2)
if tmp == []:
return True
return False
while True:
try:
puzzle = list(map(int, list(input())))
ans = []
for i in range(1, 10):
if puzzle.count(i) <= 3 and is_solved(puzzle + [i]):
ans.append(i)
if ans:
print(*ans)
else:
print(0)
except EOFError:
break
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s840701905 | p00043 | Accepted | from sys import *
from collections import *
def uck(e,y):
d = Counter(dict(e))
for i in xrange(1,13):
if d[i] < 0 or d[i] >= 5: return False
ab = 0
for i in xrange(1,10): ab += abs(d[i])
if ab == 0: return True
for i in xrange(1,10):
if d[i] == 0 : continue
d[i]-=3
if uck(d,y): return True
d[i]+=3
if not y:
d[i]-=2
if uck(d,True): return True
d[i]+=2
d[i]-=1;d[i+1]-=1;d[i+2]-=1
if uck(d,y):return True
for s in stdin:
s = map(int,s[:-1]); v = ""
for j in xrange(1,10):
if len(s) == 14: s=s[:-1]
s.append(j)
if uck(Counter(sorted(s)),False): v += str(j)+" "
if v == "": print 0
else: print v[:-1] | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s569962490 | p00043 | Accepted | import sys
def pokakito(num_line):
if not num_line and flag == 1:
result_lis.append(check_num)
return True
for num in num_line:
if three(num, num_line): return True
if two(num, num_line): return True
if straight(num, num_line): return True
def three(num, num_line):
count = 0
for check in num_line[:3]:
if check == num:
count += 1
else:
if count == 3:
if pokakito(num_line[3:]): return True
def two(num, num_line):
global flag
count = 0
for check in num_line[:2]:
if check == num:
count += 1
else:
if count == 2:
flag += 1
if pokakito(num_line[2:]): return True
flag -= 1
def straight(num, num_line):
num_lis = [num,num+1,num+2]
for i in range(3):
for check in num_lis:
if check < 0 or (not check in num_line):
for i in range(3):
num_lis[i] = num_lis[i]-1
break
else:
for n in num_lis:
index = 0
while num_line:
if num_line[index] == n:
del num_line[index]
break
index += 1
else:
if pokakito(num_line): return True
flag = 0
result_lis = []
check_num = 0
for input_line in sys.stdin:
for i in range(9):
check_num = i+1
input_line = input_line.rstrip()
line = sorted(input_line + str(check_num))
line = ''.join(line)
index = line.find(str(check_num))
if line[index:index+5] == str(check_num)*5:
continue
pokakito([int(char) for char in line])
result = sorted([str(num) for num in result_lis])
flag = 0
else:
if result_lis:
print ' '.join(result)
else:
print 0
flag = 0
result_lis = []
check_num = 0 | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s911071232 | p00043 | Accepted | import sys
def pokakito(num_line):
if not num_line and flag == 1:
result_lis.append(check_num)
return True
for num in num_line:
if three(num, num_line): return True
if two(num, num_line): return True
if straight(num, num_line): return True
def three(num, num_line):
count = 0
for check in num_line[:3]:
if check == num:
count += 1
else:
if count == 3:
if pokakito(num_line[3:]): return True
def two(num, num_line):
global flag
count = 0
for check in num_line[:2]:
if check == num:
count += 1
else:
if count == 2:
flag += 1
if pokakito(num_line[2:]): return True
flag -= 1
def straight(num, num_line):
for check in [num,num+1,num+2]:
if not check in num_line:
break
else:
for n in [num,num+1,num+2]:
index = 0
while num_line:
if num_line[index] == n:
del num_line[index]
break
index += 1
else:
if pokakito(num_line): return True
flag = 0
result_lis = []
check_num = 0
for input_line in sys.stdin:
for i in range(9):
check_num = i+1
input_line = input_line.rstrip()
line = sorted(input_line + str(check_num))
line = ''.join(line)
index = line.find(str(check_num))
if line[index:index+5] == str(check_num)*5:
continue
pokakito([int(char) for char in line])
result = sorted([str(num) for num in result_lis])
flag = 0
else:
if result_lis:
print ' '.join(result)
else:
print 0
flag = 0
result_lis = []
check_num = 0 | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s590492330 | p00043 | Accepted | #memo roiti 899204
def rm_s(h):
seth=set(h)
for hai in seth:
if set([hai,hai+1,hai+2])<=seth:
if len(h)==3:
return 1
h1=h[:]
for i in range(3):
h1.remove(hai+i)
return is_hora(h1)
else:
return 0
def rm_k(h):
for hai in set(h):
if h.count(hai)>=3:
if len(h)==3:
return 1
h1=h[:]
for i in range(3):
h1.remove(hai)
return is_hora(h1)
else:
return 0
def is_hora(h):
return rm_k(h) or rm_s(h)
while 1:
try:
h=map(int,raw_input())
ans=[]
for a in range(1,10):
if h.count(a)<=3:
h1=h[:]+[a]
for d in set(h1):
if 2<= h1.count(d):
h1=h[:]+[a]
h1.remove(d)
h1.remove(d)
if is_hora(h1):
ans.append(a)
break
print ' '.join(map(str, sorted(ans))) if len(ans)>0 else 0
except:
break | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s184729034 | p00043 | Accepted | def ch(data):
data.sort()
if max(data.count(i) for i in range(1, 10)) > 4:
return False
if len(data) == 2 and data[0] == data[1]:
return True
for i in range(1, 10):
if data.count(i) >= 3:
tmp = data[:]
for _ in range(3):
tmp.remove(i)
if ch(tmp):
return True
for i in range(7):
if i + 1 in data and i + 2 in data and i + 3 in data:
tmp = data[:]
for j in range(3):
tmp.remove(i + j + 1)
if ch(tmp):
return True
return False
while True:
try:
data = list(map(int, input()))
if not len(data):
break
except:
break
res = []
for i in range(1, 10):
if ch(data + [i]):
res.append(i)
print(*res if len(res) else [0]) | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s750214267 | p00043 | Accepted |
def check(nums):
for i in range(9):
if(nums[i]>4):return False
for head in range(9):
anums=nums[:]
if(anums[head]<2):continue
anums[head]-=2
for i in range(9):
if(anums[i]>=3):
anums[i]-=3
while(anums[i]>0):
if i>=7:break
ok=True
for j in range(i,i+3):
if anums[j]<=0:
ok=False
if not ok:
break
for j in range(i,i+3):
anums[j]-=1
if not any(anums):
return True
return False
while True:
st=''
try:
st=input()
except:
break
nums=[0 for i in range(9)]
for c in st:
nums[int(c)-1]+=1
anss=[]
for n in range(0,9):
nums[n]+=1
if(check(nums[:])):anss.append(n+1)
nums[n]-=1
if(len(anss)==0):anss.append(0)
print(' '.join(map(str,anss))) | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s020075829 | p00043 | Accepted | def is_hora(lst):
for i in range(1,10):
if lst[i] >= 2:
if(is_4chunk(lst,i)): return True
return False
def is_4chunk(lst,atama):
searchlist = [0]*10
for i in range(10):
searchlist[i] = lst[i]
searchlist[atama] -= 2
for i in range(1,8):
if searchlist[i] < 0: return False
if searchlist[i] >=3: searchlist[i]-=3
if searchlist[i] ==1:
searchlist[i]-=1
searchlist[i+1]-=1
searchlist[i+2]-=1
elif searchlist[i] ==2:
searchlist[i]-=2
searchlist[i+1]-=2
searchlist[i+2]-=2
return (searchlist[8] == 0 or searchlist[8] == 3) and (searchlist[9] == 0 or searchlist[9] == 3)
while True:
try:
instr = input()
pai = [0]*10
ans = []
for i in range(13):
pai[(int(instr[i]))] += 1
for i in range(1,10):
if pai[i] == 4: continue
pai[i] += 1
if is_hora(pai): ans.append(i)
pai[i] -= 1
if len(ans)!=0:
print(" ".join(list(map(str,ans))))
else: print(0)
except EOFError: break | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s613447063 | p00043 | Accepted | def Solve(c,s):
if s:
if max(c)>4:return False
for i in range(9):
if c[i]>=2:
cc=c[:]
cc[i]-=2
if Solve(cc,False):return True
else:
check=0
for i in range(4):check+=c.count(3*i)
if check==9:return True
else:
for i in range(7):
if c[i]>=1:
cc=c[:]
isneg=False
for j in range(3):
cc[i+j]-=1
if cc[i+j]<0:
isneg=True
break
if isneg==False and Solve(cc,False):return True
_in=""
while True:
ans=[]
try:_in=input()
except EOFError:break
for i in range(9):
l=(_in+str(i+1))[::1]
count=[l.count(str(j+1))for j in range(9)]
if Solve(count,True):ans.append(str(i+1))
print(0 if len(ans)==0 else " ".join(ans)) | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s927133770 | p00043 | Accepted | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0043
"""
import sys
from sys import stdin
input = stdin.readline
def dfs(hand, count):
# ??¢??????n????????£??????????????¨????¢??????????
if count < 1:
return True
for i, n in enumerate(hand[1:], start=1):
if n == 0:
continue
if n >= 3:
c_hand = hand[:]
c_hand[i] -= 3
res = dfs(c_hand[:], count-1)
if res:
return True
if i > 7:
return False
if hand[i+1] >= 1 and hand[i+2] >= 1:
c_hand = hand[:]
c_hand[i] -= 1
c_hand[i+1] -= 1
c_hand[i+2] -= 1
res = dfs(c_hand[:], count-1)
if res:
return True
else:
return False
def solve(data):
"""
1) ??????1??????????????¨
2) ??¢??????4??????????????¨
3) ????????°??????5?????\??????????????¨
:param data: ??????
:return: ??????????????????
"""
ans = [] # ???????????????????¨????
# ?????¨?????????l???9??????????????????????????????????????????????????§??????????????????????????????????????§????????°????????????????????°????????????????????????
for tsumo in range(1, 10):
my_hand = data[:]
my_hand.append(tsumo) # ????????????????????°??????1????¶????
remaining = [0] * 10
for n in my_hand:
remaining[n] += 1
if max(remaining) > 4: # ?????????3?¢????
continue
# ?????????1????¢????
for i, atama in enumerate(remaining[1:], start=1):
if atama >= 2:
c_remaining = remaining[:]
c_remaining[i] -= 2
res = dfs(c_remaining[:], 4)
if res:
ans.append(tsumo)
break
return ans
def main(args):
#hand = '3649596966777'
#data = list(map(int, list(hand)))
for line in sys.stdin:
data = list(map(int, list(line.strip())))
result = solve(data)
if len(result) > 0:
print(*result)
else:
print(0)
if __name__ == '__main__':
main(sys.argv[1:])
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s334632573 | p00043 | Accepted | def check_set(hand):
set_list = []
for i in range(9):
if hand.count(i + 1) >= 3:
set_list.append([i + 1, i + 1, i + 1])
if i + 1 in hand and i + 2 in hand and i + 3 in hand:
set_list.append([i + 1, i + 2, i + 3])
return set_list
def check_winning(hand):
if len(hand) == 2:
if hand[0] == hand[1]:
return True
else:
return False
set_tmp_list = check_set(hand)
if len(set_tmp_list) == 0:
return False
for set_tmp in set_tmp_list:
hand_tmp = hand[:]
for i in range(3):
hand_tmp.remove(set_tmp[i])
res = check_winning(hand_tmp)
if res:
break
else:
continue
return res
while True:
try:
inp = list(map(int, list(input())))
ans = []
for i in range(9):
if inp.count(i + 1) >= 4:
continue
inp_tmp = inp[:]
inp_tmp.append(i + 1)
if check_winning(inp_tmp):
ans.append(i + 1)
if len(ans) == 0:
print(0)
else:
print(*ans)
except:
break
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s219248606 | p00043 | Accepted | import sys
def f(c,h=0):
if 2 in c and sum(c)==2:return 1
if 5 in c:return 0 # sum(c)==2
if 4 in c:
k=c.index(4);c[k]-=3
if f(c,h+1):return 1
c[k]+=3
if 3 in c:
k=c.index(3);c[k]-=3
if f(c,h+1):return 1
c[k]+=3
for i in range(7):
if c[i]and c[i+1]and c[i+2]:
c[i]-=1;c[i+1]-=1;c[i+2]-=1
if f(c,h+1):return 1
c[i]+=1;c[i+1]+=1;c[i+2]+=1
n='123456789'
for e in sys.stdin:
e=list(e)
a=[i for i in n if f([(e+[i]).count(j)for j in n])]
if a:print(*a)
else:print(0)
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s635875296 | p00043 | Accepted | import sys
def f(c):
if sum(c)in c:return 1
if 5 in c or sum(c)==2:return 0
if 4 in c:
k=c.index(4);c[k]-=3
if f(c):return 1
c[k]+=3
if 3 in c:
k=c.index(3);c[k]-=3
if f(c):return 1
c[k]+=3
for i in range(7):
if c[i]and c[i+1]and c[i+2]:
c[i]-=1;c[i+1]-=1;c[i+2]-=1
if f(c):return 1
c[i]+=1;c[i+1]+=1;c[i+2]+=1
n='123456789'
for e in sys.stdin:
e=list(e)
a=[i for i in n if f([(e+[i]).count(j)for j in n])]
if a:print(*a)
else:print(0)
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s834014700 | p00043 | Accepted | import sys
def f(c):
if sum(c)in c:return 1
if 5 in c:return 0
if 4 in c:
k=c.index(4);c[k]-=3
if f(c):return 1
c[k]+=3
if 3 in c:
k=c.index(3);c[k]-=3
if f(c):return 1
c[k]+=3
for i in range(7):
if c[i]and c[i+1]and c[i+2]:
c[i]-=1;c[i+1]-=1;c[i+2]-=1
if f(c):return 1
c[i]+=1;c[i+1]+=1;c[i+2]+=1
n='123456789'
for e in sys.stdin:
e=list(e)
a=[i for i in n if f([(e+[i]).count(j)for j in n])]
if a:print(*a)
else:print(0)
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s769014618 | p00043 | Accepted | import sys
def p(c,l,b):
for i in l:c[i]+=[-1,1][b]
def f(c):
if sum(c)in c:return 1
if 5 in c:return 0
if 4 in c:
k=c.index(4);c[k]-=3
if f(c):return 1
c[k]+=3
if 3 in c:
k=c.index(3);c[k]-=3
if f(c):return 1
c[k]+=3
for i in range(7):
if c[i]and c[i+1]and c[i+2]:
p(c,[i,i+1,i+2],0)
if f(c):return 1
p(c,[i,i+1,i+2],1)
n='123456789'
for e in sys.stdin:
e=list(e)
a=[i for i in n if f([(e+[i]).count(j)for j in n])]
if a:print(*a)
else:print(0)
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s402814461 | p00043 | Accepted | import sys
def g(c,i):
a=[0]*9
for j in e+[i]:a[j-1]+=1
return a
def f(c):
if sum(c)in c:return 1
if 5 in c:return 0
if 4 in c:
k=c.index(4);c[k]-=3
if f(c):return 1
c[k]+=3
if 3 in c:
k=c.index(3);c[k]-=3
if f(c):return 1
c[k]+=3
for i in range(7):
if c[i]and c[i+1]and c[i+2]:
c[i]-=1;c[i+1]-=1;c[i+2]-=1
if f(c):return 1
c[i]+=1;c[i+1]+=1;c[i+2]+=1
for e in sys.stdin:
e=list(map(int,e.strip()))
a=[i for i in range(1,10)if f(g(e,i))]
if a:print(*a)
else:print(0)
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s133081895 | p00043 | Accepted | import sys
def f(c):
if sum(c)in c:return 1
if 5 in c:return 0
if 4 in c:
k=c.index(4);c[k]-=3
if f(c):return 1
c[k]+=3
if 3 in c:
k=c.index(3);c[k]-=3
if f(c):return 1
c[k]+=3
for i in range(7):
if c[i]and c[i+1]and c[i+2]:
c[i]-=1;c[i+1]-=1;c[i+2]-=1
if f(c):return 1
c[i]+=1;c[i+1]+=1;c[i+2]+=1
n='123456789'
for e in sys.stdin:
c=[list(e).count(j)for j in n]
a=[]
for i in range(9):
t=c[:];t[i]+=1
if f(t):a+=[i+1]
if a:print(*a)
else:print(0)
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s551638537 | p00043 | Accepted | def check(nums):
#print(nums)
#5回以上出てこないか判別
for i in range(9):
if(nums[i]>4):
return False
for head in range(9):
#作業用の配列を作る
anums=nums[:]
#頭ができているか確認
if(anums[head]<2):
continue
anums[head]-=2
for i in range(9):
#三つ同じものがある場合はそれをひとまとめにする
if(anums[i]>=3):
anums[i]-=3
while(anums[i]>0):
#8以上が1になってても成立しないからFalse
if i>=7:
break
ok=True
for j in range(i,i+3):
if anums[j]<=0:
ok=False
#okがFalseなら順番になってない
if not ok:
break
#okがTrueなら順番になっているので一ずつ減らす。
for j in range(i,i+3):
anums[j]-=1
#全て0になっていればTrue
if not any(anums):
return True
return False
while True:
st=""
try:
st=input()
except:
break
#9個の配列を作り0を入れる
nums=[0 for i in range(9)]
#各数字の数を数える
for c in st:
nums[int(c)-1]+=1
#答えの配列を作る
anss=[]
#与えられたものに1~9を一つずつ加えてそれぞれで判定
for n in range(0,9):
nums[n]+=1
if(check(nums[:])):
anss.append(n+1)
nums[n]-=1
if(len(anss)==0):
anss.append(0)
print(" ".join(map(str,anss)))
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s997133066 | p00043 | Accepted | from collections import deque
try:
while True:
a = list(sorted(map(int, input())))
result = []
for i in range(1, 10):
if a.count(i) == 4:
continue
_a = sorted(a+[i])
dq = deque([(_a, 0)])
while dq:
hand, mentu = dq.popleft()
if mentu == 5:
if not hand:
result.append(i)
break
continue
elif mentu > 5:
continue
current = hand[0]
if hand.count(current) >= 2:
dq.append((hand[2:], mentu+1))
if hand.count(current) >= 3:
dq.append((hand[3:], mentu+1))
if current+1 in hand and current+2 in hand:
_hand = hand[:]
del _hand[0]
del _hand[_hand.index(current+1)]
del _hand[_hand.index(current+2)]
dq.append((_hand, mentu+1))
print(" ".join(map(str, result)) if result else 0)
except EOFError:
exit()
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s741221675 | p00043 | Accepted | import sys
def dfs(hands, pair):
hands.sort()
if not hands:
return True
target = hands[0]
# sequence
if all(map(lambda x: x in hands, range(target, target + 3))):
for i in range(target, target + 3):
hands.remove(i)
if dfs(hands, pair):
return True
for i in range(target, target + 3):
hands.append(i)
# triple
if hands.count(target) >= 3:
for i in range(3):
hands.remove(target)
if dfs(hands, pair):
return True
for i in range(3):
hands.append(target)
# pair
if not pair and hands.count(target) >= 2:
for i in range(2):
hands.remove(target)
if dfs(hands, True):
return True
for i in range(2):
hands.append(target)
return False
for line in filter(lambda line: line.strip(), sys.stdin.readlines()):
result = []
data = [int(ch) for ch in line.strip()]
for num in filter(lambda x: data.count(x) < 4, range(1, 10)):
data_cp = list(data)
data_cp.append(num)
data_cp.sort()
if dfs(data_cp, False):
result.append(num)
if result:
print " ".join(map(str, result))
else:
print 0 | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s920724182 | p00043 | Accepted | import sys
for line in sys.stdin.readlines():
li=[0]*10
for i in map(int,line.strip()):
li[i]+=1
ans=[]
for addnum in [i for i in xrange(1,10) if not li[i]>=4]:
t_li=li[:]
t_li[addnum]+=1
for remnum in [i for i in xrange(1,10) if t_li[i]>=2]:
t2_li=t_li[:]
t2_li[remnum]-=2
top=1
while (not -1 in t2_li) and top<=7:
if t2_li[top]==0:
top+=1
elif t2_li[top]>=3:
t2_li[top]-=3
else:
for i in xrange(3):
t2_li[top+i]-=1
if top==8 and (t2_li[8]==0 or t2_li[8]==3) and (t2_li[9]==0 or t2_li[9]==3):
ans.append(addnum)
break
if ans==[]:print 0
else:print " ".join(map(str,ans))
#temp | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s459877547 | p00043 | Accepted | def main():
while True:
try:
n = [int(x) for x in raw_input()]
n.sort()
solve(n)
except EOFError as e:
break
def solve(input_numbers):
valid_numbers = []
c = count_number(input_numbers);
for i in range(9):
if c[i] == 4:
continue
c[i] += 1
if isvalid(c, 0, False):
valid_numbers.append(i+1)
c[i] -= 1
s = " ".join(map(str, valid_numbers)) if len(valid_numbers) > 0 else "0"
print(s)
def count_number(input_numbers):
c = [0] * 9
for i in input_numbers:
c[i-1] += 1
return c
def isvalid(input_numbers, pos, head):
if pos == 8:
if head and input_numbers[8] == 0:
return True
elif head and input_numbers[8] == 3:
return True
elif (not head) and input_numbers[8] == 2:
return True
else:
return False
if input_numbers[pos] == 0:
return isvalid(input_numbers, pos+1, head)
if input_numbers[pos] == 1:
if not can_sequence(input_numbers, pos, 1):
return False
else:
input_numbers[pos] -= 1
input_numbers[pos+1] -= 1
input_numbers[pos+2] -= 1
r = isvalid(input_numbers, pos+1, head)
input_numbers[pos] += 1
input_numbers[pos+1] += 1
input_numbers[pos+2] += 1
return r
if input_numbers[pos] == 2:
if not head:
input_numbers[pos] -= 2
r = isvalid(input_numbers, pos+1, True)
input_numbers[pos] += 2
if r:
return True
if can_sequence(input_numbers, pos, 2):
input_numbers[pos] -= 2
input_numbers[pos+1] -= 2
input_numbers[pos+2] -= 2
r = isvalid(input_numbers, pos+1, head)
input_numbers[pos] += 2
input_numbers[pos+1] += 2
input_numbers[pos+2] += 2
return r
if input_numbers[pos] == 3:
input_numbers[pos] -= 3
r = isvalid(input_numbers, pos+1, head)
input_numbers[pos] += 3
if r:
return True
if can_sequence(input_numbers, pos, 1):
input_numbers[pos] -= 2
r = isvalid(input_numbers, pos, True)
input_numbers[pos] += 2
return r
else:
return False
if input_numbers[pos] == 4:
input_numbers[pos] -= 3
r = isvalid(input_numbers, pos, head)
input_numbers[pos] += 3
if r:
return True
if not head:
input_numbers[pos] -= 2
r = isvalid(input_numbers, pos, True)
input_numbers[pos] += 2
return r
else:
return False
def can_sequence(input_numbers, pos, num):
if pos > 6:
return False
return input_numbers[pos] >= num and input_numbers[pos+1] >= num and input_numbers[pos+2] >= num
main() | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s450728808 | p00043 | Accepted |
import sys
DEBUG = False
def solv(nums):
r = []
for i in range(1, 10):
if DEBUG:
print 'i: ', i
if judge(list(nums), i):
r.append(i)
if DEBUG:
print '===='
if len(r) == 0:
r.append(0)
return r
def judge(nums, n):
if nums.count(n) >= 4:
return False
else:
nums.append(n)
nums.sort()
heads = overlup(nums)
r = []
for h in heads:
if DEBUG:
print 'nums: ', nums
nums2 = list(nums)
nums2.pop(nums2.index(h))
nums2.pop(nums2.index(h))
if DEBUG:
print 'head: ', h
print 'nums2: ', nums2
if judge2(nums2):
r.append(h)
if r:
return True
else:
return False
def judge2(nums):
if not nums:
if DEBUG:
print '---'
return True
nums2 = list(nums)
h3 = []
h3.append(nums.pop(0))
try:
j = nums.index(h3[0] + 1)
h3.append(nums.pop(j))
k = nums.index(h3[0] + 2)
h3.append(nums.pop(k))
if DEBUG:
print h3
if judge2(nums):
return True
except ValueError:
for i in range(1, len(h3)):
nums.append(h3.pop(i))
nums.sort()
h3 = []
h3.append(nums2.pop(0))
h3.append(nums2.pop(0))
if h3[0] == h3[1]:
h3.append(nums2.pop(0))
if DEBUG:
print h3
if h3[1] == h3[2]:
return judge2(nums2)
else:
return False
else:
return False
def overlup(lis):
r = []
def func(x, y):
if x == y and x not in r:
r.append(x)
return y
reduce(func, lis)
return r
def difference(lis):
return [y - x for x, y in zip(lis, lis[1:])]
c = 0
for line in sys.stdin:
c += 1
if DEBUG:
print 'CASE:', str(c)
numbers = map(int, line.rstrip('\n'))
print ' '.join(map(str, solv(numbers))) | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s243343412 | p00043 | Accepted | def Judge(P):
for h in range(1,10):
if P[h]>=2:
H=P[:]
H[h]-=2
flag=True
for i in range(1,10):
while H[i]%3:
for j in range(3):
H[i+j]-=1
if H[i+j]<0:
flag=False
if flag:
return True
return False
while True:
try:
s=map(int,raw_input())
except EOFError:
break
L=[0]*12
ans=[]
for i in range(len(s)):
L[s[i]]+=1
for i in range(1,10):
L[i]+=1
if max(L)!=5 and Judge(L[:]):
ans.append(str(i))
L[i]-=1
print " ".join(ans) if len(ans)!=0 else 0 | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s339728095 | p00043 | Accepted | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
def solve(L):
m = min(L)
cnt = L.count(m)
if cnt > 4:
return False
for _ in xrange(cnt):
L.remove(m)
if cnt in (1, 4):
if not L.count(m+1) or not L.count(m+2):
return False
L.remove(m+1)
L.remove(m+2)
elif cnt == 2:
if L.count(m+1) < 2 or L.count(m+2) < 2:
return False
L.remove(m+1)
L.remove(m+1)
L.remove(m+2)
L.remove(m+2)
return True if not len(L) else solve(L)
for line in stdin:
data = [int(s) for s in line.strip()]
data.append(0)
answers = []
for i in xrange(1, 10):
data[-1] = i
if data.count(i) > 4:
continue
for pair in xrange(1, 10):
if data.count(pair) < 2:
continue
L = data[:]
L.remove(pair)
L.remove(pair)
if solve(L):
answers.append(str(i))
break
print(' '.join(answers) if answers else '0') | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s296595059 | p00043 | Accepted | NUM="0123456789"
def atama(x):
return [e for e in set(x) if x.count(e)>=2]
def koutu(x,i):
return x.count(i)>=3
def shuntu(x,i):
return i<8 and x.count(i)>0 and x.count(i+1)>0 and x.count(i+2)>0
def make(x):
return [int(c) for c in x]
def check(x):
for e in set(x):
if koutu(x,e):
y = [NUM[e]*3]
x1=x+[]
x1.remove(e)
x1.remove(e)
x1.remove(e)
if len(x1)==0: return y
else:
y1 = check(x1)
if len(y1)>0: return y+y1
elif shuntu(x,e):
x1=x+[]
y = [NUM[e:e+3]]
x1.remove(e)
x1.remove(e+1)
x1.remove(e+2)
if len(x1)==0: return y
else:
y1 = check(x1)
if len(y1)>0: return y+y1
return ""
try:
while True:
s = raw_input()
y = []
for e in NUM[1:]:
if s.count(e)>=4: continue
x = make(s+e)
for e0 in atama(x):
s0= [ NUM[e0]*2]
x1 = x+[]
x1.remove(e0)
x1.remove(e0)
s0 += check(x1)
if len(s0)==5:
y.append(e)
break
if len(y)==0: print 0
else:
for e in y:
print e,
print
except:
pass | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s294805589 | p00043 | Accepted | def check(x,j=1):
if sum(x)==0: return True
for i in range(j,10):
y = x[:]
if y[i]>=3:
y[i] -= 3
if check(y,i): return True
y = x[:]
if i<8 and y[i]>0 and y[i+1]>0 and y[i+2]>0:
y[i] -= 1
y[i+1] -= 1
y[i+2] -= 1
if check(y,i): return True
return False
while True:
c = [0]*10
try:
for e in map(int,raw_input()):
c[e] += 1
except:
break
f = False
for i in range(1,10):
c1=c[:]
if c1[i]>=4: continue
else: c1[i]+=1
atama = [j for j,e in enumerate(c1) if e>=2]
for e in atama:
c1[e]-=2
if check(c1):
f = True
print i,
break
c1[e]+=2
if f: print
else: print 0 | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s393343090 | p00043 | Accepted | def check(x,j=1):
if sum(x)==0: return True
for i in range(j,10):
if x[i]>0:break
y = x[:]
if y[i]>=3:
y[i] -= 3
if check(y,i): return True
y = x[:]
if i<8 and y[i]>0 and y[i+1]>0 and y[i+2]>0:
y[i] -= 1
y[i+1] -= 1
y[i+2] -= 1
if check(y,i): return True
return False
while True:
c = [0]*10
try:
for e in map(int,raw_input()):
c[e] += 1
except:
break
f = False
for i in range(1,10):
c1=c[:]
if c1[i]>=4: continue
else: c1[i]+=1
atama = [j for j,e in enumerate(c1) if e>=2]
for e in atama:
c1[e]-=2
if check(c1):
f = True
print i,
break
c1[e]+=2
if f: print
else: print 0 | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s078884237 | p00043 | Accepted | import sys
def check(x,j=1):
if sum(x)==0: return 1
i = j
while x[i]==0: i+=1
y = x[:]
if y[i]>=3:
y[i] -= 3
if check(y,i): return 1
y = x[:]
if i<8 and y[i]>0 and y[i+1]>0 and y[i+2]>0:
y[i] -= 1
y[i+1] -= 1
y[i+2] -= 1
if check(y,i): return 1
return 0
for s in sys.stdin:
c = [0]*10
for e in map(int,s[:-1]): c[e] += 1
f = 0
R = range(1,10)
for i in R:
c1=c[:]
if c1[i]>=4:continue
c1[i]+=1
for j in R:
if c1[j]<2:continue
c1[j]-=2
if check(c1):
f = 1
print i,
break
c1[j]+=2
if f: print
else: print 0 | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s590920194 | p00043 | Accepted | def rm_shuntsu(hand):
for hai in set(hand):
if (hai in hand) and (hai+1 in hand) and (hai+2 in hand):
if len(hand) == 3: return True
hand1 = hand[:]
hand1.remove(hai);hand1.remove(hai+1);hand1.remove(hai+2)
return is_hora(hand1)
else: return False
def rm_kotsu(hand):
for hai in set(hand):
if hand.count(hai) >= 3:
if len(hand) == 3: return True
hand1 = hand[:]
hand1.remove(hai);hand1.remove(hai);hand1.remove(hai)
return is_hora(hand1)
else: return False
def is_hora(hand):
return rm_shuntsu(hand) or rm_kotsu(hand)
while True:
try:
hand = map(int, raw_input())
ans = []
for tumo in range(1,10):
if hand.count(tumo) <= 3:
for janto in set(hand+[tumo]):
if 2 <= (hand+[tumo]).count(janto):
hand1 = hand[:]+[tumo]
hand1.remove(janto);hand1.remove(janto)
if is_hora(hand1):
ans.append(tumo)
break
print " ".join(map(str, sorted(ans))) if len(ans) > 0 else 0
except:
break | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s357751291 | p00043 | Accepted | def rm_s(h):
for hai in set(h):
if (hai in h) and (hai+1 in h) and (hai+2 in h):
if len(h) == 3: return 1
h1 = h[:]
for i in range(3): h1.remove(hai+i)
return is_hora(h1)
else: return 0
def rm_k(h):
for hai in set(h):
if h.count(hai) >= 3:
if len(h) == 3: return 1
h1 = h[:]
for i in range(3): h1.remove(hai)
return is_hora(h1)
else: return 0
def is_hora(h):
return rm_s(h) or rm_k(h)
while True:
try:
h = map(int, raw_input())
ans = []
for add in range(1,10):
if h.count(add) <= 3:
h1 = h[:]+[add]
for d in set(h1):
if 2 <= h1.count(d):
h1 = h[:]+[add]
h1.remove(d);h1.remove(d)
if is_hora(h1):
ans.append(add)
break
print " ".join(map(str, sorted(ans))) if len(ans) > 0 else 0
except:
break | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s695398339 | p00043 | Accepted | def rm_s(h):
for hai in set(h):
if (hai in h) and (hai+1 in h) and (hai+2 in h):
if len(h) == 3: return 1
h1 = h[:]
for i in range(3): h1.remove(hai+i)
return is_hora(h1)
else: return 0
def rm_k(h):
for hai in set(h):
if h.count(hai) >= 3:
if len(h) == 3: return 1
h1 = h[:]
for i in range(3): h1.remove(hai)
return is_hora(h1)
else: return 0
def is_hora(h):
return rm_k(h) or rm_s(h)
while True:
try:
h = map(int, raw_input())
ans = []
for add in range(1,10):
if h.count(add) <= 3:
h1 = h[:]+[add]
for d in set(h1):
if 2 <= h1.count(d):
h1 = h[:]+[add]
h1.remove(d);h1.remove(d)
if is_hora(h1):
ans.append(add)
break
print " ".join(map(str, sorted(ans))) if len(ans) > 0 else 0
except:
break | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s895684486 | p00043 | Accepted | def rm_s(h):
seth = set(h)
for hai in seth:
if set([hai,hai+1,hai+2]) <= seth:
if len(h) == 3: return 1
h1 = h[:]
for i in range(3): h1.remove(hai+i)
return is_hora(h1)
else: return 0
def rm_k(h):
for hai in set(h):
if h.count(hai) >= 3:
if len(h) == 3: return 1
h1 = h[:]
for i in range(3): h1.remove(hai)
return is_hora(h1)
else: return 0
def is_hora(h):
return rm_k(h) or rm_s(h)
while True:
try:
h = map(int, raw_input())
ans = []
for add in range(1,10):
if h.count(add) <= 3:
h1 = h[:]+[add]
for d in set(h1):
if 2 <= h1.count(d):
h1 = h[:]+[add]
h1.remove(d);h1.remove(d)
if is_hora(h1):
ans.append(add)
break
print " ".join(map(str, sorted(ans))) if len(ans) > 0 else 0
except:
break | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s156771814 | p00043 | Accepted | def f(a):
if a == [0] * 10:
return True
for i in range(1, 10):
if a[i] < 3: continue
b = list(a)
b[i] -= 3
if f(b):
return True
for i in range(3, 10):
if a[i - 2] == 0 or a[i - 1] == 0 or a[i] == 0: continue
b = list(a)
for j in range(i - 2, i + 1):
b[j] -= 1
if f(b):
return True
return False
try:
while True:
a = [0] * 10
for c in raw_input():
a[int(c)] += 1
d = []
for i in range(1, 10):
if a[i] == 4: continue
b = list(a)
b[i] += 1
for j in range(1, 10):
if b[j] < 2: continue
c = list(b)
c[j] -= 2
if f(c):
d.append(str(i))
break
print ' '.join(d) if d else 0
except EOFError:
pass | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s359340708 | p00043 | Accepted | from collections import Counter
while 1:
try:
puzzle = map(int, raw_input())
except EOFError:
break
ret = []
for i in xrange(1, 10):
cnt = Counter(puzzle + [i])
if cnt[i] > 4:
continue
for j in xrange(1, 10):
if cnt[j] < 2:
continue
tmp = Counter(puzzle + [i])
tmp[j] -= 2
for k in xrange(1, 10):
if not tmp[k]:
continue
if tmp[k] >= 3:
tmp[k] -= 3
while tmp[k] and tmp[k + 1] and tmp[k + 2]:
tmp[k] -= 1
tmp[k + 1] -= 1
tmp[k + 2] -= 1
if tmp[k]:
break
else:
ret.append(i)
break
if ret:
print ' '.join(map(str, ret))
else:
print 0 | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s930737189 | p00043 | Accepted | import sys
readlines = sys.stdin.readlines
write = sys.stdout.write
memo = {}
def solve(s):
d = [0]*10
for c in s:
d[int(c)] += 1
def dfs(i, d):
if i == 10:
return True
key = tuple(d)
if s in key:
return memo[key]
if d[i] == 0:
return dfs(i+1, d)
if d[i] >= 3:
d[i] -= 3
r = dfs(i, d)
d[i] += 3
if r:
memo[key] = True
return True
if i+2 <= 9 and d[i+1] >= 1 and d[i+2] >= 1:
d[i] -= 1; d[i+1] -= 1; d[i+2] -= 1
r = dfs(i, d)
d[i] += 1; d[i+1] += 1; d[i+2] += 1
if r:
memo[key] = True
return True
memo[key] = False
return False
ans = []
for k in range(1, 10):
if d[k] == 4:
continue
d[k] += 1
for i in range(10):
if d[i] >= 2:
d[i] -= 2
r = dfs(0, d)
d[i] += 2
if r:
ans.append(k)
break
d[k] -= 1
if not ans:
ans.append(0)
return ans
for line in readlines():
res = solve(line.strip())
write(" ".join(map(str, res)))
write("\n")
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s617542846 | p00043 | Accepted | from collections import Counter
from copy import copy
def _check(pi):
pi=sorted(pi)
if len(pi)==0:
return True
retval=False
try:
_pi=copy(pi)
tmp=_pi[0]
for i in range(3):
_pi.remove(tmp)
retval = retval or _check(_pi)
except:
pass
try:
_pi=copy(pi)
tmp=_pi[0]
for i in range(3):
_pi.remove(tmp+i)
retval = retval or _check(_pi)
except:
pass
return retval
def check(pi,tsumo):
pi=pi+[tsumo]
c=Counter(pi)
for i in range(1,10):
if c[i]>4:
return False
for i in range(1,10):
if c[i]>=2:
_pi = copy(pi)
_pi.remove(i)
_pi.remove(i)
_pi=sorted(_pi)
if _check(_pi):
return True
return False
while True:
try:
s=input()
s=[int(i) for i in s]
retval=[]
for i in range(1,10):
if check(s,i):
retval.append(str(i))
if len(retval)==0:
print("0")
else:
print(" ".join(retval))
except EOFError:
break
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s321715673 | p00043 | Accepted | def check(nums):
for i in range(9):
if(nums[i]>4):return False
for head in range(9):
anums=nums[:]
if(anums[head]<2):continue
anums[head]-=2
for i in range(9):
if(anums[i]>=3):
anums[i]-=3
while(anums[i]>0):
if i>=7:break
ok=True
for j in range(i,i+3):
if anums[j]<=0:
ok=True
if not ok:
break
for j in range(i,i+3):
anums[j]-=1
if not any(anums):
return True
return False
while True:
st=""
try:
st=input()
if st=="":break
except:break
nums=[0 for i in range(9)]
for c in st:
nums[int(c)-1]+=1
anss=[]
for n in range(0,9):
nums[n]+=1
if(check(nums[:])):anss.append(n+1)
nums[n]-=1
if(len(anss)==0):anss.append(0)
print(" ".join(map(str,anss)))
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s689193294 | p00043 | Accepted | from itertools import combinations_with_replacement, combinations
def gen_dict(nums):
r = {}
for i in nums:
if i in r.keys():
r[i] += 1
else:
r[i] = 1
return r
def has_more_4(num_dict):
for i in num_dict.values():
if i > 4: return True
return False
def gen_conseq3(nums):
r = []
for i in range(1, 8):
for j in range(i, i+3):
if j not in nums: break
else:
r.append((i, i+1, i+2))
return r
def gen_same(n, num_dict):
r = []
for i, v in num_dict.items():
if v >= n: r.append(i)
return r
def gen_prec(c1s, c2s, c3):
r = []
for i in c1s:
for j in i:
r.append(j)
for i in c2s:
for j in range(3): r.append(i)
for j in range(2):
r.append(c3)
return sorted(r)
while True:
try: line = input()
except EOFError: break
founds = []
for i in range(1, 10):
ln = line + str(i)
nums = sorted(list(map(int, ln[:])))
num_dict = gen_dict(nums)
if has_more_4(num_dict):
continue
conseq_3s = gen_conseq3(nums)
same_3s = gen_same(3, num_dict)
same_2s = gen_same(2, num_dict)
was_found = False
for r in range(1, 5):
if was_found: break
for c1s in combinations_with_replacement(conseq_3s, r):
if was_found: break
for c2s in combinations(same_3s, 4-r):
if was_found: break
for c3 in same_2s:
pred = gen_prec(c1s, c2s, c3)
if pred == nums:
founds.append(str(i))
was_found = True
if founds:
print(' '.join(founds))
else:
print(0)
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s825420812 | p00043 | Runtime Error | import scala.io.StdIn.{readLine,readInt}
object Main extends App {
val seq1 = for(i<-1 to 9) yield Vector(i,i,i)
val seq2 = for(i<-1 to 7) yield Vector(i,i+1,i+2)
def check(m:Vector[Int], count:Int,u:Int,v:Int):Boolean =
if(m.length != count) false
else if(count==2) m(0)==m(1)
else
(u to 8).exists( i=> check(m diff seq1(i),count-3,i+1,v)) || (v to 6).exists(i=> check(m diff seq2(i),count-3,u,i))
Iterator.continually(readLine).takeWhile ( _!=null ).foreach { line =>
val l = line.map(_.asDigit).toVector
val m = (1 to 9).filter { i=> l.count( _==i ) < 4 && check((i+:l).sorted,14,0,0) }
if(m.length>0) println(m.mkString(" ")) else println(0)
}
} | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s154419502 | p00043 | Runtime Error | import sys
def f(c,h=0):
if 2 in c and sum(c)==2:return 1
if 5 in c:return 0 # sum(c)==2
if 4 in c:
k=c.index(4);c[k]-=3
if f(c,h+1):return 1
c[k]+=3
if 3 in c:
k=c.index(3);c[k]-=3
if f(c,h+1):return 1
c[k]+=3
for i in range(7):
if c[i]and c[i+1]and c[i+2]:
c[i]-=1;c[i+1]-=1;c[i+2]-=1
if f(c,h+1):return 1
c[i]+=1;c[i+1]+=1;c[i+2]+=1
n='123456789'
for e in sys.stdin:
e=list(e)
a=[i for i in n if f([(e+[i]).count(j)for j in n])]
print(*a if a else 0)
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s034930116 | p00043 | Runtime Error | import sys
def f(c,h=0):
if 2 in c and sum(c)==2:return 1
if 5 in c:return 0 # sum(c)==2
if 4 in c:
k=c.index(4);c[k]-=3
if f(c,h+1):return 1
c[k]+=3
if 3 in c:
k=c.index(3);c[k]-=3
if f(c,h+1):return 1
c[k]+=3
for i in range(7):
if c[i]and c[i+1]and c[i+2]:
c[i]-=1;c[i+1]-=1;c[i+2]-=1
if f(c,h+1):return 1
c[i]+=1;c[i+1]+=1;c[i+2]+=1
n='123456789'
for e in sys.stdin:
e=list(e.strip())
a=[i for i in n if f([(e+[i]).count(j)for j in n])]
print(*a if a else 0)
| 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s244894053 | p00043 | Runtime Error |
def dfs(hands, pair):
hands.sort()
if not hands:
return True
target = hands[0]
# sequence
if all(map(lambda x: x in hands, range(target, target + 3))):
for i in range(target, target + 3):
hands.remove(i)
if dfs(hands, pair):
return True
for i in range(target, target + 3):
hands.append(i)
# triple
if hands.count(target) >= 3:
for i in range(3):
hands.remove(target)
if dfs(hands, pair):
return True
for i in range(3):
hands.append(target)
# pair
if not pair and hands.count(target) >= 2:
for i in range(2):
hands.remove(target)
if dfs(hands, True):
return True
for i in range(2):
hands.append(target)
return False
for line in filter(lambda line: line.strip(), open("input.txt").readlines()):
result = []
data = [int(ch) for ch in line.strip()]
for num in filter(lambda x: data.count(x) < 4, range(1, 10)):
data_cp = list(data)
data_cp.append(num)
data_cp.sort()
if dfs(data_cp, False):
result.append(num)
print result | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s029031198 | p00043 | Runtime Error |
def dfs(hands, pair):
hands.sort()
if not hands:
return True
target = hands[0]
# sequence
if all(map(lambda x: x in hands, range(target, target + 3))):
for i in range(target, target + 3):
hands.remove(i)
if dfs(hands, pair):
return True
for i in range(target, target + 3):
hands.append(i)
# triple
if hands.count(target) >= 3:
for i in range(3):
hands.remove(target)
if dfs(hands, pair):
return True
for i in range(3):
hands.append(target)
# pair
if not pair and hands.count(target) >= 2:
for i in range(2):
hands.remove(target)
if dfs(hands, True):
return True
for i in range(2):
hands.append(target)
return False
for line in filter(lambda line: line.strip(), stdin.readlines()):
result = []
data = [int(ch) for ch in line.strip()]
for num in filter(lambda x: data.count(x) < 4, range(1, 10)):
data_cp = list(data)
data_cp.append(num)
data_cp.sort()
if dfs(data_cp, False):
result.append(num)
print " ".join(result) | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s547229816 | p00043 | WA: Presentation Error | import sys
def check(x,j=1):
if sum(x)==0: return 1
i = j
while x[i]==0: i+=1
y = x[:]
if y[i]>=3:
y[i] -= 3
if check(y,i): return 1
y = x[:]
if i<8 and y[i]>0 and y[i+1]>0 and y[i+2]>0:
y[i] -= 1
y[i+1] -= 1
y[i+2] -= 1
if check(y,i): return 1
return 0
for s in sys.stdin:
c = [0]*10
for e in map(int,s[:-1]): c[e] += 1
f = 0
R = range(1,10)
for i in R:
c1=c[:]
if c1[i]>=4:continue
c1[i]+=1
for j in R:
if c1[j]<2:continue
c1[j]-=2
if check(c1):
f = 1
print i,
break
c1[j]+=2
print[0,""][f] | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s075939916 | p00043 | WA: Presentation Error | import sys
def check(x,j=1):
if sum(x)==0: return 1
i = j
while x[i]==0: i+=1
y = x[:]
if y[i]>=3:
y[i] -= 3
if check(y,i): return 1
y = x[:]
if i<8 and y[i]>0 and y[i+1]>0 and y[i+2]>0:
y[i] -= 1
y[i+1] -= 1
y[i+2] -= 1
if check(y,i): return 1
return 0
for s in sys.stdin:
c = [0]*10
for e in map(int,s[:-1]): c[e] += 1
f = 0
R = range(1,10)
for i in R:
c1=c[:]
if c1[i]>=4:continue
c1[i]+=1
for j in R:
if c1[j]<2:continue
c1[j]-=2
if check(c1):
f = 1
print i,
break
c1[j]+=2
print[0,"\n"][f] | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s322242156 | p00043 | WA: Presentation Error | import sys
def check(x,j=1):
if sum(x)==0: return 1
i = j
while x[i]==0: i+=1
y = x[:]
if y[i]>=3:
y[i] -= 3
if check(y,i): return 1
y = x[:]
if i<8 and y[i]>0 and y[i+1]>0 and y[i+2]>0:
y[i] -= 1
y[i+1] -= 1
y[i+2] -= 1
if check(y,i): return 1
return 0
for s in sys.stdin:
c = [0]*10
for e in map(int,s[:-1]): c[e] += 1
f = 0
R = range(1,10)
for i in R:
c1=c[:]
if c1[i]>=4:continue
c1[i]+=1
for j in R:
if c1[j]<2:continue
c1[j]-=2
if check(c1):
f = 1
print i,
break
c1[j]+=2
print["0\n","\n"][f], | 3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
| 2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
|
<H1>パズル</H1>
<p>
1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。
</p>
<p>
パズルの完成条件は
</p>
<ul>
<li>同じ数字を２つ組み合わせたものが必ずひとつ必要です。</li>
<li>残りの12 個の数字は、３個の数字の組み合わせ４つです。<br>
３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。</li>
<li>同じ数字は4 回まで使えます。</li>
</ul>
<p>
13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。
</p>
<p>例えば与えられた文字列が 3456666777999 の場合<br/>
<br/>
「2」があれば、 <span>234 567 666 77 999</span><br/>
「3」があれば、 <span>33 456 666 777 999</span><br/>
「5」があれば、 <span>345 567 666 77 999</span><br/>
「8」があれば、 <span>345 666 678 77 999</span><br/>
<br/>
というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
</pre>
|
s024134677 | p00044 | Wrong Answer | import math
def p_l(n):
for i in range(n-1, 2, -1):
flag=0
for j in range(2, int(math.sqrt(i)) + 1):
if i % j == 0:
flag=1
if flag==1:continue
return i
def p_h(n):
for i in range(n+1,50022):
flag=0
for j in range(2, int(math.sqrt(i)) + 1):
if i % j == 0:
flag=1
if flag==1:continue
return i
while 1:
try:
n=int(input())
print(p_l(n),p_h(n))
except:break
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s226121887 | p00044 | Wrong Answer | def sieve(n):
res = []
nums = [1] * n
nums[0] = 0
for i in range(int(n ** 0.5) + 1):
if nums[i] == 0: continue
j = 2
while (i + 1) * j <= n:
nums[(i+1) * j - 1] = 0
j += 1
for i in range(len(nums)):
if nums[i] == 1:
res.append(i+1)
return res
primes = sieve(50000)
while True:
try:
n = int(input())
minn, maxn = 0, 0
for i in range(len(primes)):
if primes[i] > n:
maxn = primes[i]
minn = primes[i-1]
if minn == n: minn = primes[i-2]
break
print('%d %d' % (minn, maxn))
except:
break | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s075459047 | p00044 | Wrong Answer | from sys import *
maxnum = 60000
primes = [True]*maxnum
primes[0] = primes[1] = False
for i in xrange(maxnum):
if i >= maxnum**0.5 : break
if not primes[i]: continue
for j in xrange(i*2,maxnum,i): primes[j] = False
for s in stdin:
d = int(s)
for i in reversed(xrange(2,d-1)):
if primes[i]: print i,; break
for i in xrange(d+1,maxnum):
if primes[i]: print i;break | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s504242831 | p00044 | Wrong Answer | import sys
n=60000
prime = [1]*(n+1)
(prime[0],prime[1])=(0,0)
for i in [v for v in xrange(2,n+1) if v*v<n+1]:
for j in xrange(i*i,n+1,i):
prime[j]=0
for inp in ["19","3517"]:
i=int(inp)
j=int(inp)
while i<n:
if prime[i+1]==1:
break
i+=1
while j>0:
if prime[j-1]==1:
break
j-=1
print j-1,i+1 | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s166159895 | p00044 | Wrong Answer | #!/usr/bin/env python
# -*- coding: utf-8 -*-
import bisect
import sys
def sieve(n):
prime = []
isprime = [1] * n
isprime[0] = isprime[1] = False
for i in range(2, n):
if(isprime[i] == False):continue
prime.append(i)
for j in range(2*i, n, i):
isprime[j] = False
return prime
prime = sieve(100000)
for n in sys.stdin:
n = int(n)
m = bisect.bisect_left(prime, n)
print prime[m - 1], prime[m + 1] | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s504964950 | p00044 | Wrong Answer | def prime_t(t):
i=2
while i**2<=t:
if t%i==0:
return 0
i+=1
return 1
l=[]
for i in range(2,50000):
if prime_t(i):
l.append(i)
#print l
while 1:
try:
o=y=50000
n=int(raw_input())
for i in l:
if y<n and n<i:
print y,i
break
elif y==n and o<n and n<i:
print o,i
break
o=y
y=i
except:
break | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s146300802 | p00044 | Wrong Answer | # -*- coding: utf-8 -*-
import sys
primes = [2]
for i in range(3, 50022):
flag = True
for p in primes:
if i % p == 0:
flag = False
break
if flag:
primes.append(i)
print primes
for line in sys.stdin:
n = int(line)
if n == 50000:
print "49999 50021"
else:
i = 0
while primes[i] < n and i < len(primes):
i += 1
if primes[i] == n:
s = primes[i-1]
else:
s = primes[i]
m = primes[i+1]
print s, m | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s722212511 | p00044 | Wrong Answer | # -*- coding: utf-8 -*-
import sys
primes = [2]
for i in range(3, 50022):
flag = True
for p in primes:
if i % p == 0:
flag = False
break
if flag:
primes.append(i)
for line in sys.stdin:
n = int(line)
if n == 50000:
print "49999 50021"
else:
i = 0
while primes[i] < n and i < len(primes):
i += 1
if primes[i] == n:
s = primes[i-1]
else:
s = primes[i]
m = primes[i+1]
print s, m | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s306232782 | p00044 | Wrong Answer | pr=[True]*50001
for i in range(2,224):
if pr[i]:
for j in range(i*2,50001,i):
pr[j]=False
while True:
try:
n=int(input())
except:
break
for i in range(n-1,0,-1):
if pr[i]:
print(i,end=" ")
break
for i in range(n+1,50001):
if pr[i]:
print(i)
break | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s836937430 | p00044 | Wrong Answer | from itertools import takewhile, dropwhile
pn, tmp = [], [i for i in range(2, 50000)]
while tmp[0] < 224:
v = tmp.pop(0)
pn.append(v)
tmp = list(filter(lambda x: x%v!=0, tmp))
for t in tmp: pn.append(t)
while True:
try:
n = int(input())
print(list(takewhile(lambda x: x<n, pn))[-1], list(dropwhile(lambda x: x<=n, pn))[0])
except:
break
| 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s657374608 | p00044 | Wrong Answer | from itertools import takewhile, dropwhile
pn, tmp = [], [i for i in range(2, 50000)]
while tmp[0] < 224:
v = tmp.pop(0)
pn.append(v)
tmp = list(filter(lambda x: x%v!=0, tmp))
for t in tmp: pn.append(t)
while True:
try:
n = int(input())
a, b = list(takewhile(lambda x: x<n, pn))[-1], list(dropwhile(lambda x: x<=n, pn))[0]
print(a, b)
except:
break | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s010645892 | p00044 | Wrong Answer | def f(s,p):
p.append(s.pop(0))
for i,num in enumerate(s):
if num % p[-1] == 0:
s.pop(i)
return 0
def vol44(k):
for i in range(len(p)):
if p[i] == k:
print(p[i-1],p[i+1])
break
elif p[i] > k:
print(p[i-1],p[i])
break
primes = list(range(2,50000))
arr = []
while not arr or arr[-1] ** 2 < primes[-1]:
f(primes,arr)
p = arr+primes
n = []
while True:
try:
n.append(int(input()))
except EOFError:
break
for i in range(len(n)):
vol44(n[i]) | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s330204770 | p00044 | Wrong Answer | # Aizu Problem 0009: Prime Number
#
import sys, math, os, bisect
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
def primes2(n):
""" Input n>=6, Returns a list of primes, 2 <= p < n """
n, correction = n-n%6+6, 2-(n%6>1)
sieve = [True] * (n//3)
for i in range(1,int(n**0.5)//3+1):
if sieve[i]:
k=3*i+1|1
sieve[ k*k//3 ::2*k] = [False] * ((n//6-k*k//6-1)//k+1)
sieve[k*(k-2*(i&1)+4)//3::2*k] = [False] * ((n//6-k*(k-2*(i&1)+4)//6-1)//k+1)
return [2,3] + [3*i+1|1 for i in range(1,n//3-correction) if sieve[i]]
primes = primes2(50000)
for line in sys.stdin:
n = int(line)
if n in primes:
idx = primes.index(n)
print(primes[idx-1], primes[idx+1])
#idx = bisect.bisect_right(primes, n)
#print(idx) | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s303668534 | p00044 | Wrong Answer | import sys
import math
primes = [2]
for line in sys.stdin:
n = int(line)
for i in range(max(primes) + 1, n):
if i % 2 == 0:
continue
elif math.sqrt(i) == 0:
continue
elif len([j for j in primes if i % j == 0]) > 0:
continue
primes.append(i)
for i in range(n - 1, 1, -1):
if i % 2 == 0:
continue
elif math.sqrt(i) == 0:
continue
elif len([j for j in primes if i % j == 0 and i != j]) > 0:
continue
print(i, end=" ")
break
for i in range(n + 1, n + 1000):
if i % 2 == 0:
continue
elif math.sqrt(i) == 0:
continue
elif len([j for j in primes if i % j == 0]) > 0:
continue
print(i)
break | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s411385441 | p00044 | Wrong Answer | import sys
import math
primes = [2]
for line in sys.stdin:
n = int(line)
for i in range(max(primes) + 1, n):
if i % 2 == 0:
continue
elif math.sqrt(i) == 0:
continue
elif len([j for j in primes if i % j == 0]) > 0:
continue
primes.append(i)
for i in range(n - 1, 1, -1):
if i % 2 == 0:
continue
elif math.sqrt(i) == 0:
continue
elif len([j for j in primes if i % j == 0 and i != j]) > 0:
continue
print(i, end=" ")
break
for i in range(n + 1, n + 1000):
if i % 2 == 0:
continue
elif math.sqrt(i) == 0:
continue
elif len([j for j in primes if i % j == 0 and i != j]) > 0:
continue
print(i)
break | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s584063615 | p00044 | Wrong Answer | import sys
import math
primes = [2]
for line in sys.stdin:
try:
n = int(line)
for i in range(max(primes) + 1, n):
if i % 2 == 0:
continue
elif math.sqrt(i) == 0:
continue
elif len([j for j in primes if i % j == 0]) > 0:
continue
primes.append(i)
for i in range(n - 1, 1, -1):
if i % 2 == 0:
continue
elif math.sqrt(i) == 0:
continue
elif len([j for j in primes if i % j == 0 and i != j]) > 0:
continue
print(i, end=" ")
break
for i in range(n + 1, n + 1000):
if i % 2 == 0:
continue
elif math.sqrt(i) == 0:
continue
elif len([j for j in primes if i % j == 0 and i != j]) > 0:
continue
print(i)
break
except:
break | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s222038996 | p00044 | Wrong Answer | import sys
import math
primes = [2]
for line in sys.stdin:
try:
n = int(line)
for i in range(max(primes) + 1, n):
if i % 2 == 0:
continue
elif math.sqrt(i) == 0:
continue
elif len([j for j in primes if i % j == 0]) > 0:
continue
primes.append(i)
for i in range(n - 1, 1, -1):
if i % 2 == 0:
continue
elif math.sqrt(i) == 0:
continue
elif len([j for j in primes if i % j == 0 and i != j]) > 0:
continue
print(i, end=" ")
break
for i in range(n + 1, n + 10000):
if i % 2 == 0:
continue
elif math.sqrt(i) == 0:
continue
elif len([j for j in primes if i % j == 0 and i != j]) > 0:
continue
print(i)
break
except:
break | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s464883842 | p00044 | Wrong Answer | import sys
import math
primes = [2]
for line in sys.stdin:
try:
n = int(line)
for i in range(max(primes) + 1, n):
if i % 2 == 0:
continue
elif math.sqrt(i) == 0:
continue
elif len([j for j in primes if i % j == 0]) > 0:
continue
primes.append(i)
print(primes[-1] if primes[-1] != n else primes[-2], end=" ")
for i in range(n + 1, n + 10000):
if i % 2 == 0:
continue
elif math.sqrt(i) == 0:
continue
elif len([j for j in primes if i % j == 0 and i != j]) > 0:
continue
print(i)
break
except:
break | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
s331421886 | p00044 | Wrong Answer | # 04.77 sec -> Time Limit Exceeded?
import sys
import math
# Sieve of Eratosthenes
N = 50000
searchList = list(range(3, N + 1, 2))
primes = [2]
while True:
top = searchList.pop(0)
primes.append(top)
if top > math.sqrt(N):
break
searchList = [s for s in searchList if s % top != 0]
primes.extend(searchList)
for line in sys.stdin:
try:
n = int(line)
pre = 2
for p in primes:
if p < n:
pre = p
if p > n:
print(pre, p)
break
except:
break | 19
3517
| 17 23
3511 3527
|
<H1>素数 II</H1>
<p>
素数というのは、1 よりも大きくそれ自身か 1 でしか割りきれない整数をいいます。例えば、2 は、2 と 1 でしか割り切れないので素数ですが、12 は、12 と 1 のほかに、2, 3, 4, 6 で割りきれる数なので素数ではありません。
</p>
<p>
整数 <var>n</var> を入力したとき、<var>n</var> より小さい素数のうち最も大きいものと、<var>n</var> より大きい素数のうち最も小さいものを出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> (3 ≤ <var>n</var> ≤ 50,000) が１行に与えられます。
</p>
<p>
データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> より小さい素数のうち最大のものと、<var>n</var> より大きい素数のうち最小のものを１つのスペースで区切って１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
19
3517
</pre>
<H2>Output for the Sample Input</H2>
<pre>
17 23
3511 3527
</pre>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.