submission_id string | problem_id string | status string | code string | input string | output string | problem_description string |
|---|---|---|---|---|---|---|
s147516259 | p00040 | Accepted | A2Z="abcdefghijklmnopqrstuvwxyz"
def decode(L1,L2,msg):
x=[]
for c in msg:
if 'a'<=c<='z':
c = L2[L1.index(c)]
x.append(c)
return "".join(x)
def affine(msg, key):
a,b = key
L = [A2Z[(i*a+b)%26] for i in range(26)]
L = "".join(L)
return decode(A2Z,L,msg)
def rot(msg, a):
if a==0: return msg
a = a % 26
L = A2Z[a:]+A2Z[:a]
return decode(A2Z,L,msg)
def find(msg):
c0=ord('t')
for i in range(26):
x = affine(msg,[i,0])
a = (c0-ord(x[0]))%26
x = rot(x,a)
if x in['this','that']: return [i,a]
return []
n = input()
for i in range(n):
msg = raw_input()
for w in msg.split():
if len(w)==4:
key = find(w)
if key!=[]: break
print affine(msg,key) | 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
|
s406183810 | p00040 | Accepted | dict = ["a","b","c","d","e","f","g","h","i","j","k","l","m",\
"n","o","p","q","r","s","t","u","v","w","x","y","z"]
lsalpha = [1,3,5,7,9,11,15,17,19,21,23,25]
n = int(raw_input())
for roop in range(n):
code = raw_input()
for alpha in lsalpha:
flag = 0
for beta in range(26):
decode = ""
for chara in code:
if chara != " ":
f = dict.index(chara)
for i in range(26):
if (alpha*i + beta)%26 == f:
dechara = dict[i]
break
decode += dechara
else:
decode += " "
if decode.count("that") > 0 or decode.count("this") > 0:
flag = 1
break
if flag == 1:
break
print decode | 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
|
s086786660 | p00040 | Accepted | dict = ["a","b","c","d","e","f","g","h","i","j","k","l","m",\
"n","o","p","q","r","s","t","u","v","w","x","y","z"]
lsalpha = [1,3,5,7,9,11,15,17,19,21,23,25]
def decode(alpha, beta, code):
msg = ""
for chara in code:
if chara != " ":
f = dict.index(chara)
for i in range(26):
if (alpha*i + beta)%26 == f:
dechara = dict[i]
break
msg += dechara
else:
msg += " "
return msg
n = int(raw_input())
for roop in range(n):
code = raw_input()
for alpha in lsalpha:
flag = 0
for beta in range(26):
msg = decode(alpha, beta, code)
if msg.count("that") > 0 or msg.count("this") > 0:
flag = 1
break
if flag == 1:
break
print msg | 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
|
s933588050 | p00040 | Accepted | import string
A2Z="abcdefghijklmnopqrstuvwxyz"
def decode(msg,L):
t = string.maketrans(A2Z,L)
s = string.translate(msg,t)
return s
def affine(msg, a, b):
L = "".join([A2Z[(i*a+b)%26]for i in range(26)])
return decode(msg,L)
def rot(msg, a):
a = a % 26
L = "".join(A2Z[a:]+A2Z[:a])
return decode(msg,L)
def checkkey(s):
c0="t"
for i in range(26):
a = 0
x = affine(s,i,0)
if x[0]!=c0:
a = (ord(c0)-ord(x[0]))%26
x = rot(x,a)
if x in['this','that']: return i,a
return -1,-1
n = input()
for i in range(n):
s = raw_input()
for w in s.split():
if len(w)==4:
a,b = checkkey(w)
if a!=-1: break
print affine(s,a,b) | 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
|
s231996323 | p00040 | Accepted | import string
A2Z="abcdefghijklmnopqrstuvwxyz"
R=range(26)
def decode(msg,L):
x=""
for c in msg: x+=(L[A2Z.index(c)] if "a"<=c<="z" else c)
return x
def affine(msg, a, b):
L="".join([A2Z[(i*a+b)%26]for i in R])
s = decode(msg,L)
return s
def rot(msg, a):
a = a % 26
L = A2Z[a:]+A2Z[:a]
s = decode(msg,L)
return s
def checkkey(s):
c0="t"
for i in R:
a = 0
x = affine(s,i,0)
c = A2Z.index(x[0])
if c!=19:
a = (19-c)%26
x = rot(x,a)
if x in['this','that']: return i,a
return -1,-1
n = input()
while n:
n-=1
s = raw_input()
for w in s.split():
if len(w)==4:
a,b = checkkey(w)
if a!=-1: break
print affine(s,a,b) | 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
|
s708195413 | p00040 | Accepted | A2Z="abcdefghijklmnopqrstuvwxyz"
def affine(msg, a, b):
s=""
for c in msg: s+=(A2Z[(A2Z.index(c)*a+b)%26] if "a"<=c<="z" else c)
return s
def rot(msg, a):
a = a % 26
L = A2Z[a:]+A2Z[:a]
s=""
for c in msg: s+=(L[A2Z.index(c)] if "a"<=c<="z" else c)
return s
def checkkey(s):
c0="t"
for i in range(26):
a = 0
x = affine(s,i,0)
c = A2Z.index(x[0])
if c!=19:
a = (19-c)%26
x = rot(x,a)
if x in['this','that']: return i,a
return -1,-1
n = input()
while n:
n-=1
s = raw_input()
for w in s.split():
if len(w)==4:
a,b = checkkey(w)
if a!=-1: break
print affine(s,a,b) | 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
|
s755740495 | p00040 | Accepted | A2Z="abcdefghijklmnopqrstuvwxyz"
def affine(msg, a, b):
s=""
for c in msg: s+=(A2Z[(A2Z.index(c)*a+b)%26] if "a"<=c<="z" else c)
return s
def checkkey(s):
for i in range(26):
a = 0
x = affine(s,i,0)
c = A2Z.index(x[0])
if c!=19:
a = (19-c)%26
x = affine(x,1,a)
if x in['this','that']: return i,a
return -1,-1
n = input()
while n:
n-=1
s = raw_input()
for w in s.split():
if len(w)==4:
a,b = checkkey(w)
if a!=-1: break
print affine(s,a,b) | 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
|
s145565192 | p00040 | Accepted | for i in range(int(raw_input())):
s = raw_input()
for a in range(1, 1000):
for b in range(26):
def f(s, a, b):
return ''.join([chr(((ord(c) - ord('a')) * a + b) % 26 + ord('a')) for c in s])
if f('that', a, b) in s or f('this', a, b) in s:
dic = dict([(chr((i * a + b) % 26 + ord('a')), chr(i + ord('a'))) for i in range(26)])
print ''.join([dic.get(c, c) for c in s])
break
else:
continue
break | 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
|
s965659384 | p00040 | Accepted | def encode(string, a, b):
ret = ''
for x in string:
tmp = ord(x) - ord('a')
if 0 <= tmp <= 26:
ret += chr((a * tmp + b) % 26 + ord('a'))
else:
ret += x
return ret
n = input()
for t in xrange(n):
line = raw_input()
for i in xrange(1, 10000):
f = False
if not (26 % i and i % 26):
continue
for j in xrange(26):
txt = encode(line, i, j)
if 'that' in txt or 'this' in txt:
print txt
f = True
break
if f:
break | 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
|
s140142214 | p00040 | Accepted | from itertools import product
alphabet = 'abcdefghijklmnopqrstuvwxyz'
def decrypt(s):
for a in range(1, 26, 2):
if a == 13: continue
for b in range(26):
x = ''.join(chr(ord('a') + (a * i + b) % 26) for i in range(26))
t = s.translate(str.maketrans(x, alphabet))
if 'this' in t or 'that' in t:
return t
n = int(input())
for i in range(n):
s = input()
print(decrypt(s)) | 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
|
s237515283 | p00040 | Accepted | import sys
readline = sys.stdin.readline
write = sys.stdout.write
def convert(s, a, b):
res = []
ca = ord('a')
for c in s:
if c == ' ':
res.append(" ")
else:
res.append(chr((((ord(c) - ca)*a + b) % 26) + ca))
return "".join(res)
def solve():
s = readline().strip()
for a in range(26):
for b in range(26):
s1 = convert(s, a, b)
if "that" in s1 or "this" in s1:
write(s1)
write("\n")
T = int(readline())
for i in range(T):
solve()
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
|
s055717336 | p00040 | Accepted | n=int(input())
def GCD(a,b):
if min(a,b)==0:
return max(a,b)
else:
return GCD(min(a,b),max(a,b)%min(a,b))
def affine(a,b,word):
retval=""
for w in word:
retval+=chr(ord('a')+((ord(w)-ord('a'))*a+b)%26)
return retval
for i in range(n):
encrypted=input().split(" ")
for a in range(1,27):
for b in range(1,27):
if GCD(a,26)!=1:
continue
plain=[affine(a,b,s) for s in encrypted]
if ("this" in plain) or ("that" in plain):
print(" ".join(plain))
break
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
|
s452713404 | p00040 | Accepted | def affine(word, alpha, beta):
word = list(word)
for i in range(len(word)):
ascii = ((ord(word[i]) - ord('a')) * alpha + beta) % 26;
word[i] = chr(ascii + ord('a'));
return ''.join(word)
alphas = [1, 3, 5, 7, 9, 11, 15, 17, 19, 21, 23, 25]
for x in range(int(input())):
words = input().split(' ')
for alpha in range(26):
for beta in range(26):
string = list(map(lambda x: affine(x, alpha, beta), words))
if 'that' in string or 'this' in string:
print(*string)
break
else:
continue
break
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
|
s489850363 | p00040 | Accepted | n=int(input())
#最後に97を足せばよい
for i in range(n):
cty=list(input())
#αは26と互いに素
con=[1,3,5,7,9,11,13,15,17,19,21,23,25]
for alf in con:
for bet in range(26):
tmp=0
voca=[]
new=[]
while tmp<len(cty):
#単語ごとに区切る
if ord(cty[tmp])<97:
new.append(''.join(voca))
#print(new)
voca=[]
else:
voca.append(chr(((alf*(int(ord(cty[tmp])-97))+bet)%26)+97))
tmp+=1
new.append(''.join(voca))
if 'that'in new or 'this'in new:
for k in range(len(new)):
if k==len(new)-1:
print(''.join(new[k]))
else:
print(''.join(new[k]), end=' ')
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
|
s394964316 | p00040 | Accepted | m = [chr(ord('a')+i) for i in range(26)]
t = {}
for i in range(26):
t[m[i]] = i
def affine(s):
for a in range(26):
for b in range(26):
text = ''.join([m[a * (t[x] - b + 26) % 26]
if x != ' ' else ' ' for x in s])
if 'that' in text or 'this' in text:
return text
n = int(input())
for i in range(n):
print(affine(input()))
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
|
s771220184 | p00040 | Accepted | n=int(input())
for i in range(n):
import math
s=input()
s_l=list(map(str,s.split()))
s_ci=[]
for i in s_l:
if len(i)==4:
k_l=[]
for j in i:
k=ord(j)-97
k_l.append(k)
s_ci.append(k_l)
a_list=[]
for i in range(1,1000):
if math.gcd(i,26)==1:a_list.append(i)
for a in a_list:
for b in range(26):
for k in s_ci:
word=""
for l in k:
word+=chr(((l*a-b)%26)+97)
if word=="that" or word=="this":break
if word=="that" or word=="this":break
if word=="that" or word=="this":break
s_l=[]
for i in s:
if i==" ":
s_l.append(-1)
else:
k=ord(i)-97
s_l.append(k)
ans=""
for i in s_l:
if i==-1:ans+=" "
else:
ans+=chr(((i*a-b)%26)+97)
print(ans)
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
|
s511276555 | p00040 | Accepted | E = 10**-10
def decy(a):
return [ord(i)-97 for i in a]
def encr(a):
return "".join([chr(i+97) for i in a])
def deaffin(j,a,b):
cont_ = 1
for i in range(100):
if cont_ == 0:
break
elif ((j-b+26*i)/a)//1 == (j-b+26*i)/a:
cont_ = 0
return int((j-b+26*i)/a)%26
n = int(input())
for _ in range(n):
sen = input()
words = sen.split()
wordsl = [len(i) for i in words]
wordsn = [decy(i) for i in words]
fourn = []
for i in range(len(wordsl)):
if wordsl[i] == 4:
fourn.append(wordsn[i])
a_ = 0
b_ = 0
cont = 1
for a in [1,3,5,7,9,11,15,17,19,21,23,25]:
if cont != 0:
for b in range(26):
if cont != 0:
for i in fourn:
deco = [chr(deaffin(j,a,b)+97) for j in i]
if deco == ["t","h","i","s"] or deco == ["t","h","a","t"]:
a_ = a
b_ = b
cont = 0
break
dec_wordsn = [[deaffin(j,a_,b_) for j in i] for i in wordsn]
dec_words = [encr(i) for i in dec_wordsn]
print(" ".join(dec_words))
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
|
s850313452 | p00040 | Accepted | A_BASE = ord('a')
A = [1, 3, 5, 7, 9, 11, 15, 17, 19, 21, 23, 25]
def brute_force(len4s, dwords):
b = 0
for a in A:
while b < 26:
for word in len4s:
dec = [(a * r + b) % 26 for r in word]
if dec in [[19, 7, 8, 18], [19, 7, 0, 19]]:
dec_words = [''.join([chr((a*r + b) % 26 + A_BASE) for r in dw]) for dw in dwords]
return ' '.join(dec_words)
b += 1
b = 0
def solve():
n = int(input())
for _ in range(n):
text = input()
words = text.split()
dwords = [[ord(ch) - A_BASE for ch in word] for word in words]
len4s = [dw for dw in dwords if len(dw) == 4]
print(brute_force(len4s, dwords))
if __name__ == "__main__":
solve()
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
|
s487629725 | p00040 | Runtime Error | import sys
f = sys.stdin
import string
OFFSET = ord('a')
def to_gamma(c):
return ord(c) - OFFSET
def from_gamma(gamma, alpha, beta):
return chr((alpha * gamma + beta) % 26 + OFFSET)
def affine(c, alpha, beta):
return from_gamma(to_gamma(c), alpha, beta)
# g[0]==g[3]である前提
def search_that(w):
b = to_gamma(w[2])
for a in range(26):
if w[0] == affine('t',a,b) and w[1] == affine('h',a,b):
return a, b
return -1, -1
def search_this(g):
a = (to_gamma(w[0]) - to_gamma(w[3]) + 26) % 26
for b in range(26):
if w[0] == affine('t',a,b) and w[1] == affine('h',a,b) and w[2] == affine('i',a,b) and w[3] == affine('s',a,b):
return a, b
return -1, -1
def search(w):
if w[0] == w[3]:
return search_that(w)
else:
return search_this(w)
n = int(f.readline())
for i in range(n):
line = f.readline().strip()
words = [word for word in line.split() if len(word) == 4]
for word in words:
a, b = search(word)
if a != -1:
print(line.translate(str.maketrans(''.join([affine(c, a, b) for c in string.ascii_lowercase]), string.ascii_lowercase)))
break
| 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
|
s047334270 | p00040 | Runtime Error | def affine_cipher(word,alpha,beta):
newword = ''
for c in word:
newword += w[(alpha*dic[c]+beta)%26]
return newword
def find_quad_word(sentence):
r = []
for word in sentence:
if len(word)==4:
r.append(word)
return r
def get_alpha_and_beta(quad_word):
'''return alpha,beta'''
alpha_list = [i for i in range(26) if 26%i !=0]
beta_list = [i for i in range(26)]
for alpha in alpha_list:
for beta in beta_list:
tmp = affine_cipher(quad_word,alpha,beta)
if tmp=='that' or tmp == 'this':
return alpha,beta
else:
pass
def main():
for i in range(int(raw_input())):
s = raw_input().split()
quad_word_list = find_quad_word(s)
for quad_word in quad_word_list:
if get_alpha_and_beta(quad_word) is not None:
alpha,beta = get_alpha_and_beta(quad_word)
new_sentence=[]
for word in s:
new_sentence.append(affine_cipher(word,alpha,beta))
print ' '.join(new_sentence)
import string
w = string.ascii_lowercase
dic={}
for n,ch in enumerate(w):
dic[ch]=n
main() | 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
|
s147883287 | p00040 | Runtime Error | from math import gcd
def unzip(strlist,a,b):
ret = []
for word in strlist:
tmp = ""
for i in range(len(word)):
tmp += chr(((ord(word[i])-97)*a+b)%26+97)
ret.append(tmp)
return ret
n = int(input())
for _ in range(n):
instr = input().split()
for a in range(1,26):
if gcd(1,26)!=1 : continue
for b in range(26):
if "this" in unzip(instr, a, b):
print(" ".join(unzip(instr, a, b)))
elif "that" in unzip(instr, a, b):
print(" ".join(unzip(instr, a, b))) | 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
|
s169719439 | p00040 | Runtime Error | list_a = [0,1,3,5,7,9,11,13,15,17,19,21,23]
num_al = {0:'a',1:'b',2:'c',3:'d',4:'e',5:'f',6:'g',7:'h',8:'i',9:'j',10:'k',11:'l',12:'m',13:'n',14:'o',15:'p',16:'q',17:'r',18:'s',19:'t',20:'u',21:'v',22:'w',23:'x',24:'y',25:'z'}
n = input() + 1
for val in range(1,n):
num_a = 0
num_b = 0
sentence = raw_input()
words = []
for val in sentence:
words.append(val)
words_num = []
for val in words:
if val == 'a':
words_num.append(0)
elif val == 'b':
words_num.append(1)
elif val == 'c':
words_num.append(2)
elif val == 'd':
words_num.append(3)
elif val == 'e':
words_num.append(4)
elif val == 'f':
words_num.append(5)
elif val == 'g':
words_num.append(6)
elif val == 'h':
words_num.append(7)
elif val == 'i':
words_num.append(8)
elif val == 'j':
words_num.append(9)
elif val == 'k':
words_num.append(10)
elif val == 'l':
words_num.append(11)
elif val == 'm':
words_num.append(12)
elif val == 'n':
words_num.append(13)
elif val == 'o':
words_num.append(14)
elif val == 'p':
words_num.append(15)
elif val == 'q':
words_num.append(16)
elif val == 'r':
words_num.append(17)
elif val == 's':
words_num.append(18)
elif val == 't':
words_num.append(19)
elif val == 'u':
words_num.append(20)
elif val == 'v':
words_num.append(21)
elif val == 'w':
words_num.append(22)
elif val == 'x':
words_num.append(23)
elif val == 'y':
words_num.append(24)
elif val == 'z':
words_num.append(25)
else:
words_num.append(' ')
sentence_num = ''
for val in words_num:
sentence_num += str(val)
words_trans = []
sentence_trans = ''
while True:
for val in words_num:
if val == ' ':
words_trans.append(' ')
else:
words_trans.append(num_al[(list_a[num_a] * val + num_b) % 26])
for val in words_trans:
sentence_trans += str(val)
if 'this' in sentence_trans:
break
elif 'that' in sentence_trans:
break
else:
words_trans = []
sentence_trans = ''
if num_b != 25:
num_b += 1
else:
num_b = 0
num_a += 1
continue
print sentence_trans | 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
|
s012105230 | p00040 | Runtime Error | list_a = [0,1,3,5,7,9,11,13,15,17,19,21,23]
num_al = {0:'a',1:'b',2:'c',3:'d',4:'e',5:'f',6:'g',7:'h',8:'i',9:'j',10:'k',11:'l',12:'m',13:'n',14:'o',15:'p',16:'q',17:'r',18:'s',19:'t',20:'u',21:'v',22:'w',23:'x',24:'y',25:'z'}
n = input() + 1
for val in range(1,n):
num_a = 0
num_b = 0
sentence = raw_input()
words = []
for val in sentence:
words.append(val)
words_num = []
for val in words:
if val == 'a':
words_num.append(0)
elif val == 'b':
words_num.append(1)
elif val == 'c':
words_num.append(2)
elif val == 'd':
words_num.append(3)
elif val == 'e':
words_num.append(4)
elif val == 'f':
words_num.append(5)
elif val == 'g':
words_num.append(6)
elif val == 'h':
words_num.append(7)
elif val == 'i':
words_num.append(8)
elif val == 'j':
words_num.append(9)
elif val == 'k':
words_num.append(10)
elif val == 'l':
words_num.append(11)
elif val == 'm':
words_num.append(12)
elif val == 'n':
words_num.append(13)
elif val == 'o':
words_num.append(14)
elif val == 'p':
words_num.append(15)
elif val == 'q':
words_num.append(16)
elif val == 'r':
words_num.append(17)
elif val == 's':
words_num.append(18)
elif val == 't':
words_num.append(19)
elif val == 'u':
words_num.append(20)
elif val == 'v':
words_num.append(21)
elif val == 'w':
words_num.append(22)
elif val == 'x':
words_num.append(23)
elif val == 'y':
words_num.append(24)
elif val == 'z':
words_num.append(25)
else:
words_num.append(' ')
sentence_num = ''
for val in words_num:
sentence_num += str(val)
words_trans = []
sentence_trans = ''
while True:
for val in words_num:
if val == ' ':
words_trans.append(' ')
else:
words_trans.append(num_al[(list_a[num_a] * val + num_b) % 26])
for val in words_trans:
sentence_trans += str(val)
if 'this' in sentence_trans:
break
elif 'that' in sentence_trans:
break
else:
words_trans = []
sentence_trans = ''
if num_b != 25:
num_b += 1
else:
num_b = 0
num_a += 1
continue
print sentence_trans | 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
|
s556325882 | p00040 | Runtime Error | list_a = [0,1,3,5,7,9,11,13,15,17,19,21,23]
num_al = {0:'a',1:'b',2:'c',3:'d',4:'e',5:'f',6:'g',7:'h',8:'i',9:'j',10:'k',11:'l',12:'m',13:'n',14:'o',15:'p',16:'q',17:'r',18:'s',19:'t',20:'u',21:'v',22:'w',23:'x',24:'y',25:'z'}
n = input() + 1
for val in range(1,n):
num_a = 0
num_b = 0
sentence = raw_input()
words = []
for val in sentence:
words.append(val)
words_num = []
for val in words:
if val == 'a':
words_num.append(0)
elif val == 'b':
words_num.append(1)
elif val == 'c':
words_num.append(2)
elif val == 'd':
words_num.append(3)
elif val == 'e':
words_num.append(4)
elif val == 'f':
words_num.append(5)
elif val == 'g':
words_num.append(6)
elif val == 'h':
words_num.append(7)
elif val == 'i':
words_num.append(8)
elif val == 'j':
words_num.append(9)
elif val == 'k':
words_num.append(10)
elif val == 'l':
words_num.append(11)
elif val == 'm':
words_num.append(12)
elif val == 'n':
words_num.append(13)
elif val == 'o':
words_num.append(14)
elif val == 'p':
words_num.append(15)
elif val == 'q':
words_num.append(16)
elif val == 'r':
words_num.append(17)
elif val == 's':
words_num.append(18)
elif val == 't':
words_num.append(19)
elif val == 'u':
words_num.append(20)
elif val == 'v':
words_num.append(21)
elif val == 'w':
words_num.append(22)
elif val == 'x':
words_num.append(23)
elif val == 'y':
words_num.append(24)
elif val == 'z':
words_num.append(25)
else:
words_num.append(' ')
sentence_num = ''
for val in words_num:
sentence_num += str(val)
words_trans = []
sentence_trans = ''
while True:
for val in words_num:
if val == ' ':
words_trans.append(' ')
else:
words_trans.append(num_al[(list_a[num_a] * val + num_b) % 26])
for val in words_trans:
sentence_trans += str(val)
if 'this' in sentence_trans:
break
elif 'that' in sentence_trans:
break
else:
words_trans = []
sentence_trans = ''
if num_b != 26:
num_b += 1
else:
num_b = 0
num_a += 1
continue
print sentence_trans | 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
|
s856868510 | p00040 | Runtime Error | list_a = [0,1,3,5,7,9,11,13,15,17,19,21,23]
num_al = {0:'a',1:'b',2:'c',3:'d',4:'e',5:'f',6:'g',7:'h',8:'i',9:'j',10:'k',11:'l',12:'m',13:'n',14:'o',15:'p',16:'q',17:'r',18:'s',19:'t',20:'u',21:'v',22:'w',23:'x',24:'y',25:'z'}
n = input() + 1
for val in range(1,n):
num_a = 0
num_b = 0
sentence = raw_input()
words = []
for val in sentence:
words.append(val)
words_num = []
for val in words:
if val == 'a':
words_num.append(0)
elif val == 'b':
words_num.append(1)
elif val == 'c':
words_num.append(2)
elif val == 'd':
words_num.append(3)
elif val == 'e':
words_num.append(4)
elif val == 'f':
words_num.append(5)
elif val == 'g':
words_num.append(6)
elif val == 'h':
words_num.append(7)
elif val == 'i':
words_num.append(8)
elif val == 'j':
words_num.append(9)
elif val == 'k':
words_num.append(10)
elif val == 'l':
words_num.append(11)
elif val == 'm':
words_num.append(12)
elif val == 'n':
words_num.append(13)
elif val == 'o':
words_num.append(14)
elif val == 'p':
words_num.append(15)
elif val == 'q':
words_num.append(16)
elif val == 'r':
words_num.append(17)
elif val == 's':
words_num.append(18)
elif val == 't':
words_num.append(19)
elif val == 'u':
words_num.append(20)
elif val == 'v':
words_num.append(21)
elif val == 'w':
words_num.append(22)
elif val == 'x':
words_num.append(23)
elif val == 'y':
words_num.append(24)
elif val == 'z':
words_num.append(25)
else:
words_num.append(' ')
sentence_num = ''
for val in words_num:
sentence_num += str(val)
words_trans = []
sentence_trans = ''
while True:
for val in words_num:
if val == ' ':
words_trans.append(' ')
else:
words_trans.append(num_al[(list_a[num_a+1] * val + num_b) % 26])
for val in words_trans:
sentence_trans += str(val)
if 'this' in sentence_trans:
break
elif 'that' in sentence_trans:
break
else:
words_trans = []
sentence_trans = ''
if num_b != 25:
num_b += 1
else:
num_b = 0
num_a += 1
continue
print sentence_trans | 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
|
s467529826 | p00040 | Runtime Error | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
from string import ascii_lowercase
from itertools import count
def gcd(m, n):
m, n = sorted([m, n])
while n:
m, n = n, m % n
return m
def encode(char, A, B):
return chr(((A * (ord(char) - 97) + B) % 26) + 97)
def solve(words):
for a in (i for i in count(0) if gcd(i, 26) == 1):
for b in range(26):
for word in words:
that = ''.join(encode(c, a, b) for c in 'that')
if word == that:
return (a, b)
this = ''.join(encode(c, a, b) for c in 'this')
if word == this:
return (a, b)
def main():
for _ in range(int(stdin.readline())):
line = stdin.readline()
a, b = solve([s for s in line.split() if len(s) == 4])
d = {encode(c, a, b): c for c in ascii_lowercase}
d[b' '] = b' '
print(''.join(d[c] for c in line))
if __name__ == '__main__':
main() | 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
|
s516363661 | p00040 | Runtime Error | A2Z="abcdefghijklmnopqrstuvwxyz"
def decode(L1,L2,msg):
x=[]
for c in msg:
if 'a'<=c<='z':
c = L2[L1.index(c)]
x.append(c)
return "".join(x)
def affine(msg, key):
a,b = key
L = [A2Z[(i*a+b)%26] for i in range(26)]
L = "".join(L)
return decode(A2Z,L,msg)
def rot(msg, a):
if a==0: return msg
a = a % 26
L = A2Z[a:]+A2Z[:a]
return decode(A2Z,L,msg)
def find(msg):
c0=ord('t')
for i in range(3,26,2):
x = affine(msg,[i,0])
a = (c0-ord(x[0]))%26
x = rot(x,a)
if x in['this','that']: return [i,a]
n = input()
for i in range(n):
msg = raw_input()
for w in msg.split():
if len(w)==4:
key = find(w)
if key!=[]: break
print affine(msg,key) | 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
|
s426287584 | p00040 | Runtime Error | A2Z="abcdefghijklmnopqrstuvwxyz"
def decode(L1,L2,msg):
x=[]
for c in msg:
if 'a'<=c<='z':
c = L2[L1.index(c)]
x.append(c)
return "".join(x)
def affine(msg, key):
a,b = key
L = [A2Z[(i*a+b)%26] for i in range(26)]
L = "".join(L)
return decode(A2Z,L,msg)
def rot(msg, a):
if a==0: return msg
a = a % 26
L = A2Z[a:]+A2Z[:a]
return decode(A2Z,L,msg)
def find(msg):
c0=ord('t')
for i in range(3,26,2):
x = affine(msg,[i,0])
a = (c0-ord(x[0]))%26
x = rot(x,a)
if x in['this','that']: return [i,a]
return []
n = input()
for i in range(n):
msg = raw_input()
for w in msg.split():
if len(w)==4:
key = find(w)
if key!=[]: break
print affine(msg,key) | 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
|
s196103674 | p00040 | Runtime Error | dict = ["a","b","c","d","e","f","g","h","i","j","k","l","m",\
"n","o","p","q","r","s","t","u","v","w","x","y","z"]
lsalpha = [1,3,5,7,9,11,15,17,19,21,23,25]
def deaffine(alpha, beta, code):
decode = ""
for chara in code:
if chara != " ":
f = dict.index(chara)
for i in range(26):
if (alpha*i + beta)%26 == f:
dechara = dict[i]
break
decode += dechara
else:
decode += " "
return decode
n = int(raw_input())
for roop in range(n):
code = raw_input()
for alpha in lsalpha:
flag = 0
for beta in range(26):
deaffine(alpha, beta, code)
if decode.count("that") > 0 or decode.count("this") > 0:
flag = 1
break
if flag == 1:
break
print decode | 1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
| i submit that there is another point of view
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>アフィン暗号</H1>
<p>
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
</p>
<center>
<!--
<p>
F(γ) = (α・γ＋β) mod 26
</p>
-->
<p>
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
</p>
</center>
<p>
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
</p>
<p>
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
</p>
<pre>
that
this
</pre>
<p>
のいずれかが必ず含まれているものとします。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
</p>
<H2>Output</H2>
<p>
各データセットに対して、復号した元の文章を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
</pre>
<H2>Output for the Sample Input</H2>
<pre>
i submit that there is another point of view
</pre>
|
s487891121 | p00042 | Wrong Answer | from sys import stdin
case = 0
while(True):
case += 1
W = int(stdin.readline())
if not W: break
print("Case %d"%case)
N = int(stdin.readline())
v = [0] * N
w = [0] * N
dp = [[0]*(W + 1) for _ in range(N + 1)]
for k in range(N):
v[k], w[k] = map(int, stdin.readline().split(","))
for i in range(N-1,-1,-1):
for j in range(W+1):
if j < w[i]:
dp[i][j] = dp[i + 1][j]
else:
dp[i][j] = max(dp[i + 1][j], dp[i + 1][j - w[i]] + v[i])
print(dp[0][W])
for i in range(W+1):
if dp[0][i] == dp[0][W]: print(i); break
| 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s855784759 | p00042 | Wrong Answer | #coding:utf-8
import sys
import copy
def main():
line = sys.stdin.readline()
i = 1
#case
while int(line) != 0:
analy(line, i)
i = i + 1
line = sys.stdin.readline()
def analy(line, case):
#整列
weight = int(line)
num = int(sys.stdin.readline())
data = []
for i in range(num):
a = sys.stdin.readline()
b = [int(n) for n in a.split(",")]
#価値、重さ
data.append(b)
#軽い順に並び替える,同じ重さなら価値の低い順になってる
data.sort(key=lambda x:(x[1], x[0]))
#重さ重複を削除
i = 0
while i < len(data)-1:
if data[i][1] == data[i+1][1]:
del data[i]
else:
i = i + 1
num = len(data)
yar(data, weight, num, case)
def yar(data, weight, num ,case):
# 価値、重さ
tmp = [[0,0]]
kek = []
calc(tmp, data, weight, kek, num)
kek.sort(key=lambda x:(x[0], -x[1]))
kek.reverse()
print("Case " + str(case) + ':')
print(kek[0][0])
print(kek[0][1])
def calc(tmp, data, weight, kek, num):
for j in range(num):
a = len(tmp)
for i in range(a):
#とりあえず全てにおなじdataのやつを足してくわえる
tlis = copy.deepcopy(tmp[i])
tlis[0] = data[j][0] + tlis[0]
tlis[1] = data[j][1] + tlis[1]
if tlis[1] <= weight:
tmp.append(tlis)
else:
#軽い順に並べてるのでそれがダメだと残りの要素すべて×、その後も×になる
for k in range(i,a):
kek.append(tmp[i])
del tmp[i]
break
#軽い順に並び替える,同じ重さなら価値の低い順になってる
tmp.sort(key=lambda x:(x[1],x[0]))
for j in range(len(tmp)):
kek.append(tmp[j])
if __name__ == "__main__":
main() | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s726413243 | p00042 | Wrong Answer | #coding:utf-8
import sys
import copy
def main():
line = sys.stdin.readline()
i = 1
#case
while int(line) != 0:
analy(line, i)
i = i + 1
line = sys.stdin.readline()
def analy(line, case):
weight = int(line)
num = int(sys.stdin.readline())
data = []
for i in range(num):
a = sys.stdin.readline()
b = [int(n) for n in a.split(",")]
data.append(b)
data.sort(key=lambda x:(x[1], x[0]))
i = 0
while i < len(data)-1:
if data[i][1] == data[i+1][1]:
del data[i]
else:
i = i + 1
num = len(data)
yar(data, weight, num, case)
def yar(data, weight, num ,case):
tmp = [[0,0]]
kek = []
calc(tmp, data, weight, kek, num)
kek.sort(key=lambda x:(x[0], -x[1]))
kek.reverse()
print("Case " + str(case) + ':')
print(kek[0][0])
print(kek[0][1])
def calc(tmp, data, weight, kek, num):
for j in range(num):
a = len(tmp)
for i in range(a):
tlis = copy.deepcopy(tmp[i])
tlis[0] = data[j][0] + tlis[0]
tlis[1] = data[j][1] + tlis[1]
if tlis[1] <= weight:
tmp.append(tlis)
else:
for k in range(i,a):
kek.append(tmp[i])
del tmp[i]
break
tmp.sort(key=lambda x:(x[1],x[0]))
i = 0
while i < len(tmp)-1:
if tmp[i][1] == tmp[i+1][1]:
del tmp[i]
else:
i = i + 1
for j in range(len(tmp)):
kek.append(tmp[j])
if __name__ == "__main__":
main() | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s770715413 | p00042 | Wrong Answer | caseN = 0
while True:
caseN += 1
W = int(input())
if W == 0: break
N = int(input())
tr = [list(map(int, input().split(','))) for _ in range(N)]
dp = [[0 for x in range(W+1)] for y in range(N+1)]
for x in range(N):
for y in range(W+1):
if y >= tr[x][1]:
dp[x+1][y] = max(dp[x+1][y], dp[x][y-tr[x][1]]+tr[x][0])
sum_weight = 0
sum_value = 0
for x in range(W+1):
if dp[N][x] > sum_value:
sum_weight = x
sum_value = dp[N][x]
print("Case ", caseN, ":", sep='')
print(sum_value, sum_weight, sep='\n') | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s521050709 | p00042 | Wrong Answer | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from itertools import *
from sys import *
def solve(n,w):
lp,lw = [],[]
for i in xrange(n):
s = map(int, raw_input().split(","))
lp.append(s[0])
lw.append(s[1])
mp = mw = 0
for e in product([0,1],repeat=n):
cw = sum([ lw[i] for i in range(len(e)) if e[i] ])
cp = sum([ lp[i] for i in range(len(e)) if e[i] ])
if cw < w and cp > mp : mp = cp ; mw = cw
print mp
print mw
case = 0
while True:
case += 1
w = int(raw_input())
if w == 0: break
n = int(raw_input())
print "Case %d:" % (case)
solve(n,w) | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s224381691 | p00042 | Wrong Answer | # -*- coding:utf-8 -*-
def solve(c, W, vl):
dp = [0] * W
for v in vl:
for i in reversed(xrange(v[1], W)):
dp[i] = max(dp[i - v[1]] + v[0], dp[i])
print "Case {}:".format(c)
print dp[W-1]
print len(filter(lambda x:x < dp[W-1], dp))
c = 1
while 1:
W = int(raw_input())
if not W: break
N = int(raw_input())
solve(c, W, [map(int, raw_input().split(",")) for _ in xrange(N)])
c += 1 | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s256341066 | p00042 | Wrong Answer | # -*- coding:utf-8 -*-
def solve(c, W, vl):
dp = [0] * W
for v in vl:
for i in reversed(xrange(v[1], W)):
dp[i] = max(dp[i - v[1]] + v[0], dp[i])
print "Case {}:\n{}\n{}".format(c,dp[W-1],len(filter(lambda x: x<dp[W-1], dp)))
c = 1
while 1:
W = int(raw_input())
if not W: break
N = int(raw_input())
solve(c, W, [map(int, raw_input().split(",")) for _ in xrange(N)])
c += 1 | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s820545572 | p00042 | Wrong Answer | # -*- coding:utf-8 -*-
def solve(c, W, vl):
dp = [0] * W
for v in vl:
for i in reversed(xrange(v[1], W)):
dp[i] = max(dp[i - v[1]] + v[0], dp[i])
print "Case {}:\n{}\n{}".format(c, dp[W-1], dp.index(dp[W-1]))
c = 1
while 1:
W = int(raw_input())
if not W: break
N = int(raw_input())
solve(c, W, [map(int, raw_input().split(",")) for _ in xrange(N)])
c += 1 | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s575474410 | p00042 | Wrong Answer | # -*- coding:utf-8 -*-
def solve(c, W, vl):
dp = [0] * W
for v in vl:
for i in xrange(W-1, v[1]-1, -1):
dp[i] = max(dp[i - v[1]] + v[0], dp[i])
print "Case {}:\n{}\n{}".format(c, dp[W-1], dp.index(dp[W-1]))
c = 1
while 1:
W = int(raw_input())
if not W: break
N = int(raw_input())
solve(c, W, [map(int, raw_input().split(",")) for _ in xrange(N)])
c += 1 | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s705077178 | p00042 | Wrong Answer | while True:
try:
case=0
while True:
case+=1
weight=input()
if weight==0:
break
N=input()
data=[[0 for i in range(2)] for j in range(N)]
for i in range(N):
data[i][0],data[i][1]=map(int,raw_input().split(","))
table=[[-1 for i in range(weight+1)] for j in range(N)]
for i in range(N):
table[i][0]=0
table[0][data[0][1]]=data[0][0]
for i in range(0,N-1):
for j in range(weight+1):
if table[i][j]!=-1 and j+data[i+1][1] <= weight:
table[i+1][j+data[i+1][1]]=table[i][j]+data[i+1][0]
sum=max(table[N-1])
print "Case "+str(case)+":"
print sum
print table[N-1].index(sum)
except:
break | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s089195867 | p00042 | Wrong Answer | while True:
try:
case=0
while True:
case+=1
weight=input()
if weight==0:
break
N=input()
if N==0:
print "Case "+str(case)+":"
print 0
print 0
break
data=[[0 for i in range(2)] for j in range(N)]
for i in range(N):
data[i][0],data[i][1]=map(int,raw_input().split(","))
table=[[-1 for i in range(weight+1)] for j in range(N)]
for i in range(N):
table[i][0]=0
table[0][data[0][1]]=data[0][0]
for i in range(0,N-1):
for j in range(weight+1):
if table[i][j]!=-1 and j+data[i+1][1] <= weight:
table[i+1][j+data[i+1][1]]=table[i][j]+data[i+1][0]
sum=max(table[N-1])
print "Case "+str(case)+":"
print sum
print table[N-1].index(sum)
except:
break | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s687496619 | p00042 | Wrong Answer | while True:
try:
case=0
while True:
case+=1
weight=input()
if weight==0:
break
N=input()
data=[[0 for i in range(2)] for j in range(N)]
for i in range(N):
data[i][0],data[i][1]=map(int,raw_input().split(","))
table=[[-1 for i in range(weight+1)] for j in range(N)]
for i in range(N):
table[i][0]=0
table[0][data[0][1]]=data[0][0]
for i in range(0,N-1):
for j in range(weight+1):
if table[i][j]!=-1 and j+data[i+1][1] <= weight and\
table[i][j+data[i+1][1]] < table[i][j]+data[i+1][0]:
table[i+1][j+data[i+1][1]]=table[i][j]+data[i+1][0]
sum=max(table[N-1])
print "Case "+str(case)+":"
print sum
print table[N-1].index(sum)
except:
break | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s569417166 | p00042 | Wrong Answer | def asmr(lis):
global m_v, m_w
for i, v_w in enumerate(lis):
if sum(w) + v_w[1] <= W:
v.append(v_w[0])
w.append(v_w[1])
asmr(lis[i+1:])
del v[-1]
del w[-1]
else:
if (m_v == None) or (m_v < sum(v)):
m_v = sum(v)
m_w = sum(w)
elif m_v == sum(v):
if m_w > sum(w):
m_w = sum(w)
else:
if (m_v == None) or (m_v < sum(v)):
m_v = sum(v)
m_w = sum(w)
elif m_v == sum(v):
if m_w > sum(w):
m_w = sum(w)
while True:
W = int(raw_input())
if W == 0: break
N = int(raw_input())
lis = [map(int, raw_input().split(',')) for i in range(N)]
lis = sorted(lis, key=lambda x: x[0], reverse=True)
m_v = None
m_w = None
v = []
w = []
asmr(lis)
print m_v
print m_w | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s072340613 | p00042 | Wrong Answer | # ナップサック問題を python で解く
case = 0
while True:
case += 1
w = int(input())
if w == 0:
break
n = int(input())
item = []
for i in range(n):
item.append(tuple(map(int, input().split(","))))
dp = [ [0 for j in range(w + 1)] for i in range(n + 1) ]
for i in range(n):
for j in range(w + 1):
value = item[i][0]
weight = item[i][1]
# dp[i][j] : 0..i番目の荷物、重さ j 以下の最大の価値
if j - weight >= 0 and dp[i+1][j - weight] == dp[i][j - weight]:
dp[i+1][j] = max(dp[i][j], dp[i+1][j - weight] + value)
else:
dp[i+1][j] = max(dp[i][j], dp[i+1][j-1])
for j in range(w + 1):
if dp[n][j] == dp[n][w]:
max_w = j
break
print("Case {0}".format(case))
print(dp[n][w])
print(max_w) | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s562718548 | p00042 | Wrong Answer | # ナップサック問題を python で解く
case = 0
while True:
case += 1
w = int(input())
if w == 0:
break
n = int(input())
item = []
for i in range(n):
item.append(tuple(map(int, input().split(","))))
dp = [ [0 for j in range(w + 1)] for i in range(n + 1) ]
for i in range(n):
for j in range(w + 1):
value = item[i][0]
weight = item[i][1]
# dp[i][j] : 0..i番目の荷物、重さ j 以下の最大の価値
if j - weight >= 0 and dp[i+1][j - weight] == dp[i][j - weight]:
dp[i+1][j] = max(dp[i][j], dp[i+1][j - weight] + value)
else:
dp[i+1][j] = max(dp[i][j], dp[i+1][j-1])
for j in range(w + 1):
if dp[n][j] == dp[n][w]:
max_w = j
break
print("Case {0}:".format(case))
print(dp[n][w])
print(max_w) | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s920502217 | p00042 | Wrong Answer | 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 furoshiki(i, w_limit):
global treasures
if not i or not w_limit:
return (0, 0)
v, w = treasures[i - 1]
not_stole = furoshiki(i - 1, w_limit)
if w_limit < w:
return not_stole
stole_v_total, stole_w_total = furoshiki(i - 1, w_limit - w)
stole_v_total += v
stole_w_total -= w
return max(not_stole, (stole_v_total, stole_w_total))
case = 1
while True:
w = int(input())
if not w:
break
n = int(input())
treasures = [None] * n
for i in range(n):
treasures[i] = tuple(map(int, input().split(',')))
total_v, total_w = furoshiki(n, w)
print('Case {}:'.format(case))
print(total_v)
print(-total_w)
case += 1 | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s218431475 | p00042 | Wrong Answer | import sys
class Item_class():
def __init__(self, value, weight):
self.value = value
self.weight = weight
def rec_dp(i, j):
if dp[i][j] != -1:
return dp[i][j]
res = 0
if i == n:
res == 0
elif j < item[i].weight:
res = rec_dp(i+1, j)
else:
res = max(rec_dp(i+1, j), rec_dp(i+1, j-item[i].weight)+item[i].value)
dp[i][j] = res
return res
k = 0
while True:
W = int(raw_input())
if not W:
break
k += 1
n = int(raw_input())
item = []
dp = [[-1 for j in range(W+1)] for i in range(n+1)]
for i in range(n):
v, w = map(int, raw_input().split(','))
item.append(Item_class(v, w))
item.append(Item_class(0, 0))
v_max = rec_dp(0, W)
print "Case %d:" %(k)
print v_max
w_sum = 0
for i in range(1, n+1):
if dp[i][W] != v_max:
w_sum += item[i-1].weight
print w_sum | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s713369439 | p00042 | Wrong Answer |
def rec(i, j):
if dp[i][j] != -1:
return dp[i][j]
if i == N:
ans = 0, W - j
elif j < wl[i]:
ans = rec(i + 1, j)
else:
v1, w1 = rec(i + 1, j)
v2, w2 = rec(i + 1, j - wl[i])
v2 += vl[i]
if v1 > v2:
ans = v1, w1
elif v1 < v2:
ans = v2, w2
elif v1 == v2:
if w1 < w2:
ans = v1, w1
else:
ans = v2, w2
dp[i][j] = ans
return ans
while True:
W = int(input())
if W == 0: break
N = int(input())
vl = []
wl = []
for _ in range(N):
v, w = map(int, input().split(','))
vl.append(v)
wl.append(w)
dp = [[-1 for j in range(2000)] for i in range(2000)]
v, w = rec(0, W)
print(v, w) | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s410035971 | p00042 | Wrong Answer | while True:
cnt = 0
cnt += 1
maxweight = int(input())
if maxweight == 0:
break
length = int(input())
tresure = []
dp = [[0 for n in range(length+1)] for m in range(maxweight + 1)]
answeight = 0
ansvalue = 0
for l in range(length):
v,w = (int(n) for n in input().split(","))
tresure.append([v,w])
for outer in range(length + 1):
if outer == 0:
continue
weight = tresure[outer-1][1]
value = tresure[outer-1][0]
dp[weight][outer] = max(dp[weight][outer],value)
for inner in range(maxweight + 1):
if dp[inner][outer - 1] != 0:
beforevalue = dp[inner][outer - 1]
beforeweight = inner
dp[inner][outer] = max(beforevalue,dp[inner][outer])
if beforeweight + weight <= maxweight:
nowvalue = dp[beforeweight + weight][outer]
dp[beforeweight + weight][outer] = max(nowvalue,beforevalue+value)
#print(dp)
for a in range(maxweight+1):
#print(dp[a][length])
if ansvalue < dp[a][length]:
ansvalue = dp[a][length]
answeight = a
print("Case {0}:".format(cnt))
print(ansvalue)
print(answeight) | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s839981874 | p00042 | Wrong Answer | c=1
while 1:
W=int(input())
if W==0:break
n=int(input())
dp=[0]*(W+1)
for i in range(n):
v,w = map(int, input().split(','))
for j in range(W,w-1,-1):
dp[j]=max(dp[j-w]+v,dp[j])
for i in range(W):
if dp[W]==dp[i]:break
print('Case %d\n%d\n%d'%(c,dp[W],i))
c+=1 | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s122642601 | p00042 | Wrong Answer | c=1
while 1:
W=int(input())
if W==0:break
n=int(input())
dp=[0]*(W+1)
for i in range(n):
v,w = map(int, input().split(','))
for j in range(W,w-1,-1):
dp[j]=max(dp[j-w]+v,dp[j])
for i in range(W):
if dp[W]==dp[i]:break
print('Case %d:\n%d\n%d'%(c,dp[W],i))
c+=1 | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s934941686 | p00042 | Wrong Answer | c=1
while 1:
W=int(input())
if W==0:break
dp=[0]*(W+1)
for i in range(int(input())):
v,w = map(int, input().split(','))
for j in range(W,w-1,-1):
if dp[j]<dp[j-w]:dp[j]=dp[j-w]
for i in range(W+1):
if dp[W]==dp[i]:break
print('Case %d:\n%d\n%d'%(c,dp[W],i))
c+=1 | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s490740568 | p00042 | Wrong Answer | case = 1
while 1:
W = int(input())
if W == 0:
break
N = int(input())
v = []
w = []
for _ in range(N):
v_, w_ = map(int,input().split(","))
v.append(v_)
w.append(w_)
dp = [[0 for _ in range(W)] for _ in range(N)]
for i in range(w[0],W):
dp[0][i] = v[0]
for i in range(1, N):
for j in range(W):
if j - w[i] < 0:
dp[i][j] = dp[i-1][j]
else:
dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i]]+v[i])
res = dp[N-1][W-1]
minw = min([i for i in range(W) if dp[N-1][i] == res])
print("Case "+str(case)+":")
print(res)
print(minw)
case += 1 | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s347836557 | p00042 | Wrong Answer | # -*- coding: utf-8 -*-
import sys
import os
import math
import itertools
case = 1
for s in sys.stdin:
W = int(s)
if W == 0:
break
N = int(input())
values = []
weights = []
for i in range(N):
v, w = map(int, input().split(','))
values.append(v)
weights.append(w)
max_value = 0
max_value_weight = 0
for use_flags in itertools.product([0, 1], repeat=len(weights)):
sum_value = 0
sum_weight = 0
for i, use_flag in enumerate(use_flags):
if use_flag == 1:
sum_value += values[i]
sum_weight += weights[i]
if sum_weight <= W and sum_value > max_value:
max_value = sum_value
max_value_weight = sum_weight
case += 1
print('Case {}:'.format(case))
print(max_value)
print(max_value_weight) | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s035860161 | p00042 | Wrong Answer | # coding: utf-8
# Here your code !
count = 1
while 1:
W = int(input())
if W == 0:
break
N = int(input())
data =[]
dp = [[[-1,0]for i in range(W+1)]for i in range(N+1)]
for i in range(N):
data.append(input().split(","))
for i in range(W+1):
dp[N][i][0] = 0
for i in reversed(range(N)):
for capa in range(W):
if int(data[i][1]) > capa:
dp[i][capa][0] = dp[i+1][capa][0]
dp[i][capa][1] = dp[i+1][capa][1]
else:
dp[i][capa][0] = max(int(data[i][0])+dp[i+1][capa-int(data[i][1])][0],dp[i+1][capa][0])
dp[i][capa][1] = dp[i+1][capa][1]
if dp[i][capa][0] != dp[i+1][capa][0]:
dp[i][capa][1] += int(data[i][1])
print("Case " + str(count) +":")
print(max(max(dp))[0])
print(max(max(dp))[1])
count += 1 | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s103483183 | p00042 | Wrong Answer | # coding: utf-8
count = 1
while 1:
W = int(input())
if W == 0:
break
N = int(input())
data =[]
dp = [[[-1,0]for i in range(W+1)]for i in range(N+1)]
for i in range(N):
data.append(input().split(","))
for i in range(W+1):
dp[N][i][0] = 0
for i in reversed(range(N)):
for capa in range(W):
if int(data[i][1]) > capa:
dp[i][capa][0] = dp[i+1][capa][0]
dp[i][capa][1] = dp[i+1][capa][1]
else:
dp[i][capa][0] = max(int(data[i][0])+dp[i+1][capa-int(data[i][1])][0],dp[i+1][capa][0])
dp[i][capa][1] = dp[i+1][capa][1]
if dp[i][capa][0] != dp[i+1][capa][0]:
dp[i][capa][1] += int(data[i][1])
print("Case " + str(count) +":")
print(max(max(dp))[0])
print(max(max(dp))[1])
count += 1 | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s095006222 | p00042 | Wrong Answer | # coding: utf-8 | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s615202296 | p00042 | Wrong Answer | # coding: utf-8
# Here your code !
count = 1
while 1:
W = int(input())
if W == 0:
break
N = int(input())
data =[]
dp = [[[-1,0]for i in range(W+1)]for i in range(N+1)]
for i in range(N):
data.append(input().split(","))
for i in range(W+1):
dp[N][i][0] = 0
for i in reversed(range(N)):
for capa in range(W+1):
if int(data[i][1]) > capa:
dp[i][capa][0] = dp[i+1][capa][0]
dp[i][capa][1] = dp[i+1][capa][1]
else:
dp[i][capa][0] = max(int(data[i][0])+dp[i+1][capa-int(data[i][1])][0],dp[i+1][capa][0])
dp[i][capa][1] = dp[i+1][capa][1]
if dp[i][capa][0] != dp[i+1][capa][0]:
dp[i][capa][1] += int(data[i][1])
print("Case " + str(count) +":")
print(max(max(dp))[0])
print(max(max(dp))[1])
print(dp)
count += 1 | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s347620502 | p00042 | Wrong Answer | # coding: utf-8
# Here your code !
count = 1
while 1:
W = int(input())
if W == 0:
break
N = int(input())
data =[]
dp = [[[-1,0]for i in range(W+1)]for i in range(N+1)]
for i in range(N):
data.append(input().split(","))
for i in range(W+1):
dp[N][i][0] = 0
for i in reversed(range(N)):
for capa in range(W+1):
if int(data[i][1]) > capa:
dp[i][capa][0] = dp[i+1][capa][0]
dp[i][capa][1] = dp[i+1][capa][1]
else:
dp[i][capa][0] = max(int(data[i][0])+dp[i+1][capa-int(data[i][1])][0],dp[i+1][capa][0])
dp[i][capa][1] = dp[i+1][capa][1]
if dp[i][capa][0] != dp[i+1][capa][0]:
dp[i][capa][1] += int(data[i][1])
print("Case " + str(count) +":")
print(max(max(dp))[0])
print(max(max(dp))[1])
count += 1 | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s770341239 | p00042 | Wrong Answer | # coding: utf-8
# Here your code !
count = 1
while 1:
W = int(input())
if W == 0:
break
N = int(input())
data =[]
dp = [[[-1,0]for i in range(W+1)]for i in range(N+1)]
for i in range(N):
data.append(input().split(","))
for i in range(W+1):
dp[N][i][0] = 0
for i in reversed(range(N)):
for capa in range(W+1):
if int(data[i][1]) > capa:
dp[i][capa][0] = dp[i+1][capa][0]
dp[i][capa][1] = dp[i+1][capa][1]
else:
dp[i][capa][0] = max(int(data[i][0])+dp[i+1][capa-int(data[i][1])][0],dp[i+1][capa][0])
dp[i][capa][1] = capa
print("Case " + str(count) +":")
print(max(max(dp))[0])
print(max(max(dp))[1])
count += 1 | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s069880487 | p00042 | Wrong Answer | # coding: utf-8
# Here your code !
count = 1
while 1:
W = int(input())
if W == 0:
break
N = int(input())
data =[]
dp = [[[-1,0]for i in range(W+1)]for i in range(N+1)]
for i in range(N):
data.append(input().split(","))
for i in range(W+1):
dp[N][i][0] = 0
for i in reversed(range(N)):
for capa in range(W+1):
if int(data[i][1]) > capa:
dp[i][capa][0] = dp[i+1][capa][0]
dp[i][capa][1] = dp[i+1][capa][1]
else:
dp[i][capa][0] = max(int(data[i][0])+dp[i+1][capa-int(data[i][1])][0],dp[i+1][capa][0])
dp[i][capa][1] = capa
# if dp[i][capa][0] != dp[i+1][capa][0]:
# dp[i][capa][1] -= int(data[i][1])
print("Case " + str(count) +":")
print(max(max(dp))[0])
print(max(max(dp))[1])
#print(dp)
count += 1 | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s732748311 | p00042 | Wrong Answer | from itertools import combinations
case = 0
while True :
limit = int(input())
if limit == 0 : break
case += 1
number = int(input())
value, weight = [], []
for _ in range(number) :
a, b = input().split(',')
value.append(int(a))
weight.append(int(b))
temp1, temp2 = [], []
for _ in range(1, number+1) :
temp1.append(list(combinations(value, _)))
temp2.append(list(combinations(weight, _)))
temp1, temp2 = sum(temp1, []), sum(temp2, [])
value, weight = [], []
for _ in temp1 : value.append(sum(_))
for _ in temp2 : weight.append(sum(_))
result = [0, 0]
for _ in range(len(temp1)) :
if result[0] < value[_] and weight[_] < limit :
result = value[_], weight[_]
elif result[0] == value and weight[_] < result[1] :
result = value[_], weight[_]
print('Case {} :'.format(case))
print(result[0])
print(result[1]) | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s234136948 | p00042 | Wrong Answer | from itertools import combinations
case = 0
while True :
limit = int(input())
if limit == 0 : break
case += 1
number = int(input())
value, weight = [], []
for _ in range(number) :
a, b = input().split(',')
value.append(int(a))
weight.append(int(b))
temp1, temp2 = [], []
for _ in range(1, number+1) :
temp1.append(list(combinations(value, _)))
temp2.append(list(combinations(weight, _)))
temp1, temp2 = sum(temp1, []), sum(temp2, [])
value, weight = [], []
for _ in temp1 : value.append(sum(_))
for _ in temp2 : weight.append(sum(_))
result = [0, 0]
for _ in range(len(temp1)) :
if result[0] < value[_] and weight[_] < limit :
result = value[_], weight[_]
elif result[0] == value and weight[_] < result[1] :
result = value[_], weight[_]
print('Case {}:'.format(case))
print(result[0])
print(result[1]) | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s345584759 | p00042 | Wrong Answer | c = 0
while True:
W = int(input())
if W == 0:
break
c += 1
N = int(input())
vl = [0]
wl = [0]
max_w = 0
max_v = 0
for i in range(N):
[v,w] = list(map(int,input().split(",")))
vl.append(v)
wl.append(w)
dp = [[0 for i in range(W+1)] for j in range(N+1)]
for i in range(N+1):
for j in range(W+1):
if i == 0 or j == 0:
dp[i][j] = 0
else:
if wl[i] <= j:
dp[i][j] = max(dp[i-1][j-wl[i]] + vl[i], dp[i-1][j])
if dp[i][j] > max_v:
max_v = dp[i][j]
max_w = j - 1
else:
dp[i][j] = dp[i-1][j]
print("Case "+str(c)+":")
print(max_v)
print(max_w) | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s846440313 | p00042 | Wrong Answer | C_num = 1
while True:
Nap = []
W = int(input())
if W == 0:
break
N = int(input())
for i in range(N):
v,w = map(int,input().split(","))
Nap.append([v,w])
DP = [[0 for j in range(W + 1)] for i in range(N + 1)]
for i in range(1,N+1):
for j in range(W+1):
if j - Nap[i-1][1] >= 0:
DP[i][j] = max(DP[i-1][j],DP[i - 1][j - Nap[i - 1][1]] + Nap[i - 1][0])
else:
DP[i][j] = DP[i-1][j]
omo = DP[N].index(DP[N][W])
print("Case ",C_num,":",sep = "",end = "\n")
print(DP[N][W])
print(omo) | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s435770139 | p00042 | Wrong Answer | import itertools
def solve(W, N, v):
cache = {}
def loop(i, w):
if (i, w) in cache:
return cache[i, w]
if i == N:
return (0, 0)
cache[i, w] = loop(i + 1, w)
if v[i][1] <= w:
t = loop(i + 1, w - v[i][1])
cache[i, w] = max(cache[i, w], (t[0] + v[i][0], t[1] + v[i][1]), key=lambda u: u[0])
return cache[i, w]
return loop(0, W)
for dn in itertools.count(1):
W = int(input())
if W == 0: break
N = int(input())
v = [tuple(map(int, input().split(','))) for _ in range(N)]
# optim = solve(W, N, v)
# print("Case %d:\n%d\n%d" % (dn, optim[0], optim[1])) | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s611172091 | p00042 | Wrong Answer | # Aizu Problem 0042: A Thief
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
def knapsack(n, v, w, W):
#
# 0/1 knapsack implementation
#
# Input:
# Values (stored in array v)
# Weights (stored in array w)
# Number of distinct items (n)
# Knapsack capacity (W)
#
m = [[0 for _ in range(W + 1)] for __ in range(N + 1)]
for i in range(1, N + 1):
for j in range(W + 1):
if w[i - 1] > j:
m[i][j] = m[i-1][j]
else:
m[i][j] = max(m[i-1][j], m[i-1][j-w[i - 1]] + v[i - 1])
print(m)
return m[N][W]
def total_value(items, max_weight):
return sum([x[2] for x in items]) if sum([x[1] for x in items]) < max_weight else 0
cache = {}
def solve(items, max_weight):
if not items:
return ()
if (items,max_weight) not in cache:
head = items[0]
tail = items[1:]
include = (head,) + solve(tail, max_weight - head[1])
dont_include = solve(tail, max_weight)
if total_value(include, max_weight) > total_value(dont_include, max_weight):
answer = include
else:
answer = dont_include
cache[(items,max_weight)] = answer
return cache[(items,max_weight)]
case = 0
while True:
cache = {}
W = int(input())
if W == 0:
break
N = int(input())
items = []
for n in range(N):
a, b = [int(_) for _ in input().split(',')]
items.append(("", b, a))
items = tuple(items)
solution = solve(items, W)
case += 1
print("Case %d:" % case)
print(sum([x[2] for x in solution]))
print(sum([x[1] for x in solution])) | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s516395175 | p00042 | Wrong Answer | # Aizu Problem 0042: A Thief
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
def knapsack(n, v, w, W):
#
# 0/1 knapsack implementation
#
# Input:
# Values (stored in array v)
# Weights (stored in array w)
# Number of distinct items (n)
# Knapsack capacity (W)
#
m = [[0 for _ in range(W + 1)] for __ in range(N + 1)]
for i in range(1, N + 1):
for j in range(W + 1):
if w[i - 1] > j:
m[i][j] = m[i-1][j]
else:
m[i][j] = max(m[i-1][j], m[i-1][j-w[i - 1]] + v[i - 1])
print(m)
return m[N][W]
def total_value(items, max_weight):
return sum([x[2] for x in items]) if sum([x[1] for x in items]) < max_weight else 0
cache = {}
def solve(items, max_weight):
if not items:
return ()
if (items,max_weight) not in cache:
head = items[0]
tail = items[1:]
include = (head,) + solve(tail, max_weight - head[1])
dont_include = solve(tail, max_weight)
if total_value(include, max_weight) > total_value(dont_include, max_weight):
answer = include
else:
answer = dont_include
cache[(items,max_weight)] = answer
return cache[(items,max_weight)]
case = 0
while True:
cache = {}
W = int(input())
if W == 0:
break
N = int(input())
items = []
for n in range(N):
a, b = [int(_) for _ in input().split(',')]
items.append(("", b, a))
items = tuple(items)
solution = solve(items, W)
case += 1
print("Case %d:" % case)
print(total_value(solution, W))
print(sum([x[1] for x in solution])) | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s412048157 | p00042 | Wrong Answer | count=1
while True:
vw=[[0,0]]
W=int(input())
if W==0:
break
n=int(input())
for i in range(n):
vw.append(list(map(int,input().split(','))))
dp=[]
weight=[]
for _ in range(n+1):
dp.append([0 for i in range(W+1)])
weight.append([0 for i in range(W+1)])
for i in range(1,n+1):
for j in range(0,W-vw[i][1]+1):
dp[i][j+vw[i][1]]=max(dp[i-1][j+vw[i][1]],dp[i-1][j]+vw[i][0])
if dp[i][j+vw[i][1]]==dp[i-1][j]+vw[i][0]:
weight[i][j+vw[i][1]]=weight[i-1][j]+vw[i][1]
else:
weight[i][j+vw[i][1]]=weight[i-1][j]
print('Case '+'{}'.format(count)+':')
print(dp[n][W])
print(weight[n][W])
count+=1
| 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s241016742 | p00042 | Wrong Answer | count=1
while True:
vw=[[0,0]]
W=int(input())
if W==0:
break
n=int(input())
for i in range(n):
vw.append(list(map(int,input().split(','))))
dp=[]
weight=[]
for _ in range(n+1):
dp.append([0 for i in range(W+1)])
weight.append([0 for i in range(W+1)])
for i in range(1,n+1):
for j in range(0,W-vw[i][1]+1):
dp[i][j+vw[i][1]]=max(dp[i-1][j+vw[i][1]],dp[i-1][j]+vw[i][0])
if dp[i-1][j+vw[i][1]]==dp[i-1][j]+vw[i][0]:
weight[i][j+vw[i][1]]=min(weight[i-1][j]+vw[i][1],weight[i-1][j])
elif dp[i][j+vw[i][1]]==dp[i-1][j]+vw[i][0]:
weight[i][j+vw[i][1]]=weight[i-1][j]+vw[i][1]
else:
weight[i][j+vw[i][1]]=weight[i-1][j]
print('Case '+'{}'.format(count)+':')
print(dp[n][W])
print(weight[n][W])
count+=1
| 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s121343000 | p00042 | Wrong Answer | count=1
while True:
vw=[[0,0]]
W=int(input())
if W==0:
break
n=int(input())
for i in range(n):
vw.append(list(map(int,input().split(','))))
dp=[]
weight=[]
for _ in range(n+1):
dp.append([0 for i in range(W+1)])
weight.append([0 for i in range(W+1)])
for i in range(1,n+1):
for j in range(0,W-vw[i][1]+1):
dp[i][j+vw[i][1]]=max(dp[i-1][j+vw[i][1]],dp[i-1][j]+vw[i][0])
if dp[i-1][j+vw[i][1]]==dp[i-1][j]+vw[i][0]:
weight[i][j+vw[i][1]]=min(weight[i-1][j]+vw[i][1],weight[i-1][j+vw[i][1]])
elif dp[i][j+vw[i][1]]==dp[i-1][j]+vw[i][0]:
weight[i][j+vw[i][1]]=weight[i-1][j]+vw[i][1]
else:
weight[i][j+vw[i][1]]=weight[i-1][j+vw[i][1]]
print('Case '+'{}'.format(count)+':')
print(dp[n][W])
print(weight[n][W])
count+=1
| 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s162323798 | p00042 | Wrong Answer | import itertools
case = 0
while True:
case += 1
w_max = int(input())
if w_max == 0:
break
n = int(input())
t = []
for i in range(n):
t.append(list(map(int, input().split(","))))
v_best = 0
w_best = w_max
p_all = itertools.product([0,1], repeat=n)
for p in p_all:
v = 0
w = 0
for i in range(n):
v += p[i]*t[i][0]
w += p[i]*t[i][1]
if v > v_best and w < w_max:
v_best = v
w_best = w
elif v == v_best and w < w_best:
v_best = v
w_best = w
print("Case:",case)
print(v_best)
print(w_best)
| 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s060884170 | p00042 | Wrong Answer | import itertools
case = 0
while True:
case += 1
w_max = int(input())
if w_max == 0:
break
n = int(input())
t = []
for i in range(n):
t.append(list(map(int, input().split(","))))
v_best = 0
w_best = 0
p_all = itertools.product([0,1], repeat=n)
for p in p_all:
v = 0
w = 0
for i in range(n):
v += p[i]*t[i][0]
w += p[i]*t[i][1]
if v > v_best and w < w_max:
v_best = v
w_best = w
elif v == v_best and w < w_best:
v_best = v
w_best = w
print("Case:",case)
print(v_best)
print(w_best)
| 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s052406105 | p00042 | Wrong Answer | import itertools
case = 0
while True:
case += 1
w_max = int(input())
if w_max == 0:
break
n = int(input())
t = []
for i in range(n):
t.append(list(map(int, input().split(","))))
v_best = 0
w_best = 0
p_all = itertools.product([0,1], repeat=n)
for p in p_all:
v = 0
w = 0
for i in range(n):
v += p[i]*t[i][0]
w += p[i]*t[i][1]
if v > v_best and w < w_max:
v_best = v
w_best = w
elif v == v_best and w < w_best:
v_best = v
w_best = w
print("Case",case,":")
print(v_best)
print(w_best)
| 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s031248185 | p00042 | Wrong Answer | import itertools
case = 0
while True:
case += 1
w_max = int(input())
if w_max == 0:
break
n = int(input())
t = []
for i in range(n):
t.append(list(map(int, input().split(","))))
v_best = 0
w_best = 0
p_all = itertools.product([0,1], repeat=n)
for p in p_all:
v = 0
w = 0
for i in range(n):
v += p[i]*t[i][0]
w += p[i]*t[i][1]
if v > v_best and w < w_max:
v_best = v
w_best = w
elif v == v_best and w < w_best:
v_best = v
w_best = w
print("Case ",case,":",sep="")
print(v_best)
print(w_best)
| 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s420651133 | p00042 | Wrong Answer | """
0-1ナップザック
dp[i][j]...i個目までの宝で重さjの時の価値の最大
wi = wlst[i]...i個目の重さ
vi = vlst[i]...i個目の価値
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - wi] + vi) (wi <= j)
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) (wi > j)
"""
def main():
case = 0
while True:
w = int(input())
if not w:
break
case += 1
n = int(input())
vlst = [0]
wlst = [0]
for _ in range(n):
vin, win = map(int, input().split(","))
vlst.append(vin)
wlst.append(win)
dp = [[0 for _ in range(w + 1)] for _ in range(n + 1)]
for i in range(1, n + 1):
vi, wi = vlst[i], wlst[i]
dpi = dp[i]
dpim = dp[i - 1]
for j in range(1, w + 1):
if j >= wlst[i]:
dpi[j] = max(dpim[j], dpi[j - 1], dpim[j - wi] + vi)
else:
dpi[j] = max(dpi[j], dpi[j - 1])
print("Case " + str(case) + ":")
print(dp[n][w])
for i in range(w, -1, -1):
if dp[n][i] != dp[n][w]:
print(i + 1)
break
main()
| 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s361620393 | p00042 | Wrong Answer | # AOJ 0042 A Thief
# Python3 2018.6.22 bal4u
MAX = 1003
for cno in range(1, 100):
lim = int(input())
if lim == 0: break
print("Case ", cno, ":", sep='')
N = int(input())
vw = []
for i in range(N):
v, w = list(map(int, input().split(',')))
vw.append((v, w))
V = [[0 for j in range(MAX)] for i in range(2)]
W = [[0 for j in range(MAX)] for i in range(2)]
k1, k2 = 0, 1
for i in range(N):
for j in range(lim):
if vw[i][1] > j:
V[k2][j] = V[k1][j]
W[k2][j] = W[k1][j]
else:
d = j - vw[i][1]
if V[k1][d] + vw[i][0] >= V[k1][j]:
V[k2][j] = V[k1][d] + vw[i][0]
W[k2][j] = W[k1][d] + vw[i][1]
else:
V[k2][j] = V[k1][j]
W[k2][j] = W[k1][j];
k1, k2 = k2, 1-k1
print(V[k1][lim-1], W[k1][lim-1], sep='\n');
| 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s129210084 | p00042 | Wrong Answer |
import sys
class Treasure:
def __init__(self, value, weight):
self.value = value
self.weight = weight
def solv(treasures, w_limit):
treasures.sort(cmp_treasure)
swag = reduce(take_treasure(w_limit), treasures, (0, 0))
return swag
def cmp_treasure(a, b):
if a.value == b.value:
return cmp(a.weight, b.weight)
else:
return cmp(b.value, a.value)
def take_treasure(w):
def func(acc, t):
if acc[1] + t.weight <= w:
value = acc[0] + t.value
weight = acc[1] + t.weight
return (value, weight)
else:
return acc
return func
case = 0
while True:
w_limit = int(sys.stdin.readline())
case += 1
if w_limit == 0:
exit()
n = int(sys.stdin.readline())
treasures = []
for i in range(n):
v, w = map(int, sys.stdin.readline().split(','))
treasures.append(Treasure(v, w))
value, weight = solv(treasures, w_limit)
print 'Case ' + str(case) + ':'
print value
print weight | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s648208479 | p00042 | Wrong Answer |
import sys
class Treasure:
def __init__(self, value, weight):
self.value = value
self.weight = weight
def unit_value(self):
return self.value / self.weight
def solv(treasures, w_limit):
# treasures.sort(cmp_treasure)
treasures.sort(lambda t1, t2: cmp(t2.unit_value, t1.unit_value))
swag = reduce(take_treasure(w_limit), treasures, (0, 0))
return swag
def cmp_treasure(a, b):
if a.value == b.value:
return cmp(a.weight, b.weight)
else:
return cmp(b.value, a.value)
def take_treasure(w):
def func(acc, t):
if acc[1] + t.weight <= w:
value = acc[0] + t.value
weight = acc[1] + t.weight
return (value, weight)
else:
return acc
return func
case = 0
while True:
w_limit = int(sys.stdin.readline())
case += 1
if w_limit == 0:
exit()
n = int(sys.stdin.readline())
treasures = []
for i in range(n):
v, w = map(int, sys.stdin.readline().split(','))
treasures.append(Treasure(v, w))
value, weight = solv(treasures, w_limit)
print 'Case ' + str(case) + ':'
print value
print weight | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s093955220 | p00042 | Wrong Answer |
import sys
import itertools
class Treasure:
def __init__(self, value, weight):
self.value = value
self.weight = weight
def solv(treasures, w_limit):
treasures.sort(lambda a, b: cmp(b.value, a.value))
tvw = (0, 0)
for ts in t_combinations(treasures):
w = t_sum_weight(ts)
if w <= w_limit:
v = t_sum_value(ts)
if tvw[0] < v:
tvw = (v, w)
elif tvw[0] == v:
if w < tvw[1]:
tvw = (v, w)
return tvw
def t_combinations(t):
l = len(t)
for x in range(l+1, 1, -1):
for y in itertools.combinations(t, x):
yield y
def t_sum_weight(ts):
return sum(map(lambda x: x.weight, ts))
def t_sum_value(ts):
return sum(map(lambda x: x.value, ts))
def rightest(tss):
return reduce(lambda a, b: take_right(a, b), tss)
def take_right(a, b):
if t_sum_weight(a) <= t_sum_weight(b):
return a
else:
return b
case = 0
while True:
weight_limit = int(sys.stdin.readline())
case += 1
if weight_limit == 0:
exit()
n = int(sys.stdin.readline())
treasures = []
for i in range(n):
v, w = map(int, sys.stdin.readline().split(','))
treasures.append(Treasure(v, w))
value, weight = solv(treasures, weight_limit)
print 'Case ' + str(case) + ':'
print value
print weight | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s876200215 | p00042 | Wrong Answer | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
from itertools import count, combinations
for case in count(1):
W = int(stdin.readline())
if not W:
break
N = int(stdin.readline())
data = []
for _ in range(N):
data.append([int(s) for s in stdin.readline().split(',')])
total = []
for i in range(1, N+1):
for cmb in combinations(data, i):
tv, tw = 0, 0
for value, weight in cmb:
tv += value
tw += weight
if tw < W:
total.append((tv, tw))
if len(total):
tv, tw = max(total, key=lambda(tv, tw): (tv, -tw))
else:
tv, tw = 0, 0
print('Case {}:\n{}\n{}'.format(case, tv, tw)) | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s706394475 | p00042 | Wrong Answer | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
from itertools import count, combinations
for case in count(1):
W = int(stdin.readline().strip())
if not W:
break
N = int(stdin.readline().strip())
data = []
for _ in range(N):
data.append([int(s) for s in stdin.readline().split(',')])
total = []
for i in range(1, N+1):
for cmb in combinations(data, i):
tv, tw = 0, 0
for value, weight in cmb:
tv += value
tw += weight
if tw < W:
total.append((tv, tw))
if len(total):
tv, tw = max(total, key=lambda(tv, tw): (tv, -tw))
else:
tv, tw = 0, 0
print('Case {}:\n{}\n{}'.format(case, tv, tw)) | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s467709846 | p00042 | Wrong Answer | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
from itertools import count, combinations
for case in count(1):
W = int(stdin.readline().strip())
if not W:
break
N = int(stdin.readline().strip())
data = []
for _ in range(N):
data.append([int(s) for s in stdin.readline().strip().split(',')])
total = []
for i in range(1, N+1):
for cmb in combinations(data, i):
tv, tw = 0, 0
for value, weight in cmb:
tv += value
tw += weight
if tw < W:
total.append((tv, tw))
if len(total):
tv, tw = max(total, key=lambda(tv, tw): (tv, -tw))
else:
tv, tw = 0, 0
print('Case {}:\n{}\n{}'.format(case, tv, tw)) | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s747563878 | p00042 | Wrong Answer | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
from itertools import count, combinations
for case in count(1):
W = int(stdin.readline().strip())
if not W:
break
N = int(stdin.readline().strip())
data = []
for _ in range(N):
data.append([int(s) for s in stdin.readline().strip().split(',')])
total = []
for i in range(1, N+1):
for cmb in combinations(data, i):
tv, tw = 0, 0
for value, weight in cmb:
tv += value
tw += weight
if tw <= W-1:
total.append((tv, tw))
if len(total):
tv, tw = max(total, key=lambda(tv, tw): (tv, -tw))
else:
tv, tw = 0, 0
print('Case {}:\n{}\n{}'.format(case, tv, tw)) | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s940448336 | p00042 | Wrong Answer | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
from itertools import count, combinations
for case in count(1):
WEIGHT = int(stdin.readline().strip())
if not WEIGHT:
break
NUM = int(stdin.readline().strip())
data = []
for _ in range(NUM):
data.append([int(s) for s in stdin.readline().strip().split(',')])
total = []
for i in range(1, NUM+1):
for cmb in combinations(data, i):
tw = sum(w for v, w in cmb)
if tw < WEIGHT:
total.append((sum(v for v, w in cmb), tw))
if len(total):
tv, tw = max(total, key=lambda(tv, tw): (tv, -tw))
else:
tv, tw = 0, 0
print('Case {}:\n{}\n{}'.format(case, tv, tw)) | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s295556674 | p00042 | Wrong Answer | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
from itertools import count, combinations
for case in count(1):
WEIGHT = int(stdin.readline().strip())
if not WEIGHT:
break
NUM = int(stdin.readline().strip())
data = []
for _ in range(NUM):
data.append([int(s) for s in stdin.readline().strip().split(',')])
total = []
for i in range(1, NUM+1):
for cmb in combinations(data, i):
tw = sum(w for v, w in cmb)
if WEIGHT > tw:
total.append((sum(v for v, w in cmb), tw))
if len(total):
tv, tw = max(total, key=lambda(tv, tw): (tv, -tw))
else:
tv, tw = 0, 0
print('Case {}:\n{}\n{}'.format(case, tv, tw)) | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s690061217 | p00042 | Wrong Answer | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
from itertools import count, combinations
for case in count(1):
WEIGHT = int(stdin.readline().strip())
if not WEIGHT:
break
NUM = int(stdin.readline().strip())
data = []
for _ in range(NUM):
data.append([int(s) for s in stdin.readline().strip().split(',')])
total = []
for i in range(1, NUM+1):
for cmb in combinations(data, i):
tw = sum(w for v, w in cmb)
if WEIGHT > tw:
total.append((sum(v for v, w in cmb), tw))
print(total)
if len(total):
tv, tw = max(total, key=lambda(tv, tw): (tv, -tw))
else:
tv, tw = 0, 0
print('Case {}:\n{}\n{}'.format(case, tv, tw)) | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s234638941 | p00042 | Wrong Answer | count =0
while True:
W = input()
if (W==0): break
work={0:0}
count +=1
N = input()
for i in range(N):
p,w = input()
for w0 in work.keys():
w1 = w0+w
p1 = work[w0]+p
if w1>W or (work.has_key(w1) and work[w1]>=p1): continue
work[w1] = p1
m = max(work.values())
tmp = work.values().index(m)
n = work.keys()[tmp]
print "Case %d:" %(count)
print m
print n | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s486225809 | p00042 | Wrong Answer | count =0
while True:
W = input()
if W==0: break
work=[0]*1001
count +=1
N = input()
m=0
n=0
for i in range(N):
p,w = input()
for w0 in range(W+1)[::-1]:
p0 = work[w0]
if w0>0 and p0==0: continue
w1 = w0+w
p1 = p0+p
if w1<W and work[w1]<p1:
work[w1] = p1
if m<p1:
m=p1
n=w1
print "Case {}:".format(count)
print m
print n
| 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s030915902 | p00042 | Wrong Answer | def f():
global dt
p,w = input()
R = range(W+1)[::-1]
for w0 in R[:-1]:
w1,p1 = w0+w,dt[w0]+p
if w1<=W and dt[w1]<p1: dt[w1]=p1
dt[w]=dt[0]+p
return
c = 0
while 1:
W = input()
if W==0: break
dt = [0]*1001
c += 1
N = input()
for i in range(N): f()
m = max(dt)
n = dt.index(m)
print "Case {}:".format(c)
print m
print n | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s721088382 | p00042 | Wrong Answer | def mlist(n, *args, **keys):
if args:
return [mlist(*args, **keys) for i in range(n)]
else:
return [keys.get('default')] * n
while True:
w = int(raw_input())
if w == 0: break
n = int(raw_input())
a, b = zip(*[map(int, raw_input().split(',')) for i in range(n)])
c = mlist(1010, 1010)
c[0][0] = 0
for i in range(n):
for j in range(w + 1):
if c[i][j] is None: continue
c[i + 1][j] = max(c[i + 1][j], c[i][j])
if j + b[i] <= w:
c[i + 1][j + b[i]] = max(c[i + 1][j + b[i]], c[i][j] + a[i])
mx = max(c[n])
print mx
print c[n].index(mx) | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s054694074 | p00042 | Time Limit Exceeded | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from itertools import *
from sys import *
def solve(n,w):
lp,lw = [],[]
for i in xrange(n):
s = map(int, raw_input().split(","))
lp.append(s[0])
lw.append(s[1])
mp = mw = 0
for e in product([0,1],repeat=n):
cw = sum([ lw[i] for i in range(len(e)) if e[i] ])
cp = sum([ lp[i] for i in range(len(e)) if e[i] ])
if cp == mp and mw > cw: mw = cw
if w >= cw and cp > mp: mp = cp; mw = cw
print mp
print mw
case = 0
while True:
case += 1
w = int(raw_input())
if w == 0: break
n = int(raw_input())
print "Case %d:" % (case)
solve(n,w) | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s783294303 | p00042 | Time Limit Exceeded | def furoshiki(i, w_limit):
global treasures
if not i or not w_limit:
return (0, 0)
v, w = treasures[i - 1]
not_stole = furoshiki(i - 1, w_limit)
if w_limit < w:
return not_stole
stole_v_total, stole_w_total = furoshiki(i - 1, w_limit - w)
stole_v_total += v
stole_w_total -= w
return max(not_stole, (stole_v_total, stole_w_total))
case = 1
while True:
w = int(input())
if not w:
break
n = int(input())
treasures = [None] * n
for i in range(n):
treasures[i] = tuple(map(int, input().split(',')))
total_v, total_w = furoshiki(n, w)
print('Case {}:'.format(case))
print(total_v)
print(-total_w)
case += 1 | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s760441953 | p00042 | Time Limit Exceeded | memo = {}
def furoshiki(i, w_limit):
global memo, treasures
if not i or not w_limit:
return (0, 0)
if (i, w_limit) in memo:
return memo[(i, w_limit)]
v, w = treasures[i - 1]
not_stole = furoshiki(i - 1, w_limit)
if w_limit < w:
return not_stole
stole_v_total, stole_w_total = furoshiki(i - 1, w_limit - w)
stole_v_total += v
stole_w_total -= w
return max(not_stole, (stole_v_total, stole_w_total))
case = 1
while True:
w = int(input())
if not w:
break
n = int(input())
treasures = [None] * n
for i in range(n):
treasures[i] = tuple(map(int, input().split(',')))
total_v, total_w = furoshiki(n, w)
print('Case {}:'.format(case))
print(total_v)
print(-total_w)
memo.clear()
case += 1 | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s981117355 | p00042 | Time Limit Exceeded | import re
def solve(w,v):
n = len(v)
val0 = 0
wgt0 = 0
for i in range(1,2**n):
s = bin(i)
s1 = '0'*n + re.sub(r'0b', '', s)
t = list(map(int, list(s1[-n:])))
val = wgt = 0
for i in range(n):
if t[i]==1:
val += v[i][0]
wgt += v[i][1]
if wgt > w:
continue
if val > val0 or (val==val0 and wgt<wgt0):
val0 = val
wgt0 = wgt
return(val0,wgt0)
case=0
while True:
case += 1
f = []
wlim = int(input().strip())
if wlim==0:
break
n = int(input().strip())
for i in range(n):
v,w = map(int,input().strip().split(','))
f.append((v,w))
val,wgt = solve(wlim,f)
print('Case %d:' % case)
print(val)
print(wgt) | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s330868610 | p00042 | Time Limit Exceeded | import re
def solve(w,v):
n = len(v)
val0 = 0
wgt0 = 0
for i in range(1,2**n):
s = bin(i)
s1 = '0'*n + re.sub(r'0b', '', s)
t = list(map(int, list(s1[-n:])))
val = wgt = 0
for i in range(n):
if t[i]==1:
val += v[i][0]
wgt += v[i][1]
if wgt > w:
break
if wgt > w:
continue
if val > val0 or (val==val0 and wgt<wgt0):
val0 = val
wgt0 = wgt
return(val0,wgt0)
case=0
while True:
case += 1
f = []
wlim = int(input().strip())
if wlim==0:
break
n = int(input().strip())
for i in range(n):
v,w = map(int,input().strip().split(','))
f.append((v,w))
val,wgt = solve(wlim,f)
print('Case %d:' % case)
print(val)
print(wgt) | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s778843038 | p00042 | Time Limit Exceeded | def ns(vs, ws, i, j):
if i == len(vs):
return [0, 0]
else:
if ws[i] > j:
return ns(vs, ws, i+1, j)
else:
vwoi, wwoi = ns(vs, ws, i+1, j)
tmp = ns(vs, ws, i+1, j-ws[i])
return max(ns(vs, ws, i+1, j), [vs[i]+tmp[0], ws[i]+tmp[1]], key = lambda x: x[0])
casenum = 1
while True:
W = int(input())
if W == 0:
break
N = int(input())
vs, ws = [], []
for _ in range(N):
v, w = map(int, input().split(','))
vs.append(v)
ws.append(w)
v, w = ns(vs, ws, 0, W)
print('Case ' + str(casenum) + ':')
print(v)
print(w)
casenum += 1 | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s505380398 | p00042 | Time Limit Exceeded | # -*- coding: utf-8 -*-
import sys
import os
import math
import itertools
case = 1
for s in sys.stdin:
W = int(s)
if W == 0:
break
N = int(input())
values = []
weights = []
for i in range(N):
v, w = map(int, input().split(','))
values.append(v)
weights.append(w)
max_value = 0
max_value_weight = 0
for use_flags in itertools.product([0, 1], repeat=len(weights)):
sum_value = 0
sum_weight = 0
for i, use_flag in enumerate(use_flags):
if use_flag == 1:
sum_value += values[i]
sum_weight += weights[i]
if sum_weight <= W and sum_value > max_value:
max_value = sum_value
max_value_weight = sum_weight
print('Case {}:'.format(case))
case += 1
print(max_value)
print(max_value_weight) | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s578653006 | p00042 | Time Limit Exceeded | import itertools
case = 0
while True:
case += 1
w_max = int(input())
if w_max == 0:
break
n = int(input())
t = []
for i in range(n):
t.append(list(map(int, input().split(","))))
v_best = 0
w_best = 0
p_all = itertools.product([0,1], repeat=n)
for p in p_all:
v = 0
w = 0
for i in range(n):
v += p[i]*t[i][0]
w += p[i]*t[i][1]
if v > v_best and w <= w_max:
v_best = v
w_best = w
elif v == v_best and w < w_best:
v_best = v
w_best = w
print("Case ",case,":",sep="")
print(v_best)
print(w_best)
| 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s328392428 | p00042 | Time Limit Exceeded |
import sys
import itertools
class Treasure:
def __init__(self, value, weight):
self.value = value
self.weight = weight
def solv(treasures, w_limit):
tvw = (0, 0)
for ts in t_combinations(treasures):
w = t_sum_weight(ts)
if w <= w_limit:
v = t_sum_value(ts)
if tvw[0] < v:
tvw = (v, w)
elif tvw[0] == v:
if w < tvw[1]:
tvw = (v, w)
return tvw
def t_combinations(t):
l = len(t)
for x in range(1, l+1):
for y in itertools.combinations(t, x):
yield y
def t_sum_weight(ts):
return sum(map(lambda x: x.weight, ts))
def t_sum_value(ts):
return sum(map(lambda x: x.value, ts))
def rightest(tss):
return reduce(lambda a, b: take_right(a, b), tss)
def take_right(a, b):
if t_sum_weight(a) <= t_sum_weight(b):
return a
else:
return b
case = 0
while True:
weight_limit = int(sys.stdin.readline())
case += 1
if weight_limit == 0:
exit()
n = int(sys.stdin.readline())
treasures = []
for i in range(n):
v, w = map(int, sys.stdin.readline().split(','))
treasures.append(Treasure(v, w))
value, weight = solv(treasures, weight_limit)
print 'Case ' + str(case) + ':'
print value
print weight | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s708133270 | p00042 | Time Limit Exceeded |
import sys
import itertools
class Treasure:
def __init__(self, value, weight):
self.value = value
self.weight = weight
def solv(treasures, w_limit):
treasures.sort(lambda a, b: cmp(b.value, a.value))
tvw = (0, 0)
for ts in t_combinations(treasures):
w = t_sum_weight(ts)
if w <= w_limit:
v = t_sum_value(ts)
if tvw[0] < v:
tvw = (v, w)
elif tvw[0] == v:
if w < tvw[1]:
tvw = (v, w)
return tvw
def t_combinations(t):
l = len(t)
for x in range(l, 0, -1):
for y in itertools.combinations(t, x):
yield y
def t_sum_weight(ts):
return sum(map(lambda x: x.weight, ts))
def t_sum_value(ts):
return sum(map(lambda x: x.value, ts))
def rightest(tss):
return reduce(lambda a, b: take_right(a, b), tss)
def take_right(a, b):
if t_sum_weight(a) <= t_sum_weight(b):
return a
else:
return b
case = 0
while True:
weight_limit = int(sys.stdin.readline())
case += 1
if weight_limit == 0:
exit()
n = int(sys.stdin.readline())
treasures = []
for i in range(n):
v, w = map(int, sys.stdin.readline().split(','))
treasures.append(Treasure(v, w))
value, weight = solv(treasures, weight_limit)
print 'Case ' + str(case) + ':'
print value
print weight | 50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.