submission_id string | problem_id string | status string | code string | input string | output string | problem_description string |
|---|---|---|---|---|---|---|
s328333673 | p00056 | Time Limit Exceeded | p=[1]*50001
for i in range(2,int(50000**0.5)+1):
if p[i]:
for j in range(i*i,50000,i):p[j]=0
while 1:
n=int(input())
if n==0:break
print(sum(1 for i in range(2,n//2+1) if p[i] and p[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>
|
s702788128 | p00056 | Time Limit Exceeded | p=[]
for i in range(2,50000):
for j in range(2,int(i**0.5)+1):
if not i%j:break
else:p+=[i]
while 1:
n=int(input())
if n==0:break
print(sum(1 for i in range(2,n//2+1) if i in p and n-i in p)) | 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>
|
s497902133 | p00056 | Time Limit Exceeded | p=[]
for i in range(2,50000):
for j in range(2,int(i**0.5)+1):
if not i%j:break
else:p+=[i]
while 1:
n=int(input())
if n==0:break
if n&1:print(int(n-2 in p))
else:print(sum(1 for i in range(2,n//2+1) if i in p and n-i in p)) | 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>
|
s431257720 | p00056 | Time Limit Exceeded | p=[]
for i in range(2,50000):
for j in range(2,int(i**0.5)+1):
if not i%j:break
else:p+=[i]
while 1:
n=int(input())
if n==0:break
c=0
if n&1:print(int(n-2 in p));continue
else:
for x in p:
if x>n//2:break
if n-x in p: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>
|
s146288141 | p00056 | Time Limit Exceeded | p=[2]
for i in range(3,50000,2):
for j in range(2,int(i**0.5)+1):
if not i%j:break
else:p+=[i]
while 1:
n=int(input())
if n==0:break
c=0
if n&1:c=int(n-2 in p)
else:
for x in p:
if x>n//2:break
if n-x in p: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>
|
s368442573 | p00056 | Time Limit Exceeded | p=[i for i in range(50000)]
for i in range(2,int(50000**0.5)+1):
if p[i]:
for j in range(i*i,50000,i):p[j]=0
p=sorted(set(p))[2:]
while 1:
n=int(input())
if n==0:break
c=0
if n&1:c=int(n-2 in p)
else:
for x in p:
if x>n//2:break
if n-x in p: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>
|
s478134846 | p00056 | Time Limit Exceeded | N=50000
p=[i for i in range(N)]
for i in range(2,int(N**0.5)+1):
if p[i]:
for j in range(i*i,N,i):p[j]=0
p=sorted(set(p))[2:]
while 1:
n=int(input())
if n==0:break
c=0
if n&1:c=int(n-2 in p)
else:
for x in p:
if x>n//2:break
if n-x in p: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>
|
s562536757 | p00056 | Time Limit Exceeded | p=[1]*50001
for i in range(2,int(50000**0.5)+1):
if p[i]:
for j in range(i*i,50000,i):p[j]=0
while 1:
n=int(input())
if n==0:break
print(sum(1 for i in range(2,n//2) if p[i] and p[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>
|
s899239791 | p00056 | Time Limit Exceeded | def sieve(n):
is_prime = [True] * (n + 1)
for i in range(2,n + 1):
if is_prime [i] == False:
continue
for j in range(i * 2,n + 1,i):
is_prime [j] = False
return {i for i in range(2,n + 1) if is_prime [i]}
prime = sieve(100000)
while True:
N = int(input())
if N == 0:
break
ans = 0
for i in range(2,N // 2 + 1):
if i in prime and (N - i) in prime:
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>
|
s080639408 | p00056 | Time Limit Exceeded | def sieve(n):
is_prime = [True] * (n + 1)
for i in range(2,n + 1):
if is_prime [i] == False:
continue
for j in range(i * 2,n + 1,i):
is_prime [j] = False
return {i for i in range(2,n + 1) if is_prime [i]}
prime = sieve(100000)
dic = {}
while True:
N = int(input())
if N == 0:
break
if N in dic:
print(dic [N])
continue
ans = 0
for i in range(2,N // 2 + 1):
if i in prime and (N - i) in prime:
ans += 1
print(ans)
if not N in dic:
dic [N] = 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>
|
s657964564 | p00056 | Time Limit Exceeded | def sieve(n):
is_prime = [True] * (n + 1)
for i in range(2,n + 1):
if is_prime [i] == False:
continue
for j in range(i * 2,n + 1,i):
is_prime [j] = False
return [i for i in range(2,n + 1) if is_prime [i]]
prime = sieve(50000)
dic = {}
for i in prime:
for j in prime:
if i < j:
continue
if i + j in dic:
dic [i + j] += 1
else:
dic [i + j] = 1
while True:
N = int(input())
if N == 0:
break
if N in dic:
print(dic [N])
else:
print(0) | 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>
|
s701166462 | p00056 | Time Limit Exceeded | def sieve(n):
is_prime = [True] * (n + 1)
for i in range(2,n + 1):
if is_prime [i] == False:
continue
for j in range(i * 2,n + 1,i):
is_prime [j] = False
return [i for i in range(2,n + 1) if is_prime [i]]
prime = sieve(50000)
dic = {}
for i in prime:
for j in prime:
if i < j or i + j > 50000:
continue
if i + j in dic:
dic [i + j] += 1
else:
dic [i + j] = 1
while True:
N = int(input())
if N == 0:
break
if N in dic:
print(dic [N])
else:
print(0) | 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>
|
s236916313 | p00056 | Time Limit Exceeded | 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
while True:
n = int(input())
if n == 0:
break
ans = 0
mid = n // 2
if primes[mid] and n%2 == 0:
ans += 1
left = [k for k, b in enumerate(primes[:mid]) if b]
right = [k+mid+1 for k, b in enumerate(primes[mid+1:n]) if b]
for i in right:
for j in left:
if i+j == n:
ans += 1
break
if i+j > n:
break
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>
|
s512686607 | p00056 | Time Limit Exceeded | 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
primes = [k for k, b in enumerate(primes) if b]
while True:
n = int(input())
if n == 0:
break
ans = 0
mid = n // 2
if mid in primes and n%2==0:
ans += 1
l, r = bisect.bisect_left(primes, mid), bisect.bisect_left(primes, n)
left = [v for v in primes[:l]]
right = [v for v in primes[l:r]]
for i in right:
for j in left:
if i+j == n:
ans += 1
break
if i+j > n:
break
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>
|
s211856482 | p00056 | Time Limit Exceeded | # -*- coding: utf-8 -*-
import sys
import os
memo = {}
def is_prime(n):
if n in memo:
return memo[n]
if n==2 or n==3:
return True
if n%2==0 or n<2:
return False
for i in range(3,int(n**0.5)+1,2):
if n%i==0:
memo[n] = False
return False
memo[n] = True
return True
for s in sys.stdin:
n = int(s)
if n == 0:
break
if n % 2 == 1:
if is_prime(n - 2):
print(1)
else:
print(0)
else:
counter = 0
for i in range(1, n, 2):
prime0 = i
prime1 = n - i
if prime0 <= prime1 and is_prime(prime0) and is_prime(prime1):
counter += 1
print(counter) | 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>
|
s940930127 | p00056 | Time Limit Exceeded | # -*- coding: utf-8 -*-
import sys
import os
memo = {}
def is_prime(n):
if n in memo:
return memo[n]
if n==2 or n==3:
return True
if n%2==0 or n<2:
return False
for i in range(3,int(n**0.5)+1,2):
if n%i==0:
memo[n] = False
return False
memo[n] = True
return True
for s in sys.stdin:
n = int(s)
if n == 0:
break
if n % 2 == 1:
if is_prime(n - 2):
print(1)
else:
print(0)
else:
counter = 0
for i in range(1, n // 2 + 1, 2):
prime0 = i
prime1 = n - i
if prime0 <= prime1 and is_prime(prime0) and is_prime(prime1):
counter += 1
print(counter) | 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>
|
s143605268 | p00056 | Time Limit Exceeded | # -*- coding: utf-8 -*-
import sys
import os
N = 50001
lst = [True] * N
lst[0] = False
lst[1] = False
for i in range(2, int(N ** 0.5) + 1):
if lst[i]:
for j in range(2, N):
index = i * j
if index < N:
lst[i * j] = False
print('len', len(lst))
for s in sys.stdin:
n = int(s)
if n == 0:
break
if n % 2 == 1:
if lst[n - 2]:
print(1)
else:
print(0)
elif n == 4:
print(1)
else:
counter = 0
for i in range(1, n // 2 + 1, 2):
prime0 = i
prime1 = n - i
if prime0 <= prime1 and lst[prime0] and lst[prime1]:
#print(prime0, prime1)
counter += 1
print(counter) | 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>
|
s104649620 | p00056 | Time Limit Exceeded | # -*- coding: utf-8 -*-
import sys
import os
N = 50001
lst = [True] * N
lst[0] = False
lst[1] = False
for i in range(2, int(N ** 0.5) + 1):
if lst[i]:
for j in range(2, N // i + 1):
index = i * j
if index < N:
lst[i * j] = False
for s in sys.stdin:
n = int(s)
if n == 0:
break
if n % 2 == 1:
if lst[n - 2]:
print(1)
else:
print(0)
elif n == 4:
print(1)
else:
counter = 0
for i in range(1, n // 2 + 1, 2):
prime0 = i
prime1 = n - i
if prime0 <= prime1 and lst[prime0] and lst[prime1]:
#print(prime0, prime1)
counter += 1
print(counter) | 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>
|
s996961014 | p00056 | Time Limit Exceeded | # -*- coding: utf-8 -*-
import sys
import os
N = 50001
lst = [True] * N
lst[0] = False
lst[1] = False
for i in range(4, N // 2 + 1, 2):
lst[i] = False
for i in range(3, int(N ** 0.5) + 1, 2):
if lst[i]:
for j in range(2, N // i + 1):
index = i * j
if index < N:
lst[i * j] = False
for s in sys.stdin:
n = int(s)
if n == 0:
break
if n % 2 == 1:
if lst[n - 2]:
print(1)
else:
print(0)
elif n == 4:
print(1)
else:
counter = 0
for i in range(1, n // 2 + 1, 2):
prime0 = i
prime1 = n - i
if prime0 <= prime1 and lst[prime0] and lst[prime1]:
#print(prime0, prime1)
counter += 1
print(counter) | 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>
|
s118659418 | p00056 | Time Limit Exceeded | # -*- coding: utf-8 -*-
import sys
import os
N = 50001
lst = [True] * N
lst[0] = False
lst[1] = False
for i in range(2, int(N ** 0.5) + 1):
if lst[i]:
for j in range(2 * i, N, i):
lst[j] = False
for s in sys.stdin:
n = int(s)
if n == 0:
break
elif n % 2 == 1:
if lst[n - 2]:
print(1)
else:
print(0)
elif n == 4:
print(1)
else:
counter = 0
for i in range(1, n // 2 + 1, 2):
prime0 = i
prime1 = n - i
if prime0 <= prime1 and lst[prime0] and lst[prime1]:
#print(prime0, prime1)
counter += 1
print(counter) | 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>
|
s106996442 | p00056 | Time Limit Exceeded | # -*- coding: utf-8 -*-
import sys
import os
N = 50001
lst = [True] * N
lst[0] = False
lst[1] = False
for i in range(2, int(N ** 0.5) + 1):
if lst[i]:
for j in range(i * i, N, i):
lst[j] = False
primes = [i for i in range(1, N) if lst[i]]
for s in sys.stdin:
n = int(s)
if n == 0:
break
elif n % 2 == 1:
if lst[n - 2]:
print(1)
else:
print(0)
elif n == 4:
print(1)
else:
counter = 0
for prime0 in primes:
prime1 = n - prime0
if prime0 <= prime1 and lst[prime1]:
#print(prime0, prime1)
counter += 1
print(counter) | 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>
|
s696760527 | p00056 | Time Limit Exceeded | import sys
N = 50001
lst = [True] * N
lst[0] = False
lst[1] = False
for i in range(2, int(N ** 0.5) + 1):
if lst[i]:
for j in range(i * i, N, i):
lst[j] = False
primes = [i for i in range(1, N) if lst[i]]
for s in sys.stdin:
n = int(s)
if n == 0:
break
elif n % 2 == 1:
if lst[n - 2]:
print(1)
else:
print(0)
elif n == 4:
print(1)
else:
counter = 0
for prime0 in primes:
prime1 = n - prime0
if prime0 <= prime1 and lst[prime1]:
#print(prime0, prime1)
counter += 1
print(counter) | 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>
|
s446995258 | p00056 | Time Limit Exceeded | #??¨????????????????????????
prime = [1 for i in range(50000)]
prime[0]=2
prime[1]=0
l = []
for i in range(2,50000):
if prime[i]==1:
prime[0]=i
for j in range(i+1,50000):
if j%prime[0] == 0:
prime[j] = 0
for i in range(1,50000):
if prime[i] == 1:
l.append(i)
while 1:
count = 0
num = int(input())
if num == 0:
break
for i in range(len(l)):
for j in range(i,len(l)):
if num == (l[i] + l[j]):
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>
|
s039630942 | p00056 | Time Limit Exceeded | #??¨????????????????????????
prime = [1 for i in range(50000)]
prime[0]=2
prime[1]=0
l = []
for i in range(2,int(50000**(1/2))):
if prime[i]==1:
prime[0]=i
for j in range(i+1,50000):
if j%prime[0] == 0:
prime[j] = 0
for i in range(1,50000):
if prime[i] == 1:
l.append(i)
while 1:
count = 0
num = int(input())
if num == 0:
break
for i in range(len(l)):
for j in range(i,len(l)):
if num == (l[i] + l[j]):
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>
|
s331409665 | p00056 | Time Limit Exceeded | #??¨????????????????????????
prime = [1 for i in range(50000)]
prime[0]=2
prime[1]=0
l = []
for i in range(2,int(50000**(1/2))):
if prime[i] == 1:
for j in range(2,50000):
if i*j >= 50000:
break
else:
prime[i*j] = 0
for i in range(1,50000):
if prime[i] == 1:
l.append(i)
while 1:
count = 0
num = int(input())
if num == 0:
break
for i in range(len(l)):
if l[i] >= num:
break
else:
for j in range(i,len(l)):
if num < (l[i] + l[j]):
break
else:
if num == (l[i] + l[j]):
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>
|
s913097391 | p00056 | Time Limit Exceeded | 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()
while True:
n = int(input())
if n == 0:
break
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>
|
s572516626 | p00056 | Time Limit Exceeded | isPrime = []
prime = []
import math
def init():
for i in range(50000 + 1):
isPrime.append(True)
def eratos():
isPrime[0] = False
isPrime[1] = False
for i in range(2, int(math.sqrt(50000)) + 1):
if (isPrime[i]):
for j in range(i * 2, 50000 + 1, i):
isPrime[j] = False
for i in range(2, 50001):
if isPrime[i]:
prime.append(i)
init()
eratos()
while True:
n = int(input())
if n == 0:
break
count = 0
if n % 2:
if isPrime[n - 2]:
count += 1
else:
if n == 4:
count += 1
else:
for i in prime:
if i > (n // 2):
break
if (n - i) in prime:
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>
|
s667071414 | p00056 | Time Limit Exceeded | from math import sqrt, ceil, pow
# https://github.com/mccricardo/sieve_of_atkin/blob/master/sieve_of_atkin.py
class SieveOfAtkin:
def __init__(self, limit):
self.limit = limit
self.primes = []
self.sieve = [False] * (self.limit + 1)
def flip(self, prime):
try:
self.sieve[prime] = True if self.sieve[prime] == False else False
except KeyError:
pass
def invalidate(self, prime):
try:
if self.sieve[prime] == True: self.sieve[prime] = False
except KeyError:
pass
def isPrime(self, prime):
try:
return self.sieve[prime]
except KeyError:
return False
def getPrimes(self):
testingLimit = int(ceil(sqrt(self.limit)))
for i in range(testingLimit):
for j in range(testingLimit):
# n = 4*i^2 + j^2
n = 4 * int(pow(i, 2)) + int(pow(j, 2))
if n <= self.limit and (n % 12 == 1 or n % 12 == 5):
self.flip(n)
# n = 3*i^2 + j^2
n = 3 * int(pow(i, 2)) + int(pow(j, 2))
if n <= self.limit and n % 12 == 7:
self.flip(n)
# n = 3*i^2 - j^2
n = 3 * int(pow(i, 2)) - int(pow(j, 2))
if n <= self.limit and i > j and n % 12 == 11:
self.flip(n)
for i in range(5, testingLimit):
if self.isPrime(i):
k = int(pow(i, 2))
for j in range(k, self.limit, k):
self.invalidate(j)
self.primes = [2, 3] + [x for x in range(len(self.sieve)) if self.isPrime(x) and x >= 5]
return self.primes
def solve(num, primes):
result = 0
sub_primes = [x for x in primes if x < num]
for x in sub_primes:
if (num-x) in sub_primes:
result += 1
if (num-x)*2 == num:
result += 1
return result//2
if __name__ == '__main__':
A = SieveOfAtkin(50000)
A.getPrimes()
while True:
num = int(input())
if num == 0:
break
# ????????¨???????????¨???
result = solve(num, A.primes)
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>
|
s432428094 | p00056 | Time Limit Exceeded | from math import sqrt, ceil, pow
# https://github.com/mccricardo/sieve_of_atkin/blob/master/sieve_of_atkin.py
class SieveOfAtkin:
def __init__(self, limit):
self.limit = limit
self.primes = []
self.sieve = [False] * (self.limit + 1)
def flip(self, prime):
try:
self.sieve[prime] = True if self.sieve[prime] == False else False
except KeyError:
pass
def invalidate(self, prime):
try:
if self.sieve[prime] == True: self.sieve[prime] = False
except KeyError:
pass
def isPrime(self, prime):
try:
return self.sieve[prime]
except KeyError:
return False
def getPrimes(self):
testingLimit = int(ceil(sqrt(self.limit)))
for i in range(testingLimit):
for j in range(testingLimit):
# n = 4*i^2 + j^2
n = 4 * int(pow(i, 2)) + int(pow(j, 2))
if n <= self.limit and (n % 12 == 1 or n % 12 == 5):
self.flip(n)
# n = 3*i^2 + j^2
n = 3 * int(pow(i, 2)) + int(pow(j, 2))
if n <= self.limit and n % 12 == 7:
self.flip(n)
# n = 3*i^2 - j^2
n = 3 * int(pow(i, 2)) - int(pow(j, 2))
if n <= self.limit and i > j and n % 12 == 11:
self.flip(n)
for i in range(5, testingLimit):
if self.isPrime(i):
k = int(pow(i, 2))
for j in range(k, self.limit, k):
self.invalidate(j)
self.primes = [2, 3] + [x for x in range(len(self.sieve)) if self.isPrime(x) and x >= 5]
return self.primes
def solve(num, primes):
result = 0
sub_primes = set(x for x in primes if x < num)
for x in sub_primes:
if (num-x) in sub_primes:
result += 1
if (num-x)*2 == num:
result += 1
return result//2
if __name__ == '__main__':
A = SieveOfAtkin(50000)
A.getPrimes()
while True:
num = int(input())
if num == 0:
break
# ????????¨???????????¨???
result = solve(num, A.primes)
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>
|
s913095129 | p00056 | Time Limit Exceeded | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0056
"""
from math import sqrt, ceil, pow
# https://github.com/mccricardo/sieve_of_atkin/blob/master/sieve_of_atkin.py
class SieveOfAtkin:
def __init__(self, limit):
self.limit = limit
self.primes = []
self.sieve = [False] * (self.limit + 1)
def flip(self, prime):
try:
self.sieve[prime] = True if self.sieve[prime] == False else False
except KeyError:
pass
def invalidate(self, prime):
try:
if self.sieve[prime] == True: self.sieve[prime] = False
except KeyError:
pass
def isPrime(self, prime):
try:
return self.sieve[prime]
except KeyError:
return False
def getPrimes(self):
testingLimit = int(ceil(sqrt(self.limit)))
for i in range(testingLimit):
for j in range(testingLimit):
# n = 4*i^2 + j^2
n = 4 * int(pow(i, 2)) + int(pow(j, 2))
if n <= self.limit and (n % 12 == 1 or n % 12 == 5):
self.flip(n)
# n = 3*i^2 + j^2
n = 3 * int(pow(i, 2)) + int(pow(j, 2))
if n <= self.limit and n % 12 == 7:
self.flip(n)
# n = 3*i^2 - j^2
n = 3 * int(pow(i, 2)) - int(pow(j, 2))
if n <= self.limit and i > j and n % 12 == 11:
self.flip(n)
for i in range(5, testingLimit):
if self.isPrime(i):
k = int(pow(i, 2))
for j in range(k, self.limit, k):
self.invalidate(j)
self.primes = [2, 3] + [x for x in range(len(self.sieve)) if self.isPrime(x) and x >= 5]
return self.primes
def solve(num, primes):
result = 0
sub_primes = set(x for x in primes if x < num)
while sub_primes:
x = sub_primes.pop()
if x*2 == num:
result += 1
elif (num-x) in sub_primes:
result += 1
sub_primes.remove(num-x)
return result
if __name__ == '__main__':
A = SieveOfAtkin(50000)
A.getPrimes()
while True:
num = int(input())
if num == 0:
break
# ????????¨???????????¨???
result = solve(num, A.primes)
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>
|
s309651044 | p00056 | Time Limit Exceeded | from math import sqrt, ceil, pow
import bisect
# https://github.com/mccricardo/sieve_of_atkin/blob/master/sieve_of_atkin.py
class SieveOfAtkin:
def __init__(self, limit):
self.limit = limit
self.primes = []
self.sieve = [False] * (self.limit + 1)
def flip(self, prime):
try:
self.sieve[prime] = True if self.sieve[prime] == False else False
except KeyError:
pass
def invalidate(self, prime):
try:
if self.sieve[prime] == True: self.sieve[prime] = False
except KeyError:
pass
def isPrime(self, prime):
try:
return self.sieve[prime]
except KeyError:
return False
def getPrimes(self):
testingLimit = int(ceil(sqrt(self.limit)))
for i in range(testingLimit):
for j in range(testingLimit):
# n = 4*i^2 + j^2
n = 4 * int(pow(i, 2)) + int(pow(j, 2))
if n <= self.limit and (n % 12 == 1 or n % 12 == 5):
self.flip(n)
# n = 3*i^2 + j^2
n = 3 * int(pow(i, 2)) + int(pow(j, 2))
if n <= self.limit and n % 12 == 7:
self.flip(n)
# n = 3*i^2 - j^2
n = 3 * int(pow(i, 2)) - int(pow(j, 2))
if n <= self.limit and i > j and n % 12 == 11:
self.flip(n)
for i in range(5, testingLimit):
if self.isPrime(i):
k = int(pow(i, 2))
for j in range(k, self.limit, k):
self.invalidate(j)
self.primes = [2, 3] + [x for x in range(len(self.sieve)) if self.isPrime(x) and x >= 5]
return self.primes
def solve1(num, primes):
result = 0
sub_primes = set(x for x in primes if x < num)
for x in sub_primes:
if (num-x) in sub_primes:
# print('solve1: {} + {} = {}'.format(x, num-x, num))
result += 1
if (num-x)*2 == num:
result += 1
return result//2
def solve2(num, primes):
result = 0
sub_primes = set(x for x in primes if x < num)
while sub_primes:
x = sub_primes.pop()
if x*2 == num:
result += 1
elif (num-x) in sub_primes:
result += 1
sub_primes.remove(num-x)
return result
def solve3(num, primes):
result = 0
sub_primes = [x for x in primes if x < num]
primes_len = len(sub_primes)
# print('solve3: primes_len: {}'.format(primes_len))
# print(sub_primes)
n = 0
while True:
if sub_primes[n] > num/2:
break
i = bisect.bisect_left(sub_primes, num-sub_primes[n])
if i != primes_len and sub_primes[i] == num-sub_primes[n]:
# print('solve3: {} + {} = {}'.format(sub_primes[n], num-sub_primes[n], num))
result += 1
n += 1
return result
if __name__ == '__main__':
A = SieveOfAtkin(50000)
A.getPrimes()
while True:
num = int(input())
if num == 0:
break
# ????????¨???????????¨???
result = solve3(num, A.primes)
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>
|
s082751195 | p00056 | Time Limit Exceeded | from math import sqrt, ceil, pow
import bisect
# https://github.com/mccricardo/sieve_of_atkin/blob/master/sieve_of_atkin.py
class SieveOfAtkin:
def __init__(self, limit):
self.limit = limit
self.primes = []
self.sieve = [False] * (self.limit + 1)
def flip(self, prime):
try:
self.sieve[prime] = True if self.sieve[prime] == False else False
except KeyError:
pass
def invalidate(self, prime):
try:
if self.sieve[prime] == True: self.sieve[prime] = False
except KeyError:
pass
def isPrime(self, prime):
try:
return self.sieve[prime]
except KeyError:
return False
def getPrimes(self):
testingLimit = int(ceil(sqrt(self.limit)))
for i in range(testingLimit):
for j in range(testingLimit):
# n = 4*i^2 + j^2
n = 4 * int(pow(i, 2)) + int(pow(j, 2))
if n <= self.limit and (n % 12 == 1 or n % 12 == 5):
self.flip(n)
# n = 3*i^2 + j^2
n = 3 * int(pow(i, 2)) + int(pow(j, 2))
if n <= self.limit and n % 12 == 7:
self.flip(n)
# n = 3*i^2 - j^2
n = 3 * int(pow(i, 2)) - int(pow(j, 2))
if n <= self.limit and i > j and n % 12 == 11:
self.flip(n)
for i in range(5, testingLimit):
if self.isPrime(i):
k = int(pow(i, 2))
for j in range(k, self.limit, k):
self.invalidate(j)
self.primes = [2, 3] + [x for x in range(len(self.sieve)) if self.isPrime(x) and x >= 5]
return self.primes
def solve1(num, primes):
result = 0
sub_primes = set(x for x in primes if x < num)
for x in sub_primes:
if (num-x) in sub_primes:
# print('solve1: {} + {} = {}'.format(x, num-x, num))
result += 1
if (num-x)*2 == num:
result += 1
return result//2
def solve2(num, primes):
result = 0
sub_primes = set(x for x in primes if x < num)
while sub_primes:
x = sub_primes.pop()
if x*2 == num:
result += 1
elif (num-x) in sub_primes:
result += 1
sub_primes.remove(num-x)
return result
def solve3(num, primes):
result = 0
sub_primes = [x for x in primes if x < num]
primes_len = len(sub_primes)
# print('solve3: primes_len: {}'.format(primes_len))
# print(sub_primes)
n = 0
while True:
if sub_primes[n] > num/2:
break
i = bisect.bisect_left(sub_primes, num-sub_primes[n])
if i != primes_len and sub_primes[i] == num-sub_primes[n]:
# print('solve3: {} + {} = {}'.format(sub_primes[n], num-sub_primes[n], num))
result += 1
n += 1
return result
if __name__ == '__main__':
A = SieveOfAtkin(50000)
A.getPrimes()
while True:
num = int(input())
if num == 0:
break
# ????????¨???????????¨???
result = solve1(num, A.primes)
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>
|
s870363777 | p00056 | Time Limit Exceeded | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0056
"""
from math import sqrt, ceil, pow
import bisect
# https://github.com/mccricardo/sieve_of_atkin/blob/master/sieve_of_atkin.py
class SieveOfAtkin:
def __init__(self, limit):
self.limit = limit
self.primes = []
self.sieve = [False] * (self.limit + 1)
def flip(self, prime):
try:
self.sieve[prime] = True if self.sieve[prime] == False else False
except KeyError:
pass
def invalidate(self, prime):
try:
if self.sieve[prime] == True: self.sieve[prime] = False
except KeyError:
pass
def isPrime(self, prime):
try:
return self.sieve[prime]
except KeyError:
return False
def getPrimes(self):
testingLimit = int(ceil(sqrt(self.limit)))
for i in range(testingLimit):
for j in range(testingLimit):
# n = 4*i^2 + j^2
n = 4 * int(pow(i, 2)) + int(pow(j, 2))
if n <= self.limit and (n % 12 == 1 or n % 12 == 5):
self.flip(n)
# n = 3*i^2 + j^2
n = 3 * int(pow(i, 2)) + int(pow(j, 2))
if n <= self.limit and n % 12 == 7:
self.flip(n)
# n = 3*i^2 - j^2
n = 3 * int(pow(i, 2)) - int(pow(j, 2))
if n <= self.limit and i > j and n % 12 == 11:
self.flip(n)
for i in range(5, testingLimit):
if self.isPrime(i):
k = int(pow(i, 2))
for j in range(k, self.limit, k):
self.invalidate(j)
self.primes = [2, 3] + [x for x in range(len(self.sieve)) if self.isPrime(x) and x >= 5]
return self.primes
def solve1(num, primes):
# 7.43[s]
result = 0
list_primes = [x for x in primes if x < num]
set_primes = set(list_primes)
for x in list_primes:
if x > num/2:
break
if (num-x) in set_primes:
# print('solve1: {} + {} = {}'.format(x, num-x, num))
result += 1
# if (num-x)*2 == num:
# result += 1
return result
def solve2(num, primes):
result = 0
sub_primes = set(x for x in primes if x < num)
while sub_primes:
x = sub_primes.pop()
if x*2 == num:
result += 1
elif (num-x) in sub_primes:
result += 1
sub_primes.remove(num-x)
return result
def solve3(num, primes):
# 17.96[s]
result = 0
sub_primes = [x for x in primes if x < num]
primes_len = len(sub_primes)
# print('solve3: primes_len: {}'.format(primes_len))
# print(sub_primes)
n = 0
while True:
if sub_primes[n] > num/2:
break
i = bisect.bisect_left(sub_primes, num-sub_primes[n])
if i != primes_len and sub_primes[i] == num-sub_primes[n]:
# print('solve3: {} + {} = {}'.format(sub_primes[n], num-sub_primes[n], num))
result += 1
n += 1
return result
if __name__ == '__main__':
A = SieveOfAtkin(50000)
A.getPrimes()
while True:
num = int(input())
if num == 0:
break
# ????????¨???????????¨???
result = solve1(num, A.primes)
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>
|
s347523821 | p00056 | Time Limit Exceeded | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0056
"""
from math import sqrt, ceil, pow
import bisect
# https://github.com/mccricardo/sieve_of_atkin/blob/master/sieve_of_atkin.py
class SieveOfAtkin:
def __init__(self, limit):
self.limit = limit
self.primes = []
self.sieve = [False] * (self.limit + 1)
def flip(self, prime):
try:
self.sieve[prime] = True if self.sieve[prime] == False else False
except KeyError:
pass
def invalidate(self, prime):
try:
if self.sieve[prime] == True: self.sieve[prime] = False
except KeyError:
pass
def isPrime(self, prime):
try:
return self.sieve[prime]
except KeyError:
return False
def getPrimes(self):
testingLimit = int(ceil(sqrt(self.limit)))
for i in range(testingLimit):
for j in range(testingLimit):
# n = 4*i^2 + j^2
n = 4 * int(pow(i, 2)) + int(pow(j, 2))
if n <= self.limit and (n % 12 == 1 or n % 12 == 5):
self.flip(n)
# n = 3*i^2 + j^2
n = 3 * int(pow(i, 2)) + int(pow(j, 2))
if n <= self.limit and n % 12 == 7:
self.flip(n)
# n = 3*i^2 - j^2
n = 3 * int(pow(i, 2)) - int(pow(j, 2))
if n <= self.limit and i > j and n % 12 == 11:
self.flip(n)
for i in range(5, testingLimit):
if self.isPrime(i):
k = int(pow(i, 2))
for j in range(k, self.limit, k):
self.invalidate(j)
self.primes = [2, 3] + [x for x in range(len(self.sieve)) if self.isPrime(x) and x >= 5]
return self.primes
def solve1(num, primes):
# 6.94[s]
result = 0
set_primes = set(x for x in primes if x < num)
for x in primes:
if x > num/2:
break
if (num-x) in set_primes:
# print('solve1: {} + {} = {}'.format(x, num-x, num))
result += 1
return result
def solve2(num, primes):
result = 0
sub_primes = set(x for x in primes if x < num)
while sub_primes:
x = sub_primes.pop()
if x*2 == num:
result += 1
elif (num-x) in sub_primes:
result += 1
sub_primes.remove(num-x)
return result
def solve3(num, primes):
# 17.96[s]
result = 0
sub_primes = [x for x in primes if x < num]
primes_len = len(sub_primes)
# print('solve3: primes_len: {}'.format(primes_len))
# print(sub_primes)
n = 0
while True:
if sub_primes[n] > num/2:
break
i = bisect.bisect_left(sub_primes, num-sub_primes[n])
if i != primes_len and sub_primes[i] == num-sub_primes[n]:
# print('solve3: {} + {} = {}'.format(sub_primes[n], num-sub_primes[n], num))
result += 1
n += 1
return result
if __name__ == '__main__':
A = SieveOfAtkin(50000)
A.getPrimes()
while True:
num = int(input())
if num == 0:
break
# ????????¨???????????¨???
result = solve1(num, A.primes)
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>
|
s851500922 | p00056 | Time Limit Exceeded | 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
while True:
n = int(input())
if n == 0:
break
print(sum(primes[i] and primes[n-i] for i in range(2, n//2+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>
|
s459649291 | p00056 | Time Limit Exceeded | 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 = [i for i, k in enumerate(primes) if k]
while True:
n = int(input())
if n == 0:
break
I = bisect.bisect(values, n//2)
tmp = values[:I]
print(sum(n - t in tmp for t in tmp)) | 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>
|
s831846921 | p00056 | Time Limit Exceeded | 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())
if n == 0:
break
elif n%2 == 1:
print(0)
continue
cnt = 0
for i in range(n):
if c[i] == 1 and c[n-i] == 1:
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>
|
s639501380 | p00056 | Time Limit Exceeded | n = 50001
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())
if n == 0:
break
elif n%2 == 1:
print(0)
continue
cnt = 0
for i in range(n):
if c[i] == 1 and c[n-i] == 1:
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>
|
s336322904 | p00056 | Time Limit Exceeded | n = 50001
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())
if n == 0:
break
elif n%2 == 1:
print(0)
continue
cnt = 0
for i in range(n//2):
if c[i] == 1 and c[n-i] == 1:
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>
|
s468114715 | p00056 | Time Limit Exceeded | 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(n//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>
|
s730677859 | p00056 | Time Limit Exceeded | n = 50001
is_prime = [True for i in range(n)]
is_prime[0] = is_prime[1] = False
i = 2
while i**2 <= n:
j = i*2
while j < n:
is_prime[j] = False
j += i
i += 1
cnt_pair = [0 for i in range(n)]
for i in range(n):
cnt = 0
if i%2 == 0:
for j in range(n):
if is_prime[j] and is_prime[n - j]:
cnt += 1
cnt_pair[i] = cnt
while True:
n = int(input())
if n == 0:
break
print(cnt_pair[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>
|
s641389665 | p00056 | Time Limit Exceeded | n = 50001
is_prime = [True for i in range(n)]
is_prime[0] = is_prime[1] = False
i = 2
while i**2 <= n:
j = i*2
while j < n:
is_prime[j] = False
j += i
i += 1
cnt_pair = [0 for i in range(n)]
for i in range(n):
cnt = 0
if i%2 == 0:
for j in range(0, n//2):
if is_prime[j] and is_prime[n - j]:
cnt += 1
cnt_pair[i] = cnt
while True:
n = int(input())
if n == 0:
break
print(cnt_pair[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>
|
s058355479 | p00056 | Time Limit Exceeded | n = 50001
is_prime = [True for i in range(n)]
is_prime[0] = is_prime[1] = False
i = 2
while i**2 <= n:
j = i*2
while j < n:
is_prime[j] = False
j += i
i += 1
cnt_pair = [0 for i in range(n)]
for i in range(n):
if is_prime[i]:
for j in range(i, n):
if i + j >= n:
break
if is_prime[j]:
cnt_pair[i + j] += 1
while True:
n = int(input())
if n == 0:
break
print(cnt_pair[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>
|
s624066049 | p00056 | Time Limit Exceeded | n = 50001
is_prime = [True for i in range(n)]
is_prime[0] = is_prime[1] = False
i = 2
while i**2 <= n:
j = i*2
while j < n:
is_prime[j] = False
j += i
i += 1
cnt_pair = [0 for i in range(n)]
for i in range(n//2):
if is_prime[i]:
for j in range(i, n - i):
if is_prime[j]:
cnt_pair[i + j] += 1
while True:
n = int(input())
if n == 0:
break
print(cnt_pair[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>
|
s757624296 | p00056 | Time Limit Exceeded | n = 50001
is_prime = [True for i in range(n)]
is_prime[0] = is_prime[1] = False
i = 2
while i**2 <= n:
j = i*2
while j < n:
is_prime[j] = False
j += i
i += 1
cnt_pair = [0 for i in range(n)]
for i in range(3, n//2, 2):
if is_prime[i]:
for j in range(i, n - i, 2):
if is_prime[j]:
cnt_pair[i + j] += 1
while True:
n = int(input())
if n == 0:
break
print(cnt_pair[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>
|
s379399555 | p00056 | Time Limit Exceeded | def get_input():
while True:
try:
yield ''.join(input())
except EOFError:
break
MAX = 50000
primes = list()
for i in range(MAX):
primes.append(True)
primes[0] = False
primes[1] = False
for i in range(2, MAX):
j = i + i
while j < MAX:
primes[j] = False
j = j + i
while True:
N = int(input())
if N == 0:
break
ans = 0
for i in range(1,N//2 + 1):
if primes[i] and 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>
|
s083112961 | p00056 | Time Limit Exceeded | def get_input():
while True:
try:
yield ''.join(input())
except EOFError:
break
MAX = 50000
primes = list()
for i in range(MAX):
primes.append(True)
primes[0] = False
primes[1] = False
for i in range(2, MAX):
j = i + i
while j < MAX:
primes[j] = False
j = j + i
while True:
N = int(input())
if N == 0:
break
ans = 0
if N % 2 == 0:
for i in range(1,N//2 + 1):
if primes[i] and primes[N-i]:
ans += 1
else:
if primes[2] and primes[N-2]:
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>
|
s012718152 | p00056 | Time Limit Exceeded | def get_input():
while True:
try:
yield ''.join(input())
except EOFError:
break
MAX = 50001
primes = list()
for i in range(MAX):
primes.append(True)
primes[0] = False
primes[1] = False
for i in range(2, MAX):
j = i + i
while j < MAX:
primes[j] = False
j = j + i
primeList = []
for i in range(MAX):
if primes[i]:
primeList.append(i)
ans = [0 for i in range(MAX*2+1)]
for i in range(len(primeList)):
for j in range(i, len(primeList)):
k = primeList[i] + primeList[j]
ans[k] += 1
while True:
N = int(input())
if N == 0:
break
print(ans[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>
|
s344944711 | p00056 | Time Limit Exceeded | from itertools import *
n=range(49994);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 iter(input,'0'):x=int(x);print(sum(1 for a,b in combinations_with_replacement(p[:x],2)if a+b==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>
|
s365817411 | p00056 | Time Limit Exceeded | from itertools import *
n=range(49994);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 iter(input,'0'):
x=int(x)
if x%2:print(sum(1 for c in p[1:x]if 2+c==x))
elif x-4:print(sum(1 for a,b in combinations_with_replacement(p[1:x],2)if a+b==x))
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>
|
s942611528 | p00056 | Time Limit Exceeded | from itertools import *
n=range(49994);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 iter(input,'0'):
x=int(x)
if x%2:print(sum(1 for c in p[1:x]if 2+c==x))
elif x-4:print(sum(1 for a in p[1:x]for b in p[1:x]if a+b==x))
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>
|
s481301436 | p00056 | Time Limit Exceeded | from itertools import *
n=range(49994);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 iter(input,'0'):
x=int(x)
if x%2:print(sum(1 for c in p[2:x]if 2+c==x))
elif x-4:print(sum(1 for a,b in combinations_with_replacement(p[1:x],2)if a+b==x))
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>
|
s539829814 | p00056 | Time Limit Exceeded | 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])
for x in iter(input,'0'):x=int(x);y=x//2+1;print(sum(a[x-d]>0 for d in compress(n[:y],a[:y])))
| 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>
|
s714407229 | p00056 | Time Limit Exceeded | 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])
for x in iter(input,'0'):x=int(x);y=x//2+1;print(sum(a[x-d]>0 for d in a[:y]))
| 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>
|
s187099608 | p00056 | Time Limit Exceeded | import bisect,sys
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])
for x in map(int,sys.stdin):
if x:y=x//2+1;print(sum(1 for d in compress(n[:y],a[:y])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>
|
s389176751 | p00056 | Time Limit Exceeded | MAX = 50001
is_prime = [True for _ in range(MAX)]
is_prime[0] = is_prime[1] = False
for i in range(2, int(MAX ** (1 / 2)) + 1):
if is_prime[i]:
for j in range(i ** 2, MAX, i):
is_prime[j] = False
primes = [i for i in range(MAX) if is_prime[i]]
def main():
while True:
n = int(input())
if not n:
break
primes_less_than_n = [i for i in primes if i <= n // 2]
ans = 0
for i in primes_less_than_n:
if i > n // 2:
break
if is_prime[n - i]:
ans += 1
print(ans)
main()
| 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>
|
s505688515 | p00056 | Time Limit Exceeded | # AOJ 0056 Goldbach's Conjecture
# Python3 2018.6.16 bal4u
MAX = 50001
HALF = 25000
prime = [True]*MAX
def sieve(max):
for i in range(4, max, 2):
prime[i] = False
sqrt = int(max**0.5)
print('Sqrt=',sqrt)
for i in range(3, sqrt, 2):
if prime[i] is True:
for j in range(i*i, max, i):
prime[j] = False
sieve(MAX)
ans = [0]*(MAX*2)
ans[4] = 1
for i in range(3, MAX, 2):
if prime[i]: ans[i+2] = 1
for i in range(3, HALF, 2):
if prime[i]:
for j in range(i, MAX, 2):
if prime[j]: ans[i+j] += 1
while True:
n = int(input())
if n == 0: break
print(ans[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>
|
s674625039 | p00056 | Time Limit Exceeded | from bisect import bisect_left
ub = 50000
primes = {2} | set(range(3, ub, 2))
du = primes.difference_update
for n in range(3, ub, 2):
if n in primes:
du(range(n*3, ub, n*2))
primes = list(primes)
while True:
n = int(input())
if n == 0:
break
l, r = 0, bisect_left(primes, n-2)
ans = 0
while l <= r:
if primes[l]+primes[r] > n:
r -= 1
ans += (primes[l]+primes[r] == n)
l += 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>
|
s368132760 | p00056 | Time Limit Exceeded | #!/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 solve():
prime_list = make_prime_list(50000)
while True:
n = input()
if n > 0:
count = 0
index = 0
rev_index = len(prime_list) - 1
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:
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>
|
s068949266 | p00056 | Time Limit Exceeded | #!/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:
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:
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>
|
s828391027 | p00056 | Time Limit Exceeded | n=5*10**4
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
while True:
n=input()
if n==0:break
c=0
for i in xrange(n/2+1):
if p[i] and p[n-i]: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>
|
s000433688 | p00056 | Time Limit Exceeded | 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
while True:
n=input()
if n==0:break
c=0
for i in xrange(n/2+1):
if p[i] and p[n-i]: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>
|
s963400259 | p00056 | Time Limit Exceeded |
import sys
def solv(n):
r = 0
m = n / 2
ps = filter(lambda x: x <= m, primes)
for p in ps:
q = n - p
if q in primes:
r += 1
return r
def prime_list(n):
limit = int(n ** 0.5) + 1
lis = range(1, n + 1, 2)
lis[0] = 2
while True:
if len(lis) == 0:
break
p = lis.pop(0)
yield p
if p <= limit:
lis = [x for x in lis if x % p != 0]
primes = []
for p in prime_list(50000):
primes.append(p)
while True:
n = int(sys.stdin.readline())
if n == 0:
exit()
print solv(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>
|
s604943553 | p00056 | Time Limit Exceeded |
import sys
def solv(n):
r = 0
for p in primes:
if n/2 < p:
break
q = n - p
if q in primes:
r += 1
return r
def prime_list(n):
limit = int(n ** 0.5) + 1
lis = range(1, n + 1, 2)
lis[0] = 2
while True:
if len(lis) == 0:
break
p = lis.pop(0)
yield p
if p <= limit:
lis = [x for x in lis if x % p != 0]
primes = []
for p in prime_list(50000):
primes.append(p)
while True:
n = int(sys.stdin.readline())
if n == 0:
exit()
print solv(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>
|
s681511273 | p00056 | Time Limit Exceeded |
import sys
def solv(n):
r = 0
if n % 2 == 1:
if (n-2) in primes:
return 1
else:
for p in primes:
if n/2 < p:
break
q = n - p
if q in primes:
r += 1
return r
def prime_list(n):
limit = int(n ** 0.5) + 1
lis = range(1, n + 1, 2)
lis[0] = 2
while True:
if len(lis) == 0:
break
p = lis.pop(0)
yield p
if p <= limit:
lis = [x for x in lis if x % p != 0]
primes = []
for p in prime_list(50000):
primes.append(p)
while True:
n = int(sys.stdin.readline())
if n == 0:
exit()
print solv(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>
|
s861437380 | p00056 | Time Limit Exceeded |
import sys
def solv(n):
r = 0
if n % 2 == 1:
if (n-2) in primes:
r = 1
else:
for p in primes:
if n/2 < p:
break
q = n - p
# if q in primes:
if binary_search(primes, q):
r += 1
return r
def prime_list(n):
limit = int(n ** 0.5) + 1
lis = range(1, n + 1, 2)
lis[0] = 2
while True:
if len(lis) == 0:
break
p = lis.pop(0)
yield p
if p <= limit:
lis = [x for x in lis if x % p != 0]
def binary_search(lis, x):
if len(lis) == 0:
return None
i = len(lis) / 2
if lis[i] == x:
return x
elif x < lis[i]:
return binary_search(lis[:i], x)
else:
return binary_search(lis[i+1:], x)
primes = []
for p in prime_list(50000):
primes.append(p)
while True:
n = int(sys.stdin.readline())
if n == 0:
exit()
print solv(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>
|
s307979407 | p00056 | Time Limit Exceeded |
import sys
def solv(n):
r = 0
if n % 2 == 1:
# if (n-2) in primes:
if binary_search(primes, n-2):
r = 1
else:
for p in primes:
if n/2 < p:
break
q = n - p
# if q in primes:
if binary_search(primes, q):
r += 1
return r
def prime_list(n):
limit = int(n ** 0.5) + 1
lis = range(1, n + 1, 2)
lis[0] = 2
while True:
if len(lis) == 0:
break
p = lis.pop(0)
yield p
if p <= limit:
lis = [x for x in lis if x % p != 0]
def binary_search(lis, x):
if len(lis) == 0:
return None
i = len(lis) / 2
if lis[i] == x:
return x
elif x < lis[i]:
return binary_search(lis[:i], x)
else:
return binary_search(lis[i+1:], x)
primes = []
for p in prime_list(50000):
primes.append(p)
while True:
n = int(sys.stdin.readline())
if n == 0:
exit()
print solv(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>
|
s814188043 | p00056 | Time Limit Exceeded | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
from itertools import combinations_with_replacement
L = range(2, 50000)
P = []
while L[0] ** 2 < 50000:
P.append(L[0])
L = [i for i in L if i % P[-1]]
P.extend(L)
del L
for line in stdin:
if line.startswith('0'):
break
n = int(line)
cnt = 0
for a, b in combinations_with_replacement(P, 2):
if a >= n:
break
if a + b == n:
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>
|
s349732970 | p00056 | Time Limit Exceeded | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
from itertools import combinations_with_replacement
L = range(2, 50000)
P = []
while L[0] ** 2 < 50000:
P.append(L[0])
L = [i for i in L if i % P[-1]]
P.extend(L)
del L
for line in stdin:
if line.startswith('0'):
break
n = int(line)
cnt = 0
if n % 2 or not (n in P):
for a, b in combinations_with_replacement(P, 2):
if a >= n:
break
if a + b == n:
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>
|
s590105598 | p00056 | Time Limit Exceeded | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
from itertools import combinations_with_replacement
def enum_prime(m):
L = range(2, m)
P = []
while L[0] ** 2 < m:
P.append(L[0])
L = [i for i in L if i % P[-1]]
return P + L
P1 = enum_prime(50000)
P2 = P1[:]
for line in stdin:
if line.startswith('0'):
break
n = int(line)
cnt = 0
if n % 2 == 0:
for a in P1:
if a + a == n:
cnt += 1
break
for b in P2:
if b < a:
continue
if a + b == n:
cnt += 1
break
if a + b > n:
break
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>
|
s664683933 | p00056 | Time Limit Exceeded | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
def enum_prime(m):
L = range(2, m)
P = []
while L[0] ** 2 < m:
P.append(L[0])
L = [i for i in L if i % P[-1]]
return P + L
P = enum_prime(50000)
length = len(P)
for line in stdin:
if line.startswith('0'):
break
n = int(line)
cnt = 0
if (n - 2) in P:
cnt = 1
elif n % 2 == 0:
for i in xrange(length):
for j in xrange(i, length):
s = P[i] + P[j]
if s >= n:
if s == n:
cnt += 1
break
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>
|
s682975152 | p00056 | Time Limit Exceeded | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
def enum_prime(m):
L = range(2, m)
P = []
while L[0] ** 2 < m:
P.append(L[0])
L = [i for i in L if i % P[-1]]
return P + L
P = enum_prime(50000)
for line in stdin:
if line.startswith('0'):
break
n = int(line)
cnt = 0
if n % 2 == 0:
for p in P:
if (n - p) in P:
cnt += 1
elif p + p > n:
break
elif (n - 2) 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>
|
s352702725 | p00056 | Time Limit Exceeded | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
def enum_prime(m):
L = [True for _ in xrange(m + 1)]
L[0] = L[1] = False
for i in xrange(2, m + 1):
if not L[i]:
continue
for j in xrange(i + i, m + 1, i):
L[j] = False
if m < i * i:
break
return L
P = enum_prime(50000)
for line in stdin:
if line.startswith('0'):
break
n = int(line)
cnt = 0
if n % 2 == 0:
for p, isprime in enumerate(P):
if not isprime:
continue
if p + p > n:
break
if P[n - p]:
cnt += 1
elif P[n - 2]:
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>
|
s563924365 | p00056 | Time Limit Exceeded | p = [True] * (50000)
p[0] = p[1] = False
for i in range(2, len(p)):
if p[i]:
for j in range(i * 2, len(p), i):
p[j] = False
while True:
n = int(raw_input())
if n == 0:
break
c = 0
for i in range(n/2+1):
if p[i] and p[n-i]:
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>
|
s999776455 | p00056 | Time Limit Exceeded | 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 SIEVES if 0<e<=n/2 and SIEVES[(n-e)/2]!=0])
return x
SIEVES=sieve(50000)
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>
|
s961554980 | p00056 | Time Limit Exceeded | 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
b=n/2
if n==2 or n==3: return 1
if n%2==1:
if n-2 in PRIMES: x=1
else:
for e in PRIMES:
if e>b:break
if n-e in PRIMES: x+=1
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>
|
s166483747 | p00056 | Time Limit Exceeded | 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)]
while True:
n = int(raw_input())
if n == 0:
break
count = 0
for i in range(n/2):
if p[i] == 1:
m = n - (i+1)
if p[m-1] == 1:
count += 1
print count | 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>
|
s045947768 | p00056 | Time Limit Exceeded | 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)]
prime = []
for i in range(len(p)):
if p[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>
|
s265454982 | p00056 | Time Limit Exceeded | 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)]
while True:
n = int(raw_input())
if n == 0:
break
count = 0
m = n/2
for i in range(m):
if p[i] == 1 and 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>
|
s495648681 | p00056 | Time Limit Exceeded | 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 [v for v in a if v]
def isPrime(p):
if p < 2:
return False
for i in count(2):
if i * i > p:
return True
if p % i == 0:
return False
a = sieve(50000)
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 isPrime(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>
|
s430266906 | p00056 | Time Limit Exceeded | N = 50000
t = [1]*N
p = []
for i in range(3, N + 1, 2):
if t[i]:
p.append(i)
for j in range(3*i, N+1, 2*i): t[j] = 0
while True:
n = int(input())
if n == 0: break
if n % 2:
print(1 if n - 2 in p else 0)
else:
count = 0
for p1 in p:
if 2*p1 > n: break
if n - p1 in p: 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>
|
s178938733 | p00056 | Accepted | import sys
from bisect import bisect_right
from itertools import chain, compress
ub = 50000
is_prime = [0, 0, 1, 1] + [0]*(ub-3)
is_prime[5::6] = is_prime[7::6] = [1]*int(ub/6)
primes = [2, 3]
append = primes.append
for n in chain(range(5, ub, 6), range(7, ub, 6)):
if is_prime[n]:
append(n)
is_prime[n*3::n*2] = [0]*((ub-n)//(n*2))
primes.sort()
for n in map(int, sys.stdin):
if not n:
break
if n%2:
print(is_prime[n-2])
else:
print(len([1 for p in primes[:bisect_right(primes, n/2)] if is_prime[n-p]]))
| 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>
|
s399350653 | p00056 | Accepted | from itertools import *
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] ]
c = [0]*maxnum*2
for i,j in combinations_with_replacement(p,2):
c[i+j] += 1
for s in sys.stdin:
d = int(s)
if d == 0: break
print c[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>
|
s224045988 | p00056 | Accepted | 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
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>
|
s396405576 | p00056 | Accepted | 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,50000):
if pri(i):
l.append(i)
s=5133
ans={}
for i in range(5132):
for j in range(i,5133):
a,b=l[i],l[j]
if a+b>50000:
break
if ans.has_key(a+b):
ans[a+b]+=1
else:
ans[a+b]=1
while 1:
n=int(raw_input())
if n==0:
break
print ans[n] if ans.has_key(n) else 0 | 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>
|
s124158023 | p00056 | Accepted | 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)
sp = set(p)
while True:
n = int(input())
if not n:
break
if n & 1:
print(int(n - 2 in sp))
continue
n2 = n // 2
cnt = 0
for i in p:
if n2 < i:
break
if n - i in sp:
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>
|
s173708524 | p00056 | Accepted | def make_tbl(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 tbl
tbl = make_tbl(50000)
ps = [i for i in range(50000) if tbl[i]]
while True:
n = int(input())
if not n:
break
res = 0
if n % 2:
if tbl[n - 2]:
res += 1
else:
res = 0
for p in ps:
if 2 * p > n:
break
if tbl[n - p]:
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>
|
s593177737 | p00056 | Accepted | 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
if n == 4:
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>
|
s873342755 | p00056 | Accepted | # aoj0056.py
LIM = 50001
# prepare primes
is_prime = [True for _ in range(LIM)]
is_prime[0] = is_prime[1] = False
# sieve of eratosthenes
for x in range(LIM//2 + 1):
if is_prime[x]:
for y in range(x*x, LIM, x):
is_prime[y] = False
primes = [x for x in range(LIM) if is_prime[x]]
# END `prepare primes`
count_arr = [0 for x in range(LIM)]
len_primes = len(primes)
for x in range(len_primes):
p = primes[x]
for y in range(x, len_primes):
q = primes[y]
if p+q >= LIM:
break
count_arr[p+q] += 1
while True:
n = int(input())
if n == 0:
break
print(count_arr[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>
|
s600020487 | p00056 | Accepted | pr = [True] * 50001
for i in range(2,225):
if pr[i]:
for j in range(i * 2, 50001, i):
pr[j] = False
prime = [2] + [i for i in range(3, 50001, 2) if pr[i]]
def gold_count(n):
res = 0
for i in prime:
if i > n // 2:
break
if pr[n - i]:
res += 1
return res
while True:
n = int(input())
if n == 0:
break
print(gold_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>
|
s841384721 | p00056 | Accepted | pr = [True] * 50001
for i in range(2,225):
if pr[i]:
for j in range(i * 2, 50001, i):
pr[j] = False
prime = [2] + [i for i in range(3, 50001, 2) if pr[i]]
def gold_count(n):
res = 0
if pr[n - 2]:
res += 1
for i in range(3, n // 2 + 1, 2):
if pr[i] and pr[n - i]:
res += 1
return res
while True:
n = int(input())
if n == 0:
break
print(gold_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>
|
s632001536 | p00056 | Accepted | pr = [True] * 50001
for i in range(2,225):
if pr[i]:
for j in range(i * 2, 50001, i):
pr[j] = False
def gold_count(n):
res = 0
if pr[n - 2]:
res += 1
for i in range(3, n // 2 + 1, 2):
if pr[i] and pr[n - i]:
res += 1
return res
while True:
n = int(input())
if n == 0:
break
print(gold_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>
|
s380775621 | p00056 | Accepted | 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_right(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>
|
s507386617 | p00056 | Accepted | isPrime = []
prime = []
count = []
def init():
for i in range(50000 + 1):
isPrime.append(True)
count.append(0)
def eratos():
isPrime[0] = False
isPrime[1] = False
for i in range(2, int((50000 ** (1 / 2))) + 1):
if (isPrime[i]):
for j in range(i * 2, 50000 + 1, i):
isPrime[j] = False
for i in range(2, 50001):
if isPrime[i]:
prime.append(i)
def table():
for i in prime:
for j in prime:
if i < j:
continue
if i + j > 50000:
continue
count[i + j] += 1
init()
eratos()
table()
while True:
n = int(input())
if n == 0:
break
print(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>
|
s218562124 | p00056 | Accepted | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0056
"""
from math import sqrt, ceil, pow
import bisect
# https://github.com/mccricardo/sieve_of_atkin/blob/master/sieve_of_atkin.py
class SieveOfAtkin:
def __init__(self, limit):
self.limit = limit
self.primes = []
self.sieve = [False] * (self.limit + 1)
def flip(self, prime):
try:
self.sieve[prime] = True if self.sieve[prime] == False else False
except KeyError:
pass
def invalidate(self, prime):
try:
if self.sieve[prime] == True: self.sieve[prime] = False
except KeyError:
pass
def isPrime(self, prime):
try:
return self.sieve[prime]
except KeyError:
return False
def getPrimes(self):
testingLimit = int(ceil(sqrt(self.limit)))
for i in range(testingLimit):
for j in range(testingLimit):
# n = 4*i^2 + j^2
n = 4 * int(pow(i, 2)) + int(pow(j, 2))
if n <= self.limit and (n % 12 == 1 or n % 12 == 5):
self.flip(n)
# n = 3*i^2 + j^2
n = 3 * int(pow(i, 2)) + int(pow(j, 2))
if n <= self.limit and n % 12 == 7:
self.flip(n)
# n = 3*i^2 - j^2
n = 3 * int(pow(i, 2)) - int(pow(j, 2))
if n <= self.limit and i > j and n % 12 == 11:
self.flip(n)
for i in range(5, testingLimit):
if self.isPrime(i):
k = int(pow(i, 2))
for j in range(k, self.limit, k):
self.invalidate(j)
self.primes = [2, 3] + [x for x in range(len(self.sieve)) if self.isPrime(x) and x >= 5]
return self.primes
def solve1(num, primes):
# 6.94[s]
result = 0
# list_primes = [x for x in primes if x < num]
i = bisect.bisect_left(primes, num)
list_primes = primes[:i]
set_primes = set(list_primes)
for x in list_primes:
if x > num/2:
break
if (num-x) in set_primes:
# print('solve1: {} + {} = {}'.format(x, num-x, num))
result += 1
return result
def solve2(num, primes):
result = 0
sub_primes = set(x for x in primes if x < num)
while sub_primes:
x = sub_primes.pop()
if x*2 == num:
result += 1
elif (num-x) in sub_primes:
result += 1
sub_primes.remove(num-x)
return result
def solve3(num, primes):
# 17.96[s]
result = 0
sub_primes = [x for x in primes if x < num]
primes_len = len(sub_primes)
# print('solve3: primes_len: {}'.format(primes_len))
# print(sub_primes)
n = 0
while True:
if sub_primes[n] > num/2:
break
i = bisect.bisect_left(sub_primes, num-sub_primes[n])
if i != primes_len and sub_primes[i] == num-sub_primes[n]:
# print('solve3: {} + {} = {}'.format(sub_primes[n], num-sub_primes[n], num))
result += 1
n += 1
return result
if __name__ == '__main__':
A = SieveOfAtkin(50000)
A.getPrimes()
while True:
num = int(input())
if num == 0:
break
# ????????¨???????????¨???
result = solve1(num, A.primes)
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>
|
s863090188 | p00056 | Accepted | 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 = [i for i, k in enumerate(primes) if k]
while True:
n = int(input())
if n == 0:
break
I = bisect.bisect(values, n//2)
print(sum(primes[n-i] for i in values[: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>
|
s783577250 | p00056 | Accepted | # Aizu Problem 0056: Goldbach's Conjecture
#
import sys, math, os, bisect
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
def primes2(n):
""" Input n>=6, Returns a list of primes, 2 <= p < n """
n, correction = n-n%6+6, 2-(n%6>1)
sieve = [True] * (n//3)
for i in range(1,int(n**0.5)//3+1):
if sieve[i]:
k=3*i+1|1
sieve[ k*k//3 ::2*k] = [False] * ((n//6-k*k//6-1)//k+1)
sieve[k*(k-2*(i&1)+4)//3::2*k] = [False] * ((n//6-k*(k-2*(i&1)+4)//6-1)//k+1)
return [2,3] + [3*i+1|1 for i in range(1,n//3-correction) if sieve[i]]
primes = primes2(50000)
pset = set(primes)
while True:
n = int(input())
if n == 0:
break
S = 0
for p in primes:
if p > n // 2:
break
if n - p in pset:
S += 1
print(S) | 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>
|
s064501833 | p00056 | Accepted | 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 = [i for i, k in enumerate(primes) if k]
while True:
n = int(input())
if n == 0:
break
I = bisect.bisect(values, n//2)
print(sum(primes[n-v] for v in values[: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>
|
s393463978 | p00056 | Accepted | 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 = [i for i, k in enumerate(primes) if k]
while True:
n = int(input())
if n == 0:
break
I = bisect.bisect(values, n//2)
print(sum(1 for v in values[:I] if primes[n-v])) | 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>
|
s471250921 | p00056 | Accepted | 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 = [i for i, k in enumerate(primes) if k]
while True:
n = int(input())
if n == 0:
break
I = bisect.bisect(values, n//2)
print(sum(1 for v in values[:I] if primes[n-v])) | 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.