Problem:
ゴールドバッハ予想
ゴールドバッハ予想とは「6 以上のどんな偶数も、2 つの素数 (*1) の和として表わすことができる」というものです。
たとえば、偶数の 12 は
12 = 5 + 7
、18 は
18 = 5 + 13 = 7 + 11
などと表すことができます。
和が 134 となる 2 つの素数の組み合せをすべて書き出すと、以下の通りとなります。
134 = 3+131 = 7+127 = 31+103 = 37+97 = 61+73 = 67+67
= 131+3 = 127+7 = 103+31 = 97+37 = 73+61
与えられた数が大きくなると、いくらでも素数の組み合せが見つかるような気がします。しかし、現代数学をもってしてもこの予想を証明することも、反例を作ることもできません(*2)。ちょっと不思議な感じがしますね。
そこで、ゴールドバッハ予想を鑑賞するために、偶数
n
を入力とし、和が
n
となる 2 つの素数の組み合せの数を求めるプログラムを作成してください。
和が
n
となる素数の組み合せの数とは
n = p + q
かつ
p ≤ q
であるような正の素数
p
,
q
の組み合せの数です。上の例からわかるように和が 134 となる素数の組み合せは6 個です。
(*1)  素数とは、1 または自分自身以外に約数を持たない整数のことである。なお、1 は素数ではない。
(*2)  2007 年 2 月現在、5×10
17
までの全ての偶数について成り立つことが確かめられている。(Wikipedia)
Input
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロひとつの行で示されます。 各データセットとして、１つの偶数
n
(6 ≤
n
≤ 1000000) が１行に与えられます。
データセットの数は 500 を超えません。
Output
データセット毎に素数の組み合せの数を１行に出力します。
Sample Input
134
4330
34808
98792
0
Output for the Sample Input
6
72
274
607

Submitted solutions:

code_snippet: #include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for (long long i=0;i<(long long)(n);i++)
#define all(v) v.begin(),v.end()
using ll=long long;
using pll=pair<ll,ll>;
using tll=tuple<ll,ll,ll>;
const ll inf=-(1ll<<60),INF=(1ll<<60);
template<class T> void chmin(T &a,T b){
    if(a>b){
        a=b;
    }
}
template<class T> void chmax(T &a,T b){
    if(a<b){
        a=b;
    }
}

int main(){
    vector<bool> v(1000010,true);
    v[0]=false;
    v[1]=false;
    for(ll i=2;i<1000010;i++){
        if(!v[i]) continue;
        ll x=i+i;
        while(x<1000010){
            v[x]=false;
            x+=i;
        }
    }
    while(true){
        ll n;
        cin >> n;
        if(n==0) return 0;
        ll cnt=0;
        for(ll i=2;i<n/2+1;i++){
            if(i<=n-i&&v[i]&&v[n-i]) cnt++;
        }
        cout << cnt << endl;
    }
}
accuracy: 1
time_ms: 10
memory_kb: 3464
final_rank: 3

code_snippet: #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
bool f(ll p){
  if(p==1){
    return false;
  }
  else{
    for(ll i=2;i*i<=p;i++){
      if(p%i==0){
        return false;
      }
    }
    return true;
  }
}
int main() {
  ll kannkeinasi=0;
  set<ll> s;
  rep(i,1000001){
    if(f(i)){
      s.insert(i);
    }
  }
  while(kannkeinasi>=0){
  ll N;
  cin >> N;
  ll p=N;
  if(p==0){
    return 0;
  }
  if(N>=6){
    ll ans=0;
  for(ll i=1;i<=N/2;i+=2){
    if(s.count(i)&&s.count(N-i)){
      ans++;
    }
  }
  cout << ans << endl;
  }
  }
}
accuracy: 1
time_ms: 580
memory_kb: 6772
final_rank: 20

code_snippet: #include<bits/stdc++.h>
using namespace std;

int main(){
  int M = 1000000;
  vector<bool> P(M+1,true);
  P[0] = P[1] = false;
  for(int i=2;i<=M;i++){
    for(int j=2;j*j<=i;j++){
      if(i%j == 0){
        P[i] = false;
        break;
      }
    }
  }
  for(;;){
    int N;
    cin >> N;
    if(N == 0) break;
    int ans = 0;
    for(int i=0;i<=N/2;i++) if(P[i] && P[N-i]) ans++;
    cout << ans << endl;
  }
}
accuracy: 1
time_ms: 140
memory_kb: 3260
final_rank: 8

