Rekursion größten Primfaktor finden funktioniert nicht

sserio

Bekanntes Mitglied
Hallo habt ihr eine idee wie man den größten Primfaktor mit hilfe einer Rekursion herausfindet? Bei mir ist es irgendwie ne endlosschleife, weil ich nicht weiß wie ich einen wert abspeicher, wenn der divider eine Primzahl ist und der andere nicht( wieder in die Rekursion) . Also falls ihr Tipps habt gerne stellen. Ps code kann unübersichtlich wirken:
Java:
package ProjectEuler3;

import java.util.List;
import java.util.ArrayList;

public class Main {

    public static void main(String[] args) {
        for (int i = 0; i < findPrimeNumbers().size(); i++) {
            System.out.println(findPrimeNumbers().get(i));
        }
    }


    public static List<Integer> getPrimeFactor(int num) {
        List<Integer> list = new ArrayList<>();
        for (Integer n : findPrimeNumbers()) {
            if (num == n) {
                list.add(num);
                break;
            }
        }
        for (int i = 2; num % i != 0; i++) {
            if (num % i == 0) {
                for (Integer n : findPrimeNumbers()) {
                    if (num / i == n) {
                        if (i == n) {
                            list.add(i, num / i);
                        }
                    }
                    if (num / i == n && i != n) {
                        for (int p : getPrimeFactoR(i)) {
                            list.add(p);
                        }

                    } else if (num / i != n && i == n) {
                        for (int l : getPrimeFactoR(num / i)) {
                            list.add(l);
                        }

                    }
                }

            }
        }
        return list;
    }

    public static int[] getPrimeFactoR(int num) {
        int[] arr = new int[num];
        for (Integer n : findPrimeNumbers()) {
            if (num == n) {
                return new int[]{num};

            }
        }
        for (int i = 2; num % i != 0; i++) {
            if (num % i == 0) {
                for (Integer n : findPrimeNumbers()) {
                    if (num / i == n) {
                        if (i == n) {
                            int[] temp = new int[]{num / i, i};
                            arr = temp;
                        }
                    }
                    if (num / i == n && i != n) {
                        int[] temp = new int[]{num / i};
                        arr = temp;
                        getPrimeFactoR(i);
                    } else if (num / i != n && i == n) {
                        int[] temp = new int[]{i};
                        arr = temp;
                        getPrimeFactoR(num / i);
                    }
                }

            }
        }
        return arr;
    }

    public static List<Integer> findPrimeNumbers() {
        List<Integer> list = new ArrayList<>();
        int counter = 0;
        int zaehler = 0;
        for (int i = 2; i < 20000; i++) {
            for (Integer n : list) {
                if (isTrue(i, n)) {
                    counter++;
                }
            }
            if (counter == 0) {
                list.add(i);
                zaehler++;
            } else counter = 0;
        }
        return list;
    }
Java:
public static boolean isTrue(int n, int m) {
        return n % m == 0;
    }
}
 
Zuletzt bearbeitet von einem Moderator:
G

Gelöschtes Mitglied 65838

Gast
schau dir bitte zuerst miches antwort an im anderen thread

Ps code kann unübersichtlich wirken:
er wirkt nicht nur so er ist es


der ansatz an dem ich mich erinnere ist

du probierst aus zb bei 40

Java:
2 * 2 => drunter
3 * 3 => drunter
...
6 * 6 => drunter
7 * 7 => drüber => stoppen ! und jetz wieder retour

40 % 7 == 0 ? nein also kleiner
40 % 6 == 0 ? nein also kleiner
40 % 5 == 0 ? ja

5 ist der größte primfaktor fürs erste

jetzt mathematik

5 * x = 40 // hat x einen größeren primfaktor als 5 ?
x  = 4 // nochmal prim faktor zerlegung bist du nur noch primfaktoren hast
// da 4 kleiner ist als der erste primfaktor kann man eig shcon aufhören
...
 
