submission_id string | problem_id string | status string | code string | input string | output string | problem_description string |
|---|---|---|---|---|---|---|
s492298158 | p00055 | Accepted | while 1:
try:
n = input()
except EOFError:
break
ret = n
for i in xrange(9):
if i % 2:
n /= 3
else:
n *= 2
ret += n
print ret | 1.0
2.0
3.0
| 7.81481481
15.62962963
23.44444444
|
<H1>数列</H1>
<p>
次のように定義されている数列があります。
</p>
<ul>
<li>すべての偶数番目の項は一つ前の項に 2 を掛けたものと等しい数である。</li>
<li>すべての奇数番目の項は一つ前の項を 3 で割ったものと等しい数である。</li>
</ul>
<p>
この数列の初項 <var>a</var> を読み込み、初項から第 10 項までの和 <var>s(10)</var> を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のテストケースからなります。各テストケースとして、数列の初項を表す実数 <var>a</var> (1.0 ≤ <var>a</var> ≤ 10.0) が１行に与えられます。
</p>
<p>
テストケースの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
テストケースごとに <var>s(10)</var> を１行に出力します。
</p>
<p>
出力は0.000001以下の誤差を含んでもよい。
</p>
<H2>Sample Input</H2>
<pre>
1.0
2.0
3.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
7.81481481
15.62962963
23.44444444
</pre>
|
s908098874 | p00055 | Accepted | while True:
try:
s = input()
except EOFError:
break
a = float(s)
x = 0
for i in range(5):
x += a
a *= 2
x += a
a /= 3
print(x) | 1.0
2.0
3.0
| 7.81481481
15.62962963
23.44444444
|
<H1>数列</H1>
<p>
次のように定義されている数列があります。
</p>
<ul>
<li>すべての偶数番目の項は一つ前の項に 2 を掛けたものと等しい数である。</li>
<li>すべての奇数番目の項は一つ前の項を 3 で割ったものと等しい数である。</li>
</ul>
<p>
この数列の初項 <var>a</var> を読み込み、初項から第 10 項までの和 <var>s(10)</var> を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のテストケースからなります。各テストケースとして、数列の初項を表す実数 <var>a</var> (1.0 ≤ <var>a</var> ≤ 10.0) が１行に与えられます。
</p>
<p>
テストケースの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
テストケースごとに <var>s(10)</var> を１行に出力します。
</p>
<p>
出力は0.000001以下の誤差を含んでもよい。
</p>
<H2>Sample Input</H2>
<pre>
1.0
2.0
3.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
7.81481481
15.62962963
23.44444444
</pre>
|
s031563647 | p00055 | Accepted | while True:
try:
a = float(input())
except:
break
S = [a]
for i in range(2,11):
if i%2==0:
Si = S[i-2] * 2
S.append(Si)
if i%2==1:
Si = S[i-2] / 3
S.append(Si)
print(f'{sum(S):.6f}')
| 1.0
2.0
3.0
| 7.81481481
15.62962963
23.44444444
|
<H1>数列</H1>
<p>
次のように定義されている数列があります。
</p>
<ul>
<li>すべての偶数番目の項は一つ前の項に 2 を掛けたものと等しい数である。</li>
<li>すべての奇数番目の項は一つ前の項を 3 で割ったものと等しい数である。</li>
</ul>
<p>
この数列の初項 <var>a</var> を読み込み、初項から第 10 項までの和 <var>s(10)</var> を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のテストケースからなります。各テストケースとして、数列の初項を表す実数 <var>a</var> (1.0 ≤ <var>a</var> ≤ 10.0) が１行に与えられます。
</p>
<p>
テストケースの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
テストケースごとに <var>s(10)</var> を１行に出力します。
</p>
<p>
出力は0.000001以下の誤差を含んでもよい。
</p>
<H2>Sample Input</H2>
<pre>
1.0
2.0
3.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
7.81481481
15.62962963
23.44444444
</pre>
|
s540385446 | p00055 | Accepted | while True :
try :
a = float(input())
except EOFError :
break
S = []
S.append(0)
S.append(a)
for i in range(2, 11) :
if i % 2 == 0 :
S.append(S[i-1] * 2)
else :
S.append(S[i-1] / 3)
print(sum(S))
| 1.0
2.0
3.0
| 7.81481481
15.62962963
23.44444444
|
<H1>数列</H1>
<p>
次のように定義されている数列があります。
</p>
<ul>
<li>すべての偶数番目の項は一つ前の項に 2 を掛けたものと等しい数である。</li>
<li>すべての奇数番目の項は一つ前の項を 3 で割ったものと等しい数である。</li>
</ul>
<p>
この数列の初項 <var>a</var> を読み込み、初項から第 10 項までの和 <var>s(10)</var> を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のテストケースからなります。各テストケースとして、数列の初項を表す実数 <var>a</var> (1.0 ≤ <var>a</var> ≤ 10.0) が１行に与えられます。
</p>
<p>
テストケースの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
テストケースごとに <var>s(10)</var> を１行に出力します。
</p>
<p>
出力は0.000001以下の誤差を含んでもよい。
</p>
<H2>Sample Input</H2>
<pre>
1.0
2.0
3.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
7.81481481
15.62962963
23.44444444
</pre>
|
s060183056 | p00055 | Accepted | import sys
readlines = sys.stdin.readlines
write = sys.stdout.write
def solve():
for line in readlines():
a = float(line)
s = 0
for i in range(10):
s += a
if i % 2:
a /= 3
else:
a *= 2
write("%.16f\n" % s)
solve()
| 1.0
2.0
3.0
| 7.81481481
15.62962963
23.44444444
|
<H1>数列</H1>
<p>
次のように定義されている数列があります。
</p>
<ul>
<li>すべての偶数番目の項は一つ前の項に 2 を掛けたものと等しい数である。</li>
<li>すべての奇数番目の項は一つ前の項を 3 で割ったものと等しい数である。</li>
</ul>
<p>
この数列の初項 <var>a</var> を読み込み、初項から第 10 項までの和 <var>s(10)</var> を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のテストケースからなります。各テストケースとして、数列の初項を表す実数 <var>a</var> (1.0 ≤ <var>a</var> ≤ 10.0) が１行に与えられます。
</p>
<p>
テストケースの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
テストケースごとに <var>s(10)</var> を１行に出力します。
</p>
<p>
出力は0.000001以下の誤差を含んでもよい。
</p>
<H2>Sample Input</H2>
<pre>
1.0
2.0
3.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
7.81481481
15.62962963
23.44444444
</pre>
|
s122038369 | p00055 | Accepted | while True:
try:
a1 = float(input())
ans = beforeNum = a1
for i in range(2,11):
if i % 2 == 0:
beforeNum *= 2
else:
beforeNum /= 3
ans += beforeNum
print(ans)
except:
break
| 1.0
2.0
3.0
| 7.81481481
15.62962963
23.44444444
|
<H1>数列</H1>
<p>
次のように定義されている数列があります。
</p>
<ul>
<li>すべての偶数番目の項は一つ前の項に 2 を掛けたものと等しい数である。</li>
<li>すべての奇数番目の項は一つ前の項を 3 で割ったものと等しい数である。</li>
</ul>
<p>
この数列の初項 <var>a</var> を読み込み、初項から第 10 項までの和 <var>s(10)</var> を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のテストケースからなります。各テストケースとして、数列の初項を表す実数 <var>a</var> (1.0 ≤ <var>a</var> ≤ 10.0) が１行に与えられます。
</p>
<p>
テストケースの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
テストケースごとに <var>s(10)</var> を１行に出力します。
</p>
<p>
出力は0.000001以下の誤差を含んでもよい。
</p>
<H2>Sample Input</H2>
<pre>
1.0
2.0
3.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
7.81481481
15.62962963
23.44444444
</pre>
|
s919848777 | p00055 | Accepted | while True:
try:
n=float(input())
except:
break
num=2
tmp=round(n,9)
total=round(n,9)
while num<=10:
if num%2==0:
tmp=round(tmp*2,9)
else:
tmp=round(tmp/3,9)
total+=tmp
num+=1
print(round(total,8))
| 1.0
2.0
3.0
| 7.81481481
15.62962963
23.44444444
|
<H1>数列</H1>
<p>
次のように定義されている数列があります。
</p>
<ul>
<li>すべての偶数番目の項は一つ前の項に 2 を掛けたものと等しい数である。</li>
<li>すべての奇数番目の項は一つ前の項を 3 で割ったものと等しい数である。</li>
</ul>
<p>
この数列の初項 <var>a</var> を読み込み、初項から第 10 項までの和 <var>s(10)</var> を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のテストケースからなります。各テストケースとして、数列の初項を表す実数 <var>a</var> (1.0 ≤ <var>a</var> ≤ 10.0) が１行に与えられます。
</p>
<p>
テストケースの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
テストケースごとに <var>s(10)</var> を１行に出力します。
</p>
<p>
出力は0.000001以下の誤差を含んでもよい。
</p>
<H2>Sample Input</H2>
<pre>
1.0
2.0
3.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
7.81481481
15.62962963
23.44444444
</pre>
|
s891483083 | p00055 | Accepted | while True:
try:
f = float(input())
except:
break
L = [None]*10
L[0] = f
for i in range(1,10):
if i % 2 > 0:
L[i] = L[i-1] *2
else:
L[i] = L[i-1] /3
print("{:.8f}".format(sum(L)))
| 1.0
2.0
3.0
| 7.81481481
15.62962963
23.44444444
|
<H1>数列</H1>
<p>
次のように定義されている数列があります。
</p>
<ul>
<li>すべての偶数番目の項は一つ前の項に 2 を掛けたものと等しい数である。</li>
<li>すべての奇数番目の項は一つ前の項を 3 で割ったものと等しい数である。</li>
</ul>
<p>
この数列の初項 <var>a</var> を読み込み、初項から第 10 項までの和 <var>s(10)</var> を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のテストケースからなります。各テストケースとして、数列の初項を表す実数 <var>a</var> (1.0 ≤ <var>a</var> ≤ 10.0) が１行に与えられます。
</p>
<p>
テストケースの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
テストケースごとに <var>s(10)</var> を１行に出力します。
</p>
<p>
出力は0.000001以下の誤差を含んでもよい。
</p>
<H2>Sample Input</H2>
<pre>
1.0
2.0
3.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
7.81481481
15.62962963
23.44444444
</pre>
|
s631808251 | p00055 | Accepted | while True:
try:
a = []
a.append(float(input()))
except:
break
for i in range(2,11):
a.append(a[i - 2]*2 if i%2==0 else a[i-2]/3)
print(sum(a))
| 1.0
2.0
3.0
| 7.81481481
15.62962963
23.44444444
|
<H1>数列</H1>
<p>
次のように定義されている数列があります。
</p>
<ul>
<li>すべての偶数番目の項は一つ前の項に 2 を掛けたものと等しい数である。</li>
<li>すべての奇数番目の項は一つ前の項を 3 で割ったものと等しい数である。</li>
</ul>
<p>
この数列の初項 <var>a</var> を読み込み、初項から第 10 項までの和 <var>s(10)</var> を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のテストケースからなります。各テストケースとして、数列の初項を表す実数 <var>a</var> (1.0 ≤ <var>a</var> ≤ 10.0) が１行に与えられます。
</p>
<p>
テストケースの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
テストケースごとに <var>s(10)</var> を１行に出力します。
</p>
<p>
出力は0.000001以下の誤差を含んでもよい。
</p>
<H2>Sample Input</H2>
<pre>
1.0
2.0
3.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
7.81481481
15.62962963
23.44444444
</pre>
|
s651201945 | p00055 | Accepted | while 1:
try:
be = float(input())
sum = be
for i in range(2, 11):
if i % 2 == 0:
be *= 2
sum += be
if i % 2 == 1:
be /= 3
sum += be
print(sum)
except:
break
| 1.0
2.0
3.0
| 7.81481481
15.62962963
23.44444444
|
<H1>数列</H1>
<p>
次のように定義されている数列があります。
</p>
<ul>
<li>すべての偶数番目の項は一つ前の項に 2 を掛けたものと等しい数である。</li>
<li>すべての奇数番目の項は一つ前の項を 3 で割ったものと等しい数である。</li>
</ul>
<p>
この数列の初項 <var>a</var> を読み込み、初項から第 10 項までの和 <var>s(10)</var> を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のテストケースからなります。各テストケースとして、数列の初項を表す実数 <var>a</var> (1.0 ≤ <var>a</var> ≤ 10.0) が１行に与えられます。
</p>
<p>
テストケースの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
テストケースごとに <var>s(10)</var> を１行に出力します。
</p>
<p>
出力は0.000001以下の誤差を含んでもよい。
</p>
<H2>Sample Input</H2>
<pre>
1.0
2.0
3.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
7.81481481
15.62962963
23.44444444
</pre>
|
s244933594 | p00055 | Accepted | import sys
for line in sys.stdin:
a = float(line)
S = a
for i in range(2, 11):
if i % 2 == 0:
a *= 2
else:
a /= 3
S += a
print(S)
| 1.0
2.0
3.0
| 7.81481481
15.62962963
23.44444444
|
<H1>数列</H1>
<p>
次のように定義されている数列があります。
</p>
<ul>
<li>すべての偶数番目の項は一つ前の項に 2 を掛けたものと等しい数である。</li>
<li>すべての奇数番目の項は一つ前の項を 3 で割ったものと等しい数である。</li>
</ul>
<p>
この数列の初項 <var>a</var> を読み込み、初項から第 10 項までの和 <var>s(10)</var> を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のテストケースからなります。各テストケースとして、数列の初項を表す実数 <var>a</var> (1.0 ≤ <var>a</var> ≤ 10.0) が１行に与えられます。
</p>
<p>
テストケースの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
テストケースごとに <var>s(10)</var> を１行に出力します。
</p>
<p>
出力は0.000001以下の誤差を含んでもよい。
</p>
<H2>Sample Input</H2>
<pre>
1.0
2.0
3.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
7.81481481
15.62962963
23.44444444
</pre>
|
s847743602 | p00055 | Accepted | # coding=utf-8
###
### for python program
###
import sys
import math
# math class
class mymath:
### pi
pi = 3.14159265358979323846264338
### Prime Number
def pnum_eratosthenes(self, n):
ptable = [0 for i in range(n+1)]
plist = []
for i in range(2, n+1):
if ptable[i]==0:
plist.append(i)
for j in range(i+i, n+1, i):
ptable[j] = 1
return plist
### GCD
def gcd(self, a, b):
if b == 0:
return a
return self.gcd(b, a%b)
### LCM
def lcm(self, a, b):
return (a*b)//self.gcd(a,b)
### Mat Multiplication
def mul(self, A, B):
ans = []
for a in A:
c = 0
for j, row in enumerate(a):
c += row*B[j]
ans.append(c)
return ans
mymath = mymath()
### output class
class output:
### list
def list(self, l):
l = list(l)
#print(" ", end="")
for i, num in enumerate(l):
print(num, end="")
if i != len(l)-1:
print(" ", end="")
print()
output = output()
### input sample
#i = input()
#N = int(input())
#A, B, C = [x for x in input().split()]
#N, K = [int(x) for x in input().split()]
#inlist = [int(w) for w in input().split()]
#R = float(input())
#A.append(list(map(int,input().split())))
#for line in sys.stdin.readlines():
# x, y = [int(temp) for temp in line.split()]
#abc list
#abc = [chr(ord('a') + i) for i in range(26)]
### output sample
# print("{0} {1} {2:.5f}".format(A//B, A%B, A/B))
# print("{0:.6f} {1:.6f}".format(R*R*math.pi,R*2*math.pi))
# print(" {}".format(i), end="")
# def printA(A):
# for i, n in enumerate(A):
# print(n, end='')
# if i != N-1:
# print(' ', end='')
# print()
# リスト内包表記 ifあり
# [x-k if x != 0 else x for x in C]
# ソート
# N = N.sort()
# 10000個の素数リスト
# P = mymath.pnum_eratosthenes(105000)
def is_integer(n):
try:
float(n)
except ValueError:
return False
else:
return float(n).is_integer()
def dist(A, B):
d = 0
for i in range(len(A)):
d += (A[i]-B[i])**2
d = d**(1/2)
return d
def get_input():
N = []
while True:
try:
#N.append(input())
#N.append(int(input()))
N.append(float(input()))
except EOFError:
break
return N
N = get_input()
for ans in N:
pre = ans
for i in range(2,11):
if i % 2 == 0:
pre = (pre*2)
ans += pre
else:
pre = (pre/3)
ans += pre
print(ans)
| 1.0
2.0
3.0
| 7.81481481
15.62962963
23.44444444
|
<H1>数列</H1>
<p>
次のように定義されている数列があります。
</p>
<ul>
<li>すべての偶数番目の項は一つ前の項に 2 を掛けたものと等しい数である。</li>
<li>すべての奇数番目の項は一つ前の項を 3 で割ったものと等しい数である。</li>
</ul>
<p>
この数列の初項 <var>a</var> を読み込み、初項から第 10 項までの和 <var>s(10)</var> を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のテストケースからなります。各テストケースとして、数列の初項を表す実数 <var>a</var> (1.0 ≤ <var>a</var> ≤ 10.0) が１行に与えられます。
</p>
<p>
テストケースの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
テストケースごとに <var>s(10)</var> を１行に出力します。
</p>
<p>
出力は0.000001以下の誤差を含んでもよい。
</p>
<H2>Sample Input</H2>
<pre>
1.0
2.0
3.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
7.81481481
15.62962963
23.44444444
</pre>
|
s984741085 | p00055 | Accepted | while 1:
try:
print(7.81481481*float(input()))
except:break
| 1.0
2.0
3.0
| 7.81481481
15.62962963
23.44444444
|
<H1>数列</H1>
<p>
次のように定義されている数列があります。
</p>
<ul>
<li>すべての偶数番目の項は一つ前の項に 2 を掛けたものと等しい数である。</li>
<li>すべての奇数番目の項は一つ前の項を 3 で割ったものと等しい数である。</li>
</ul>
<p>
この数列の初項 <var>a</var> を読み込み、初項から第 10 項までの和 <var>s(10)</var> を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のテストケースからなります。各テストケースとして、数列の初項を表す実数 <var>a</var> (1.0 ≤ <var>a</var> ≤ 10.0) が１行に与えられます。
</p>
<p>
テストケースの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
テストケースごとに <var>s(10)</var> を１行に出力します。
</p>
<p>
出力は0.000001以下の誤差を含んでもよい。
</p>
<H2>Sample Input</H2>
<pre>
1.0
2.0
3.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
7.81481481
15.62962963
23.44444444
</pre>
|
s105173646 | p00055 | Accepted | while 1:
try:
n=[0]*10
n[0]=float(input())
for i in range(1,10):
if i%2==1:
n[i]=n[i-1]*2
elif i%2==0:
n[i]=n[i-1]/3
print(f'{sum(n):.8f}')
except:break
| 1.0
2.0
3.0
| 7.81481481
15.62962963
23.44444444
|
<H1>数列</H1>
<p>
次のように定義されている数列があります。
</p>
<ul>
<li>すべての偶数番目の項は一つ前の項に 2 を掛けたものと等しい数である。</li>
<li>すべての奇数番目の項は一つ前の項を 3 で割ったものと等しい数である。</li>
</ul>
<p>
この数列の初項 <var>a</var> を読み込み、初項から第 10 項までの和 <var>s(10)</var> を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のテストケースからなります。各テストケースとして、数列の初項を表す実数 <var>a</var> (1.0 ≤ <var>a</var> ≤ 10.0) が１行に与えられます。
</p>
<p>
テストケースの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
テストケースごとに <var>s(10)</var> を１行に出力します。
</p>
<p>
出力は0.000001以下の誤差を含んでもよい。
</p>
<H2>Sample Input</H2>
<pre>
1.0
2.0
3.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
7.81481481
15.62962963
23.44444444
</pre>
|
s161729501 | p00055 | Accepted | while(1):
try:
a = float(input())
b = []
for i in range(10):
if i == 0:
b.append(a)
else:
if i%2 == 0:
a = a/3
b.append(a)
else:
a = a*2
b.append(a)
s = sum(b)
print("{:.8f}".format(s))
except EOFError:
break
| 1.0
2.0
3.0
| 7.81481481
15.62962963
23.44444444
|
<H1>数列</H1>
<p>
次のように定義されている数列があります。
</p>
<ul>
<li>すべての偶数番目の項は一つ前の項に 2 を掛けたものと等しい数である。</li>
<li>すべての奇数番目の項は一つ前の項を 3 で割ったものと等しい数である。</li>
</ul>
<p>
この数列の初項 <var>a</var> を読み込み、初項から第 10 項までの和 <var>s(10)</var> を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のテストケースからなります。各テストケースとして、数列の初項を表す実数 <var>a</var> (1.0 ≤ <var>a</var> ≤ 10.0) が１行に与えられます。
</p>
<p>
テストケースの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
テストケースごとに <var>s(10)</var> を１行に出力します。
</p>
<p>
出力は0.000001以下の誤差を含んでもよい。
</p>
<H2>Sample Input</H2>
<pre>
1.0
2.0
3.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
7.81481481
15.62962963
23.44444444
</pre>
|
s949423088 | p00055 | Accepted | while 1:
try:
n = float(input())
except:
break
ans = n
for i in range(2, 11):
if i % 2 == 0:
tmp = n * 2
else:
tmp = n / 3
ans += tmp
n = tmp
print(ans)
| 1.0
2.0
3.0
| 7.81481481
15.62962963
23.44444444
|
<H1>数列</H1>
<p>
次のように定義されている数列があります。
</p>
<ul>
<li>すべての偶数番目の項は一つ前の項に 2 を掛けたものと等しい数である。</li>
<li>すべての奇数番目の項は一つ前の項を 3 で割ったものと等しい数である。</li>
</ul>
<p>
この数列の初項 <var>a</var> を読み込み、初項から第 10 項までの和 <var>s(10)</var> を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のテストケースからなります。各テストケースとして、数列の初項を表す実数 <var>a</var> (1.0 ≤ <var>a</var> ≤ 10.0) が１行に与えられます。
</p>
<p>
テストケースの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
テストケースごとに <var>s(10)</var> を１行に出力します。
</p>
<p>
出力は0.000001以下の誤差を含んでもよい。
</p>
<H2>Sample Input</H2>
<pre>
1.0
2.0
3.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
7.81481481
15.62962963
23.44444444
</pre>
|
s125373640 | p00055 | Accepted | while True:
try: a = float(input())
except: break
ans = a
for i in range(9):
a = a*2*((i+1)&1)+a/3*(i&1)
ans += a
print("%.8f"%ans)
| 1.0
2.0
3.0
| 7.81481481
15.62962963
23.44444444
|
<H1>数列</H1>
<p>
次のように定義されている数列があります。
</p>
<ul>
<li>すべての偶数番目の項は一つ前の項に 2 を掛けたものと等しい数である。</li>
<li>すべての奇数番目の項は一つ前の項を 3 で割ったものと等しい数である。</li>
</ul>
<p>
この数列の初項 <var>a</var> を読み込み、初項から第 10 項までの和 <var>s(10)</var> を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のテストケースからなります。各テストケースとして、数列の初項を表す実数 <var>a</var> (1.0 ≤ <var>a</var> ≤ 10.0) が１行に与えられます。
</p>
<p>
テストケースの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
テストケースごとに <var>s(10)</var> を１行に出力します。
</p>
<p>
出力は0.000001以下の誤差を含んでもよい。
</p>
<H2>Sample Input</H2>
<pre>
1.0
2.0
3.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
7.81481481
15.62962963
23.44444444
</pre>
|
s332421820 | p00055 | Accepted | while True:
num_list = []
try:num_list.append(float(input()))
except:break
for i in range(1,10):
#奇数の場合だけど0スタートなので偶数扱い
if i % 2 == 1:
num_list.append(num_list[i-1] * 2)
#偶数の場合だけど0スタートなので奇数扱い
else:
num_list.append(num_list[i-1] / 3)
print(sum(num_list))
| 1.0
2.0
3.0
| 7.81481481
15.62962963
23.44444444
|
<H1>数列</H1>
<p>
次のように定義されている数列があります。
</p>
<ul>
<li>すべての偶数番目の項は一つ前の項に 2 を掛けたものと等しい数である。</li>
<li>すべての奇数番目の項は一つ前の項を 3 で割ったものと等しい数である。</li>
</ul>
<p>
この数列の初項 <var>a</var> を読み込み、初項から第 10 項までの和 <var>s(10)</var> を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のテストケースからなります。各テストケースとして、数列の初項を表す実数 <var>a</var> (1.0 ≤ <var>a</var> ≤ 10.0) が１行に与えられます。
</p>
<p>
テストケースの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
テストケースごとに <var>s(10)</var> を１行に出力します。
</p>
<p>
出力は0.000001以下の誤差を含んでもよい。
</p>
<H2>Sample Input</H2>
<pre>
1.0
2.0
3.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
7.81481481
15.62962963
23.44444444
</pre>
|
s142636373 | p00055 | Runtime Error | import sys
for e in sys.stdin:
t=[a,
a*2,
a*2/3,
a*2/3*2,
a*2/3*2/3,
a*2/3*2/3*2,
a*2/3*2/3*2/3,
a*2/3*2/3*2/3*2,
a*2/3*2/3*2/3*2/3,
a*2/3*2/3*2/3*2/3*2]
print(sum(t))
| 1.0
2.0
3.0
| 7.81481481
15.62962963
23.44444444
|
<H1>数列</H1>
<p>
次のように定義されている数列があります。
</p>
<ul>
<li>すべての偶数番目の項は一つ前の項に 2 を掛けたものと等しい数である。</li>
<li>すべての奇数番目の項は一つ前の項を 3 で割ったものと等しい数である。</li>
</ul>
<p>
この数列の初項 <var>a</var> を読み込み、初項から第 10 項までの和 <var>s(10)</var> を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のテストケースからなります。各テストケースとして、数列の初項を表す実数 <var>a</var> (1.0 ≤ <var>a</var> ≤ 10.0) が１行に与えられます。
</p>
<p>
テストケースの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
テストケースごとに <var>s(10)</var> を１行に出力します。
</p>
<p>
出力は0.000001以下の誤差を含んでもよい。
</p>
<H2>Sample Input</H2>
<pre>
1.0
2.0
3.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
7.81481481
15.62962963
23.44444444
</pre>
|
s774492610 | p00055 | Runtime Error | while 1:
x = float(input())
s=x
for i in range(9):
if i % 2 == 0:
s = s*2
x+=s
if i % 2 == 1:
s = s/3
x+=s
print(x)
| 1.0
2.0
3.0
| 7.81481481
15.62962963
23.44444444
|
<H1>数列</H1>
<p>
次のように定義されている数列があります。
</p>
<ul>
<li>すべての偶数番目の項は一つ前の項に 2 を掛けたものと等しい数である。</li>
<li>すべての奇数番目の項は一つ前の項を 3 で割ったものと等しい数である。</li>
</ul>
<p>
この数列の初項 <var>a</var> を読み込み、初項から第 10 項までの和 <var>s(10)</var> を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のテストケースからなります。各テストケースとして、数列の初項を表す実数 <var>a</var> (1.0 ≤ <var>a</var> ≤ 10.0) が１行に与えられます。
</p>
<p>
テストケースの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
テストケースごとに <var>s(10)</var> を１行に出力します。
</p>
<p>
出力は0.000001以下の誤差を含んでもよい。
</p>
<H2>Sample Input</H2>
<pre>
1.0
2.0
3.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
7.81481481
15.62962963
23.44444444
</pre>
|
s885078111 | p00055 | Runtime Error | while True:
a = float(raw_input())
sum = a
for i in range(2,11):
if i % 2 == 0:
a *= 2.0
sum += a
else:
a /= 3.0
sum += a
print sum | 1.0
2.0
3.0
| 7.81481481
15.62962963
23.44444444
|
<H1>数列</H1>
<p>
次のように定義されている数列があります。
</p>
<ul>
<li>すべての偶数番目の項は一つ前の項に 2 を掛けたものと等しい数である。</li>
<li>すべての奇数番目の項は一つ前の項を 3 で割ったものと等しい数である。</li>
</ul>
<p>
この数列の初項 <var>a</var> を読み込み、初項から第 10 項までの和 <var>s(10)</var> を出力するプログラムを作成してください。
</p>
<H2>Input</H2>
<p>
入力は複数のテストケースからなります。各テストケースとして、数列の初項を表す実数 <var>a</var> (1.0 ≤ <var>a</var> ≤ 10.0) が１行に与えられます。
</p>
<p>
テストケースの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
テストケースごとに <var>s(10)</var> を１行に出力します。
</p>
<p>
出力は0.000001以下の誤差を含んでもよい。
</p>
<H2>Sample Input</H2>
<pre>
1.0
2.0
3.0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
7.81481481
15.62962963
23.44444444
</pre>
|
s980678026 | p00056 | Wrong Answer | import sys
f = sys.stdin
def create_prime(n):
prime = [1] * (n + 1)
prime[:2] = [0, 0]
for i in range(len(prime)):
if prime[i]:
for j in range(2 * i, len(prime), i):
prime[j] = 0
return prime
sieve = create_prime(50000)
prime = []
for i in range(25001):
if sieve[i]:
prime.append(i)
while True:
n = int(f.readline())
if n == 0:
break
cnt = 0
temp = n // 2 + 1
for i in prime:
if i > temp:
break
if sieve[n - i]:
cnt += 1
print(cnt) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s324593633 | p00056 | Wrong Answer | # -*- coding: utf-8 -*-
import sys,itertools
prime_list = [2,3,5,7,11]
for n in map(int, sys.stdin):
if n==0: break
prime_sub_list = [p for p in prime_list if p < n]
sum_list = [x+y for x,y in itertools.combinations(prime_sub_list,2)]
print sum_list.count(n)
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s526524143 | p00056 | Wrong Answer | import sys,itertools
prim_flg_list=[1]*50000
prim_flg_list[0]=prim_flg_list[1]=0
prim_flg_list[4::2]=[0]*len(prim_flg_list[4::2])
for i in xrange(3,224,2):prim_flg_list[i*i::i]=[0]*len(prim_flg_list[i*i::i])
prime_list = [p for p in xrange(0,50000) if prim_flg_list[p]]
sum_count_list = [0]*100001
iter=itertools.combinations_with_replacement(prime_list,2)
for combi in iter:
sum_count_list[combi[0]+combi[1]]+=1
for input in map(int, sys.stdin):
print sum_count_list[input] | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s788033239 | p00056 | Wrong Answer | import sys,itertools
input_list = map(int, sys.stdin)
max_input = max(input_list)
prim_flg_list=[1]*max_input
prim_flg_list[0]=prim_flg_list[1]=0
prim_flg_list[4::2]=[0]*len(prim_flg_list[4::2])
for i in range(3,int(max_input**0.5),2):prim_flg_list[i*i::i]=[0]*len(prim_flg_list[i*i::i])
prime_list = [p for p in range(0,max_input) if prim_flg_list[p]]
sum_count_list = [0]*(max_input*2+1)
iter=itertools.combinations_with_replacement(prime_list,2)
for combi in iter:
sum_count_list[combi[0]+combi[1]]+=1
for input in input_list:
print sum_count_list[input] | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s909941066 | p00056 | Wrong Answer | def primes(n):
l = [1 for i in range(n+1)]
l[0] = l[1] = 0
for i in range(2,int((n)**(1/2))+1):
if l[i] == 1:
for j in range(2,n//i+1):
l[i*j] = 0
return l
l = primes(50000)
while True:
n = int(input())
if n == 0:
break
count = 0
if not(n%2):
for i in range(3,n//2+1,2):
if (l[i] and l[n-i]):
count += 1
else:
if l[n-2]:
count += 1
print(count) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s340621942 | p00056 | Wrong Answer | import bisect
primes = [0,0] + [1]*49999
for i in range(2, 223):
if primes[i]:
for j in range(i*i, 50001, i):
primes[j] = 0
values = [k for k, b in enumerate(primes) if b]
while True:
n = int(input())
if n == 0:
break
end = bisect.bisect_left(values, n//2)
print(sum(1 for i in values[:end+1] if primes[n-i])) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s135329995 | p00056 | Wrong Answer | import bisect
primes = [0,0] + [1]*49999
for i in range(2, 223):
if primes[i]:
for j in range(i*i, 50001, i):
primes[j] = 0
values = [k for k, b in enumerate(primes) if b]
while True:
n = int(input())
if n == 0:
break
end = bisect.bisect_left(values, n//2)
print(sum(1 for i in values[:end] if primes[n-i])) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s247475415 | p00056 | Wrong Answer | primes = [0,0] + [1]*49999
for i in range(2, 223):
if primes[i]:
for j in range(i*i, 50001, i):
primes[j] = 0
values = [k for k, b in enumerate(primes) if b]
while True:
n = int(input())
if n == 0:
break
ans = 0
for i in values:
if i > n//2:
break
if primes[n-i]:
ans += 1
print(ans) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s753333700 | p00056 | Wrong Answer | import bisect
primes = [0,0] + [1]*49999
for i in range(2, 224):
if primes[i]:
for j in range(i*i, 50001, i):
primes[j] = 0
values = [k for k, b in enumerate(primes) if b]
while True:
n = int(input())
if n == 0:
break
end = bisect.bisect_left(values, n//2)
print(sum(1 for i in values[:end] if primes[n-i])) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s783015537 | p00056 | Wrong Answer | import bisect
primes = [0,0] + [1]*49999
for i in range(2, 224):
if primes[i]:
for j in range(i*i, 50001, i):
primes[j] = 0
values = [k for k, b in enumerate(primes) if b]
while True:
n = int(input())
if n == 0:
break
end = bisect.bisect_left(values, n//2)+1
print(sum(1 for i in values[:end] if primes[n-i])) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s815652819 | p00056 | Wrong Answer | import bisect
primes = [0,0] + [1]*49999
for i in range(2, 225):
if primes[i]:
for j in range(i*i, 50001, i):
primes[j] = 0
values = [k for k, b in enumerate(primes) if b]
while True:
n = int(input())
if n == 0:
break
end = bisect.bisect_left(values, n//2)+1
print(sum(1 for i in values[:end] if primes[n-i])) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s080578493 | p00056 | Wrong Answer | isPrime = []
def init():
for i in range(50000 + 1):
isPrime.append(True)
def eratos():
isPrime[0] = False
isPrime[1] = False
for i in range(2, 50000 + 1):
for j in range(i * 2, 50000 + 1, i):
isPrime[j] = False
init()
eratos()
n = int(input())
count = 0
for i in range(2, n // 2 + 1):
if isPrime[i] & isPrime[n - i]:
count += 1
print(count) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s909821960 | p00056 | Wrong Answer | import math
from itertools import combinations_with_replacement
def is_prime(q):
q = abs(q)
if q == 2: return True
if q < 2 or q&1 == 0: return False
return pow(2, q-1, q) == 1
def main():
while True:
n = int(input())
if n == 0:
break
elif n%2 != 0:
print('0')
continue
prime = []
for i in range(n):
if is_prime(i):
prime.append(i)
count = 0
for value in combinations_with_replacement(prime,2):
if sum(value) == n:
count += 1
print(count)
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s470433116 | p00056 | Wrong Answer | import math
from itertools import combinations_with_replacement
def is_prime(q):
q = abs(q)
if q == 2: return True
if q < 2 or q&1 == 0: return False
return pow(2, q-1, q) == 1
def main():
while True:
n = int(input())
if n == 0:
break
prime = []
for i in range(n):
if is_prime(i):
prime.append(i)
count = 0
for value in combinations_with_replacement(prime,2):#combinations_with_replacementは重複あり組み合せ
if sum(value) == n:
count += 1
print(count)
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s134759816 | p00056 | Wrong Answer | n = 50000
c = [1 for i in range(n)]
c[0] = 0
i = 2
while i**2 <= n:
j = i*2
while j <= n:
c[j - 1] = 0
j += i
i += 1
while True:
n = int(input())
cnt = 0
if n == 0:
break
elif n%2 == 0:
for i in range(0, n//2, 2):
if c[i] == 1 and c[n-i] == 1:
cnt +=1
print(cnt*2)
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s290469151 | p00056 | Wrong Answer | n = 50000
c = [1 for i in range(n)]
c[0] = 0
i = 2
while i**2 <= n:
j = i*2
while j <= n:
c[j - 1] = 0
j += i
i += 1
while True:
n = int(input())
cnt = 0
if n == 0:
break
elif n%2 == 0:
for i in range(0, n//2, 2):
if c[i] == 1 and c[n-i-2] == 1:
cnt +=1
print(cnt*2)
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s161942162 | p00056 | Wrong Answer | n = 50001
is_prime = [i for i in range(n)]
is_prime[0] = is_prime[1] = 0
i = 2
while i**2 <= n:
j = i*2
while j < n:
is_prime[j] = 0
j += i
i += 1
prime = set(is_prime)
while True:
cnt = 0
n = int(input())
if n == 0:
break
elif n%2 == 1:
print(0)
continue
for i in prime:
if i > n//2:
continue
if n - i in prime:
cnt += 1
print(cnt)
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s021758340 | p00056 | Wrong Answer | n = 50001
is_prime = [i for i in range(n)]
is_prime[0] = is_prime[1] = 0
i = 2
while i**2 <= n:
j = i*2
while j < n:
is_prime[j] = 0
j += i
i += 1
prime_set = set(is_prime)
prime_set.remove(0)
prime_list = sorted(list(prime_set))
while True:
cnt = 0
n = int(input())
if n == 0:
break
elif n%2 == 1:
print(0)
continue
for i in prime_list:
if i > n//2:
break
if n - i in prime_set:
cnt += 1
print(cnt)
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s837748735 | p00056 | Wrong Answer | import bisect
from itertools import *
n=range(50001);a=list(n);a[1]=0
for i in range(2,224):a[i*2::i]=[0]*len(a[i*2::i])
p=list(compress(n,a))
for x in iter(input,'0'):
x=int(x)
if x%2:print(sum(2+c==x for c in p[:bisect.bisect(p,x)-1]))
elif x-4:print(sum(1 for c in p[:bisect.bisect(p,x//2)]if a[x-c]))
else:print(1)
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s734030806 | p00056 | Wrong Answer | import bisect,sys
from itertools import *
n=range(50001);a=list(n)
for i in range(2,224):a[i*2::i]=[0]*len(a[i*2::i])
p=list(compress(n,a))
for x in map(int,sys.stdin):
if x:print(sum(1 for d in p[:bisect.bisect(p,x//2)]if a[x-d]))
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s193517070 | p00056 | Wrong Answer | #!/usr/bin/env python:
# -*- coding: utf-8 -*-
import sys
def make_prime_list(lim):
lst = [True for i in xrange(lim + 1)]
num = 2
while num ** 2 <= lim:
for i in xrange(num * 2, lim + 1, num):
lst[i] = False
num += 1
while not lst[num]:
num += 1
return [i for i in xrange(2, lim + 1) if lst[i]]
def binary_search(n, prime_list):
rLim = len(prime_list) - 1
lLim = 0
while lLim < rLim:
middle = (rLim + lLim) / 2
if prime_list[middle] == n:
return middle
elif prime_list[middle] < n:
lLim = middle + 1
else:
rLim = middle - 1
while prime_list[rLim] < n and rLim < len(prime_list) - 1:
rLim += 1
return rLim
def solve():
prime_list = make_prime_list(50000)
while True:
n = input()
if n > 0:
if n % 2 == 0:
count = 0
index = 0
rev_index = binary_search(n, prime_list)
while index <= rev_index:
while prime_list[index] + prime_list[rev_index] > n:
rev_index -= 1
if prime_list[index] + prime_list[rev_index] == n:
count += 1
index += 1
print count
else:
if n - 2 in prime_list:
print 1
else:
print 0
else:
sys.exit()
if __name__ == "__main__":
solve() | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s748838046 | p00056 | Wrong Answer | import itertools
N=50000+1
p=[True]*N
p[0],p[1]=False,False
for i in xrange(2,int(N**0.5)+1):
if p[i]==True:
for j in xrange(i**2,N,i):
p[j]=False
plist=[i for i in xrange(N) if p[i]]
c=[0]*N*2
for i,j in itertools.combinations(plist,2):
c[i+j]+=1
while True:
n=input()
if n==0:break
print c[n]
| 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s576268458 | p00056 | Wrong Answer | import itertools
N=50000+1
p=[True]*N
p[0],p[1]=False,False
for i in xrange(2,int(N**0.5)+1):
if p[i]==True:
for j in xrange(i**2,N,i):
p[j]=False
plist=[i for i in xrange(N) if p[i]]
c=[0]*N*2
for i,j in itertools.combinations(plist,2):
c[i+j]+=1
for i in xrange(N):
c[i+i]+=1
while True:
n=input()
if n==0:break
print c[n] | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s007571892 | p00056 | Wrong Answer | import sys
def sieve(m):
N=range(1,m+2,2)
r=int(m**.5)
h=len(N)
N[0]=0
for i in range(h):
x=N[i]
if x>r: break
if x and i+x<h: N[i+x:h:x]=[0] * ((h-1-i-x)/x+1)
return N
def f0056(n):
x=0
if n%2==1:
if SIEVES[(n-2)/2]!=0: x=1
else:
x=len([e for e in PRIMES if 0<e<=n/2 and SIEVES[(n-e)/2]!=0])
return x
SIEVES=sieve(50000)
PRIMES=filter(None,[2]+SIEVES)
for n in sys.stdin:
n=int(n)
if n==0: break
print f0056(n) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s810559178 | p00056 | Wrong Answer | import sys
def sieve(m):
N=range(1,m+2,2)
r=int(m**.5)
h=len(N)
N[0]=0
for i in range(h):
x=N[i]
if x>r: break
if x and i+x<h: N[i+x:h:x]=[0] * ((h-1-i-x)/x+1)
return N
def f0056(n):
x=0
if n%2==1:
if SIEVES[(n-2)/2]!=0: x=1
else:
for e in PRIMES:
if e>n/2: break
if SIEVES[(n-e)/2]!=0:x+=1
return x
SIEVES=sieve(50000)
PRIMES=filter(None,SIEVES)
for n in sys.stdin:
n=int(n)
if n==0: break
print f0056(n) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s200592136 | p00056 | Wrong Answer | import sys
def sieve(m):
N=range(1,m+2,2)
r=int(m**.5)
h=len(N)
N[0]=0
for i in range(h):
x=N[i]
if x>r: break
if x and i+x<h: N[i+x:h:x]=[0] * ((h-1-i-x)/x+1)
return N
def f0056(n):
x=0
if n%2==1:
if SIEVES[(n-2)/2]!=0: x=1
else:
for e in PRIMES:
if e>n/2: break
if SIEVES[(n-e)/2]!=0:x+=1
return x
SIEVES=sieve(50000)
PRIMES=[2]+filter(None,SIEVES)
for n in sys.stdin:
n=int(n)
if n==0: break
print f0056(n) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s183425329 | p00056 | Wrong Answer | import math
r = 50001
sqrt = int(math.sqrt(r))
p = [1]*r
p[0] = 0
prime = []
for i in range(1,sqrt):
if p[i]:
p[2*i+1::i+1] = [0 for x in range(2*i+1,r,i+1)]
prime.append(i+1)
while True:
n = int(raw_input())
if n == 0:
break
count = 0
for i in prime:
if i > n/2:
break
m = n - i
if prime.count(m) == 1:
count += 1
print count | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s043142232 | p00056 | Wrong Answer | import math
r = 50001
sqrt = int(math.sqrt(r))
p = [1]*r
p[0] = 0
pp = []
for i in range(1,sqrt):
if p[i]:
p[2*i+1::i+1] = [0 for x in range(2*i+1,r,i+1)]
pp.append(i)
while True:
n = int(raw_input())
if n == 0:
break
count = 0
for i in pp:
if i+1 > n/2:
break
if p[n-i-2] == 1:
count += 1
print count | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s349700352 | p00056 | Wrong Answer | import math
r = 50001
sqrt = int(math.sqrt(r))
p = [1]*r
p[0] = 0
pp = []
for i in range(1,sqrt):
if p[i]:
p[2*i+1::i+1] = [0 for x in range(2*i+1,r,i+1)]
pp.append(i)
while True:
n = int(raw_input())
if n == 0:
break
count = 0
for i in pp:
if i+1 > n/2:
break
if p[n-i-3] == 1:
count += 1
print count | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s450770050 | p00056 | Wrong Answer | import math
r = 50001
sqrt = int(math.sqrt(r))
p = [1]*r
p[0] = 0
for i in range(1,sqrt):
if p[i]:
p[2*i+1::i+1] = [0 for x in range(2*i+1,r,i+1)]
pp = []
for i in range(25000):
if p[i] == 1:
pp.append(i)
while True:
n = int(raw_input())
if n == 0:
break
count = 0
m = n/2
for i in pp:
if i+1 > m:
break
if p[i]*p[m-i-1] == 1:
count += 1 | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s698961644 | p00056 | Wrong Answer | import math
r = 50001
sqrt = int(math.sqrt(r))
p = [1]*r
p[0] = 0
for i in range(1,sqrt):
if p[i]:
p[2*i+1::i+1] = [0 for x in range(2*i+1,r,i+1)]
pp = []
for i in range(25000):
if p[i] == 1:
pp.append(i)
while True:
n = int(raw_input())
if n == 0:
break
count = 0
m = n/2
for i in pp:
if i+1 > m:
break
if p[i]*p[m-i-1] == 1:
count += 1
print count | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s074485427 | p00056 | Wrong Answer | import sys
def sieve(m):
N=range(1,m+2,2)
r=int(m**.5)
h=len(N)
N[0]=0
i=0
while i<h:
x=N[i]
if x>r: break
if x and i+x<h: N[i+x:h:x]=[0]*((h-1-i-x)/x+1)
i+=1
return N
def f0056(n):
x=0
if n&1==0:
a=n/2
for e in PRIMES:
if e>a: break
if S[(n-e)/2]: x+=1
elif S[n/2-1]: x=1
return x
S=sieve(50000)
PRIMES=[2]+filter(None,S)
for n in sys.stdin:
n=int(n)
if n==0: break
print f0056(n) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s513337027 | p00056 | Wrong Answer | import sys
def sieve(m):
N=range(1,m+2,2)
r=int(m**.5)
h=len(N)
N[0]=0
i=0
while i<h:
x=N[i]
if x>r: break
if x and i+x<h: N[i+x:h:x]=[0]*((h-1-i-x)/x+1)
i+=1
return N
def f0056(n):
x=0
if n==4: x=1
elif n&1==0:
a=n/2
for e in PRIMES:
if e>a: break
if S[(n-e)/2]: x+=1
elif S[n/2-1]: x=1
return x
S=sieve(50000)
PRIMES=[2]+filter(None,S)
for n in sys.stdin:
n=int(n)
if n==0: break
print f0056(n) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s825142762 | p00056 | Wrong Answer | import sys
def sieve(m):
N=range(1,m+2,2)
r=int(m**.5)
h=len(N)
N[0]=0
i=0
while i<h:
x=N[i]
if x>r: break
if x and i+x<h: N[i+x:h:x]=[0]*((h-1-i-x)/x+1)
i+=1
return N
def f0056(n):
x=0
if n<4: x=0
elif n==4: x=1
elif n%2==0:
a=n/2
for e in PRIMES:
if e>a: break
if S[(n-e)/2]: x+=1
elif S[(n-2)/2]: x=1
return x
S=sieve(50000)
PRIMES=[2]+filter(None,S)
for n in sys.stdin:
n=int(n)
if n==0: break
print f0056(n) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s437277072 | p00056 | Wrong Answer | import sys
def sieve(m):
N=range(1,m+2,2)
r=int(m**.5)
h=len(N)
N[0]=0
for i in range(h):
x=N[i]
if x>r: break
if x and i+x<h: N[i+x:h:x]=[0]*((h-1-i-x)/x+1)
return N
def f0056(n):
x=0
if n<4: x=0
elif n==4: x=1
elif n%2==0:
a=n/2
for e in PRIMES:
if e>a: break
if S[(n-e)/2]: x+=1
elif S[(n-2)/2]: x=1
return x
S=sieve(50000)
PRIMES=[2]+filter(None,S)
for n in sys.stdin:
n=int(n)
if n==0: break
print f0056(n) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s761748699 | p00056 | Wrong Answer | import sys
def sieve(m):
N=range(1,m+2,2)
r=int(m**.5)
h=len(N)
N[0]=0
for i in range(h):
x=N[i]
if x>r: break
if x and i+x<h: N[i+x:h:x]=[0]*((h-1-i-x)/x+1)
return N
def f0056(n):
x=0
if n<4: x=0
elif n==4: x=1
elif n%2==1:
if S[(n-2)/2]: x=1
else:
a=n/2
for e in PRIMES:
if e>a: break
if S[(n-e)/2]: x+=1
return x
S=sieve(50000)
PRIMES=[2]+filter(None,S)
for n in sys.stdin:
n=int(n)
if n==0: break
print f0056(n) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s053235322 | p00056 | Wrong Answer | import sys
def sieve(m):
N=range(1,m+2,2)
r=int(m**.5)
h=len(N)
N[0]=0
for i in range(h):
x=N[i]
if x>r: break
if x and i+x<h: N[i+x:h:x]=[0]*((h-1-i-x)/x+1)
return N
def f0056(n):
x=0
if n<4:x=0
elif n==4:x=1
elif n%2:
if S[(n-2)/2]: x=1
else:
a=n/2
for e in PRIMES:
if e>a: break
if S[(n-e)/2]: x+=1
return x | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s563711138 | p00056 | Wrong Answer | import sys
def sieve(m):
N=range(1,m+2,2)
r=int(m**.5)
h=len(N)
N[0]=0
for i in range(h):
x=N[i]
if x>r: break
if x and i+x<h: N[i+x:h:x]=[0]*((h-1-i-x)/x+1)
return N
def f0056(n):
x=0
if n<4:x=0
elif n==4:x=1
elif n&1:
if S[(n-2)/2]: x=1
else:
a=n/2
for e in PRIMES:
if e>a: break
if S[(n-e)/2]: x+=1
return x | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s576319492 | p00056 | Wrong Answer | import sys
def sieve(m):
N=range(1,m+2,2)
r=int(m**.5)
h=len(N)
N[0]=0
for i in range(h):
x=N[i]
if x>r: break
if x and i+x<h: N[i+x:h:x]=[0]*((h-1-i-x)/x+1)
return N
def f0056(n):
x=0
if n<4:x=0
elif n==4:x=1
elif n%2==1:
if S[n/2-1]: x=1
else:
a=n/2
for e in PRIMES:
if e>a: break
if S[(n-e)/2]: x+=1
return x | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s280870826 | p00056 | Wrong Answer | from itertools import *
def sieve(n):
a = range(n)
a[:2] = None, None
for i in range(2, n):
if i ** 2 >= n: break
if not a[i]: continue
for i in range(i ** 2, n, i):
a[i] = None
return a
b = sieve(50000)
a = [v for v in b if v]
while True:
n = int(raw_input())
if n == 0: break
if n % 2 == 1:
print 0
continue
ct = 0
for v in a:
if v > n / 2: break
if b[n - v]:
ct += 1
print ct | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s360727299 | p00056 | Wrong Answer | def sieve(n):
primes = [True] * n
primes[0] = primes[1] = False
for i in xrange(2, int(n ** 0.5) + 1):
if primes[i]:
for j in xrange(i * i, n, i):
primes[j] = False
return [i for i in xrange(n) if primes[i]]
primes_a = sieve(25000)
primes_b = set(sieve(50000))
while 1:
n = input()
if n == 0:
break
if n % 2:
print 0
continue
ret = 0
for prime in primes_a:
if prime > n / 2:
break
if n - prime in primes_b:
ret += 1
print ret | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s263555077 | p00056 | Wrong Answer | N = 50000
t = [1]*N
p = []
d = {}
for i in range(3, N + 1, 2):
if t[i]:
p.append(i)
d[i] = 1
for j in range(3*i, N+1, 2*i): t[j] = 0
while True:
n = int(input())
if n == 0: break
count = 0
if n % 2:
if n - 2 in p: count += 1
else:
for p1 in p:
if 2*p1 > n: break
if n - p1 in d: count += 1
print(count) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s174348058 | p00056 | Wrong Answer | N = 50000
t = [1]*(N + 1)
p = []
d = {}
for i in range(3, N + 1, 2):
if t[i]:
p.append(i)
d[i] = 1
for j in range(3*i, N+1, 2*i): t[j] = 0
while True:
n = int(input())
if n == 0: break
count = 0
if n % 2:
if n - 2 in p: count += 1
else:
for p1 in p:
if 2*p1 > n: break
if n - p1 in d:
count += 1
print(count) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s201664723 | p00056 | Wrong Answer | N = 50000
t = [1]*(N)
p = []
d = {}
for i in range(3, N, 2):
if t[i]:
p.append(i)
d[i] = 1
for j in range(3*i, N, 2*i): t[j] = 0
while True:
n = int(input())
if n == 0: break
count = 0
if n % 2:
if n - 2 in p: count += 1
else:
for p1 in p:
if 2*p1 > n: break
if n - p1 in d:
count += 1
print(count) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s151970235 | p00056 | Time Limit Exceeded | prm=[2,3]
for n in range(5,50000,2):
for x in prm:
if n%x==0 and x*x<=n:
break
else:
prm.append(n)
while 1:
cnt=0
n=int(input())
if n==0:
break
for i in prm:
if i>int(n/2):
break
elif n-i in prm:
print(n-i,i)
cnt+=1
print(cnt) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s519783506 | p00056 | Time Limit Exceeded | prm=[2,3]
for n in range(5,50000,2):
for x in prm:
if n%x==0 and x*x<=n:
break
else:
prm.append(n)
while 1:
cnt=0
n=int(input())
N=int(n/2)
if n==0:
break
for i in prm:
if i>N:
break
elif n-i in prm:
cnt+=1
print(cnt) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s194835011 | p00056 | Time Limit Exceeded | from itertools import *
import sys
maxnum = 50000
primes = [True]*maxnum
primes[0] = primes[1] = False
for i in xrange(maxnum):
if i >= maxnum**0.5 : break
if not primes[i]: continue
for j in xrange(i*2,maxnum,i): primes[j] = False
p = [ i for i in xrange(maxnum) if primes[i]]
for s in sys.stdin:
d = int(s)
if d == 0: break
if d % 2 == 1:
try: p.index(d-2) ;print 1
except: print 0; continue
q = [ r for r in p if r < d]
c = 0
for j,k in combinations_with_replacement(q,2):
if j+k==d: c += 1
print c | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s733503746 | p00056 | Time Limit Exceeded | import sys
maxnum = 50000
primes = [True]*maxnum
primes[0] = primes[1] = False
for i in xrange(maxnum):
if i >= maxnum**0.5 : break
if not primes[i]: continue
for j in xrange(i*2,maxnum,i): primes[j] = False
for s in sys.stdin:
d = int(s)
if d == 0: break
cnt = 0
for i in xrange(2,int(d/2+1)):
if primes[i] and primes[d-i]: cnt += 1
print cnt | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s344602035 | p00056 | Time Limit Exceeded | import sys
maxnum = 50001
primes = [True]*maxnum
primes[0] = primes[1] = False
for i in xrange(maxnum):
if i >= maxnum**0.5 : break
if not primes[i]: continue
for j in xrange(i*2,maxnum,i): primes[j] = False
for s in sys.stdin:
d = int(s)
if d == 0: break
cnt = 0
for i in xrange(2,int(d/2+1)):
if primes[i] and primes[d-i]: cnt += 1
print cnt | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s996176769 | p00056 | Time Limit Exceeded | import sys
maxnum = 50001
primes = [True]*maxnum
primes[0] = primes[1] = False
for i in xrange(maxnum):
if i >= maxnum**0.5 : break
if not primes[i]: continue
for j in xrange(i*2,maxnum,i): primes[j] = False
for s in sys.stdin:
d = int(s)
if d == 0: break
print sum( [ 1 for i in xrange(2,int(d/2+1)) if primes[i] and primes[d-i] ] ) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s251033827 | p00056 | Time Limit Exceeded | import sys
maxnum = 50001
primes = [True]*maxnum
primes[0] = primes[1] = False
for i in xrange(maxnum):
if i >= maxnum**0.5 : break
if not primes[i]: continue
for j in xrange(i*2,maxnum,i): primes[j] = False
p = [ i for i in xrange(maxnum) if primes[i] ]
for s in sys.stdin:
d = int(s)
if d == 0: break
q = [ i for i in p if i < d/2+1 ]
print sum( [ 1 for i in q if primes[d-i] ] ) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s962878351 | p00056 | Time Limit Exceeded | import sys
f = sys.stdin
def create_prime(n):
prime = [1] * (n + 1)
prime[:2] = [0, 0]
for i in range(len(prime)):
if prime[i]:
for j in range(2 * i, len(prime), i):
prime[j] = 0
return prime
prime = create_prime(50000)
while True:
n = int(f.readline())
if n == 0:
break
print(sum(1 for i in range(n // 2 + 1) if prime[i] and prime[n - i])) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s013049286 | p00056 | Time Limit Exceeded | import sys
f = sys.stdin
def create_prime(n):
prime = [1] * (n + 1)
prime[:2] = [0, 0]
for i in range(len(prime)):
if prime[i]:
for j in range(2 * i, len(prime), i):
prime[j] = 0
return prime
sieve = create_prime(50000)
import time
start = time.clock()
prime = []
for i in range(25001):
if sieve[i]:
prime.append(i)
while True:
n = int(f.readline())
if n == 0:
break
cnt = 0
for i in prime:
if i > n // 2 + 1:
break
if sieve[n - i]:
cnt += 1
print(cnt)
print(time.clock()-start) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s818831505 | p00056 | Time Limit Exceeded | import sys
f = sys.stdin
def create_prime(n):
prime = [1] * (n + 1)
prime[:2] = [0, 0]
for i in range(len(prime)):
if prime[i]:
for j in range(2 * i, len(prime), i):
prime[j] = 0
return prime
sieve = create_prime(50000)
prime = []
for i in range(25001):
if sieve[i]:
prime.append(i)
while True:
n = int(f.readline())
if n == 0:
break
cnt = 0
for i in prime:
if i > n // 2 + 1:
break
if sieve[n - i]:
cnt += 1
print(cnt) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s028803676 | p00056 | Time Limit Exceeded | import math
def pri(n):
l =[True] * n
l[0] = l[1] = False
for i in range(2,n):
if l[i]:
for j in range(i*2, n, i):
l[j] = False
return l
n=50000
s=pri(n)
l=[i for i in range(n) if s[i]]
while True:
n = int(input())
if n == 0: break
sum = 0
if n % 2 == 0:
for i in range(len(l)):
for j in range(i, len(l)):
if l[i] + l[j] == n:
sum += 1
if l[i] > n//2:
break
if l[i] > n//2:
break
print(sum) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s551064805 | p00056 | Time Limit Exceeded | import math
def pri(n):
l =[True] * n
l[0] = l[1] = False
for i in range(2,n):
if l[i]:
for j in range(i*2, n, i):
l[j] = False
return l
n=50000
s=pri(n)
l=[i for i in range(n) if s[i]]
while True:
n = int(input())
if n == 0: break
sum = 0
if n % 2 == 0:
for i in range(len(l)):
for j in range(i, len(l)):
if l[i] + l[j] == n:
sum += 1
if l[j] > n:
break
if l[i] > n // 2:
break
print(sum) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s549892666 | p00056 | Time Limit Exceeded | import math
def pri(n):
l =[True] * n
l[0] = l[1] = False
for i in range(2,n):
if l[i]:
for j in range(i*2, n, i):
l[j] = False
return l
n=50000
s=pri(n)
l=[i for i in range(n) if s[i]]
while True:
n = int(input())
if n == 0: break
sum = 0
if n % 2 == 0:
for i in l:
if i * 2 > n:
break
if n - i in l:
sum += 1
print(sum) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s495329717 | p00056 | Time Limit Exceeded | import sys
prim_flg_list=[1]*50000
prim_flg_list[0]=prim_flg_list[1]=0
prim_flg_list[4::2]=[0]*len(prim_flg_list[4::2])
for i in xrange(3,224,2):prim_flg_list[i*i::i]=[0]*len(prim_flg_list[i*i::i])
prime_list = [p for p in range(2,50000) if prim_flg_list[p]]
for n in map(int, sys.stdin):
if n==0: break
prime_sub_list = [p for p in prime_list if p < n]
i = 0
j = len(prime_sub_list)-1
count= 0
while i <= j:
sum = prime_sub_list[i] + prime_sub_list[j]
if sum == n:
count += 1
i+=1
j-=1
elif sum > n:
j-=1
else:
i+=1
print count | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s388461891 | p00056 | Time Limit Exceeded | while True:
array = []
result = 0
n = int(raw_input())
if n == 0:
break
for var1 in range(2, n):
judge = True
for var2 in range(2, var1):
if var1 % var2 == 0:
judge = False
break
if judge:
array.append(var1)
for var1 in range(0, len(array)):
for var2 in range(var1, len(array)):
if array[var1] + array[var2] == n:
result += 1
print result | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s218217719 | p00056 | Time Limit Exceeded | import itertools
def generate_primes(n):
primes = []
for i in range(2,n):
flag = True
for j in range(2,i):
if i%j == 0:
flag = False
if flag:
primes.append(i)
return primes
while True:
n = int(raw_input())
if n == 0 : break
primes = generate_primes(n)
prime_list = list(itertools.combinations_with_replacement(primes, 2))
print len(filter(lambda x: sum(x) == n, prime_list)) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s732925704 | p00056 | Time Limit Exceeded | import itertools
def generate_primes(n):
primes = []
for i in range(1,n,2):
flag = True
for j in range(2,i):
if i%j == 0:
flag = False
if flag:
primes.append(i)
return primes
while True:
n = int(raw_input())
if n == 0 : break
primes = generate_primes(n)
prime_list = list(itertools.combinations_with_replacement(primes, 2))
print len(filter(lambda x: sum(x) == n, prime_list)) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s476596600 | p00056 | Time Limit Exceeded | def pri(t):
i=2
while i**2<=t:
if t%i==0:
return 0
i=i+1
return 1
l=[]
for i in range(2,50100):
if pri(i):
l.append(i)
s=len(l)
while 1:
n=int(raw_input())
ans=set([])
if n==0:
break
for i in range(s):
for j in range(i,s):
if l[i]+l[j]==n:
ans.add((min(l[i],l[j]),max(l[i],l[j])))
elif i+j>n:
break
print len(ans) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s926476894 | p00056 | Time Limit Exceeded | def pri(t):
i=2
while i**2<=t:
if t%i==0:
return 0
i=i+1
return 1
l=[]
for i in range(2,50100):
if pri(i):
l.append(i)
s=5143
while 1:
n=int(raw_input())
ans=set([])
if n==0:
break
for i in range(s):
for j in range(i,s):
if l[i]+l[j]==n:
ans.add((min(l[i],l[j]),max(l[i],l[j])))
elif l[i]+l[j]>n:
break
print len(ans) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s544614452 | p00056 | Time Limit Exceeded | def pri(t):
i=2
while i**2<=t:
if t%i==0:
return 0
i=i+1
return 1
l=[]
for i in range(2,50100):
if pri(i):
l.append(i)
s=5143
while 1:
n=int(raw_input())
ans=set([])
if n==0:
break
for i in range(s):
if l[i]>n:
break
for j in range(i,s):
if l[i]+l[j]==n:
ans.add((min(l[i],l[j]),max(l[i],l[j])))
elif l[i]+l[j]>n:
break
print len(ans) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s900383935 | p00056 | Time Limit Exceeded | def pri(t):
i=2
while i**2<=t:
if t%i==0:
return 0
i=i+1
return 1
l=[]
for i in range(2,50100):
if pri(i):
l.append(i)
s=5143
while 1:
n=int(raw_input())
ans=0
if n==0:
break
for i in range(s):
if l[i]>n:
break
elif n-l[i] in l:
ans+=1
print ans | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s932458180 | p00056 | Time Limit Exceeded | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
import array
def primes_by_eratosthenes(limit, typecode="Q"):
search_list = array.array(typecode, range(2, limit + 1))
primes = array.array(typecode)
while True:
p = search_list.pop(0)
primes.append(p)
if p * p > limit:
break
else:
search_list = array.array(typecode, filter(
lambda x: x % p != 0, search_list))
primes.extend(search_list)
return primes
if __name__ == "__main__":
primes = primes_by_eratosthenes(50000, "I")
while True:
n = int(input())
if n == 0:
break
elif n % 2 == 1:
if n - 2 in primes:
print(1)
else:
print(0)
else:
result = 0
for p in primes:
if 2 * p > n:
break
elif n - p in primes:
result += 1
print(result) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s238269980 | p00056 | Time Limit Exceeded | from math import sqrt, floor
p = [2]
for i in range(3, 50000, 2):
for j in range(3, floor(sqrt(i)) + 1, 2):
if not i % j:
break
else:
p.append(i)
while True:
n = int(input())
if not n:
break
n2 = n // 2
cnt = 0
for i in p:
if n2 < i:
break
if n - i in p:
cnt += 1
print(cnt) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s090144925 | p00056 | Time Limit Exceeded | from math import sqrt, floor
from bisect import bisect_left
def search(x):
global p, lp
i = bisect_left(p, x)
return i != lp and p[i] == x
p = [2]
for i in range(3, 50000, 2):
for j in range(3, floor(sqrt(i)) + 1, 2):
if not i % j:
break
else:
p.append(i)
lp = len(p)
while True:
n = int(input())
if not n:
break
if n & 1:
print(int(search(n - 2)))
continue
n2 = n // 2
cnt = 0
for i in p:
if n2 < i:
break
if search(n - i):
cnt += 1
print(cnt) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s088963676 | p00056 | Time Limit Exceeded | def make_ps(n):
tbl = [False, True, False, False, False, True] * (n // 6 + 1)
for i in range(1, 4):
tbl[i] = not tbl[i]
p, stp, sqrt = 5, 2, n ** 0.5
while p < sqrt:
for i in range(p ** 2, n, 2 * p):
tbl[i] = False
while True:
p += stp
stp = 6 - stp
if tbl[p]:
break
return [i for i in range(n) if tbl[i]]
ps = make_ps(50000)
while True:
n = int(input())
if not n:
break
if n % 2:
print(1 if n - 2 in ps else 0)
else:
res = 0
for p in ps:
if p > n / 2:
break
if n - p in ps:
res += 1
print(res) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s528743964 | p00056 | Time Limit Exceeded | def make_ps(n):
tbl = [False, True, False, False, False, True] * (n // 6 + 1)
for i in range(1, 4):
tbl[i] = not tbl[i]
p, stp, sqrt = 5, 2, n ** 0.5
while p < sqrt:
for i in range(p ** 2, n, 2 * p):
tbl[i] = False
while True:
p += stp
stp = 6 - stp
if tbl[p]:
break
return [i for i in range(n) if tbl[i]]
while True:
n = int(input())
ps = make_ps(n)
if not n:
break
if n % 2:
print(1 if n - 2 in ps else 0)
else:
res = 0
for p in ps:
if p > n / 2:
break
if n - p in ps:
res += 1
print(res) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s034596741 | p00056 | Time Limit Exceeded | def make_ps(n):
tbl = [False, True, False, False, False, True] * (n // 6 + 1)
for i in range(1, 4):
tbl[i] = not tbl[i]
p, stp, sqrt = 5, 2, n ** 0.5
while p < sqrt:
for i in range(p ** 2, n, 2 * p):
tbl[i] = False
while True:
p += stp
stp = 6 - stp
if tbl[p]:
break
return [i for i in range(n) if tbl[i]]
while True:
n = int(input())
ps = make_ps(n)
if not n:
break
if n % 2:
print(1 if n - 2 in ps else 0)
else:
res = 0
for p in ps:
if p > n / 2:
break
if n - p in ps:
res += 1
print(res) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s932073640 | p00056 | Time Limit Exceeded | def make_ps(n):
tbl = [False, True, False, False, False, True] * (n // 6 + 1)
for i in range(1, 4):
tbl[i] = not tbl[i]
p, stp, sqrt = 5, 2, n ** 0.5
while p < sqrt:
for i in range(p ** 2, n, 2 * p):
tbl[i] = False
while True:
p += stp
stp = 6 - stp
if tbl[p]:
break
return [i for i in range(n) if tbl[i]]
ps = make_ps(50000)
while True:
n = int(input())
if not n:
break
res = 0
if n % 2:
if n - 2 in ps:
res += 1
else:
res = 0
for p in ps:
if p > n / 2:
break
if n - p in ps:
res += 1
print(res) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s263948352 | p00056 | Time Limit Exceeded | def make_ps(n):
tbl = [False, True, False, False, False, True] * (n // 6 + 1)
for i in range(1, 4):
tbl[i] = not tbl[i]
p, stp, sqrt = 5, 2, n ** 0.5
while p < sqrt:
for i in range(p ** 2, n, 2 * p):
tbl[i] = False
while True:
p += stp
stp = 6 - stp
if tbl[p]:
break
return [i for i in range(n) if tbl[i]]
ps = make_ps(50000)
while True:
n = int(input())
if not n:
break
res = 0
if n % 2:
if n - 2 in ps:
res += 1
else:
res = 0
for p in ps:
if 2 * p > n:
break
if n - p in ps:
res += 1
print(res) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s500051260 | p00056 | Time Limit Exceeded | def primes(n):
l = [1 for i in range(n+1)]
l[0] = l[1] = 0
for i in range(2,int((n)**(1/2))+1):
if l[i] == 1:
for j in range(2,(n)//i+1):
l[i*j] = 0
return l
l = primes(50000)
while True:
n = int(input())
if n == 0:
break
count = 0
for i in range(1,n//2+1):
if (l[i] and l[n-i]):
count += 1
print(count) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s187726916 | p00056 | Time Limit Exceeded | def primes(n):
l = [1 for i in range(n+1)]
l[0] = l[1] = 0
for i in range(2,int((n)**(1/2))+1):
if l[i] == 1:
for j in range(2,(n)//i+1):
l[i*j] = 0
l2 = [n for n in range(len(l)) if l[n]]
return l2
l = primes(50000)
while True:
n = int(input())
if n == 0:
break
count = 0
for i in range(1,n//2+1):
if (i in l) and ((n-i) in l):
count += 1
print(count) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s757834711 | p00056 | Time Limit Exceeded | def primes(n):
l = [1 for i in range(n+1)]
l[0] = l[1] = 0
for i in range(2,int((n)**(1/2))+1):
if l[i] == 1:
for j in range(2,(n)//i+1):
l[i*j] = 0
l2 = [n for n in range(len(l)) if l[n]]
return l2
l = primes(50000)
while True:
n = int(input())
if n == 0:
break
count = 0
for i in range(1,n):
if l[i] > n/2:
break
elif (n - l[i]) in l:
count += 1
print(count) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s912425589 | p00056 | Time Limit Exceeded | def primes(n):
l = [1 for i in range(n+1)]
l[0] = l[1] = 0
for i in range(2,int((n)**(1/2))+1):
if l[i] == 1:
for j in range(2,(n)//i+1):
l[i*j] = 0
return l
l = primes(50000)
while True:
n = int(input())
if n == 0:
break
count = 0
for i in range(2,n//2+1):
if (l[i] and l[n-i]):
count += 1
print(count) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s117378650 | p00056 | Time Limit Exceeded | def primes(n):
l = [1 for i in range(n+1)]
l[0] = l[1] = 0
for i in range(2,int((n)**(1/2))+1):
if l[i] == 1:
for j in range(2,n//i+1):
l[i*j] = 0
return l
while True:
n = int(input())
if n == 0:
break
l = primes(n)
count = 0
for i in range(2,n//2+1):
if (l[i] and l[n-i]):
count += 1
print(count) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
s450596668 | p00056 | Time Limit Exceeded | n=50000
p=[1]*(n+1)
p[0],p[1]=0,0
for i in range(2,int(n**0.5)+1):
if p[i]:
for j in range(i*i,n+1,i):
p[j]=0
#p=[i for i in range(n+1) if p[i]==1]
while 1:
n=int(input())
if n==0:break
c=0
for i in range(2,n//2+1):
if(p[i],p[n-i])==(1,1):c+=1
print(c) | 10
11
0
| 2
0
|
<H1>ゴールドバッハの予想</H1>
<p>
4 以上の偶数は 2 つの素数の和で表すことができるということが知られています。これはゴールドバッハ予想といい、コンピュータの計算によりかなり大きな数まで正しいことが確かめられています。例えば、10 は、7 + 3、5 + 5 の 2 通りの素数の和で表すことができます。
</p>
<p>
整数 <var>n</var> を入力し、<var>n</var> を 2 つの素数の和で表す組み合わせ数が何通りあるかを出力するプログラムを作成してください。ただし、<var>n</var> は 4 以上、50,000 以下とします。また、入力される <var>n</var> は偶数であるとはかぎりません。
</p>
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットに <var>n</var> が１行に与えられます。<var>n</var> が 0 のとき入力の最後とします。データセットの数は 10,000 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して、<var>n</var> を 2 つの素数の和で表す組み合わせ数を１行に出力して下さい。
</p>
<H2>Sample Input</H2>
<pre>
10
11
0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2
0
</pre>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.