Programmieren lernen

def primeLoop(x):
    for i in range(2, x):
        if x % i == 0:
            return True
    return False

def primes():
    # define 0, 1, 2
    primes = []
    for x in range(0, 1000):
        if x == 2:
            primes.append(x)
        if x % 2 != 0:
            # odd number
            if primeLoop(x) == False:
                primes.append(x)
    return primes
            
 
def goldbasch(primes, mode):
    for x in range(2, 1000):
        if x%2 == 0:
            imposter = True
            dontuse = []
            for i in primes:
                if x - i in primes:
                    if mode == 1:
                        print(str(x) + " = " + str(i) + " + " + str((x - i)))
                        imposter = False
                        break
                    else:
                        if i not in dontuse:
                            print(str(x) + " = " + str(i) + " + " + str((x - i)) )
                            imposter = False
                            dontuse.append(i)
                            dontuse.append(x - i)
            if imposter == True:
                print("There is an Imposter among us: " + str(x))


if __name__ == "__main__":
    prime_list = primes()
    goldbasch(prime_list, 1)
    goldbasch(prime_list, 2)

                

Lösung von: Name nicht veröffentlicht

// NET Core 3.x

using System;
using System.Collections.Generic;
using System.Linq;

namespace CS_MDL_CORE_Goldbach
{
    class Program
    {
        static void Main(string[] args)
        {
            var lstPairs = new List<(int n, int p1, int p2)>();

            for (int i = 4; i <= 1000; i+=2)
            {
                var lstPrime = Enumerable.Range(0, i).Where(x => IsPrime(x)).ToList();

                for (int k = 0; k < lstPrime.Count(); k++)
                {
                    for (int l = 0; l < lstPrime.Count(); l++)
                    {
                        if (lstPrime[k] + lstPrime[l] == i)
                        {
                            if (!lstPairs.Contains((i, lstPrime[l], lstPrime[k])))
                                lstPairs.Add((i, lstPrime[k], lstPrime[l]));
                        }
                    }
                }
            }
            lstPairs.GroupBy(t => t.n).Select(g => new { id = g.Key, values = g.Select(x => Tuple.Create(x.p1, x.p2)).ToList() }).ToList().ForEach(x => Console.WriteLine($"{x.id} -> {string.Join(", ", x.values)}"));
        }
        static bool IsPrime(int n)
        {
            if (n == 0 || n == 1) return false;
            if (n == 2) return true;
            for (int i = 2; i <= (int)Math.Ceiling(Math.Sqrt(n)); i++)
                if (n % i == 0) return false;
            return true;
        }
    }
}
                

Lösung von: Jens Kelm (@JKooP)

from itertools import combinations_with_replacement as combr, groupby

def prime_sum_pairs(limit):
    primes, non_primes = set(), set()
    for i in range(2, limit-1):
        if i not in non_primes:
            primes.add(i)
            for j in range(2*i, limit-1, i):
                non_primes.add(j)
    yield from groupby(sorted(filter(lambda x: (n:=sum(x)) % 2 == 0 and n <= limit, combr(primes, 2)), key=sum), key=sum)

print("Aufgabe 1")
for total, prime_pairs in prime_sum_pairs(14):
    print(f"{total} = {(some:=next(prime_pairs))[0]} + {some[1]}")

print("\nAufgabe 2")
for total, prime_pairs in prime_sum_pairs(14):
    print(f"{total} = {' = '.join(map(lambda x: f'{x[0]} + {x[1]}', prime_pairs))}")
                

Lösung von: Name nicht veröffentlicht

Number.prototype.isPrime = function() {
  let i = 2, num = this;
  if (num == 0 || num == 1) return false;
  if (num == 2) return true;
  while (i <= Math.ceil(Math.sqrt(num))) {
    if (num % i == 0) return false;
    i++;
  }
  return true;
}

function goldbachPrimePairs(num) {
  if (num % 2 != 0) throw('Input ist ungerade.');
  if (num <= 2) throw('Input muss größer als 2 sein');
  if (num == 4) return [[2, 2]];

  let out = [],
      primes = [],
      i, j;

  for (i = 3; i <= num; i += 2)
    if (i.isPrime()) primes.push(i);

  for (i = 0; i <= primes.length; i++)
    for (j = i; j <= primes.length; j++)
      if (primes[i] + primes[j] == num) out.push([primes[i], primes[j]]);
  return out;
}

// ausgaben
let pairs,
    i, j;

/*------------------------------------------------------------*\
| Schreibe eine Funktion/Methode, die jeweils ein mögliches    |
| Zahlenpaar bis zur Zahl 1000 ausgibt.                        |
\*------------------------------------------------------------*/
document.write('<p>');
for (i = 4; i <= 1000; i += 2) {
  pairs = goldbachPrimePairs(i);
  document.write(`
    <b>${pairs[0][0] + pairs[0][1]}</b> = ${pairs[0].join(' + ')};
  `);
}
document.write('</p>')

/*------------------------------------------------------------*\
| Schreibe eine Funktion/Methode, die alle möglichen           |
| Zahlenpaare bis zur Zahl 1000 ausgibt.                       |
\*------------------------------------------------------------*/
document.write('<hr>');
for (i = 4; i <= 1000; i += 2) {
  pairs = goldbachPrimePairs(i);
  document.write(`<p><b>${pairs[0][0] + pairs[0][1]}</b>`);
  for (j = 0; j < pairs.length; j++)
    document.write(` = ${pairs[j].join(' + ')}`);
  document.write('</p>');
}                                                     // lissalanda@gmx.at

                