rekursiv zurück ist 2 ( ergebnis von prim zerlegung ) größer als 5 .. nö also 5 ist größte prim

du fragst dich warum man da wieder zurück rehcnen muss ?
zb bei 46 wäre prim zerlegung 23 aber durchs "ausprobieren" würdest du bei 7 * 7 aufhören dh du würdest die 23 nicht finden

[CODE lang="java" title="iterative lösung raus kopiert"] static long maxPrimeFactors(long n)
{
// Initialize the maximum prime
// factor variable with the
// lowest one
long maxPrime = -1;

// Print the number of 2s
// that divide n
while (n % 2 == 0) {
maxPrime = 2;

// equivalent to n /= 2
n >>= 1;
}
// n must be odd at this point
while (n % 3 == 0) {
maxPrime = 3;
n = n / 3;
}

// now we have to iterate only for integers
// who does not have prime factor 2 and 3
for (int i = 5; i <= Math.sqrt(n); i += 6) {
while (n % i == 0) {
maxPrime = i;
n = n / i;
}
while (n % (i + 2) == 0) {
maxPrime = i + 2;
n = n / (i + 2);
}
}

// This condition is to handle the case
// when n is a prime number greater than 4
if (n > 4)
maxPrime = n;

return maxPrime;
}

// Driver code
public static void main(String[] args)
{
Long n = 15l;
System.out.println(maxPrimeFactors(n));

n = 25698751364526l;
System.out.println(maxPrimeFactors(n));
}[/CODE]

[CODE lang="java" title="rekursive lösung in c"]#include <stdio.h>

long long prime_factor_i (int n, long long huge_number) {
while (n < huge_number) {
if (huge_number % n == 0) {
huge_number /= n;
continue;
}
n++;
}
return huge_number;
}

int main (void) {
int n = 2;
long long huge_number = 60085147514LL;
long long largest_prime = 0;

largest_prime = prime_factor_i (n, huge_number);
printf ("%lld\n", largest_prime);

return 0;
}[/CODE]
 
Zuletzt bearbeitet von einem Moderator:

Jw456

Top Contributor
die sich selbst aufrufebnde Methode "getPrimeFactoR" wird gar nicht gestartet weder in der main. In der for schleife
rufst du findPrimeNumbers() auf. Dort wird deine vermeitliche Rekusion auch nicht gestartet.
 
Zuletzt bearbeitet:

sserio

Bekanntes Mitglied
schau dir bitte zuerst miches antwort an im anderen thread


er wirkt nicht nur so er ist es


der ansatz an dem ich mich erinnere ist

du probierst aus zb bei 40

Java:
2 * 2 => drunter
3 * 3 => drunter
...
6 * 6 => drunter
7 * 7 => drüber => stoppen ! und jetz wieder retour

40 % 7 == 0 ? nein also kleiner
40 % 6 == 0 ? nein also kleiner
40 % 5 == 0 ? ja

5 ist der größte primfaktor fürs erste

jetzt mathematik

5 * x = 40 // hat x einen größeren primfaktor als 5 ?
x  = 4 // nochmal prim faktor zerlegung bist du nur noch primfaktoren hast
// da 4 kleiner ist als der erste primfaktor kann man eig shcon aufhören
...
 
rekursiv zurück ist 2 ( ergebnis von prim zerlegung ) größer als 5 .. nö also 5 ist größte prim

du fragst dich warum man da wieder zurück rehcnen muss ?
zb bei 46 wäre prim zerlegung 23 aber durchs "ausprobieren" würdest du bei 7 * 7 aufhören dh du würdest die 23 nicht finden

