Primzahlen

[Sarah Schüßler]

Hallo!
Ich suche schon seit Stunden nach dem Fehler in meinem Algorithmus. Er gibt mir eine Endlosschleife mit dem Wert 1.
Der Algorithmus soll mir innerhalb eines Intervalls alle Primzahlen ausgeben.
Hier der Code:

import AlgoTools.IO;

public class Uebung31 {

  public static void main (String [] argv) {

    int zahl1, zahl2, i=1, j=1,  zwischenergebnis=1, zaehler=0, primzahl=0;                                 //Variablen initalisieren

    zahl1 = IO.readInt("Bitte eine Zahl eingeben:");   //untere Grenze

    do {
      zahl2 = IO.readInt("Bitte noch eine Zahl groesser als die erste eingeben:");
    } while (zahl2 < zahl1);                          //obere Grenze


    for (i = zahl1; i <= zahl2; i++) {                //prüfe für jede Zahl zwischen den Grenzen folgendes:

        do {
            if ((i < 2) & (i % 2 == 0)) IO.println("keine Primzahl");
            else {
               for (j = 3; j*j<=i; i+=2) {
                   if (i%j==0)
                   IO.println("keine Primzahl");
               }
            } IO.println(i);
        } while (i <= zahl2);
     }

}
}

Wäre über Tipps dankbar!

 

[deepthroat]

Hi.

Versuch doch mal den Code etwas aufzuteilen. Man sieht bei dir jetzt nur schwer durch. Schreibe dir erstmal eine Funktion, die für eine einzelne Zahl bestimmt, ob diese eine Primzahl ist.

Dann kannst du diese Funktion in der Schleife verwenden um alle Primzahlen auszugeben.

Gruß

 

[Sarah Schüßler]

Bei meinem jetzigen Algorithmus muss ja was mit der ersten for-Schleife nicht ganz stimmen-aber was? Keiner ein Tipp?
Hatte ja schon einen Algorithmus der alle Primzahlen bis 100 ausspuckte - allerdings auch die 1.
Na ich hatte mir ja auch schon überlegt dass er nur die Zahlen ausgeben soll, die, wenn man den Modulo (von der unteren bis zur oberen Grenze) berechnet, nur 2 mal den Rest 0 haben. Also die Primzahlen: durch 1 und durch sich selber modulo 0.. wie setze ich das am besten ganz simpel um

 

[deepthroat]

Also die Primzahlen: durch 1 und durch sich selber modulo 0.. wie setze ich das am besten ganz simpel um

Wie du das ganz simpel umsetzen kannst? Ganz ehrlich?! ;-] Indem du eine Funktion schreibst die bestimmt ob eine Zahl eine Primzahl ist oder nicht. Dann eine Schleife... (hm, kommt mir irgendwie bekannt vor)

Aber jetzt mal ohne Quatsch. Warum machst du es dir so schwer? Es ist klar das für dich als Anfängerin mit 3 ineinander geschachtelten Schleifen die Komplexität des Codes nicht beherrschbar ist. Dann teile den Code auf so dass du mehrere Teile hast die du überblicken kannst!

Übrigens ist nicht an der ersten for Schleife etwas falsch sondern an der innersten. Und wozu soll eigentlich die do-while Schleife gut sein? Wenn du den Code so strukturierst wie ich vorgeschlagen habe, dann ist es eigentlich trivial.

Gruß

 

[Sarah Schüßler]

Na die do-while-Schleife dient dazu, dass die zweite Zahl größer sein soll als die erste, da ich ja innerhalb eines Intervalls meine Primzahlen ausgeben lassen will. Naja könnte man eigentlich auch weglassen, da die 2te Zahl die man eingibt nicht unebdingt auch die größere sein muss- es wird ja immer ein Intervall beschrieben wenn man 2Zahlen hat.
Na dann werde ich mir das nochmal zur Gemüte führen!

 

[Sarah Schüßler]

Wie du das ganz simpel umsetzen kannst? Ganz ehrlich?! ;-] Indem du eine Funktion schreibst die bestimmt ob eine Zahl eine Primzahl ist oder nicht.

Na hierzu hatte ich mir halt gedacht dass ich einen Algorithmus schreibe der die Schleife abbricht wenn ein Modulo=0 auftaucht bevor er zur "Rechnung" durch sich selbst kommt- weil dann kann es ja keine Primzahl sein. Vielleicht hättest du dazu noch einen kleinen Tipp oder so?

 

[deepthroat]

Na die do-while-Schleife dient dazu, dass die zweite Zahl größer sein soll als die erste

