1.

package sem2.am.goldbachsconjecture;

/**
* Angewandte Mathematik, SS11
* Problem: 543 - Goldbach's Conjecture
* Link: http://uva.onlinejudge.org/external/5/543.pdf
*
* @author Florian Stein
* @author Franz Sommer
* @version 1.0, 03/28/2011
*
* Method : Ad-Hoc
* Status : Accepted
* Runtime: 1.424
*/

import java.util.*;

class Main {
public static void main(String[] args) {

// // arrayindex
// int i = 0;
//
// // arraylist
// List<Integer> list1 = new ArrayList<Integer>();
// for (int j = 0; j <= 1000000; j++) {
// if (prime(j)) {
// list1.add(j);
// i++;
// }
// }

Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()) {
int n = scanner.nextInt();

// Abbruchschleife
if (n == 0)
break;

boolean found = false;

// Vergleich mit arraylist, zu langsam
// for (int j = 0; j < list1.size() - 1; j++) {
// int tmp = 0;
// tmp = n - list1.get(j);
// if (list1.contains(tmp) && n >= 6) {
// System.out.println(n + " = " + list1.get(j) + " + " + tmp);
// found = true;
// break;
// }
// }

// Vergleich entgegengesetzt abfragen
for (int j = 0; j < n; j++) {
if (n < 1000000 && n >= 6 && n != 0) {
if (prime(j) && prime(n - j)) {
System.out.println(n + " = " + j + " + " + (n - j));
found = true;
break;
}
}
}

if (!found && n >= 6) {
System.out.println("Goldbach's conjecture is wrong");
}
}
}

// Entscheidet ob Zahl eine Primzahl
public static boolean prime(int n) {
if (n < 2)
return false;
if (n == 2)
return true;
if ((n % 2) == 0)
return false;
for (int i = 3; i <= Math.sqrt(n); i += 2) // i = i+2
{
if (n % i == 0)
return false;
}
return true;
}
}


2.

/**
* Angewandte Mathematik, SS11
* Problem: 543 - Goldbachs Conjecture
* http://uva.onlinejudge.org/external/5/543.pdf
* @author Sebastian Stumpf
* @author Benjamin Vogt
* @version 1.0, 2011-03-31 11:00:40
*
* Method : Ad-Hoc
* Status : Accepted
* Runtime: 1.512
*/

import java.util.*;

public class Main
{
public static boolean isPrime(int toCheck)
{
if(toCheck < 2)
return false;
if(toCheck == 2)
return true;
if(toCheck%2 == 0)
return false;
for(int i = 3; i <= Math.sqrt(toCheck); i += 2)
{
if(toCheck%i == 0)
return false;
}
return true;
}

public static void main(String[] args)
{
//Test DataSheet
/* StringBuilder sb = new StringBuilder("");
for(int i=6; i<=100000; i+=2)
{
sb = sb.append(i+(i%50 == 0? "\n": " "));
}
sb.append("0");
String s = sb.toString();
*/
// long start = System.currentTimeMillis();
// boolean[] primzahlen = a.ErastoPrimes(1000000);
// System.out.println("create PrimeHashSet: (ms) "+(System.currentTimeMillis() - start));

Scanner scanner = new Scanner(System.in);
int zahl;

// long start2 = System.currentTimeMillis();
while((zahl = scanner.nextInt()) != 0)
{
if(zahl%2 != 0 || zahl < 6 || zahl > 1000000)
break;
boolean abbruch = false;
for(int i = 0; i < zahl && !abbruch; i++)
{
if(isPrime(i) && isPrime(zahl - i))
{
//printf ist viel langsamer als println! Mit printf time limit exceeded!!
System.out.println(zahl+" = "+i+" + "+(zahl-i));
abbruch = true;
break;
}
}
}
// System.out.println("Algorithmus: (ms)"+(System.currentTimeMillis() - start2));
}
}

3.

/**
* Angewandte Mathematik, SS11
* Problem: 543 Goldbach's Conjecture
* Link: http://uva.onlinejudge.org/external/5/543.pdf
*
* @author Ritter Marius
* @author Wende Tom
* @author Zehentbauer Stefan
* @version 1.0, 04/04/2011
*
* Method : Ad-Hoc
* Status : Accepted
* Runtime: 1.584
*/

import java.util.Scanner;