[CODE lang="java" title="iterative lösung raus kopiert"] static long maxPrimeFactors(long n)
{
// Initialize the maximum prime
// factor variable with the
// lowest one
long maxPrime = -1;

// Print the number of 2s
// that divide n
while (n % 2 == 0) {
maxPrime = 2;

// equivalent to n /= 2
n >>= 1;
}
// n must be odd at this point
while (n % 3 == 0) {
maxPrime = 3;
n = n / 3;
}

// now we have to iterate only for integers
// who does not have prime factor 2 and 3
for (int i = 5; i <= Math.sqrt(n); i += 6) {
while (n % i == 0) {
maxPrime = i;
n = n / i;
}
while (n % (i + 2) == 0) {
maxPrime = i + 2;
n = n / (i + 2);
}
}

// This condition is to handle the case
// when n is a prime number greater than 4
if (n > 4)
maxPrime = n;

return maxPrime;
}

// Driver code
public static void main(String[] args)
{
Long n = 15l;
System.out.println(maxPrimeFactors(n));

n = 25698751364526l;
System.out.println(maxPrimeFactors(n));
}[/CODE]

[CODE lang="java" title="rekursive lösung in c"]#include <stdio.h>

long long prime_factor_i (int n, long long huge_number) {
while (n < huge_number) {
if (huge_number % n == 0) {
huge_number /= n;
continue;
}
n++;
}
return huge_number;
}

int main (void) {
int n = 2;
long long huge_number = 60085147514LL;
long long largest_prime = 0;

largest_prime = prime_factor_i (n, huge_number);
printf ("%lld\n", largest_prime);

return 0;
}[/CODE]
was ist das eigentlich für eine Sprache? verstehe nur so die Hälfte davon
 

sserio

Bekanntes Mitglied
das erste ist java das zweite ist normales c
also ich habe es jetzt auf jeden Fall geschafft, jedoch habe ich irgedenwie ein problem mit der ausgabe:
package ProjectEuler3;

import java.util.List;
import java.util.ArrayList;

public class Main {

public static void main(String[] args) {
getBiggestPrimeNum(74414);
}

public static void getBiggestPrimeNum(int num) {
if (isPrime(num)) {
System.out.println(num);
} else {
for (int i = 2; i < num; i++) {
if (num % i == 0) {
if (isPrime(num / i)) {
System.out.println(num / i);
} else getBiggestPrimeNum(num / i);
}
}
}
}

public static List<Integer> findPrimeNumbers() {
List<Integer> list = new ArrayList<>();
int counter = 0;
for (int i = 2; i < 20000; i++) {
for (Integer n : list) {
if (isTrue(i, n)) {
counter++;
}
}
if (counter == 0) {
list.add(i);
} else counter = 0;
}
return list;
}

public static boolean isPrime(int num) {
for (Integer n : findPrimeNumbers()) {
if (num == n) {
return true;
}
}
return false;
}

public static boolean isTrue(int n, int m) {
return n % m == 0;
}
}
in dem Beispiel gibt er nicht einfach nur 1283 aus, sondern :
1283
29
1283
2
1283
29
2
29
2
EDIT: habe jetzt ein break an das 2te sout drangehangen und jetzt wird
1283
1283
1283
ausgegeben.
EDIT NUMMER 2: habe jetzt ein break an das 3te sout drangehangen und es funktioniert. Weiß aber nicht wieso jetzt das ergebnis aufeinmal nur noch einmal ausgegeben wird. Vllt wegen der rekursion oder so
 
Zuletzt bearbeitet:

sserio

Bekanntes Mitglied
also ich habe es jetzt auf jeden Fall geschafft, jedoch habe ich irgedenwie ein problem mit der ausgabe:

