C# :: Aufgabe #333

3 Lösungen Lösungen öffentlich

Goldbachsche Vermutung (binär)

Fortgeschrittener - C# von JKooP - 13.10.2020 um 08:32 Uhr
Die Goldbachsche Vermutung besagt, dass jede gerade Zahl größer 2 die Summe zweier Primzahlen ist.

1. Schreibe eine Funktion/Methode, die jeweils ein mögliches Primzahlenpaar bis zur Zahl 1000 ausgibt.

Beispiele:

4 = 2 + 2 -> (2, 2)
6 = 3 + 3 -> (3, 3)
8 = 3 + 5 -> (3, 5)

Duplikate durch Vertauschung wie z.B. (3, 5) -> (5, 3) sollen verhindert werden.

2. Schreibe eine Funktion/Methode, die alle mögliche Primzahlenpaare bis zur Zahl 1000 ausgibt.

Beispiele:

10 = 3 + 7 = 5 + 5 -> [ (3, 7), (5, 3) ]
14 = 3 + 11 = 7 + 7 -> [ (3, 11), (7, 7) ]

Viel Spaß

Lösungen:

vote_ok
von Waldgeist (1930 Punkte) - 18.10.2020 um 13:08 Uhr
Quellcode ausblenden C#-Code
using System;
using System.Collections.Generic;

namespace Aufgabe_333_Goldbachse_Vermutung
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            int berechneBisZahl = 200;
            List<int> primzahlen = new List<int>();
            int variante;

            Console.WriteLine("Gibt Primzahlenpaare bis zur Zahl 1000 aus\n\n");
            Console.WriteLine("Variante 1: Gib nur 1 Zahlenpaar aus");
            Console.WriteLine("Variante 2: Gibt alle Zahlenpaare aus");
            Console.Write("Ihre Auswahl: ");
            variante = Convert.ToInt32(Console.ReadLine());

            for (int i = 2; i <= berechneBisZahl; i++)   //1 ist keine Primzahl daher i=2
            {
                if (IstPrimzahl(i))                      //prüfen ob i eine Primzahl ist
                {
                    primzahlen.Add(i);                  //wenn ja in Liste aufnehmen
                }
                if ((i > 2) & (i % 2 == 0))             //Goldbachse Vermutung gilt nur für gerade Zahlen größer als 2
                {
                    Console.Write(i + " = ");
                    for (int j = 0; j <= (primzahlen.Count - 1); j++)   //durchläuft alle Primzahlen in Liste
                    {
                        if (primzahlen[j] > (i / 2))   //wenn Primzahl an index j größer als die Hälfte der zu prüfenden Zahl abbruch, verhindert doppelte Ausgabe
                        {
                            break;
                        }
                        else
                        {
                            for (int k = 0; k <= (primzahlen.Count - 1); k++)   //durchläuft nochmals alle Primzahlen in List
                            {
                                if (primzahlen[j] + primzahlen[k] == i)         //wenn die Summe der beiden Primzahlen die Zahl i ergibt
                                {
                                    Console.Write($" {primzahlen[j]} + {primzahlen[k]} , ");  //geben wir die Löung aus!
                                    if (variante == 1)
                                    {
                                        goto doublebreak;
                                    }
                                }
                            }
                        }
                    }
                    Console.WriteLine();
                }
            doublebreak:;
                Console.WriteLine();
            }

            //Methode zm prüfen ob Zahl eine Primzahl ist
            bool IstPrimzahl(int zuprüfendeZahl)
            {
                for (int i = 2; i < zuprüfendeZahl; i++)
                {
                    if (zuprüfendeZahl % i == 0)
                    {
                        return false;
                    }
                }
                return true;
            }
        }
    }
}

vote_ok
von Trickster (330 Punkte) - 21.10.2020 um 16:51 Uhr
Quellcode ausblenden C#-Code
using System;
using System.Collections.Generic;

namespace Primzahlzwillinge
{
    class Program
    {
        static void Main(string[] args)
        {
            List<int> primzahlen = new List<int>();

            int number = 0;
            int max = 1000;

            if (number == 2)
                Console.WriteLine(2);
            primzahlen.Add(2);
            if (number % 2 == 0)
                number++;
            for (int i = number; i <= max; i += 2)
            {
                bool primzahl = true;
                for (int j = 3; j < i; ++j)
                {
                    if (i % j == 0)
                    {
                        primzahl = false;
                        break;
                    }
                }
                if (primzahl && i >= 2)
                    primzahlen.Add(i);
            }
            // so ist es einfach übersichtlicher
            for (int i = 2; i < 1000; i = i + 2)
            {
                Console.WriteLine();
                foreach (int primzahl in primzahlen)
                {
                    foreach (int primzahl2 in primzahlen)
                    {
                        if (i == primzahl + primzahl2)
                        {
                            if (primzahl2 > primzahl)
                            {
                                break;
                            }

                            Console.WriteLine($"{i} = {primzahl} + {primzahl2}");
                        }
                    }
                }
            }
            Console.ReadKey();
        }
    }
}
vote_ok
von JKooP (7540 Punkte) - 03.01.2021 um 10:52 Uhr
NET 5.x; C# 8.x
Lösung 2:
Quellcode ausblenden C#-Code
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) => n > 1 && Enumerable.Range(1, n).Where(x => n % x == 0).SequenceEqual(new[] { 1, n });
    }
}
994261

Du scheinst einen AdBlocker zu nutzen. Ich würde mich freuen, wenn du ihn auf dieser Seite deaktivierst und dich davon überzeugst, dass die Werbung hier nicht störend ist.