public class Main {

public static boolean isPrime(int zahl) {
int z = (int)Math.sqrt(zahl);
for(int i=2;i<=z;i++)
if((zahl%i)==0)
return false;
return true;
}


public static void main(String args[])
{
Scanner eingabe1 = new Scanner(System.in);
do
{
int x = eingabe1.nextInt();
if(x==0)
break;

boolean br=false;
if(x%2==0)
{
for (int i=3; i<x; i++) // und ausgegeben
{
if(isPrime(i))
{
for(int y=(x-i); y>=i;y--)
{
if(isPrime(y))
{
if(((i+y)<x))
{
break;
}
else
{
if((x==(i+y)))
{
br=true;
System.out.println(x + " = " + i + " + " + y);
break;
}
}

}
}
if(br)
{
break;
}
}
}
}
else
{
System.out.println("Goldbach's conjecture is wrong.");
}
}while(true);
}

}

4.
/**
* Angewandte Mathematik, SS11
* Problem: 543 Goldbach's Conjecture
* Link: http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&category=23&page=show_problem&problem=2113
*
* @author Peter Weismann
* @author Pirmin Schneider
* @version 1.0, 04/03/2011
*
* Method : Ad-Hoc
* Status : Accepted
* Runtime: 1.236
*/

import java.util.Scanner;
public class Main {
// Statische Variablen, die nur einmal initialisiert werden und öfter benutzt werden
static int i;
static int j;
static boolean[] isPrime = new boolean[1000001];
static int numberOfPrimes = 0;

public static void main(String[] args) {
Scanner input = new Scanner(System.in);
// value ist der eingegebene Wert
int value = input.nextInt();
// Generiert Primzahlen bis zu 1.000.000
primeGen();
boolean stop = true;


while (value != 0 && value >= 6 && value < 1000000) {
stop = true;

// Summanden werden gesucht
for (i = 1; i < value; i++ ) {
if (!(isPrime[i]) && (isPrime(value - i))) {
System.out.println(value + " = " + i + " + " + (value - i));
stop = false;
break;
}
}
// Wenn keine Summanden gefunden werden
if (stop) {
System.out.println("Goldbach's conjecture is wrong.");
}
// Nächster Wert wird eingelesen
value = input.nextInt();
}
}

// Primzahlen bis 1.000.000 werden gesucht
public static void primeGen() {

isPrime[1] = true;
int upperBoundSquareRoot = (int)Math.sqrt(1000000);

for (i = 2; i <= upperBoundSquareRoot; i++) {
if (!(isPrime[i])) {
for (j = i * i; j <= 1000000; j += i)
isPrime[j] = true;
}
}
}

// Primzahlen bis zu einer Obergrenze werden zurückgegeben
public static int getNumberOfPrimes (int value) {
numberOfPrimes = 0;
for (i = 1; i < value; i++) {
if (!(isPrime[i]))
numberOfPrimes++;
}
return numberOfPrimes;
}
// Gibt zurueck, ob eine Zahl eine Primzahl ist
public static boolean isPrime(int value) {
if (!(isPrime[value]))
return true;
else
return false;
}
}

5.

import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

/**
* Angewandte Mathematik, SS11
* Problem: 543 - Goldbach's Conjecture
* Link: http://uva.onlinejudge.org/external/5/543.pdf
*
* @author Benedikt Z¨nnchen
* @author Erik Wenzel
* @version 1.0, 03/29/2011
*
* Method : Ad-Hoc
* Status : Accepted
* Runtime: 1.536
*/

public class Main
{
private static Set<Integer> set = new HashSet<Integer>();

public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int number;

while(sc.hasNextInt() && (number = sc.nextInt()) != 0)
{
for(int i = 3; i <= number/2; i+=2)
{
if(isPrime(i) && isPrime(number-i))
{
System.out.println(number + " = " + i + " + " + (number-i));
break;
}
}
}
}

/**
* Bestimmt ob eine ganze Zahl eine Primzahl ist. (schleifen-l¨sung)
* @param n ganze zahl
* @return true wenn n eine Primzahl ist, sonst false
*/
public static boolean isPrime(int n)
{
if(n == 2)
{
set.add(n);
return true;
}
else if(n < 2 || n%2==0)
{
return false;
}
else if(set.contains(n))
{
return true;
}
for(int i = 3; i <= Math.sqrt(n); i+=2)
{
if(n%i==0)
{
return false;
}
}
set.add(n);
return true;
}

/**
* Bestimmt ob eine ganze Zahl eine Primzahl ist. (rekrusive-l¨sung)
* @param n ganze zahl
* @return true wenn n eine Primzahl ist, sonst false
*/
public static boolean isRecPrime(int n)
{
if(n==2)
{
return true;
}
else if(set.contains(n))
{
return true;
}
for(int i = 2; i < n; i++)
{
if(isPrime(i))
{
if(n%i==0)
{
return false;
}
}
}
set.add(n);
return true;
}

}

6.

/**
* Angewandte Mathematik, SS11
* Problem: 543 Goldbach's Conjecture
* Link: http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&category=23&page=show_problem&problem=2113
*
* @author Peter Weismann
* @author Pirmin Schneider
* @version 1.0, 04/03/2011
*
* Method : Ad-Hoc
* Status : Accepted
* Runtime: 1.236
*/