code_snippet: #include<bits/stdc++.h>
using namespace std;
#define MAX 1000005
bool isPrime(int n){
  for(int i=2;i*i<=n;i++) if(n%i==0) return 0;
  return 1;
}
int main(){
  int n;
  bool d[MAX]={};
  for(int i=2;i<MAX;i++) d[i]=isPrime(i);
  while(cin>>n,n){
    int ans=0;
    for(int i=2;i<=n/2;i++){
      if(d[i]&&d[n-i]) ans++;
    }cout << ans << endl;
  }
}
accuracy: 1
time_ms: 150
memory_kb: 4060
final_rank: 10

code_snippet: #include <iostream>
#include <cmath>

bool isPrime(int n)
{
	int ub = (int)std::sqrt((float)n);
	for (int p=2; p<=ub; p++) {
		if (n%p==0) return false;
	}
	return true;
}

int main()
{
	int n;
	while (true) {
		std::cin >> n;
		if (n == 0) break;
		int res = 0;
		for (int k=3; k<=n/2; k++) {
			if (isPrime(k) && isPrime(n-k)) res++;
		}
		std::cout << res << std::endl;
	}
	return 0;
}
accuracy: 1
time_ms: 610
memory_kb: 3052
final_rank: 18

code_snippet: #include <iostream>
#include <algorithm>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <numeric>
#include <bitset>
#include <cmath>

static const int MOD = 1000000007;
using ll = long long;
using u32 = unsigned;
using u64 = unsigned long long;
using namespace std;

template<class T> constexpr T INF = ::numeric_limits<T>::max()/32*15+208;

vector<int> get_prime(int n){
    if(n <= 1) return vector<int>();
    vector<bool> is_prime(n+1, true);
    vector<int> prime;
    is_prime[0] = is_prime[1] = 0;
    for (int i = 2; i <= n; ++i) {
        if(is_prime[i]) prime.emplace_back(i);
        for (auto &&j : prime){
            if(i*j > n) break;
            is_prime[i*j] = false;
            if(i % j == 0) break;
        }
    }
    return prime;
}

auto p = get_prime(1000000);

