submission_id string | problem_id string | status string | code string | input string | output string | problem_description string |
|---|---|---|---|---|---|---|
s364789151 | p00069 | Wrong Answer | import sys
import itertools
def one_step(lo,lis):
nu = [ e for e in lis ]
for j in xrange(len(nu)):
if lo[0][j] == 1:
nu[j],nu[j+1] = nu[j+1],nu[j]
return lo[1:],nu
def solve(lo,lis):
if len(lo) == 0:
return lis
nu = [ e for e in lis]
lo2,nu2 = one_step(lo,nu)
return solve(lo2,nu2)
while True:
n = input()
if n == 0: exit()
m = input()
star = input()
d = input()
lis = range(n+1)
lots = []
for i in xrange(d):
lots.append([0]+[ 1 if e == '1' else 0 for e in list(raw_input()) ] +[0])
if solve(lots,lis)[star] == m: print 0;exit()
for i,j in itertools.product(xrange(d),xrange(1,n)):
if lots[i][j-1] == 0 and lots[i][j] == 0 and lots[i][j+1] == 0:
lots[i][j] = 1
if solve(lots,lis)[star] == m: print i+1,j;break
lots[i][j] = 0
else:print 1 | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s949358880 | p00069 | Wrong Answer | def check(n,m,star,d,f):
ns=[i for i in range(n)]
for i in range(d):
for j in range(n-1):
if f[i][j]:
c=ns[j+1]
ns[j+1]=ns[j]
ns[j]=c
return ns[star-1]==m-1
while True:
n=int(input())
if(n==0):break
m=int(input())
star=int(input())
d=int(input())
f=[[False for i in range(n-1)]for j in range(d)]
for i in range(d):
st=input()
for j in range(n-1):
f[i][j]=st[j]=='1'
if check(n,m,star,d,f):
print(1)
else:
ans=False
for i in range(d):
for j in range(n-1):
if ans:break
ok=not f[i][j]
if(j>0 and f[i][j-1]) or (j<n-2 and f[i][j+1]):ok=False
if ok:
f[i][j]=True
if check(n,m,star,d,f):
print(i+1,j+1)
ans=True
f[i][j]=False
if not ans:
print(0) | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s429949703 | p00069 | Wrong Answer | def check_lots(start, goal, line):
for i in range(len(line)):
for j in range(len(line[i])):
if line[i][j] == 1:
if j == start - 1:
start -= 1
elif j == start:
start += 1
return start == goal
while True:
n = int(input())
if n == 0:
break
m = int(input())
s = int(input())
d = int(input())
l = []
for i in range(d):
l.append([0] + list(map(int, list(input()))) + [0])
d_ans = 0
n_ans = 0
if check_lots(m, s, l):
print(0)
else:
for i in range(d):
for j in range(1, n):
l_tmp = l[:]
if sum(l_tmp[i][j-1:j+2]) > 0:
continue
l_tmp[i][j] = 1
if check_lots(m, s, l_tmp):
d_ans = i + 1
n_ans = j
break
else:
continue
break
if d_ans:
print(d_ans, n_ans)
else:
print(1)
| 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s200995401 | p00069 | Wrong Answer | while True:
n = int(input())
if not n:
break
start = int(input()) - 1 #開始の位置
goal = int(input()) - 1 #あたりの位置
d = int(input())
nums = [[i for i in range(n)]] #各段での数字の並び
bars = [] #横棒リスト
for i in range(d):
s = input()
bars.append(s)
new = nums[-1][:]
for j in range(n - 1):
if s[j] == "1": #横棒があれば入れ替え
new[j], new[j + 1] = new[j + 1], new[j]
nums.append(new)
to_goal = nums[-1][goal] #あたりにたどり着くスタートの番号
for i, status in enumerate(nums):
to_goal_ind = status.index(to_goal) #to_goalの位置
start_ind = status.index(start) #startの位置
ind1, ind2 = min(to_goal_ind, start_ind), max(to_goal_ind, start_ind)
if ind2 - ind1 == 1: #隣あっていた場合
if i <= d - 1 and bars[i][ind1] == "0" and (ind2 == n - 1 or bars[i][ind2] == "0"): #隣り合う横棒がなければ出力
print(i + 1, ind1 + 1)
break
else:
print(1)
| 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s080887293 | p00069 | Wrong Answer | while True:
n = int(input())
if not n:
break
start = int(input()) - 1 #開始の位置
goal = int(input()) - 1 #あたりの位置
d = int(input())
nums = [[i for i in range(n)]] #各段での数字の並び
bars = [] #横棒リスト
for i in range(d):
s = input()
bars.append(s)
new = nums[-1][:]
for j in range(n - 1):
if s[j] == "1": #横棒があれば入れ替え
new[j], new[j + 1] = new[j + 1], new[j]
nums.append(new)
to_goal = nums[-1][goal] #あたりにたどり着くスタートの番号
for i, status in enumerate(nums[1:]):
to_goal_ind = status.index(to_goal) #to_goalの位置
start_ind = status.index(start) #startの位置
ind1, ind2 = min(to_goal_ind, start_ind), max(to_goal_ind, start_ind)
if ind2 - ind1 == 1: #隣あっていた場合
if (ind1 == 0 or bars[i][ind1 - 1] == "0") and (ind2 == n - 1 or bars[i][ind2] == "0"): #隣り合う横棒がなければ出力
print(i + 1, ind1 + 1)
break
else:
print(1)
| 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s385444292 | p00069 | Wrong Answer | while True:
n = int(input())
if not n:
break
start = int(input()) - 1 #開始の位置
goal = int(input()) - 1 #あたりの位置
d = int(input())
nums = [[i for i in range(n)]] #各段での数字の並び
bars = [] #横棒リスト
for i in range(d):
s = input()
bars.append(s)
new = nums[-1][:]
for j in range(n - 1):
if s[j] == "1": #横棒があれば入れ替え
new[j], new[j + 1] = new[j + 1], new[j]
nums.append(new)
to_goal = nums[-1][goal] #あたりにたどり着くスタートの番号
for i, status in enumerate(nums[1:]):
to_goal_ind = status.index(to_goal) #to_goalの位置
start_ind = status.index(start) #startの位置
# print(bars[i])
# print(status)
ind1, ind2 = min(to_goal_ind, start_ind), max(to_goal_ind, start_ind)
if ind2 - ind1 == 1: #隣あっていた場合
if (bars[i][ind1] == "0") and (ind1 == 0 or bars[i][ind1 - 1] == "0") and (ind2 == n - 1 or bars[i][ind2] == "0"): #隣り合う横棒がなければ出力
print(i + 1, ind1 + 1)
break
else:
print(1)
| 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s488166429 | p00069 | Wrong Answer | def Judge(data,n,d,m):
now=m-1
for i in range(d):
if now==0:
if data[i][now]:
now+=1
elif now==n-1:
if data[i][n-2]:
now-=1
elif data[i][now-1]:
now-=1
elif data[i][now]:
now+=1
return now+1
while True:
n=input()
if n==0:break
m,star,d=input(),input(),input()
data=[map(int,raw_input()) for i in range(d)]
flag=False
if Judge(data,n,d,m)==star:
print 0
else:
for i in range(d):
for j in range(n-1):
if data[i][j]==0:
data[i][j]=1
if Judge(data,n,d,m)==star:
print i+1,j+1
flag=True
break
else:
data[i][j]=0
if flag:
break
else:
print 1 | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s780979008 | p00069 | Wrong Answer | import sys
class Lot:
def __init__(self, n, w, dan):
self.n = n
self.w = w
self.dan = self._parse_dan(dan)
def _parse_dan(self, dan):
dan = map(self._parse_d, dan)
return dan
def _parse_d(self, d):
r = []
for i in range(len(d)):
if d[i]:
r.append((i+1, i+2))
return r
def cast(self, m):
for d in self.dan:
for b in d:
if b[0] == m:
m = b[1]
elif b[1] == m:
m = b[0]
if m == self.w:
return 0
else:
return 1
def solv(n, w, dan, m):
lot = Lot(n, w, dan)
r = lot.cast(m)
if r == 0:
return r
else:
a_bars = additional_bar(dan)
for ab in a_bars:
dan2 = map(list, dan)
a, b = ab
dan2[a][b] = 1
lot = Lot(n, w, dan2)
r = lot.cast(m)
if r == 0:
return "%d %d" % (a+1, b+1)
return 1
def additional_bar(dan):
r = []
for d in range(len(dan)):
if dan[d][0:2] == [0,0]:
r.append((d, 0))
if dan[d][-2:] == [0,0]:
r.append((d, len(dan[d])-1))
for i in range(len(dan[d])-2):
if dan[d][i:i+3] == [0,0,0]:
r.append((d, i+1))
return r
while True:
n = int(sys.stdin.readline())
if n == 0:
exit(0)
m = int(sys.stdin.readline())
w = int(sys.stdin.readline())
d = int(sys.stdin.readline())
dan = []
for i in range(d):
dan.append(map(int, list(sys.stdin.readline().rstrip())))
print solv(n, w, dan, m) | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s333403075 | p00069 | Wrong Answer | import sys
class Lot:
def __init__(self, n, w, dan):
self.n = n
self.w = w
self.dan = self._parse_dan(dan)
def _parse_dan(self, dan):
dan = map(self._parse_d, dan)
return dan
def _parse_d(self, d):
r = []
for i in range(len(d)):
if d[i]:
r.append((i+1, i+2))
return r
def cast(self, m):
for d in self.dan:
for b in d:
if b[0] == m:
m = b[1]
elif b[1] == m:
m = b[0]
if m == self.w:
return 0
else:
return 1
def solv(n, w, dan, m):
lot = Lot(n, w, dan)
r = lot.cast(m)
if r == 0:
return r
else:
a_bars = additional_bars(dan)
for ab in a_bars:
dan2 = map(list, dan)
a, b = ab
dan2[a][b] = 1
lot = Lot(n, w, dan2)
r = lot.cast(m)
if r == 0:
return "%d %d" % (a+1, b+1)
else:
return 1
def additional_bars(dan):
r = []
for d in range(len(dan)):
if dan[d][0:2] == [0,0]:
r.append((d, 0))
if dan[d][-2:] == [0,0]:
r.append((d, len(dan[d])-1))
for i in range(len(dan[d])-2):
if dan[d][i:i+3] == [0,0,0]:
r.append((d, i+1))
return r
while True:
n = int(sys.stdin.readline())
if n == 0:
exit(0)
m = int(sys.stdin.readline())
w = int(sys.stdin.readline())
d = int(sys.stdin.readline())
dan = []
for i in range(d):
dan.append(map(int, list(sys.stdin.readline().rstrip())))
print solv(n, w, dan, m) | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s985693810 | p00069 | Wrong Answer |
import sys
class Lot:
def __init__(self, n, w, dan):
self.n = n
self.w = w
self.dan = self._parse_dan(dan)
def _parse_dan(self, dan):
dan = map(self._parse_d, dan)
return dan
def _parse_d(self, d):
r = []
for i in range(len(d)):
if d[i]:
r.append((i+1, i+2))
return r
def cast(self, m):
for d in self.dan:
for b in d:
if b[0] == m:
m = b[1]
elif b[1] == m:
m = b[0]
if m == self.w:
return 0
else:
return 1
def solv(n, w, dan, m):
lot = Lot(n, w, dan)
r = lot.cast(m)
if r == 0:
return r
else:
a_bars = additional_bars(dan)
for ab in a_bars:
dan2 = map(list, dan)
a, b = ab
dan2[a][b] = 1
lot = Lot(n, w, dan2)
r = lot.cast(m)
if r == 0:
return "%d %d" % (a+1, b+1)
else:
return 1
def additional_bars(dan):
r = []
for d in range(len(dan)):
if dan[d][0:2] == [0,0]:
r.append((d, 0))
if dan[d][-2:] == [0,0]:
r.append((d, len(dan[d])-1))
for i in range(len(dan[d])-3):
if dan[d][i:i+3] == [0,0,0]:
r.append((d, i+1))
return r
while True:
n = int(sys.stdin.readline())
if n == 0:
exit(0)
m = int(sys.stdin.readline())
w = int(sys.stdin.readline())
d = int(sys.stdin.readline())
dan = []
for i in range(d):
dan.append(map(int, list(sys.stdin.readline().rstrip())))
print solv(n, w, dan, m) | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s620835018 | p00069 | Wrong Answer | import sys
class Lot:
def __init__(self, n, w, dan):
self.n = n
self.w = w
self.dan = self._parse_dan(dan)
def _parse_dan(self, dan):
dan = map(self._parse_d, dan)
return dan
def _parse_d(self, d):
r = []
for i in range(len(d)):
if d[i]:
r.append((i+1, i+2))
return r
def cast(self, m):
for d in self.dan:
for b in d:
if b[0] == m:
m = b[1]
elif b[1] == m:
m = b[0]
if m == self.w:
return 0
else:
return 1
def solv(n, w, dan, m):
lot = Lot(n, w, dan)
r = lot.cast(m)
if r == 0:
return r
else:
a_bars = additional_bars(dan)
print a_bars
for ab in a_bars:
dan2 = map(list, dan)
a, b = ab
dan2[a][b] = 1
lot = Lot(n, w, dan2)
r = lot.cast(m)
if r == 0:
return "%d %d" % (a+1, b+1)
else:
return 1
def additional_bars(dan):
r = []
for d in range(len(dan)):
if dan[d][0:2] == [0,0]:
r.append((d, 0))
if dan[d][-2:] == [0,0]:
r.append((d, len(dan[d])-1))
for i in range(len(dan[d])-2):
if dan[d][i:i+3] == [0,0,0]:
r.append((d, i+1))
return r
while True:
n = int(sys.stdin.readline())
if n == 0:
exit(0)
m = int(sys.stdin.readline())
w = int(sys.stdin.readline())
d = int(sys.stdin.readline())
dan = []
for i in range(d):
dan.append(map(int, list(sys.stdin.readline().rstrip())))
print solv(n, w, dan, m) | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s930441783 | p00069 | Wrong Answer | import sys
class Lot:
def __init__(self, n, w, dan):
self.n = n
self.w = w
self.dan = self._parse_dan(dan)
def _parse_dan(self, dan):
dan = map(self._parse_d, dan)
return dan
def _parse_d(self, d):
r = []
for i in range(len(d)):
if d[i]:
r.append((i+1, i+2))
return r
def cast(self, m):
for d in self.dan:
for b in d:
if b[0] == m:
m = b[1]
elif b[1] == m:
m = b[0]
if m == self.w:
return 0
else:
return 1
def solv(n, w, dan, m):
lot = Lot(n, w, dan)
r = lot.cast(m)
if r == 0:
return r
else:
a_bars = additional_bars(dan)
# print a_bars
for ab in a_bars:
dan2 = map(list, dan)
a, b = ab
dan2[a][b] = 1
lot = Lot(n, w, dan2)
r = lot.cast(m)
if r == 0:
return "%d %d" % (a+1, b+1)
else:
return 1
def additional_bars(dan):
r = []
for d in range(len(dan)):
if dan[d][0:2] == [0,0]:
r.append((d, 0))
if dan[d][-2:] == [0,0]:
r.append((d, len(dan[d])-1))
for i in range(len(dan[d])-2):
if dan[d][i:i+3] == [0,0,0]:
r.append((d, i+1))
return r
while True:
n = int(sys.stdin.readline())
if n == 0:
exit(0)
m = int(sys.stdin.readline())
w = int(sys.stdin.readline())
d = int(sys.stdin.readline())
dan = []
for i in range(d):
dan.append(map(int, list(sys.stdin.readline().rstrip())))
print solv(n, w, dan, m) | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s179198421 | p00069 | Wrong Answer | import sys
def amida(A,x):
for e in A:
if e[x]==1:x+=1
elif e[x-1]==1:x-=1
return x
def f():
for i in D:
for j in range(1,n):
if A[i][j]==0:
B=[e[:] for e in A]
B[i][j]=1
if amida(B,m)==p:
print i+1,j
return
print 1
return
while 1:
n=input()
if n==0:break
m=input()
p=input()
D=range(input())
A=[[0]+map(int,list(raw_input()))+[0] for i in D]
if amida(A,m)==p:print 0
else:f() | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s426560930 | p00069 | Wrong Answer | while True:
n = int(raw_input())
if n == 0:
break
m = int(raw_input())-1
x = int(raw_input())-1
d = int(raw_input())
amida = []
for i in range(d):
amida.append(map(int, raw_input()))
rroot = []
for i in range(d-1,-1,-1):
if x > 0:
if amida[i][x-1] == 1:
x -= 1
if x < n-1:
if amida[i][x] == 1:
x += 1
rroot.append(x)
if m == x:
print 0
else:
root = []
for i in range(d):
if m > 0:
if amida[i][m-1] == 1:
m -= 1
if m < n-1:
if amida[i][m] == 1:
m += 1
root.append(m)
rroot.reverse()
for i in range(d):
if abs(root[i]-rroot[i]) == 1:
p = min(root[i],rroot[i])
if sum(amida[i][p-1:p+1]) == 0:
print i+1, p+1
break
if i == d-1:
print 1 | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s397235249 | p00069 | Wrong Answer | while True:
n = int(raw_input())
if n == 0:
break
m,x,d = int(raw_input())-1,int(raw_input())-1,int(raw_input())
amida = ["" for i in range(d)]
for i in range(d):
amida[i] = "0" + raw_input() + "0"
rroot = []
for i in range(d-1,-1,-1):
if amida[i][x-1] == "1":
x -= 1
elif amida[i][x] == "1":
x += 1
rroot.append(x)
if m == x:
print 0
else:
root = []
for i in range(d):
if amida[i][m-1] == "1":
m -= 1
elif amida[i][m] == "1":
m += 1
root.append(m)
rroot.reverse()
for i in range(d):
if abs(root[i]-rroot[i]) == 1:
p = min(root[i],rroot[i])
if int(amida[i][p-1]) + int(amida[i][p+1]) == 0:
print i+1, p+1
break
if i == d-1:
print 1 | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s156361901 | p00069 | Accepted | def solve(pos, a):
for l in a:
if l[pos-1]:
pos -= 1
elif l[pos]:
pos += 1
return pos
while True:
n = int(input())
if not n:
break
m, atari, d = (int(input()) for _ in [0]*3)
a = [[0]+list(map(int, input()))+[0] for _ in [0]*d]
if solve(m, a) == atari:
print(0)
continue
for i, (l, (j, current), r) in ((i, _) for i, l in enumerate(a) for _ in zip(l, enumerate(l[1:], start=1), l[2:])):
if not (l | current | r):
a[i][j] = 1
if solve(m, a) == atari:
print(i+1, j)
break
a[i][j] = 0
else:
print(1)
| 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s676863692 | p00069 | Accepted | def solver(n, s, g, amida):
for a in amida:
a = list(map(int, list(a)))
r, l = 0, 0
if s != 1:
l = a[s-2]
if s != n:
r = a[s-1]
if r == 1:
s += 1
elif l == 1:
s -= 1
return True if s == g else False
while True:
n = int(input())
if n == 0: break
s = int(input())
g = int(input())
d = int(input())
amida = [input() for j in range(d)]
if solver(n, s, g, amida):
print(0)
else:
ans = None
for i in range(d):
for j in range(n-1):
a = amida[i]
if a[j] == '0':
a = a[:j] + '1' + a[j+1:]
if '11' in a:
continue
else:
if solver(n, s, g, amida[:i] + [a] + amida[i+1:]):
ans = str(i+1) + ' ' + str(j+1)
break
if ans: break
if ans:
print(ans)
else:
print(1) | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s543472229 | p00069 | Accepted | import sys
import itertools
def one_step(lo,lis):
nu = [ e for e in lis ]
for j in xrange(len(nu)):
if lo[0][j] == 1:
nu[j],nu[j+1] = nu[j+1],nu[j]
return lo[1:],nu
def solve(lo,lis):
if len(lo) == 0:
return lis
nu = [ e for e in lis]
lo2,nu2 = one_step(lo,nu)
return solve(lo2,nu2)
while True:
n = input()
if n == 0: exit()
m = input()
star = input()
d = input()
lis = range(n+1)
lots = []
for i in xrange(d):
lots.append( [0] + map(int,raw_input()) + [0])
if solve(lots,lis)[star] == m: print 0;continue
for i,j in itertools.product(xrange(d),xrange(1,n)):
if lots[i][j-1] + lots[i][j] + lots[i][j+1] == 0:
lots[i][j] = 1
if solve(lots,lis)[star] == m: print i+1,j;break
lots[i][j] = 0
else: print 1 | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s618538884 | p00069 | Accepted | import sys
import itertools
def one_step(lo,lis):
nu = [ e for e in lis ]
for j in xrange(len(nu)):
if lo[0][j] == 1:
nu[j],nu[j+1] = nu[j+1],nu[j]
return lo[1:],nu
def solve(lo,lis):
if len(lo) == 0:
return lis
nu = [ e for e in lis]
lo2,nu2 = one_step(lo,nu)
return solve(lo2,nu2)
def func(lots,lis,n,m,star,d):
for i in xrange(d):
for j in xrange(1,n):
if lots[0][j-1] + lots[0][j] + lots[0][j+1] == 0:
lots[0][j] = 1
if solve(lots,lis)[star] == m: print i+1,j;return True
lots[0][j] = 0
lots,lis = one_step(lots,lis)
return False
while True:
n = input()
if n == 0: exit()
m = input()
star = input()
d = input()
lis = range(n+1)
lots = []
for i in xrange(d):
lots.append( [0] + map(int,raw_input()) + [0])
if solve(lots,lis)[star] == m: print 0;continue
elif func(lots,lis,n,m,star,d): continue
else: print 1 | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s063679205 | p00069 | Accepted | import sys
f = sys.stdin
while True:
n = int(f.readline())
if n ==0:
break
m, star, d = [int(f.readline()) for _ in range(3)]
lines = [f.readline().strip() for _ in range(d)]
lots = [None for j in range(d + 1)]
lots[0] = [i + 1 for i in range(n)]
for i, line in enumerate(lines):
lots[i + 1] = lots[i][:]
for j, c in enumerate(line):
if c == '1':
lots[i + 1][j], lots[i + 1][j + 1] = lots[i + 1][j + 1], lots[i + 1][j]
star = lots[-1][star - 1]
if m == star:
print(0)
continue
for i, lot in enumerate(lots):
index_min = min(lot.index(m), lot.index(star))
index_max = max(lot.index(m), lot.index(star))
if i and index_max - index_min == 1:
line = lines[i - 1]
if (index_min == 0 or line[index_min - 1] == '0') and line[index_min] == '0' and (index_max == n - 1 or line[index_max] == '0' ):
print(i, min(lot.index(m), lot.index(star)) + 1)
break
if i == len(lots) - 1:
print(1) | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s397911255 | p00069 | Accepted | while 1:
n=int(raw_input())
if n==0:
break
m=int(raw_input())
x=int(raw_input())
d=int(raw_input())
D=range(d)
amida=['' for i in D]
for i in D:
amida[i]='0'+raw_input()+'0'
rroot=[]
for i in range(d-1,-1,-1):
if amida[i][x-1]=='1':
x-=1
elif amida[i][x]=='1':
x+=1
rroot.append(x)
if m==x:
print 0
else:
root=[]
for i in D:
if amida[i][m-1]=='1':
m-=1
elif amida[i][m]=='1':
m+=1
root.append(m)
rroot.reverse()
for i in D:
if abs(root[i]-rroot[i])==1:
p=min(root[i],rroot[i])
if int(amida[i][p-1])+int(amida[i][p+1])==0:
print i+1,p
break
if i==d-1:
print 1 | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s218565646 | p00069 | Accepted | def check(n,m,star,d,f):
ns=[i for i in range(n)]
for i in range(d):
for j in range(n-1):
if f[i][j]:
c=ns[j+1]
ns[j+1]=ns[j]
ns[j]=c
return ns[star-1]==m-1
while True:
n=int(input())
if(n==0):break
m=int(input())
star=int(input())
d=int(input())
f=[[False for i in range(n-1)]for j in range(d)]
for i in range(d):
st=input()
for j in range(n-1):
f[i][j]=st[j]=='1'
if check(n,m,star,d,f):
print(0)
else:
ans=False
for i in range(d):
for j in range(n-1):
if ans:break
ok=not f[i][j]
if(j>0 and f[i][j-1]) or (j<n-2 and f[i][j+1]):ok=False
if ok:
f[i][j]=True
if check(n,m,star,d,f):
print(i+1,j+1)
ans=True
f[i][j]=False
if not ans:
print(1) | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s202637414 | p00069 | Accepted | import copy
def check_lots(start, goal, line):
for i in range(len(line)):
for j in range(len(line[i])):
if line[i][j] == 1:
if j == start - 1:
start -= 1
elif j == start:
start += 1
return start == goal
while True:
n = int(input())
if n == 0:
break
m = int(input())
s = int(input())
d = int(input())
l = []
for i in range(d):
l.append([0] + list(map(int, list(input()))) + [0])
d_ans = 0
n_ans = 0
if check_lots(m, s, l):
print(0)
else:
for i in range(d):
for j in range(1, n):
l_tmp = copy.deepcopy(l[:])
if sum(l[i][j-1:j+2]) > 0:
continue
l_tmp[i][j] = 1
if check_lots(m, s, l_tmp):
d_ans = i + 1
n_ans = j
break
else:
continue
break
if d_ans:
print(d_ans, n_ans)
else:
print(1)
| 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s244550692 | p00069 | Accepted | while True:
n = int(input())
if not n:
break
start = int(input()) - 1 #開始の位置
goal = int(input()) - 1 #あたりの位置
d = int(input())
nums = [[i for i in range(n)]] #各段での数字の並び
bars = [] #横棒リスト
for i in range(d):
s = input()
bars.append(s)
new = nums[-1][:]
for j in range(n - 1):
if s[j] == "1": #横棒があれば入れ替え
new[j], new[j + 1] = new[j + 1], new[j]
nums.append(new)
to_goal = nums[-1][goal] #あたりにたどり着く初期位置
if to_goal == start: #元からあたりにたどり着く場合
print(0)
else: #各段について、to_goalとスタートが隣り合うかチェック
for i, status in enumerate(nums[1:]):
to_goal_ind = status.index(to_goal) #to_goalの位置
start_ind = status.index(start) #startの位置
ind1, ind2 = min(to_goal_ind, start_ind), max(to_goal_ind, start_ind)
if ind2 - ind1 == 1: #隣あっていた場合
if (bars[i][ind1] == "0") and (ind1 == 0 or bars[i][ind1 - 1] == "0") and (ind2 == n - 1 or bars[i][ind2] == "0"): #隣り合う横棒がなければ(入れ替え可能ならば)出力
print(i + 1, ind1 + 1)
break
else:
print(1)
| 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s202903440 | p00069 | Accepted | def main():
while True:
n = int(input())
if not n:
break
start = int(input()) - 1 #開始の位置
goal = int(input()) - 1 #あたりの位置
d = int(input())
nums = [[i for i in range(n)]] #各段での数字の並び
bars = [] #横棒リスト
for i in range(d):
s = input()
bars.append(s)
new = nums[-1][:]
for j in range(n - 1):
if s[j] == "1": #横棒があれば入れ替え
new[j], new[j + 1] = new[j + 1], new[j]
nums.append(new)
to_goal = nums[-1][goal] #あたりにたどり着く初期位置
if to_goal == start: #元からあたりにたどり着く場合
print(0)
else: #各段について、to_goalとスタートが隣り合うかチェック
for i, status in enumerate(nums[1:]):
to_goal_ind = status.index(to_goal) #to_goalの位置
start_ind = status.index(start) #startの位置
ind1, ind2 = min(to_goal_ind, start_ind), max(to_goal_ind, start_ind)
if ind2 - ind1 == 1: #隣あっていた場合
if (bars[i][ind1] == "0") and (ind1 == 0 or bars[i][ind1 - 1] == "0") and (ind2 == n - 1 or bars[i][ind2] == "0"): #隣り合う横棒がなければ(入れ替え可能ならば)出力
print(i + 1, ind1 + 1)
break
else:
print(1)
main()
| 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s701649998 | p00069 | Accepted | while True:
n = int(input())
if not n:
break
start = int(input()) - 1 #開始の位置
goal = int(input()) - 1 #あたりの位置
d = int(input())
nums = [[i for i in range(n)]] #各段での数字の並び
bars = [] #横棒リスト
for i in range(d):
s = input()
bars.append(s)
new = nums[-1][:]
for j in range(n - 1):
if s[j] == "1": #横棒があれば入れ替え
new[j], new[j + 1] = new[j + 1], new[j]
nums.append(new)
to_goal = nums[-1][goal] #あたりにたどり着く初期位置
if to_goal == start: #元からあたりにたどり着く場合
print(0)
else: #各段について、to_goalとスタートが隣り合うかチェック
for i, status in enumerate(nums[1:]):
to_goal_ind = status.index(to_goal) #to_goalの位置
start_ind = status.index(start) #startの位置
ind1, ind2 = min(to_goal_ind, start_ind), max(to_goal_ind, start_ind)
if (ind2 - ind1 == 1 #隣り合っていて、
and bars[i][ind1] == "0" #該当位置と
and (ind1 == 0 or bars[i][ind1 - 1] == "0") #左と
and (ind2 == n - 1 or bars[i][ind2] == "0")): #右に、辺がなければ出力
print(i + 1, ind1 + 1)
break
else:
print(1)
| 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s521773100 | p00069 | Accepted | # AOJ 0069: Drawing Lots II
# Python3 2018.6.28 bal4u
while True:
n = int(input())
if n == 0: break
m, p, d = [int(input()) for i in range(3)]
m -= 1
p -= 1
a = [[] for i in range(d+1)]
for i in range(d): a[i] = list(map(int, input()))
s = [[0 for j in range(n)] for i in range(d+1)]
s[d] = [i for i in range(n)]
for i in range(d-1, -1, -1):
for j in range(n): s[i][j] = s[i+1][j]
for j in range(n-1):
if a[i][j]: s[i][j], s[i][j+1] = s[i][j+1], s[i][j]
k = s[0][m]
if k == p:
print(0)
continue
f = False
for i in range(d):
for j in range(n-1):
if ((s[i][j] == k and s[i][j+1] == p) or (s[i][j] == p and s[i][j+1] == k)) \
and (j == 0 or a[i][j-1] == 0) and a[i][j] == 0 and (j == n-2 or a[i][j+1] == 0):
print(i+1, j+1)
f = True
break
if f: break
if not f: print(1)
| 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s296062933 | p00069 | Accepted | while True:
n=input()
if n==0:
break
m,goal,d=input(),input(),input()
step=[""]*d
for i in xrange(d):
step[i]="0"+raw_input()+"0"
raw=range(n+2)
for i in xrange(d):
for j in xrange(1,n+1):
if step[i][j]=="1":
raw[j],raw[j+1]=raw[j+1],raw[j]
ans=0
if not raw[goal]==m:
e=raw[goal]
raw=range(n+2)
for i in xrange(d):
if not ans==0:
break
for j in xrange(1,n+1):
if (raw[j]==m and raw[j+1]==e) or (raw[j]==e and raw[j+1]==m):
if step[i][j-1]=="0" and step[i][j]=="0" and step[i][j+1]=="0":
ans=(i+1,j)
break
if step[i][j]=="1":
raw[j],raw[j+1]=raw[j+1],raw[j]
if ans==0:
ans=1
if ans==0 or ans==1:print ans
else:print " ".join(map(str,ans)) | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s791832281 | p00069 | Accepted | def Judge(data,n,d,m):
now=m
for i in range(d):
if now==1:
if data[i][now]:
now+=1
elif now==n:
if data[i][n-1]:
now-=1
elif data[i][now-1]:
now-=1
elif data[i][now]:
now+=1
return now
while True:
n=input()
if n==0:break
m,star,d=input(),input(),input()
data=[[0]+map(int,raw_input())+[0] for i in range(d)]
flag=False
if Judge(data,n,d,m)==star:
print 0
else:
for i in range(d):
for j in range(1,n):
if data[i][j]==0 and data[i][j+1]!=1 and data[i][j-1]!=1:
data[i][j]=1
if Judge(data,n,d,m)==star:
print i+1,j
flag=True
break
else:
data[i][j]=0
if flag:
break
else:
print 1 | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s452861955 | p00069 | Accepted | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
def draw_cross(line, end, pos, left):
if left:
if pos < 1 or line[pos-1]:
return False
elif pos > 1 and line[pos-2]:
return False
elif pos < end and line[pos]:
return False
line[pos-1] = 1
return pos
if pos >= end or line[pos]:
return False
elif pos < end-1 and line[pos+1]:
return False
elif pos > 0 and line[pos-1]:
return False
line[pos] = 1
return pos + 1
def run(start, side, add, left):
end = len(side[0])
pos = start - 1
add -= 1
cross = 0
for step, line in enumerate(side):
line = line[:]
if add == step:
cross = draw_cross(line, end, pos, left)
if not cross:
return (False, False)
if pos > 0 and line[pos-1]:
pos -= 1
elif pos < end and line[pos]:
pos += 1
return (cross, pos + 1)
while True:
n = int(stdin.readline())
if not n:
break
start = int(stdin.readline())
hit = int(stdin.readline())
num_step = int(stdin.readline())
side = []
for i in range(num_step):
side.append([int(s) for s in stdin.readline().rstrip()])
cross, goal = run(start, side, 0, True)
if goal == hit:
print(0)
continue
for step in range(1, num_step+1):
cross, goal = run(start, side, step, left=True)
if goal == hit:
print(step, cross)
break
cross, goal = run(start, side, step, left=False)
if goal == hit:
print(step, cross)
break
else:
print(1) | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s779317097 | p00069 | Accepted | import sys
def amida(A,x):
for e in A:
if e[x]:x+=1
elif e[x-1]:x-=1
return x
def f():
for i in D:
for j in range(1,n):
if A[i][j-1:j+2]==[0,0,0]:
B=[e[:] for e in A]
B[i][j]=1
if amida(B,m)==p:
print i+1,j
return
print 1
return
while 1:
n=input()
if n==0:break
m=input()
p=input()
D=range(input())
A=[[0]+map(int,list(raw_input()))+[0] for i in D]
if amida(A,m)==p:print 0
else:f() | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s316392503 | p00069 | Accepted | import sys
def amida(A,x):
for e in A:
if e[x]=="1":x+=1
elif e[x-1]=="1":x-=1
return x
def f():
for i in D:
for j in range(1,n):
if A[i][j-1:j+2]=="000":
B=[e[:] for e in A]
B[i]=B[i][:j]+"1"+B[i][j+1:]
if amida(B,m)==p:
print i+1,j
return
print 1
return
while 1:
n=input()
if n==0:break
m=input()
p=input()
D=range(input())
A=["0"+raw_input()+"0" for i in D]
if amida(A,m)==p:print 0
else:f() | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s181580040 | p00069 | Accepted | while True:
n = int(raw_input())
if n == 0:
break
m = int(raw_input())
x = int(raw_input())
d = int(raw_input())
amida = ["" for i in range(d)]
for i in range(d):
amida[i] = "0" + raw_input() + "0"
rroot = []
for i in range(d-1,-1,-1):
if amida[i][x-1] == "1":
x -= 1
elif amida[i][x] == "1":
x += 1
rroot.append(x)
if m == x:
print 0
else:
root = []
for i in range(d):
if amida[i][m-1] == "1":
m -= 1
elif amida[i][m] == "1":
m += 1
root.append(m)
rroot.reverse()
for i in range(d):
if abs(root[i]-rroot[i]) == 1:
p = min(root[i],rroot[i])
if int(amida[i][p-1]) + int(amida[i][p+1]) == 0:
print i+1, p
break
if i == d-1:
print 1 | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s696435596 | p00069 | Accepted | while True:
n = int(raw_input())
if n == 0:
break
m,x,d = int(raw_input()),int(raw_input()),int(raw_input())
amida = ["" for i in range(d)]
for i in range(d):
amida[i] = "0" + raw_input() + "0"
rroot = []
for i in range(d-1,-1,-1):
if amida[i][x-1] == "1": x -= 1
elif amida[i][x] == "1" : x += 1
rroot.append(x)
if m == x: print 0
else:
root = []
for i in range(d):
if amida[i][m-1] == "1": m -= 1
elif amida[i][m] == "1" : m += 1
root.append(m)
rroot.reverse()
for i in range(d):
if abs(root[i]-rroot[i]) == 1:
p = min(root[i],rroot[i])
if int(amida[i][p-1]) + int(amida[i][p+1]) == 0:
print i+1, p
break
if i == d-1: print 1 | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s635074503 | p00069 | Accepted | import sys
readline = sys.stdin.readline
write = sys.stdout.write
def solve():
N = int(readline())
if N == 0:
return False
M = int(readline())
K = int(readline())
D = int(readline())
P = [list(map(int, readline().strip())) + [0] for i in range(D)]
INF = (10, 0); GL = (-1, 0)
X = [INF]*N
X[K-1] = GL
for i in range(D-1, -1, -1):
Pi = P[i]
for j in range(N-1):
if Pi[j]:
X[j], X[j+1] = X[j+1], X[j]
elif 0 == Pi[j-1] == Pi[j+1]:
if X[j] == GL:
X[j+1] = (i, j)
if X[j+1] == GL:
X[j] = (i, j)
if X[M-1] == GL:
write("0\n")
elif X[M-1] == INF:
write("1\n")
else:
x, y = X[M-1]
write("%d %d\n" % (x+1, y+1))
return True
while solve():
...
| 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s844751654 | p00069 | Accepted | from copy import copy
def change(n,a):
temp = a[n]
a[n] = a[n+1]
a[n+1] = temp
return a
while(1):
st = 1
n = int(input())
if n == 0:
break
elif n == 1:
st = 0
m_ = int(input())
m = m_ -1
w = int(input())
d = int(input())
b = []
forward = []
for i in range(d):
b.append([int(i) for i in list(input())])
if st == 0:
print("0")
continue
a = [i for i in range(n)]
for i in range(d):
for j in range(n-1):
if b[i][j] == 1:
a = change(j,a)
forward.append(copy(a))
if a[w-1] == m:
print(0)
else:
state = True
pivot = a[w-1]
for i in range(d):
f = forward[i]
x = f.index(m)
y = f.index(pivot)
if y - x == 1:
if b[i][x] == 0 and (x-1 < 0 or b[i][x-1] == 0) and (x+1 > n-2 or b[i][x+1] == 0):
print(i+1,x+1)
state = False
break
elif x - y == 1:
if b[i][y] == 0 and (y-1 < 0 or b[i][y-1] == 0) and (y+1 > n-2 or b[i][y+1] == 0):
print(i+1,y+1)
state = False
break
if state:
print(1)
| 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s789352828 | p00069 | Runtime Error | while True:
n = int(input())
if not n:
break
start = int(input()) - 1 #開始の位置
goal = int(input()) - 1 #あたりの位置
d = int(input())
nums = [[i for i in range(n)]] #各段での数字の並び
bars = [] #横棒リスト
for i in range(d):
s = input()
bars.append(s)
new = nums[-1][:]
for j in range(n - 1):
if s[j] == "1": #横棒があれば入れ替え
new[j], new[j + 1] = new[j + 1], new[j]
nums.append(new)
to_goal = nums[-1][goal] #あたりにたどり着くスタートの番号
for i, status in enumerate(nums):
to_goal_ind = status.index(to_goal) #to_goalの位置
start_ind = status.index(start) #startの位置
ind1, ind2 = min(to_goal_ind, start_ind), max(to_goal_ind, start_ind)
if ind2 - ind1 == 1: #隣あっていた場合
if bars[i][ind1] == "0" and (ind2 == n - 1 or bars[i][ind2] == "0"): #隣り合う横棒がなければ出力
print(i + 1, ind1 + 1)
break
else:
print(1)
| 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s957027232 | p00069 | Runtime Error | # AOJ 0069: Drawing Lots II
# Python3 2018.6.28 bal4u
while True:
n = int(input())
if n == 0: break
m, p, d = [int(input()) for i in range(3)]
a = [[0 for j in range(10)] for i in range(32)]
for i in range(1, d+1): a[i] = [0] + list(map(int, input())) + [0]
s = [[0 for j in range(10)] for i in range(32)]
for i in range(1, n+1): s[d+1][i] = i
for i in range(d, 0, -1):
for j in range(1, n+1): s[i][j] = s[i+1][j]
for j in range(1, n):
if a[i][j]: s[i][j], s[i][j+1] = s[i][j+1], s[i][j]
k = s[1][m]
if k == p:
print(0)
continue
f = False
for i in range(1, d+1):
for j in range(1, n):
if ((s[i][j] == k and s[i][j+1] == p) or (s[i][j] == p and s[i][j + 1] == k)) \
and a[i][j-1] == 0 and a[i][j] == 0 and a[i][j+1] == 0:
print(i, j)
f = True
break
if f: break
if not f: print(1)
| 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s117478207 | p00069 | Runtime Error | while True:
n=input()
if n==0:
break
m,goal,d=input(),input(),input()
step=[""]*d
for i in xrange(d):
step[i]=raw_input()
raw=range(1,n+1)
for i in xrange(d):
for j in xrange(n-1):
if step[i][j]=="1":
raw[j],raw[j+1]=raw[j+1],raw[j]
ans=0
if not raw[goal]==m:
t=raw[goal]
raw=range(1,n+1)
for i in xrange(d):
if not ans==0:break
for j in xrange(n-1):
if (raw[j]==m and raw[j+1]==t) or (raw[j+1]==m and raw[j]==t):
if (j-1<0 or step[i][j-1]=="0") and (j+1>=n or step[i][j+1]):
ans=(i+2,j+1)
break
if step[i][j]=="1":
raw[j],raw[j+1]=raw[j+1],raw[j]
if ans==0:
ans=1
print " ".join(map(str,ans)) | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s801120737 | p00069 | Runtime Error | while True:
n=input()
if n==0:
break
m,goal,d=input(),input(),input()
step=[""]*d
for i in xrange(d):
step[i]="0"+raw_input()+"0"
raw=range(n+2)
for i in xrange(d):
for j in xrange(1,n+1):
if step[i][j]=="1":
raw[j],raw[j+1]=raw[j+1],raw[j]
ans=0
if not raw[goal]==m:
e=raw[goal]
raw=range(n+2)
for i in xrange(d):
if not ans==0:
break
for j in xrange(1,n+1):
if (raw[j]==m and raw[j+1]==e) or (raw[j]==e and raw[j+1]==m):
if step[i][j-1]=="0" and step[i][j]=="0" and step[i][j+1]=="0":
ans=(i+1,j)
break
if step[i][j]=="1":
raw[j],raw[j+1]=raw[j+1],raw[j]
if ans==0:
ans=1
print " ".join(map(str,ans))
| 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s826547726 | p00069 | Runtime Error | import copy
def amida(A,x):
for e in A:
if e[x]==1:x+=1
elif e[x-1]==1:x-=1
return x
def f():
for i in range(d):
for j in range(1,n):
if A[i][j]==0:
B=copy.deepcopy(A)
B[i][j]=1
if amida(B,m)==p:
print i+1,j
return
print 1
return
import sys
n=input()
m=input()
p=input()
d=input()
A=[]
for s in sys.stdin:
if s=="0\n":break
A+=[[0]+map(int,list(s[:-1]))+[0]]
if amida(A,m)==p: print 0
else:f() | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s286281304 | p00069 | Runtime Error | import copy,sys
def amida(A,x):
for e in A:
if e[x]==1:x+=1
elif e[x-1]==1:x-=1
return x
def f():
for i in range(d):
for j in range(1,n):
if A[i][j]==0:
B=copy.deepcopy(A)
B[i][j]=1
if amida(B,m)==p:
print i+1,j
return
print 1
return
n=input()
m=input()
p=input()
d=input()
A=[]
for s in sys.stdin:
if s=="0\n":break
A+=[[0]+map(int,list(s[:-1]))+[0]]
if amida(A,m)==p: print 0
else:f() | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s387352035 | p00069 | Runtime Error | import copy,sys
def amida(A,x):
for e in A:
if e[x]==1:x+=1
elif e[x-1]==1:x-=1
return x
def f():
for i in range(d):
for j in range(1,n+1):
if A[i][j]==0:
B=copy.deepcopy(A)
B[i][j]=1
if amida(B,m)==p:
print i+1,j
return
print 1
return
n=input()
m=input()
p=input()
d=input()
A=[]
for s in sys.stdin:
if s=="0\n":break
A+=[[0]+map(int,list(s[:-1]))+[0]]
if amida(A,m)==p: print 0
else:f() | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s746083024 | p00069 | Runtime Error | import sys
def amida(A,x):
for e in A:
if e[x]==1:x+=1
elif e[x-1]==1:x-=1
return x
def f():
for i in range(d):
for j in range(1,n):
if A[i][j]==0:
B=[e[:] for e in A]
B[i][j]=1
if amida(B,m)==p:
print i+1,j
return
print 1
return
n=input()
m=input()
p=input()
d=input()
A=[]
for s in sys.stdin:
if s=="0\n":break
A+=[[0]+map(int,list(s[:-1]))+[0]]
if amida(A,m)==p: print 0
else:f() | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s201018967 | p00069 | Runtime Error | while True:
n = int(raw_input())
if n == 0:
break
m = int(raw_input())-1
x = int(raw_input())-1
d = int(raw_input())
amida = []
for i in range(d):
amida.append(map(int, raw_input()))
rroot = []
for i in range(d-1,-1,-1):
if x > 0:
if amida[i][x-1] == 1:
x -= 1
if x < 4:
if amida[i][x] == 1:
x += 1
rroot.append(x)
if m == x:
print 0
else:
root = []
for i in range(d):
if m > 0:
if amida[i][m-1] == 1:
m -= 1
if m < 4:
if amida[i][m] == 1:
m += 1
root.append(m)
rroot.reverse()
for i in range(d):
k = root[i] - rroot[i]
if abs(k) == 1:
p = min(root[i],rroot[i])
if sum(amida[i][p-1:p+1]) == 0:
print i+1, p+1
break
if i == d-1:
print 1 | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s607491650 | p00069 | Runtime Error | while True:
n = int(raw_input())
if n == 0:
break
m = int(raw_input())-1
x = int(raw_input())-1
d = int(raw_input())
amida = []
for i in range(d):
amida.append(map(int, raw_input()))
rroot = []
for i in range(d-1,-1,-1):
if x > 0:
if amida[i][x-1] == 1:
x -= 1
if x < n-1:
if amida[i][x] == 1:
x += 1
rroot.append(x)
if m == x:
print 0
else:
root = []
for i in range(d):
if m > 0:
if amida[i][m-1] == 1:
m -= 1
if m < n-1:
if amida[i][m] == 1:
m += 1
root.append(m)
rroot.reverse()
for i in range(d):
if abs(root[i]-rroot[i]) == 1:
p = min(root[i],rroot[i])
if p == 0:
if amida[i][p+1] == 0:
print i+1, p+1
break
elif p == n-1:
if amida[i][p-1] == 0:
print i+1, p+1
break
else:
if amida[i][p-1] + amida[i][p+1]) == 0:
print i+1, p+1
break
if i == d-1:
print 1 | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s447534731 | p00069 | Runtime Error | while True:
n = int(raw_input())
if n == 0:
break
m = int(raw_input())-1
x = int(raw_input())-1
d = int(raw_input())
amida = []
for i in range(d):
amida.append(map(int, raw_input()))
rroot = []
for i in range(d-1,-1,-1):
if x > 0:
if amida[i][x-1] == 1:
x -= 1
if x < n-1:
if amida[i][x] == 1:
x += 1
rroot.append(x)
if m == x:
print 0
else:
root = []
for i in range(d):
if m > 0:
if amida[i][m-1] == 1:
m -= 1
if m < n-1:
if amida[i][m] == 1:
m += 1
root.append(m)
rroot.reverse()
for i in range(d):
if abs(root[i]-rroot[i]) == 1:
p = min(root[i],rroot[i])
if p == 0:
if amida[i][p+1] == 0:
print i+1, p+1
break
elif p == n-1:
if amida[i][p-1] == 0:
print i+1, p+1
break
else:
if amida[i][p-1] + amida[i][p+1] == 0:
print i+1, p+1
break
if i == d-1:
print 1 | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s176024776 | p00069 | Runtime Error | while True:
n = int(raw_input())
if n == 0:
break
m = int(raw_input())-1
x = int(raw_input())-1
d = int(raw_input())
amida = []
for i in range(d):
amida.append(map(int, raw_input()))
rroot = []
for i in range(d-1,-1,-1):
if x > 0:
if amida[i][x-1] == 1:
x -= 1
if x < n-1:
if amida[i][x] == 1:
x += 1
rroot.append(x)
if m == x:
print 0
else:
root = []
for i in range(d):
if m > 0:
if amida[i][m-1] == 1:
m -= 1
if m < n-1:
if amida[i][m] == 1:
m += 1
root.append(m)
rroot.reverse()
for i in range(d):
if abs(root[i]-rroot[i]) == 1:
p = min(root[i],rroot[i])
if p == 0:
if amida[i][p+1] == 0:
print i+1, p+1
break
elif p == n-2:
if amida[i][p-1] == 0:
print i+1, p+1
break
else:
if amida[i][p-1] + amida[i][p+1] == 0:
print i+1, p+1
break
if i == d-1:
print 1 | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s468119581 | p00069 | Runtime Error | while True:
n = int(raw_input())
if n == 0:
break
m,x,d = int(raw_input())-1,int(raw_input())-1,int(raw_input())
amida = []
for i in range(d):
amida[i] = "0" + raw_input() + "0"
rroot = []
for i in range(d-1,-1,-1):
if amida[i][x-1] == "1":
x -= 1
elif amida[i][x] == "1":
x += 1
rroot.append(x)
if m == x:
print 0
else:
root = []
for i in range(d):
if amida[i][m-1] == "1":
m -= 1
elif amida[i][m] == "1":
m += 1
root.append(m)
rroot.reverse()
for i in range(d):
if abs(root[i]-rroot[i]) == 1:
p = min(root[i],rroot[i])
if int(amida[i][p-1]) + int(amida[i][p+1]) == 0:
print i+1, p+1
break
if i == d-1:
print 1 | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s473150211 | p00069 | Runtime Error | while True:
n = int(raw_input())
if n == 0:
break
m,x,d = int(raw_input())-1,int(raw_input())-1,int(raw_input())
amida = []
for i in range(d):
amida[i] = "0" + raw_input() + "0"
rroot = []
for i in range(d-1,-1,-1):
if amida[i][x-1] == "1":
x -= 1
elif amida[i][x] == "1":
x += 1
rroot.append(x)
if m == x:
print 0
else:
root = []
for i in range(d):
if amida[i][m-1] == "1":
m -= 1
elif amida[i][m] == "1":
m += 1
root.append(m)
rroot.reverse()
for i in range(d):
if abs(root[i]-rroot[i]) == 1:
p = min(root[i],rroot[i])
if int(amida[i][p-1]) + int(amida[i][p+1]) == 0:
print i+1, p+1
break
if i == d-1:
print 1 | 5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
| 6 4
|
<H1>あみだくじ II</H1>
<p>
縦線が <var>n</var> 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。
</p>
<ul>
<li>横線は真横に引きます。斜めに引くことはありません。</li>
<li>横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。</li>
<li>どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。</li>
<li>当りはひとつだけです。</li>
</ul>
<p>
下図 に <var>n</var> = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。
</p>
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_lotsII">
</center>
<br/>
<p>
縦線の本数 <var>n</var>、選んだ縦線の番号 <var>m</var>、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のとおりです：
</p>
<p>
１行目に、縦線の本数 <var>n</var> (1 < <var>n</var> ≤ 10) が書かれています。<br/>
２行目には、選んだ縦線の番号 <var>m</var> (1 ≤ <var>m</var> ≤ <var>n</var>) が書かれています。<br/>
３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。<br/>
４行目には、あみだくじの段数 <var>d</var> (1 ≤ <var>d</var> ≤ 30) が書かれています。<br/>
５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、<var>n</var> - 1 つの数字が並んでいます。<br/>
<!--あみだくじの段数は d です。<br/>-->
</p>
<p>
入力は１つの 0 が書かれた行で終わります。
</p>
<H2>Output</H2>
<p>
各データセットについて、選んだ縦線の番号 <var>m</var> から当りにたどり着けるかどうかに応じて以下の値を出力してください。
</p>
<ul>
<li>横線を引かなくても当りにたどり着けるときは 0 を出力してください。</li>
<li>横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。</li>
<li>横線を1 本引いても当りにたどり着けないときには 1 を出力してください。</li>
</ul>
<H2>Sample Input</H2>
<pre>
5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
6 4
</pre>
|
s557978083 | p00070 | Wrong Answer | from collections import defaultdict, Counter
import sys
# dp[n][使った数字(bit)][合計] = count
dp = [defaultdict(Counter) for _ in [0]*11]
dp[0][0][0] = 0
for i in range(1, 11):
for used, counter in dp[i-1].items():
for j in filter(lambda x: used & 2**x == 0, range(10)):
for total, count in counter.items():
dp[i][used|2**j][total+j*i] += 1
for n, s in (map(int, l.rstrip().split()) for l in sys.stdin):
print(sum(v for counter in dp[n].values() for k, v in counter.items() if k == s))
| 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s757508718 | p00070 | Wrong Answer | import time
n = raw_input().split()
s = int(n[1])
n = int(n[0])
ans = 0
def dfs(pos, tmp, tabo):
#print "pos = %d, tmp = %d" % (pos, tmp)
#print tabo
#time.sleep(1)
if (pos > n + 1 or tmp > s):
return
if (pos == n + 1 and tmp == s):
global ans
ans += 1
return
for i in range(10):
if i not in tabo:
n_tmp = tmp + pos * i
n_tabo = list(tabo)
n_tabo.append(i)
dfs(pos + 1, n_tmp, n_tabo)
tabo = []
dfs(1, 0, tabo)
print ans | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s555164591 | p00070 | Wrong Answer | n = raw_input().split()
s = int(n[1])
n = int(n[0])
ans = 0
def dfs(pos, tmp, tabo):
if (pos > n + 1 or tmp > s):
return
if (pos == n + 1 and tmp == s):
global ans
ans += 1
return
for i in range(10):
if i not in tabo:
n_tmp = tmp + pos * i
n_tabo = list(tabo)
n_tabo.append(i)
dfs(pos + 1, n_tmp, n_tabo)
tabo = []
dfs(1, 0, tabo)
print ans | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s652503264 | p00070 | Wrong Answer | import itertools
while True:
try:
n,s = map(int,raw_input().split())
except EOFError:
break
num = list(itertools.combinations(xrange(10), n))
count = 0
for var in num:
if sum(var) == s:
count += 1
print count | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s006755182 | p00070 | Wrong Answer | import itertools
while True:
try:
n,s = map(int,raw_input().split())
except EOFError:
break
count = 0
for var in itertools.combinations(range(0, 10), n):
if sum(var) == s : count += 1
print count | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s988596424 | p00070 | Wrong Answer | import sys
def memoize(f):
memo = {}
def main(*args):
if args in memo:
return memo[args]
result = memo[args] = f(*args)
return result
return main
@memoize
def get_num(remains):
result = set()
i = 0
while remains:
if remains & 1:
result.add(i)
i += 1
remains >>= 1
return result
@memoize
def calc(n, s, remains):
if not n:
if s:
return 0
else:
return 1
if s <= 0:
return 0
rs = get_num(remains)
return sum(calc(n - 1, s - n * m, remains ^ (1 << m)) for m in rs)
for line in sys.stdin:
n, s = map(int, line.split())
print(calc(n, s, (1 << 10) - 1)) | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s852583653 | p00070 | Wrong Answer | import sys
def oncount(x):
r=0
while x>0:
r+=x&1
x=x>>1
return r
dp=[[0]*331 for i in range(1024)]
for i in range(1024):
for j in range(331):
t=oncount(i)
for k in range(10):
if 1&(i>>k):
x=j-t*k
if x>=0: dp[i][j]+=dp[i&~(1<<k)][x]
for a in sys.stdin:
n,s=map(int,a.split())
ans=0
if 1<=n<=10 and 0<=s<=330:
for i in range(1024):
if oncount(i)==n:ans+=dp[i][s]
print ans | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s426780650 | p00070 | Wrong Answer | import sys
def oncount(x):
r=0
while x>0:
r+=x&1
x=x>>1
return r
dp=[[0]*331 for i in range(1024)]
for i in range(1024):
for j in range(331):
t=oncount(i)
for k in range(10):
if 1&(i>>k):
x=j-t*k
if x>=0: dp[i][j]+=dp[i&~(1<<k)][x]
for a in sys.stdin:
n,s=map(int,a.split())
ans=0
if s<=330:
for i in range(1024):
if oncount(i)==n:ans+=dp[i][s]
print ans | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s380837969 | p00070 | Wrong Answer | import sys
def oncount(x):
r=0
while x>0:
r+=x&1
x=x>>1
return r
dp=[[0]*331 for i in range(1024)]
for i in range(10):
dp[1<<i][i]=1
for i in range(1024):
for j in range(331):
t=oncount(i)
for k in range(10):
if 1&(i>>k):
x=j-t*k
if x>=0: dp[i][j]+=dp[i&~(1<<k)][x]
for a in range(1):
n,s=map(int,raw_input().split())
ans=0
if s<=330:
for i in range(1024):
if oncount(i)==n:ans+=dp[i][s]
print ans | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s569115420 | p00070 | Wrong Answer | def solve(used,rest,sum,memo):
if rest==0:
return sum==0
else:
num=0
for i in range(10):
num*=2
if used[i]:num+=1
if (num,rest,sum) in memo:
return memo[(num,rest,sum)]
if sum<0:return 0
if sum>maxs[rest]:return 0
ans=0
for i in range(10):
if not used[i]:
used[i]=True
ans+=solve(used,rest-1,sum-(i)*rest,memo)
used[i]=False
memo[(num,rest,sum)]=ans
return memo[(num,rest,sum)]
memo={}
while True:
try:
n,s=map(int,input().split())
used=[False for i in range(10)]
ans=solve(used,n,s,memo)
print(ans)
except:
break | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s944932726 | p00070 | Wrong Answer | import itertools
n, s = map(int, raw_input().split())
x = []
for i in range(10):
x.append(i)
a = list(itertools.permutations(x, n))
u = 0
m = 0
for i in range(len(a)):
for j in range(n):
u += a[i][j] * (j + 1)
if s == u:
m += 1
u = 0
print m | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s557926502 | p00070 | Wrong Answer | def check(s_i, n_i, count, i_set, memo):
if (s_i, n_i) in memo:
return memo[(s, n)]
for i in range(9):
i_set_tmp = set(i_set)
if i not in i_set:
continue
if s_i == 0 and n_i == 0:
return count + 1
elif s_i < 0 or n_i < 0:
break
else:
s_tmp = s_i - i*n_i
n_tmp = n_i - 1
i_set_tmp.remove(i)
count = check(s_tmp, n_tmp, count, i_set_tmp, memo)
return count
memo = {}
i_list = [i for i in range(10)]
while True:
try:
n, s = map(int, input().split())
ans = check(s, n, 0, set(i_list), memo)
memo[(s, n)] = ans
print(ans)
except:
break
| 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s391707296 | p00070 | Wrong Answer | s_max = [0]
for i in range(1,11):
s = 0
for j in range(i):
s += (10 - j - 1)*(i - j)
s_max.append(s)
s_min = [0,1,4,10,20,35,56,84,120]
def check(s_i, n_i, count, i_set):
for i in range(9):
i_set_tmp = set(i_set)
if i not in i_set:
continue
if s_i > s_max[n_i] or s_i < s_min[n_i]:
continue
if s_i == 0 and n_i == 0:
return count + 1
elif s_i < 0 or n_i < 0:
break
else:
s_tmp = s_i - i*n_i
n_tmp = n_i - 1
i_set_tmp.remove(i)
count = check(s_tmp, n_tmp, count, i_set_tmp)
return count
i_list = [i for i in range(10)]
while True:
try:
n, s = map(int, input().split())
ans = check(s, n, 0, set(i_list))
print(ans)
except:
break
| 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s284251393 | p00070 | Wrong Answer | import sys,itertools
for l in sys.stdin.readlines():
n,s=map(int,l.rstrip().split())
ans=0
for d in itertools.combinations(range(10),n):
if sum(d)==s: ans+=1
print ans | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s169689732 | p00070 | Wrong Answer |
import sys
import itertools
table = [{}] * 11
def solv(n, s):
if s > 330:
return 0
r = 0
if table[n]:
for ps in table[n].keys():
if table[n][ps] == s:
r += 0
else:
for p in itertools.permutations(xrange(10), n):
s0 = foo(p, n)
table[n][str(p)] = s0
if s0 == s:
r += 1
return r
def foo(perm, n):
return sum(map(lambda x, y: x * y, xrange(1, n+1), perm))
for line in sys.stdin:
n, s = map(int, line.split(' '))
print solv(n, s) | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s067383517 | p00070 | Wrong Answer |
import sys
import itertools
table = [{}] * 11
def solv(n, s):
if s > 330:
return 0
r = 0
if table[n]:
for ps in table[n].keys():
if table[n][ps] == s:
r += 0
else:
for p in itertools.permutations(xrange(10), n):
s0 = foo(p, n)
table[n][p] = s0
if s0 == s:
r += 1
return r
def foo(perm, n):
return sum(map(lambda x, y: x * y, xrange(1, n+1), perm))
for line in sys.stdin:
n, s = map(int, line.split(' '))
print solv(n, s) | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s033161863 | p00070 | Wrong Answer |
import sys
import itertools
table = [{}] * 11
def solv(n, s):
r = 0
if table[n]:
for ps in table[n].keys():
if table[n][ps] == s:
r += 0
else:
for p in itertools.permutations(xrange(10), n):
s0 = foo(p, n)
table[n][p] = s0
if s0 == s:
r += 1
return r
def foo(perm, n):
return sum(map(lambda x, y: x * y, xrange(1, n+1), perm))
for line in sys.stdin:
n, s = map(int, line.split(' '))
print solv(n, s) | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s098797982 | p00070 | Wrong Answer |
import sys
import itertools
table = [{}] * 11
def solv(n, s):
r = 0
if table[n]:
for ps in table[n].keys():
if table[n][ps] == s:
r += 1
else:
for p in itertools.permutations(xrange(10), n):
s0 = foo(p, n)
table[n][p] = s0
if s0 == s:
r += 1
return r
def foo(perm, n):
return sum(map(lambda x, y: x * y, xrange(1, n+1), perm))
for line in sys.stdin:
n, s = map(int, line.split(' '))
print solv(n, s) | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s939475044 | p00070 | Wrong Answer |
import sys
import itertools
table = [{}] * 11
def solv(n, s):
if s > 330:
return 0
r = 0
if table[n]:
for ps in table[n].keys():
if table[n][ps] == s:
r += 1
else:
for p in itertools.permutations(xrange(10), n):
s0 = foo(p, n)
table[n][p] = s0
if s0 == s:
r += 1
return r
def foo(perm, n):
return sum(map(lambda x, y: x * y, xrange(1, n+1), perm))
for line in sys.stdin:
n, s = map(int, line.split(' '))
print solv(n, s) | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s163018240 | p00070 | Wrong Answer | import sys
import itertools
table = [{}] * 11
def solv(n, s):
if s > 330:
return 0
r = 0
dic = table[n]
if dic:
for ps in dic.keys():
if dic[ps] == s:
r += 1
else:
for p in itertools.permutations(xrange(10), n):
s0 = foo(p, n)
dic[p] = s0
if s0 == s:
r += 1
return r
def foo(perm, n):
return sum(map(lambda x, y: x * y, xrange(1, n+1), perm))
for line in sys.stdin:
n, s = map(int, line.split(' '))
print solv(n, s) | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s551775046 | p00070 | Wrong Answer | import itertools,sys
for a in sys.stdin:
c=0
n,s=map(int,a.split())
for e in itertools.permutations(range(9),n):
x=0
i=n
for b in e:
x+=i*b
i-=1
if x>s:break
else:
if x==s: c+=1
print c | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s239555792 | p00070 | Wrong Answer | def mx(ls,m):
sum = 0
for i in range(m):
sum += (m-i)*ls[-i-1]
return sum
def f(ls,m,s):
global n
if mx(ls,m) < s: return 0
count = 0
if m > 0:
for i in range(len(ls)):
lls = ls[:]
a = (n-m+1)*lls.pop(i)
if s-a < 0: break
else: count += f(lls,m-1,s-a)
return count
else:
return 1 if s == 0 else 0
ls = [i for i in range(10)]
while True:
try:
n,s = map(int, raw_input().split())
print f(ls,n,s)
except:
break | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s277025947 | p00070 | Wrong Answer | def mx(ls,m):
sum = 0
for i in range(m):
sum += (m-i)*ls[-i-1]
return sum
def f(ls,m,s):
global n
count = 0
if m > 0:
if mx(ls,m) < s: return 0
for i in range(len(ls)):
lls = ls[:]
a = (n-m+1)*lls.pop(i)
if s-a < 0: break
else: count += f(lls,m-1,s-a)
return count
else:
return 1 if s == 0 else 0
ls = [i for i in range(10)]
while True:
try:
n,s = map(int, raw_input().split())
print f(ls,n,s)
except:
break | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s201532427 | p00070 | Time Limit Exceeded | from functools import reduce
from itertools import permutations
import sys
for n, s in (map(int, l.rstrip().split()) for l in sys.stdin):
print(len([1 for a in permutations(range(10), n) if sum(i*n for i,n in enumerate(a, start=1))==s]))
| 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s797294486 | p00070 | Time Limit Exceeded | def dfs(pos, tmp, tabo):
if (pos > n + 1 or tmp > s):
return
if (pos == n + 1 and tmp == s):
global ans
ans += 1
return
for i in range(10):
if i not in tabo:
n_tmp = tmp + pos * i
n_tabo = list(tabo)
n_tabo.append(i)
dfs(pos + 1, n_tmp, n_tabo)
while True:
try:
n = raw_input().split()
s = int(n[1])
n = int(n[0])
tabo = []
global ans
ans = 0
dfs(1, 0, tabo)
print ans
except:
break | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s364681574 | p00070 | Time Limit Exceeded | ans = [[0 for i in range(1024)] for j in range(12)]
def dfs(bit, d, s):
ans[d][s] += 1
for i in range(0, 10):
if (bit & (1 << i)):
dfs(bit - (1 << i), d + 1, s + (i * (d + 1)))
dfs((1 << 10) - 1, 0, 0)
while True:
try:
n,s = map(int, raw_input().split())
if (s > 1023):
print 0
else:
print ans[n][s]
except:
break | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s505422734 | p00070 | Time Limit Exceeded | import sys
import itertools
def func(li,nu,su):
count = 0
if su == 0 and 0 not in li :
return 1
elif su < 0 or nu <= 0 or len(li) == 0:
return 0
for e in li:
lisdot = [ f for f in li if not f == e ]
count += func(lisdot,nu-1,su-e*nu)
return count
lis = range(10)
for y in sys.stdin:
n,s = map(int,y.split())
print func(lis,n,s) | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s384292482 | p00070 | Time Limit Exceeded | import sys
cnt = 0
def solve(n,s,lis):
global cnt
if n<0 or s<0:
return 0
elif n == 0 and s == 0:
cnt += 1
return 0
else :
for i in xrange(len(lis)):
solve(n-1,s-n*lis[i],[ lis[j] for j in xrange(len(lis)) if not i == j ])
return cnt
for s in sys.stdin:
cnt = 0
n,s = map(int,s.split())
lis = range(10)
print solve(n,s,lis) | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s233160003 | p00070 | Time Limit Exceeded | import sys
cnt = 0
def solve(n,s,lis):
global cnt
if n<0 or s<0:
return 0
elif n == 0 and s == 0:
cnt += 1
return 0
else :
for i in xrange(len(lis)):
ll = lis[:]
a = s-n*ll.pop(i)
solve(n-1,a,ll )
return cnt
for s in sys.stdin:
cnt = 0
n,s = map(int,s.split())
lis = range(10)
print solve(n,s,lis) | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s184874887 | p00070 | Time Limit Exceeded | import sys
cnt = 0
def solve(n,s,lis):
global cnt
if n<0 or s<0:
return 0
elif n == 0 and s == 0:
cnt += 1
return 0
else :
for i in xrange(len(lis)):
ll = lis[:]
a = s-n*ll.pop(i)
if n-1 < 0 or a<0:
break
solve(n-1,a,ll )
return cnt
for s in sys.stdin:
cnt = 0
n,s = map(int,s.split())
lis = range(10)
print solve(n,s,lis) | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s539109197 | p00070 | Time Limit Exceeded | import sys
cnt = 0
def solve(n,s,lis):
global cnt
if n == 0 and s == 0:
cnt += 1
return 0
else :
for i in xrange(len(lis)):
ll = lis[:]
a = s-n*ll.pop(i)
if n-1<0 or a<0:
break
solve(n-1,a,ll )
return cnt
for s in sys.stdin:
cnt = 0
n,s = map(int,s.split())
lis = range(10)
print solve(n,s,lis) | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s767472974 | p00070 | Time Limit Exceeded | import itertools
import sys
f = sys.stdin
for line in f:
n, s = map(int, line.split())
print(sum(1 for k in itertools.permutations(range(10), n) if s == sum(k[i] * (i + 1) for i in range(n)))) | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s571169202 | p00070 | Time Limit Exceeded | import sys
f = sys.stdin
def solve(k,n,s):
if n == 1:
return 1 if s in k else 0
ret = 0
for ki in k:
value = n * ki
if s >= value:
sub = k[:]
sub.remove(ki)
ret += solve(sub,n - 1,s - value)
return ret
for line in f:
n, s = map(int, line.split())
print(solve(list(range(10)),n,s)) | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s613082317 | p00070 | Time Limit Exceeded | import sys
f = sys.stdin
def solve(k,n,s):
if n == 1:
return 1 if s in k else 0
ret = 0
for ki in k:
value = n * ki
if s >= value:
sub = k[:]
sub.remove(ki)
mini = sum(i * j for i, j in zip(range(n - 1,0,-1), sub))
maxi = sum(i * j for i, j in zip(range(n - 1,0,-1), sub[::-1]))
if mini <= s - value <= maxi:
ret += solve(sub,n - 1,s - value)
return ret
for line in f:
n, s = map(int, line.split())
print(solve(list(range(10)),n,s))
| 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s110177488 | p00070 | Time Limit Exceeded | import sys
def shy(c_p, m_c, flag):
for i in range(m_c):
k.append(c_p + i)
if flag == n:
hope(k)
else:
shy(c_p+i+1, m_c, flag+1)
m_c -= 1
del k[-1]
def hope(k):
global count
if k:
for i, v in enumerate(k):
three.append(v)
hope(k[:i]+k[i+1:])
del three[-1]
else:
ans = 0
for i in range(n):
multiple = i+1
ans += (multiple * three[i])
else:
if ans == s:
count += 1
for line in sys.stdin:
n, s = map(int, line.rstrip().split())
k = []
three = []
count = 0
m_c = 10 - n + 1
shy(0, m_c, 1)
print count | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s057854404 | p00070 | Time Limit Exceeded | def get_s():
while True:
try:
yield raw_input()
except EOFError:
break
def shy(c_p, m_c, flag):
for i in range(m_c):
k.append(c_p + i)
if flag == n:
hope(k)
else:
shy(c_p+i+1, m_c, flag+1)
m_c -= 1
del k[-1]
def hope(k):
global count
if k:
for i, v in enumerate(k):
three.append(v)
hope(k[:i]+k[i+1:])
del three[-1]
else:
ans = 0
for i in range(n):
multiple = i+1
ans += (multiple * three[i])
else:
if ans == s:
count += 1
for line in list(get_s()):
n, s = map(int, line.split())
three = []
k = []
count = 0
m_c = 10 - n + 1
shy(0, m_c, 1)
print count | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s840946753 | p00070 | Time Limit Exceeded | def get_s():
while True:
try:
yield raw_input()
except EOFError:
break
def shy(c_p, m_c, flag):
for i in range(m_c):
k.append(c_p + i)
if flag == n:
hope(k)
else:
shy(c_p+i+1, m_c, flag+1)
m_c -= 1
del k[-1]
def hope(k):
global count
if k:
for i, v in enumerate(k):
three.append(v)
hope(k[:i]+k[i+1:])
del three[-1]
else:
ans = 0
for i in range(n):
multiple = i+1
ans += (multiple * three[i])
else:
if ans == s:
count += 1
a = list(get_s())
for line in a:
n, s = map(int, line.split())
three = []
k = []
count = 0
m_c = 10 - n + 1
shy(0, m_c, 1)
print count | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s338734499 | p00070 | Time Limit Exceeded | import sys
def shy(c_p, m_c, flag):
for i in range(m_c):
k.append(c_p + i)
if flag == n:
hope(k)
else:
shy(c_p+i+1, m_c, flag+1)
m_c -= 1
del k[-1]
def hope(k):
global count
if k:
for i, v in enumerate(k):
three.append(v)
hope(k[:i]+k[i+1:])
del three[-1]
else:
ans = 0
for i in range(n):
multiple = i+1
ans += (multiple * three[i])
else:
if ans == s:
count += 1
for line in sys.stdin:
n, s = map(int, line.split())
k = []
three = []
count = 0
m_c = 10 - n + 1
shy(0, m_c, 1)
print count | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s717706595 | p00070 | Time Limit Exceeded | def shy(c_p, m_c, flag):
for i in range(m_c):
k.append(c_p + i)
if flag == n:
hope(k)
else:
shy(c_p+i+1, m_c, flag+1)
m_c -= 1
del k[-1]
def hope(k):
global count
if k:
for i, v in enumerate(k):
three.append(v)
hope(k[:i]+k[i+1:])
del three[-1]
else:
ans = 0
for i in range(n):
multiple = i+1
ans += (multiple * three[i])
else:
if ans == s:
count += 1
while True:
try:
n, s = map(int, raw_input().split())
k = []
three = []
count = 0
m_c = 10 - n + 1
shy(0, m_c, 1)
print count
except EOFError:
break | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s702555856 | p00070 | Time Limit Exceeded | import sys
from itertools import permutations
for line in sys.stdin:
n, s = map(int, line.split())
count = 0
for combi in permutations(range(10), n):
if sum(x * y for (x, y) in zip(range(1, 10), combi)) == s:
count += 1
print(count) | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s163789508 | p00070 | Time Limit Exceeded | def dfs(cnt,wa):
global ans
if cnt==n+1:return
if wa==0 and cnt==n:
ans+=1
return
for i in xrange(10):
if not used[i]:
used[i]=True
dfs(cnt+1,wa-(cnt+1)*i)
used[i]=False
return
while 1:
try:
n,s=map(int,raw_input().split())
ans=0
used=[False]*10
dfs(0,s)
print(ans)
except:
break | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s873609812 | p00070 | Time Limit Exceeded | import sys
def line():return sys.stdin.readline().strip()
import itertools
k = (0,1,2,3,4,5,6,7,8,9)
while True:
try:
cnt = 0
n,s = map(int,line().split())
for tpl in itertools.permutations(k,n):
t = 0
for i in range(len(tpl)): t+=tpl[i] * (i + 1)
if t == s:cnt+=1
print(cnt)
except:
break | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s155844694 | p00070 | Time Limit Exceeded | # ??°??????????????????????????§???????????°??????
import sys
def get_sequence(s, n, k, ks):
# s : ????¨?
# n : n????????°???
# k : k???????????°???????????????(1???10)
# ks: ?????¨?????????????????°???
if k == n:
if s % k == 0:
if s // k in ks:
#print('s:{} k:{} n:{} ks:'.format(s, k, n), end='')
print(ks)
return 1
else:
return 0
else:
return 0
cnt = 0
for i in ks:
s_copy = s
s_copy -= i * k
if s_copy < 0:
break
k_copy = k
k_copy += 1
if k_copy > n:
break
ks_copy = ks[:]
ks_copy.remove(i)
#print('i:', i)
cnt += get_sequence(s_copy, n, k_copy, ks_copy)
return cnt
def main():
while True:
line = sys.stdin.readline().strip()
if line is None or line == '':
break
data = line.split(' ')
n = int(data[0])
s = int(data[1])
cnt = get_sequence(s, n, 1, list(range(10)))
print(cnt)
if __name__ == '__main__':
main() | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s387684667 | p00070 | Time Limit Exceeded | # ??°??????????????????????????§???????????°??????
import sys
def get_sequence(s, n, k, ks):
# s : ????¨?
# n : n????????°???
# k : k???????????°???????????????(1???10)
# ks: ?????¨?????????????????°???
if k == n:
if s % k == 0:
if s // k in ks:
#print('s:{} k:{} n:{} ks:'.format(s, k, n), end='')
#print(ks)
return 1
else:
return 0
else:
return 0
cnt = 0
for i in ks:
s_copy = s
s_copy -= i * k
if s_copy < 0:
break
k_copy = k
k_copy += 1
if k_copy > n:
break
ks_copy = ks[:]
ks_copy.remove(i)
#print('i:', i)
cnt += get_sequence(s_copy, n, k_copy, ks_copy)
return cnt
def main():
while True:
line = sys.stdin.readline().strip()
if line is None or line == '':
break
data = line.split(' ')
n = int(data[0])
s = int(data[1])
cnt = get_sequence(s, n, 1, list(range(10)))
print(cnt)
if __name__ == '__main__':
main() | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s487145602 | p00070 | Time Limit Exceeded | # ??°??????????????????????????§???????????°??????
import sys
def get_max():
numbers = list(range(10))
sum = 0
for idx, num in enumerate(numbers, 1):
sum += (idx * num)
return sum
def get_sequence(s, n, k, ks):
# s : ????¨?
# n : n????????°???
# k : k???????????°???????????????(1???10)
# ks: ?????¨?????????????????°???
if k == n:
if s % k == 0 and s // k in ks:
return 1
else:
return 0
cnt = 0
for i in ks:
s_copy = s
s_copy -= i * k
if s_copy < 0:
break
k_copy = k
k_copy += 1
if k_copy > n:
break
ks_copy = ks[:]
ks_copy.remove(i)
cnt += get_sequence(s_copy, n, k_copy, ks_copy)
return cnt
def main():
max_s = get_max()
while True:
line = sys.stdin.readline().strip()
if line is None or line == '':
break
data = line.split(' ')
n = int(data[0])
s = int(data[1])
if s > max_s:
print(0)
else:
cnt = get_sequence(s, n, 1, list(range(10)))
print(cnt)
if __name__ == '__main__':
main() | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s537706684 | p00070 | Time Limit Exceeded | # ??°??????????????????????????§???????????°??????
import sys
def get_max(n):
numbers = list(range(n))
sum = 0
for idx, num in enumerate(numbers, 1):
sum += (idx * num)
return sum
def get_sequence(s, n, k, ks):
# s : ????¨?
# n : n????????°???
# k : k???????????°???????????????(1???10)
# ks: ?????¨?????????????????°???
if k == n:
if s % k == 0 and s // k in ks:
return 1
else:
return 0
cnt = 0
for i in ks:
s_copy = s
s_copy -= i * k
if s_copy < 0:
break
k_copy = k
k_copy += 1
if k_copy > n:
break
ks_copy = ks[:]
ks_copy.remove(i)
cnt += get_sequence(s_copy, n, k_copy, ks_copy)
return cnt
def main():
while True:
line = sys.stdin.readline().strip()
if line is None or line == '':
break
data = line.split(' ')
n = int(data[0])
s = int(data[1])
max_s = get_max(n)
if s > max_s:
print(0)
else:
cnt = get_sequence(s, n, 1, list(range(10)))
print(cnt)
if __name__ == '__main__':
main() | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s954953077 | p00070 | Time Limit Exceeded | # ??°??????????????????????????§???????????°??????
import sys
def get_max():
max_s = []
for i in range(1, 11):
sum = 0
for j in range(i):
sum += (9-j) * (i-j)
max_s.append(sum)
return max_s
def get_sequence(s, n, k, ks):
# s : ????¨?
# n : n????????°???
# k : k???????????°???????????????(1???10)
# ks: ?????¨?????????????????°???
if k == n:
if s % k == 0 and s // k in ks:
return 1
else:
return 0
cnt = 0
for i in ks:
s_copy = s
s_copy -= i * k
if s_copy < 0:
break
k_copy = k
k_copy += 1
if k_copy > n:
break
ks_copy = ks[:]
ks_copy.remove(i)
cnt += get_sequence(s_copy, n, k_copy, ks_copy)
return cnt
def main():
max_s = get_max()
print(max_s)
while True:
line = sys.stdin.readline().strip()
if line is None or line == '':
break
data = line.split(' ')
n = int(data[0])
s = int(data[1])
if s > max_s[n-1]:
print(0)
else:
cnt = get_sequence(s, n, 1, list(range(10)))
print(cnt)
if __name__ == '__main__':
main() | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s884631023 | p00070 | Time Limit Exceeded | # ??°??????????????????????????§???????????°??????
import sys
def get_max():
max_s = []
for i in range(1, 11):
sum = 0
for j in range(i):
sum += (9-j) * (i-j)
max_s.append(sum)
return max_s
def get_sequence(s, n, k, ks):
# s : ????¨?
# n : n????????°???
# k : k???????????°???????????????(1???10)
# ks: ?????¨?????????????????°????????????
if k == n:
if s % k == 0 and s // k in ks:
return 1
else:
return 0
if k > n:
return 0
cnt = 0
for i in ks:
s_copy = s
s_copy -= i * k
if s_copy < 0:
break
ks_copy = ks[:]
ks_copy.remove(i)
cnt += get_sequence(s_copy, n, k+1, ks_copy)
return cnt
def main():
max_s = get_max()
print(max_s)
while True:
line = sys.stdin.readline().strip()
if line is None or line == '':
break
data = line.split(' ')
n = int(data[0])
s = int(data[1])
if s > max_s[n-1]:
print(0)
else:
cnt = get_sequence(s, n, 1, list(range(10)))
#print(cnt)
if __name__ == '__main__':
main() | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s221316694 | p00070 | Time Limit Exceeded | # ??°??????????????????????????§???????????°??????
import sys
def get_min_max():
max_s = []
for i in range(1, 11):
max_sum = 0
min_sum = 0
for j in range(i):
max_sum += (9-j) * (i-j)
min_sum += j * (i-j)
max_s.append([min_sum, max_sum])
return max_s
def get_sequence(s, n, k, ks):
# s : ????¨?
# n : n????????°???
# k : k???????????°???????????????(1???10)
# ks: ?????¨?????????????????°????????????
if k == n:
if s % k == 0 and s // k in ks:
return 1
else:
return 0
if k > n:
return 0
cnt = 0
for i in ks:
s_copy = s
s_copy -= i * k
if s_copy < 0:
break
ks_copy = ks[:]
ks_copy.remove(i)
cnt += get_sequence(s_copy, n, k+1, ks_copy)
return cnt
def main():
min_max_s = get_min_max()
while True:
line = sys.stdin.readline().strip()
if line is None or line == '':
break
data = line.split(' ')
n = int(data[0])
s = int(data[1])
if s < min_max_s[n-1][0] or s > min_max_s[n-1][1]:
print(0)
else:
cnt = get_sequence(s, n, 1, list(range(10)))
print(cnt)
if __name__ == '__main__':
main() | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
s536994644 | p00070 | Time Limit Exceeded | # ??°??????????????????????????§???????????°??????
import sys
import itertools
def get_min_max():
max_s = []
for i in range(1, 11):
max_sum = 0
min_sum = 0
for j in range(i):
max_sum += (9-j) * (i-j)
min_sum += j * (i-j)
max_s.append([min_sum, max_sum])
return max_s
def get_sequence(s, n, k, ks):
# s : ????¨?
# n : n????????°???
# k : k???????????°???????????????(1???10)
# ks: ?????¨?????????????????°????????????
#print(s)
cnt = 0
l = list(range(10))
for nums in itertools.combinations(l, n):
for num in itertools.permutations(nums, len(nums)):
if num == (4, 0, 2):
print('**** (4, 0, 2) ****')
sum = 0
for index, i in enumerate(num, 1):
sum += index * i
if sum == s:
#print('num:', num)
cnt += 1
if n == 10:
break # ?¬????nums???????????????
return cnt
def main():
min_max_s = get_min_max()
while True:
line = sys.stdin.readline().strip()
if line is None or line == '':
break
data = line.split(' ')
n = int(data[0])
s = int(data[1])
if s < min_max_s[n-1][0] or s > min_max_s[n-1][1]:
print(0)
else:
cnt = get_sequence(s, n, 1, list(range(10)))
print(cnt)
if __name__ == '__main__':
main() | 3 10
3 1
| 8
0
|
<H1>Combination of Number Sequences</H1>
<p>
0 から 9 までの整数を使った <var>n</var> 個の数の並び <var>k<sub>1</sub></var>, <var>k<sub>2</sub></var>, ..., <var>k<sub>n</sub></var> を考えます。正の整数 <var>n</var> と <var>s</var> を読み込んで、<br/>
<br/>
<var>k<sub>1</sub> + 2 × k<sub>2</sub> + 3 × k<sub>3</sub> +</var> ... <var>+ n × k<sub>n</sub> = s </var><br/>
<br/>
となっているような <var>n</var> 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「<var>n</var> 個の数の並び」には同じ数が 2 回以上現われないものとします。
</p>
<H2>Input</H2>
<p>
入力は複数のデータセットからなります。各データセットとして、<var>n</var> (1 ≤ <var>n</var> ≤ 10) と <var>s</var> (0 ≤ <var>s</var> ≤ 10,000)が空白区切りで１行に与えられます。
</p>
<p>
データセットの数は 100 を超えません。
</p>
<H2>Output</H2>
<p>
データセットごとに、<var>n</var> 個の整数の和が <var>s</var> になる組み合わせの個数を１行に出力します。
</p>
<H2>Sample Input</H2>
<pre>
3 10
3 1
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
0
</pre>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.