import java.util.Scanner;
public class Main {
// Statische Variablen, die nur einmal initialisiert werden und öfter benutzt werden
static int i;
static int j;
static boolean[] isPrime = new boolean[1000001];
static int numberOfPrimes = 0;

public static void main(String[] args) {
Scanner input = new Scanner(System.in);
// value ist der eingegebene Wert
int value = input.nextInt();
// Generiert Primzahlen bis zu 1.000.000
primeGen();
boolean stop = true;


while (value != 0 && value >= 6 && value < 1000000) {
stop = true;

// Summanden werden gesucht
for (i = 1; i < value; i++ ) {
if (!(isPrime[i]) && (isPrime(value - i))) {
System.out.println(value + " = " + i + " + " + (value - i));
stop = false;
break;
}
}
// Wenn keine Summanden gefunden werden
if (stop) {
System.out.println("Goldbach's conjecture is wrong.");
}
// Nächster Wert wird eingelesen
value = input.nextInt();
}
}

// Primzahlen bis 1.000.000 werden gesucht
public static void primeGen() {

isPrime[1] = true;
int upperBoundSquareRoot = (int)Math.sqrt(1000000);

for (i = 2; i <= upperBoundSquareRoot; i++) {
if (!(isPrime[i])) {
for (j = i * i; j <= 1000000; j += i)
isPrime[j] = true;
}
}
}

// Primzahlen bis zu einer Obergrenze werden zurückgegeben
public static int getNumberOfPrimes (int value) {
numberOfPrimes = 0;
for (i = 1; i < value; i++) {
if (!(isPrime[i]))
numberOfPrimes++;
}
return numberOfPrimes;
}
// Gibt zurueck, ob eine Zahl eine Primzahl ist
public static boolean isPrime(int value) {
if (!(isPrime[value]))
return true;
else
return false;
}
}


--------------------------------------------------------------------------------------------------------------

1.
/**
 *
 * Problem #543 - Goldbach's Conjecture
 *
 *
 * @author Mariya Vlaseva
 *
 * Status : Accepted
 * Runtime: 0.964
 */

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

    /**
     * @param args
     * @throws IOException
     */
    public static void main(String... args) throws IOException {
        // Zeilen auslesen
        BufferedReader console = new BufferedReader(new InputStreamReader(System.in));
       
        int zahl;
       
        //solange auslesen, bis eine 0 eingegeben wird
        for (String line=console.readLine();!line.equals("0"); line=console.readLine()){
            zahl=Integer.parseInt(line);
           
            for (int count= 3; count<zahl; count++){
                if (6<=zahl && zahl<1000000){
                    if (primeZahl(count) && primeZahl(zahl-count)){
                        System.out.println(zahl + " = "+ count + " + " + (zahl-count));
                        break;
                    }
                }
            }
        }

    }

    private static boolean primeZahl(int prime) {
        if (prime < 2 || prime % 2 == 0)
                return false;
            else {
                for (int i=3; i*i<=prime; i+=2) {
                    if (prime%i==0)
                    return false;
                }
            return true;
            }
    }
}



2.


/**

* FWP, Ausgewählte Probleme aus dem ACM Programming Contest, SS10

* Problem: 543 Goldbach's Conjecture

* Link: http://uva.onlinejudge.org/external/5/543.pdf

* @author Viktoriya Ryabova

* @version 1.0, 04/29/2010

*

* Method : Ad-Hoc

* Status : accepted

* Runtime: 1.560

*/

import java.util.Scanner;

 

public class Main {

public static void main(String[] args) {

// TODO Auto-generated method stub

Scanner sc = new Scanner (System.in);

while(sc.hasNext()){

//zahlen aus der Konsole einlesen

int number = Integer.parseInt(sc.nextLine());

if (number>=6 && number<=1000000 && number!=0){

//über alle ungerade zahlen überprüfen, ob sie eine primzahl sind

for (int i=3; i<= number/2; i=i+2){

//von der zahl kleinste primzahl abziehen und falls der rest auch primzahl ist

//wir es als ergebnis ausgegeben (dadurch muss man nicht übeprüfen alle paare,

//bedingung, dass a - b = max ist, wird automatisch erfüllt

if(isPrime(number-i)&&isPrime(i)){

System.out.println(number + " = "+ i + " + " + (number-i));

break;

}

}

}

}

}

//Prüfen ob die zahl eine primzagl ist

public static boolean isPrime(int n) {

if (n < 2) {

return false;

}

else if (n == 2) {

return true;

}

else if (n % 2 == 0) {

return false;

}

else {

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

if (n%i==0) {

return false;

}

}

return true;

}

}

}