int main() {
    int n;
    while(cin >> n, n){
        int l = 0, ans = 0;
        for (int i = p.size()-1; i >= 0; --i) {
            while(l < i && p[l]+p[i] < n) l++;
            ans += (p[i]+p[l] == n);
        }
        cout << ans << "\n";
    }

    return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 3368
final_rank: 4

code_snippet: #include<iostream>
#include<algorithm>
#include <map>
#include <vector>
#include <stack>
#include<string>
#include<queue>
#include <regex>

using namespace std;

bool record[1000001];

int Func(int n)
{
	int count0 = 0;
	int max0 = n / 2;
	for (size_t i = 2; i <= max0; i++)
		if (record[i] && record[n - i])
			count0++;
	return count0;
}

int main()
{
	fill(record, record + 1000001, true);
	for (size_t i = 2; i < 1000001; i++)
	{
		if (record[i])
		{
			for (size_t j = 2; i * j < 1000001; j++)
			{
				record[i * j] = false;
			}
		}
	}
	int n;
	cin >> n;
	while (n)
	{
		cout << Func(n) << endl;
		cin >> n;
	}
}
accuracy: 1
time_ms: 10
memory_kb: 4060
final_rank: 6

code_snippet: #include <iostream>
#include <stdlib.h>
using namespace std;
#define limit 1000010

int main(void){
  int* table=(int*)malloc(sizeof(int)*limit);
  for(int i=0;i<limit;i++){
    table[i]=1;
  }
  table[0]=0;
  table[1]=0;
  int k;
  for(int i=0;i<limit;i++){
    if(table[i]==0)continue;
      k=2;
      while(k*i<=limit){
        table[k*i]=0;
        k++;
      }
  }
  int n;
  while(1){
    cin>>n;
    if(n==0)break;
    int retval=0;
    for(int i=1;i<=n/2;i++){
      if(table[i]==1 && table[n-i]==1){
        retval++;
      }
    }
    cout<<retval<<endl;
  }

  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 6908
final_rank: 12

code_snippet: #include <bits/stdc++.h>

using namespace std;

int PrimeNumber[1000001] = {0,0,1,1};

void findPrimeNumber(){
	int limit;
	bool flag;

	for (int i = 5; i < 1000001; i += 2) {
		limit = sqrt(i) + 1;
		flag = true;
		for (int j = 2; j < limit; j++) {
			if (i%j == 0) {
				flag = false;
				break;
			}
		}
		if (flag) {
			PrimeNumber[i] = 1;
		}
	}

	return;
}

int main() {
	int n, rest, sum;

	findPrimeNumber();
	while (cin >> n, n) {
		sum = 0;
		for (int i = 2; i < n; i++) {
			rest = n - i;
			if (i > rest) {
				break;
			}
			if (PrimeNumber[i] == 1 && PrimeNumber[rest] == 1) {
				sum++;
			}
		}
		 
		cout << sum << endl;
	}
	

	return 0;
}
accuracy: 1
time_ms: 150
memory_kb: 6956
final_rank: 17

code_snippet: #include "bits/stdc++.h"

#define REP(i,num) for(int i=0;i<(num);++i)
#define LOOP(i) while(i--)
#define ALL(c) c.begin(),c.end()
#define PRINTALL(c) for(auto pitr=c.begin();pitr!=c.end();++pitr){cout<<*pitr;if(next(pitr,1)!=c.end())cout<<' ';}cout<<endl;
#define PAIRCOMP(c,comp) [](const pair<ll,ll>& lhs,const pair<ll,ll>& rhs){return lhs.c comp rhs.c;}

using namespace std;
using ll = long long;

constexpr ll atcoder_mod = 1e9+7;

template<typename T=int>
T in(){T x; cin >> x; return (x);}
template<typename T=int,typename C=vector<T>>
C vecin(int N){C x(N);REP(i,N){x[i]=in<T>();}return move(x);}

void vout(){cout << endl;}
template<typename Head,typename... Tail>
void vout(Head&& h,Tail&&... t){cout << ' ' << h;vout(forward<Tail>(t)...);}
void out(){cout << endl;}
template<typename Head,typename... Tail>
void out(Head&& h,Tail&&... t){cout << h;vout(forward<Tail>(t)...);}

vector<ll> enum_prime(ll N){
	deque<bool> is_prime(N+1,true);
	vector<ll> P;
	for(ll i=2;i<=N;i++){
		if(is_prime[i]){
			for(ll j=i*i;j<=N;j+=i){
				is_prime[j] = false;
			}
			P.emplace_back(i);
		}
	}
	return P;
}

int main(){
	cin.tie(0);
	ios::sync_with_stdio(false);
	cout<<fixed<<setprecision(10);

	auto P=enum_prime(1000000);
	sort(ALL(P));
	int M=P.size();
	
	while(true){
		int N=in();
		if(!N) break;

		int sum = 0;
		for(int i=0;i<M;i++){
			int V=N-P[i];
			if(binary_search(P.begin()+i,P.end(),V)) sum++;
		}
		out(sum);
	}
	return 0;
}
accuracy: 1
time_ms: 190
memory_kb: 4860
final_rank: 15

code_snippet: #include <iostream>
#include <algorithm>
using namespace std;

int n;
int p[100000];

int main()
{
	int t = 0;

	for (int i = 3; i < 1000000; i += 2) {
		bool f = 1;
		for (int j = 3; j * j <= i; j++) {
			if (i % j == 0) {
				f = 0;
				break;
			}
		}

		if (f) {
			p[t] = i;
			t++;
		}
	}

	cin >> n;

	while (n) {
		int m = 0, i = 0;

		while (p[i] * 2 <= n) {
			if (binary_search(p, p + t, n - p[i]))
				m++;

			i++;
		}

		cout << m << endl;

		cin >> n;
	}

	return 0;
}
accuracy: 1
time_ms: 160
memory_kb: 3352
final_rank: 9

code_snippet: #include <bits/stdc++.h>
using namespace std;

int main(){
    cin.tie(nullptr);
    ios::sync_with_stdio(false);

    int n;
    while(cin >> n){
        if(n == 0) return 0;
        vector<bool> F(n + 1, true);
        for(int i = 2; i <= (int)sqrt(n); i++){
            if(F[i]){
                for(int j = i + i; j <= n; j += i){
                    F[j] = false;
                }
            }
        }

        int ans = 0;
        for(int i = 2; i <= n / 2; i++){
            if(F[i] and F[n - i]) ans++;
        }

        cout << ans << endl;
    }

    return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 3264
final_rank: 1

code_snippet: #include<iostream>
#include<cmath>
using namespace std;

bool judgePrimeNumber( int a )
{
    for( int i = 2; i <= sqrt(a); i++ )
        if( a % i == 0 )
            return false;
    return true;
}

int main()
{
    int n;
    bool a[1000000];
    
    a[0] = a[1] = false;
    for( int i = 2; i < 1000000; i++ )
        a[i] = judgePrimeNumber(i);

    while( cin >> n )
    {
        if( !n )
            break;

        int cnt = 0;
        for( int i = 2; i <= n / 2; i++ )
            if( a[i] && a[n-i] )
                cnt++;
            
        cout << cnt << endl;
    }

    return 0;
}
accuracy: 1
time_ms: 190
memory_kb: 4000
final_rank: 11

code_snippet: #include<vector>
#include<iostream>
#include<algorithm>
using namespace std;
namespace AOJ0185
{
	class Primes
	{
	public:
		static void GetPrimes(int max, vector<int> &primes)
		{
			vector<bool> flags(max + 1, true);
			for (int i = 2; i <= max; i++)
			{
				if (flags[i])
				{
					primes.push_back(i);
					for (int j = i; j <= max; j += i)
					{
						flags[j] = false;
					}
				}
			}
		}
	};

	class Solver
	{
	private:
		static const int MAX_N = 1000001;
		int Input()
		{
			int n;
			cin >> n;
			return n;
		}

		void Output(int answer)
		{
			cout << answer << endl;
		}

	public:
		void Solve()
		{
			vector<int> primes;
			Primes::GetPrimes(MAX_N, primes);

			int n;
			while (n = Input())
			{
				int answer = 0;
				for (int i = 0; i < primes.size(); i++)
				{
					int diff = n - primes[i];
					if (diff < primes[i])break;
					bool exist = binary_search(primes.begin(), primes.end(), diff);
					if (exist)answer++;
				}
				Output(answer);
			}
		}

	};
}

int main()
{
	AOJ0185::Solver().Solve();
}
accuracy: 1
time_ms: 10
memory_kb: 3440
final_rank: 2

code_snippet: #include<iostream>
#include<math.h>
#include<vector>
#include<algorithm>
#include<cstdio>
#include <string>
#include <complex>
#include <functional>
using namespace std;
typedef pair<int,int> P;
int cnt[7];
int main(){
    int i,j,n,prime[1000001];
    prime[0]=prime[1]=-1;
    for(i=2;i<=1000000;i++){
        if(prime[i]!=-1){
            prime[i]=1;
            for(j=i+i;j<=1000000;j+=i)prime[j]=-1;
        }
    }
    while(cin>>n,n){
        int cnt=0;
        for(i=1;i<=n/2;i++){
            if(prime[i]==1&&prime[n-i]==1) cnt++;
        }
        cout<<cnt<<endl;
        }
    return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 6988
final_rank: 13

code_snippet: #include <iostream>
#include <algorithm>
using namespace std;
#define MAX 1000001

bool isPrime[MAX];

void eratos() {
    fill(isPrime, isPrime + MAX, true);
    for (int i = 2; i < MAX; i++) {
        if (!isPrime[i]) continue;
        for (int j = i + i; j < MAX; j += i) {
            isPrime[j] = false;
        }
    }
}

int main() {
    eratos();
    int n;
    while (true) {
        cin >> n;
        if (n == 0) return 0;
        int count = 0;
        for (int i = 2; i <= n / 2; i++) {
            if (!isPrime[i]) continue;
            if (isPrime[n - i]) count++;
        }
        cout << count << endl;
    }
}
accuracy: 1
time_ms: 10
memory_kb: 3976
final_rank: 5

code_snippet: #include<iostream>
using namespace std;
#include<cmath>
bool isprime(int n) {
	if (n == 2)return true;
	if (n % 2 == 0)return false;
	for (int i = 3; i <= sqrt(n); i += 2) if (n%i == 0)return false;
	return true;
}
int main() {
	int n; while (cin >> n, n) {
		int cnt = 0;
		for (int i = 2; i <= n / 2; i++) {
			if (isprime(i) && isprime(n - i))cnt++;
		}
		cout << cnt << endl;
	}
}
accuracy: 1
time_ms: 440
memory_kb: 3008
final_rank: 16

code_snippet: #include<cstdio>
#include<iostream>
#include<algorithm>
#include<string>
#include<queue>
#include<vector>
#include<functional>
#include<cmath>
#include<map>
#include<stack>
#include<set>
#include<numeric>
#include<limits>
#include<iterator>

#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
#define rep(i,n) for(int i=0; i<n; i++)
#define INF (1<<20)

using namespace std;
typedef long long ll;
typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
typedef pair<ll, char> plc;

ll arr[1000010];

void Eratosthenes(ll n) {
	for (int i = 0; i <= n; i++)
		arr[i] = 1;

	for (int i = 2; i <= sqrt(n); i++) {
		if (arr[i]) {
			for (int j = 0; i*(j + 2) <= n; j++)
				arr[i*(j + 2)] = 0;
		}
	}
}

int main()
{
	ll n;
	while (cin >> n, n)
	{
		ll cnt = 0;
		Eratosthenes(n);
		for (int i = 2; i <= n / 2 + n % 2; i++) {
			if (arr[i]) {
				if (arr[n - i])cnt++;
			}
		}
		cout << cnt << endl;
	}
	return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 10896
final_rank: 19

code_snippet: #include <bits/stdc++.h>

using namespace std;

#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,n) FOR(i,0,n)
#define ALL(v) (v).begin(),(v).end()
#define fi first
#define se second

template<typename A, typename B> inline bool chmax(A &a, B b) { if (a<b) { a=b; return 1; } return 0; }
template<typename A, typename B> inline bool chmin(A &a, B b) { if (a>b) { a=b; return 1; } return 0; }

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<int, pll> pip;
const ll INF = 1ll<<60;
const ll MOD = 1000000007;
const double EPS  = 1e-9;

vector<int> sieve(int n) {
	vector<int> res;
	vector<bool> is_prime(n + 1, true);
	
	is_prime[0] = is_prime[1] = false;
	
	for (int i = 2; i * i <= n; i++) if (is_prime[i]) {
		res.push_back(i);
		is_prime[i] = false;
		for (int j = 2; i * j <= n; j++) if (is_prime[i * j]) {
			is_prime[i * j] = false;
		}
	}
	
	REP(i, n + 1) if (is_prime[i]) res.push_back(i);
	sort(res.begin(), res.end());
	return res;
}

int main() {
	vector<int> prime = sieve(1000000);
	set<int> ss;
	REP(i, prime.size()) ss.insert(prime[i]);
	
	int n;
	while (cin >> n, n) {
		int ans = 0;
		REP(i, prime.size()) {
			if (prime[i] * 2 > n) break;
			if (ss.find(n - prime[i]) != ss.end()) ans++;
		}
		cout << ans << endl;
	}
	return 0;
}
accuracy: 1
time_ms: 40
memory_kb: 6684
final_rank: 14

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main(){
	bool prime[1000001] = {true,true};
	vector<int> ps;
	for(int i = 4;i <= 1000000;i += 2) prime[i] = true;
	for(int i = 3;i * i <= 1000000;i += 2){
		for(int j = i * 2;j <= 1000000;j += i) prime[j] = true;
	}
	for(int i = 0;i <= 1000000;i++) if(!prime[i]) ps.push_back(i);
	int n;
	while(cin >> n,n){
		int cnt = 0;
		for(int i = 0;i < ps.size();i++){
			if(ps[i] > n / 2) break;
			if(upper_bound(ps.begin(),ps.end(),n - ps[i]) - lower_bound(ps.begin(),ps.end(),n - ps[i])) cnt++;
		}
		cout << cnt << endl;
	}
	return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 4248
final_rank: 7