in dem Beispiel gibt er nicht einfach nur 1283 aus, sondern :
1283
29
1283
2
1283
29
2
29
2
wie macht man das eigentlich so, damit das wie echter code aussieht, also wie alle das hier eigentlich auf dem Forum machen
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
N Java Rekursion - Set --> Hole den 2.größten Wert Java Basics - Anfänger-Themen 3
K Verstehe Rekursion nicht ganz Java Basics - Anfänger-Themen 7
P Frage zu Rekursion und Backtracking Java Basics - Anfänger-Themen 2
DiyarcanZeren Rekursion in Java Java Basics - Anfänger-Themen 5
M Variablen Rekursion mit 2 Parameteren Java Basics - Anfänger-Themen 4
M Lösungsweg Rekursion Java Basics - Anfänger-Themen 1
C StackOverflow bei Rekursion Java Basics - Anfänger-Themen 7
D Rekursion - Ich raffs nicht Java Basics - Anfänger-Themen 16
N Methoden Rekursion mit Kreisen Java Basics - Anfänger-Themen 7
P9cman Vokale in einem String überprüfen mittels Rekursion Java Basics - Anfänger-Themen 8
J Rekursion Java Basics - Anfänger-Themen 22
T Rekursion Programmierverständnis Java Basics - Anfänger-Themen 12
K Rekursion: Rechenmauer mit Array erstellen Java Basics - Anfänger-Themen 17
K Rekursion einer Zahlenfolge (Ab- und Aufzählung) Java Basics - Anfänger-Themen 6
Zeppi Rekursion Java Basics - Anfänger-Themen 15
V Backtracking und Rekursion Java Basics - Anfänger-Themen 15
L REKURSION Java Basics - Anfänger-Themen 13
Kirby.exe Rekursion Java Basics - Anfänger-Themen 7
N for Schleife durch Rekursion ersetzen Java Basics - Anfänger-Themen 6
X Rekursion Java Basics - Anfänger-Themen 3
H Rekursion Java Basics - Anfänger-Themen 2
D Erste Schritte Rekursion Java Basics - Anfänger-Themen 13
M Rekursion Tage Ansteckung gesamte Bevölkerung Java Basics - Anfänger-Themen 15
M Java Rekursion Java Basics - Anfänger-Themen 9
G Java Rekursion Java Basics - Anfänger-Themen 5
J Rekursion Klausur Aufgabe Java Basics - Anfänger-Themen 2
N Rekursion Java Basics - Anfänger-Themen 18
M Verständnisproblem der Rekursion bei Arrays Java Basics - Anfänger-Themen 8
X Rekursion Rätsel Java Basics - Anfänger-Themen 4
N Klassen Rekursion mit Feldern von Objekten Java Basics - Anfänger-Themen 14
W Rekursion Java Basics - Anfänger-Themen 0
D Konsolenausgabe Zahlenfolge Rekursion Java Basics - Anfänger-Themen 3
J Ping Pong Methode mit Rekursion Java Basics - Anfänger-Themen 1
N Rekursion Java Basics - Anfänger-Themen 1
B Rekursion Basic Java Basics - Anfänger-Themen 15
O Rekursion Mergesort Java Basics - Anfänger-Themen 18
G Rekursion Java Basics - Anfänger-Themen 20
M Rekursion Java Basics - Anfänger-Themen 7
F Hilfe bei Rekursion... Java Basics - Anfänger-Themen 4
A Mit Rekursion Zufallszahlen erstellen und größte finden Java Basics - Anfänger-Themen 5
B Rekursion Wurzel Java Basics - Anfänger-Themen 39
O Rekursion ordentlich aufschreiben Java Basics - Anfänger-Themen 2
B Rekursion verstehen Java Basics - Anfänger-Themen 4
O Rekursion Java Basics - Anfänger-Themen 2
E Rekursion verstehen. Java Basics - Anfänger-Themen 4
E Rekursion Kisten befüllen Java Basics - Anfänger-Themen 10
E Rekursion verstehen Java Basics - Anfänger-Themen 2
O Rekursion, String Java Basics - Anfänger-Themen 8
N Invertierte Rekursion??? Java Basics - Anfänger-Themen 5
M Bitte um Hilfe bei Quellcode (Rekursion) Java Basics - Anfänger-Themen 6
T Rekursion Warum bricht meine Funktion nicht ab Java Basics - Anfänger-Themen 4
A Hilfe bei Rekursion,Ich verstehe nicht,wie funktioniert die Rekursion in der Methode "walk" Java Basics - Anfänger-Themen 13
L Rekursion im Baum Java Basics - Anfänger-Themen 9
E Pfade eines Baums angeben ohne Rekursion Java Basics - Anfänger-Themen 20
L Rekursion Baumknoten Java Basics - Anfänger-Themen 8
L Rekursion größtes Zeichen Java Basics - Anfänger-Themen 8
L Rekursion Modulo Java Basics - Anfänger-Themen 7
I Rekursion Java Basics - Anfänger-Themen 11
H Rekursion Java Basics - Anfänger-Themen 7
N Methoden zur Rekursion (catalansche Zahlen) Java Basics - Anfänger-Themen 4
S Frage zu Rekursion... Java Basics - Anfänger-Themen 15
N Java catalansche Zahlen (Rekursion) Java Basics - Anfänger-Themen 5
S Noch eine Frage zur Rekursion... Java Basics - Anfänger-Themen 11
S Frage zu einer Rekursion Java Basics - Anfänger-Themen 15
F Methoden Abbruchbedingung bei Rekursion Java Basics - Anfänger-Themen 2
Z Rekursion Primzahlen Java Basics - Anfänger-Themen 1
K Rekursion Verständnisfrage Java Basics - Anfänger-Themen 19
L Methoden Rekursion gibt alten Wert wieder Java Basics - Anfänger-Themen 37
M Rekursion Minimums Suche Java Basics - Anfänger-Themen 12
J Rekursion Java Basics - Anfänger-Themen 5
F Aufgabe Rekursion Binärer Baum Java Basics - Anfänger-Themen 15
N Rekursion Java Basics - Anfänger-Themen 2
B Rekursion - Übung Java Basics - Anfänger-Themen 2
B Problem beim grundsätzlichen Verständnis bei Rekursion mit 2-dimensionalen Array Java Basics - Anfänger-Themen 6
P Rekursion Java Basics - Anfänger-Themen 19
G Rekursion Beispiel Java Basics - Anfänger-Themen 3
M Rekursion schreiben Java Basics - Anfänger-Themen 16
A Rekursion Funktion in eine Iterativ Funktion umwandeln Java Basics - Anfänger-Themen 9
T Array Rekursion Java Basics - Anfänger-Themen 1
B lineare und schlichte Rekursion Java Basics - Anfänger-Themen 1
A Rekursion Java Basics - Anfänger-Themen 2
B Rekursion Java Basics - Anfänger-Themen 3
A Rekursion stoppt an der falschen Stelle Java Basics - Anfänger-Themen 4
A Lineare Rekursion Java Basics - Anfänger-Themen 6
P Hilfe zur Rekursion? Java Basics - Anfänger-Themen 2
B Rekursion Schneeflocke - Kurze Frage zur Methode Java Basics - Anfänger-Themen 11
L Rekursion Java Basics - Anfänger-Themen 4
S Rekursion Rückgabe - Türme von Hanoi Java Basics - Anfänger-Themen 16
kilopack15 Rekursion und Schleifen Java Basics - Anfänger-Themen 27
E Rekursion Java Basics - Anfänger-Themen 10
G rekursion nicht verstanden Java Basics - Anfänger-Themen 5
K Rekursion-Verständnisfrage Java Basics - Anfänger-Themen 4
E Methoden String wird in Rekursion nicht überschrieben Java Basics - Anfänger-Themen 2
T 2fach Rekursion. Java Basics - Anfänger-Themen 4
N Rekursion mit if-Anweisung Java Basics - Anfänger-Themen 10
K Methoden Zahlensysteme umwandeln mittels Rekursion Java Basics - Anfänger-Themen 5
H Rekursion Binäre Suche Java Basics - Anfänger-Themen 2
P Methoden Primzahltest mit Rekursion Java Basics - Anfänger-Themen 3
C Rekursion überführen in eine normale methode Java Basics - Anfänger-Themen 1
M Methoden Rekursion nachvollziehen Java Basics - Anfänger-Themen 4

Ähnliche Java Themen

Neue Themen


Oben