Nein, die erste Schleife ist klar. Ich meine die do-while Schleife innerhalb der for Schleife.

Na hierzu hatte ich mir halt gedacht dass ich einen Algorithmus schreibe der die Schleife abbricht wenn ein Modulo=0 auftaucht bevor er zur "Rechnung" durch sich selbst kommt- weil dann kann es ja keine Primzahl sein. Vielleicht hättest du dazu noch einen kleinen Tipp oder so?

Genau das ist mit einer Funktion äußerst einfach, da man in dem Fall sofort den Wert "false" zurückgeben kann und keine Berechnung mehr durchgeführt wird. Mit mehrfach ineinander geschachtelten Schleifen müßtest du da noch eine zusätzlich Variable einführen oder ähnliche unschöne Dinge machen, die die Komplexität des Codes noch weiter erhöhen.

Dann solltest du dir evlt. nochmal die Definition der Primzahlen anschauen, denn dein Test

if ((i < 2) & (i % 2 == 0)) IO.println("keine Primzahl");

stimmt nicht. Zumal du dort das binäre "und" verwendet hast. Du meintest höchstwahrscheinlich den boolschen Operator &&. Aber dann wäre die Frage, welche natürliche Zahl kleiner als 2 ist und gleichzeitig durch 2 teilbar?

Eine Zahl könnte eine Primzahl sein, falls sie größer 2 und ungerade oder gleich 2 ist. Ansonsten ist sie per se keine Primzahl.

Die Schleife sollte im Grunde so aussehen:

for (int i = zahl1; i <= zahl2; ++i) {
  if (istPrimzahl(i)) {
    IO.println(i);
  }
}

Jetzt müßtest du nur noch die istPrimzahl Funktion schreiben.

Gruß

 

[olqs]

Also es gibt 4 Punkte in deinem Code die nicht ganz so funktionieren wie sie sollten:
1. Die If Abfrage wie schon von meinem Vorposter erwähnt.
2. Eine Überflüssige do ... while Schleife
3. In der 2. For Schleife zählst du statt der Variable j die Variable i hoch
4.. Die Ausgabe IO.println(i); die die Primzahlen ausgeben soll steht an der falschen Stelle

Hier mal ein etwas überarbeiteter CodeSchnipsel von mir:

import AlgoTools.IO;

public class Uebung31 {

        public static void main (String [] argv) {

                int zahl1, zahl2, i=1, j=1,  zwischenergebnis=1, zaehler=0, primzahl=0;                                 //Variablen initalisieren

                zahl1 = IO.readInt("Bitte eine Zahl eingeben:");   //untere Grenze

                do {
                        zahl2 = IO.readInt("Bitte noch eine Zahl groesser als die erste eingeben:");
                } while (zahl2 < zahl1);                          //obere Grenze


                for (i = zahl1; i <= zahl2; i++) {                //prüfe für jede Zahl zwischen den Grenzen folgendes:
                                if ((i < 2) || (i % 2 == 0)) {
                                        IO.println(i + " ist keine Primzahl");
                                } else {
                                        for (j = 3; j*j<=i; j+=2) {
                                                if (i%j==0) {
                                                        IO.println(i + " ist keine Primzahl");
                                                } else {
                                                        IO.println(i + " ist eine Primzahl");
                                                }
                                        }
                                }
                }

        }
}

Wenn Du wirklich nur die Primzahlen ausgeben willst, würd ich noch das if(i%j==0) in der For Schleife auf != setzen, dann fällt auch der else Zweig weg.

 

[deepthroat]

Hi.

@olqs: Dein Code beinhaltet im Grunde die gleichen Fehler wie der Originalcode von Sarah. (mit einigen Verbesserungen) Aber die Bestimmung ob eine Zahl eine Primzahl ist oder nicht, ist falsch.

Gruß

 

[olqs]

Bedingt geb ich dir Recht, die 2 hab ich übersehen, aber sonst:
Ich überprüfe, ob eine zahl < 2 ist. 0 und 1 sind keine Primzahlen.
Je nach Mathe Prof war bei mir 0 manchmal bei den natürlichen zahlen dabei, oder nicht.
Danach mit || schmeiss ich alle geraden Zahlen raus. Bis auf die 2 stimmts ja.
Und danach lauf ich alle ungeraden Zahlen durch und schau, ob meine gestestete dadurch Teilbar ist. Die ungeraden Zahlen muss ich nur bis Wurzel(i) durchlaufen. Sonst mach ich tests doppelt.

Für die 2 kann man ja noch ein "else if (i == 2)" einbauen