1. 


/* Problem : 686
* Author : Dennis Wilfert
* Author : Johann Studt
* Status : AC
* Runntime : 0.220
*/

import java.io.*;
import java.util.*;

public class Main {

public static void main(String... args){

BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
int a = 1;

/* Endlosschleife wird erst beendet wenn eine null eingegeben wird
* sind damit auch mehrzeilige Eingaben funktionieren.
*/
while(true){

StringTokenizer line = null;

try{
line = new StringTokenizer(reader.readLine());
} catch (IOException e){
System.exit(0);
}

/* Aus jeder Zeile die einzelnen mit Leerzeichen getrennten Zahlen auslesen
* bis keine Zeichen mehr kommen
*/
while (line.hasMoreTokens()) {

/* Naechstes Zeichen in der Variable a speichern, sollte es sich nicht
* um eine Zahl handeln, die Exception abfangen und a=1 setzen
* (1 ist auserhalb des erlaubten Wertebereichs)
*/
try{
a = Integer.parseInt(line.nextToken());
} catch (NumberFormatException e){
a = 1;
}

/* Fuer alle geraden Zahlen von 5 bis 32767 alle Primzahlkombinationen
* suchen und ausgeben
*/
if(a > 4 && a < 32768 && a%2 == 0){

int ahalf = a/2;
int counter = 0; // Counter fuer die anzahl der Kombinationen

// Von drei eine Primzahl suchen bis maximal zur haelfte von a
for (int i = 3; i <= ahalf; i = i+2){

boolean b = false;
int sqi = (int)Math.sqrt(i);
for (int n = 3; n <= sqi; n = n+2){

if ( i%n == 0){

b = true;
break;
}

}

/* Ist b === false wurde eine Primzahl gefunden, dann ueberpruefen
* ob die Zahl a-i auch eine Primzahl ist
*/
if ( b == false){

int i2 = a-i;
boolean b2 = false;
int sqi2 = (int)Math.sqrt(i2);

for (int n = 3; n <= sqi2; n = n+2){

if ( i2%n == 0){

b2 = true;
break;
}

if(i+i2 > a)break;
}

/* Handelt es sich bei i2 auch um eine Primzahl, dann den
* counter um eins hochzaehlen
*/
if (b2 == false){

if (a == i + i2){
counter++; // Wenn eine kombination gefunden wurde counter hochzaehlen
}

}

}


}
System.out.println(counter); // Anzahl ausgeben

}

else{

// Wenn a==0 Programm beenden
if( a == 0 ){

try {
reader.close();
} catch (IOException e) {
System.exit(0);
}
System.exit(0);
}

/* Fall a==4 gesondert betrachten, da in der oberen Schleife nur
* nach ungeraden Primzahlen gesucht wird
*/
if( a == 4){

System.out.println("1"); // Anzahl fuer 4 ausgeben
}

}
}
}

}
}

2.


/**
* Angewandte Mathematik, SS09, IFB 2C
* ACM Problem 686 - Goldbach's Conjecture 2
* Link: http://icpcres.ecs.baylor.edu/onlinejudge/index.php?option=com_onlinejudge&Itemid=8&category=7&page=show_problem&problem=484
* @author Miesel Christoph
* @author Seilbeck Robert
* @author Wolfram Andre
* @version 1.0 25.03.2009
*
* Status : Accepted
* Runtime: 0.390
*/


import java.io.*;
import java.util.Scanner;

public class Main {

static boolean primzahltest(int aNumber)
{
boolean isPrim = true;
if(aNumber==2) isPrim = true;
else
{
double limit = Math.sqrt(aNumber);
if(aNumber%2==0) isPrim = false;
for(int i = 3; i<=limit; i+=2)
{
if(aNumber%i==0) isPrim = false;
}
}
return isPrim;
}

public static void main(String[] args) throws Exception
{
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
String line = reader.readLine();
int input;

input = Integer.parseInt(line);
int counter = 0;
while(input != 0 && input <= 1000000 && input >= 4 && input % 2 == 0)
{
for(int i = 2; i<=input/2; i += 1)
{
if(primzahltest(i)&&primzahltest(input-i))
{

counter++;
}

}

System.out.println(counter);
line = reader.readLine();
input = Integer.parseInt(line);
counter = 0;

}
}

}

3.

/**
* Angewandte Mathematik, SS09, IFB 2C
* ACM Problem #543 - Goldbach Conjecture II
* Link: http://icpcres.ecs.baylor.edu/onlinejudge/external/6/686.pdf
*
* @author Mohr
* @author Schirm
* @author Mathauser
* @version 2.0, 05/03/2009
*
* Status : Accepted
* Runtime: 0.180
*/

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;


public class Main {

public static boolean isPrim(int n) {

// Zahl ist gerade
if(n % 2 == 0)
return false;

// Wurzel der Zahl
short root = (short)Math.sqrt(n);

// Schleife bis zur Wurzel im 2er Schritt
for (int i = 3; i <= root; i=i+2) {
if (n % i == 0)
return false;
}
return true;
}

public static void main(String... args) throws Exception {

BufferedReader reader = new BufferedReader(new
InputStreamReader(System.in));

// Array für alle Primzahlen < 1000000
int[] prime = new int[3512];

// Erste Primzahl einfügen, um restliche Zahlen in der
// Schleife mit 2er Schritt ab 3 einfügen zu können
prime[0] = 2;

// Aktuelle Anzahl der Elemente im Array
int anz = 1;

// Eingelesene Zahl
int zahl;

// 1. Summand
int first = 0;

// 2. Summand
int second = 0;

// Anzahl der Primzahlenpaare
int count;

// Einfügen alle Primzahlen < 32768
for(int i = 3; i < 32768; i += 2)
if(isPrim(i))
prime[anz++] = i;

while (true) {

zahl = Integer.parseInt(reader.readLine());

// Testende
if (zahl == 0)
break;

count = 0;

// Schleife über alle Primzahlen des Arrays solang first <= second ist
for(int i = 0; (first = prime[i]) <= (second = zahl - first); i++) {

// Prüfen ob second eine Primzahl ist, falls true counter erhöhen
if (Arrays.binarySearch(prime, second) >= 0)
count++;
}

// Ausgabe von count
System.out.println(count);
}
}
}