Lösung von: Lisa Salander (Heidi-Klum-Gymnasium Bottrop)

import java.util.ArrayList;

/**
 * @author Fabian Göke
 *Datum: 23.10.2020
 */
public class Berechner {

	//Main-Methode
	public static void main(String[] args) {
		Berechner unserBerechner = new Berechner();
		//Lösung der Aufgabe 1 (ein mögliches Primzahlen-Zahlenpaar für alle geraden Zahlen größer 2 bis 1000)
		System.out.println(unserBerechner.findeEinPaar(1000));
		//Lösung der Aufgabe 2 (alle möglichen Primzahlen-Zahlenpaare für alle geraden Zahlen größer 2 bis 1000)
		System.out.println(unserBerechner.findeAllePaare(1000));
	}

	//Attribute
	//Ende Attribute
	
	//Konstruktor
	public Berechner () {}
	
	//Funktion zum Berechnen von Primzahlen im gewünschten Bereich
	public ArrayList <Integer> berechnePrimzahlen (int pAnzahl) {
		ArrayList <Integer> allePrimzahlen = new ArrayList <Integer>();
		//Jede natürliche Zahl außer 0 und 1 bis zur angegeben pAnzahl wird überprüft
		for (int i=2; i<=pAnzahl; i++) {
			boolean istPrimzahl = true;
			//Falls eine Division außer mit sich selbst und mit 1 keinen Rest ergibt handelt es sich um keine Primzahl: Dies wird entsprechend markiert
			for (int a=2; a<i && istPrimzahl; a++) {
				if ((i % a) == 0) {
					istPrimzahl = false;
				}
			}
			//Alle Primzahlen werden dann eingefügt
			if (istPrimzahl) {
				allePrimzahlen.add(i);
			}
		}
		return allePrimzahlen;
	}
	
	//Funktion zum finden und berechnen eines Primzahl-Paares für alle geraden Zahlen größer 2 bis zur gewünschten Zahl (Lösung Aufgabe 1)
	public String findeEinPaar (int pAnzahl) {
		String ausgabe = "";
		//Alle benötigten Primzahlen werden bestimmt (das sind alle die maximal 2 kleiner als die größte zur berechende Zahl sind, da mit dieser Zahl und 2 das kleinste Paar gebildet werden könnte)
		ArrayList allePrimzahlen = berechnePrimzahlen (pAnzahl - 2);
		//Alle geraden Zahl größer 2 bis zur gewünschten werden geprüft
		for (int i=4; i<=pAnzahl; i+=2) {
			boolean paarGefunden = false;
			//Überprüft werden alle primzahlen die sich in der Liste befinden und kleiner als die gesuchte Zahl sind (und nur so lange bis ein Paar gefudnen wurde)
			for (int a=0; a<allePrimzahlen.size() && (int)allePrimzahlen.get(a)<i && !paarGefunden; a++) {
				//Als zweiten Teil des Paares werden ausschließlich Primzahlen überprüft, die kleiner oder gleich sind um Duplikate zu vermeiden (wie in der Aufgabe gewünscht)
				for (int b=0; b<=a; b++) {
					if (((int)allePrimzahlen.get(a)+(int)allePrimzahlen.get(b))==i) {
						ausgabe = ausgabe + i + ": (" + allePrimzahlen.get(a).toString() + ", " + allePrimzahlen.get(b).toString() + ")\n";
						paarGefunden = true;
					}
				}
			}
		}
		return ausgabe;
	}
	
	//Funktion zum finden und berechnen aller Primzahl-Paaren für alle geraden Zahlen größer 2 bis zur gewünschten Zahl (Lösung Aufgabe 2)
	public String findeAllePaare (int pAnzahl) {
		String ausgabe = "";
		//Alle benötigten Primzahlen werden bestimmt (das sind alle die maximal 2 kleiner als die größte zur berechende Zahl sind, da mit dieser Zahl und 2 das kleinste Paar gebildet werden könnte)
		ArrayList allePrimzahlen = berechnePrimzahlen (pAnzahl - 2);
		//Alle geraden Zahl größer 2 bis zur gewünschten werden geprüft
		for (int i=4; i<=pAnzahl; i+=2) {
			//Überprüft werden alle primzahlen die sich in der Liste befinden und kleiner als die gesuchte Zahl sind
			ausgabe = ausgabe + i + ": [";
			for (int a=0; a<allePrimzahlen.size() && (int)allePrimzahlen.get(a)<i; a++) {
				//Als zweiten Teil des Paares werden ausschließlich Primzahlen überprüft, die kleiner oder gleich sind um Duplikate zu vermeiden (wie in der Aufgabe gewünscht)
				for (int b=0; b<=a; b++) {
					if (((int)allePrimzahlen.get(a)+(int)allePrimzahlen.get(b))==i) {
						ausgabe = ausgabe + "(" + allePrimzahlen.get(a).toString() + ", " + allePrimzahlen.get(b).toString() + "), ";
					}
				}
			}
			ausgabe = ausgabe + "] \n";
		}
		return ausgabe;
	}
}
                

Lösung von: Fabian Göke (Friedrich-Harkort-Schule Herdecke)