Erste Schritte primzahlen ermitteln, nur zahlen als eingabe erlauben

M

marlo

Gast
moin,
bin neu in diesem forum und ebenso neu in sachen java. kurz zu meiner person: bin baujahr 66, habe in den 90er mal mit basic/vb gespielt, it-kaufmann gelernt, und seit fast 20 jahren nichts mehr mit der materie zu tun gehabt.
jetzt möchte ich java lernen und habe mir als einstieg ein progrämmchen von damals vorgenommen. dabei handelt es sich um eine lösung zur ermittlung von primzahlen.
ich arbeite da mit 2 arrays wobei letztlich dann die primzahlen von 1- usereingabe ausgegeben werden. das funktioniert.
jetzt möchte ich aber fehlervermeidung durch buchstaben,- komma eingabe verhindern.
bei eingabe von q, Q, wird beendet - funktioniert,
eingabe von "," gibt meldung aus - nur positive ganzzahlen - funtkioniert,
"." und "-" muss ich noch abfangen
aber jetzt komm ich nicht weiter:
Java:
import java.util.Scanner;
import java.io.IOException;
import java.util.Arrays;
import java.util.regex.*;

public class Primzahl
{
 static int a;
 static String s;
 static int c;
 public static void main(String[] args)
 {
 //int a, b, c;
a=0;   
Scanner scanner = new Scanner(System.in);
    do{
     System.out.println("Bitte Endzahl eingeben:  (Q beendet)");
    s = scanner.next();
     System.out.println("gedrückt wurde :" +s );
       
switch ( s )
{         
    case ("q"):
    System.out.println("Bye qq \n" );
    s="q";   
    break;
     case ("Q"):
     System.out.println("Bye QQ \n");
     s="q";
     break;
      case (","):
      System.out.println("Nur positive Ganzzahlen erlaubt \n");
      break;               
         case ("[\\d]+"):       //funktioniert nicht, ausser ich geb [\\d]+ ein ;( ich steh
                                         //aufm  schlauch 
         a=Integer.parseInt(s);
         System.out.println(a + " GESCHAFFT?");               
}         

    }
    while (s!="q"); //nur zum testen die abbruchbedingung
es sollen nur ganzzahlen >4 bis egal eingebbar sein
vielen dank für die hilfe
mfg
martin
 

mrBrown

Super-Moderator
Mitarbeiter
Statt dem case solltest du da ein if und String.matches nutzen ;)
Den Test auf "," kannst du dann auch ignorieren, der ist ja durch \d+ abgedeckt

Außerdem solltest du deine Abbruchbedinung anpassen, Strings lassen sich nur in Außnahmefällen (zB in diesem) mit == bzw != vergleichen, stattdessen solltest du da equals nutzen.
 
M

marlo

Gast
hallo mrbrown und danke,habs jetzt so am laufen, wie gewollt ;)
Code:
 [=java]
import java.util.Scanner;
import java.io.IOException;
import java.util.Arrays;
import java.util.regex.*;

public class Primzahl
{
 static int a;
 static String s;
 static int c;
 static String s2;
 public static void main(String[] args)
  {
//s2="\\D";
//int a, b, c;
a=0;  
Scanner scanner = new Scanner(System.in);
    do{
     System.out.println("Bitte Endzahl eingeben:  (Q beendet)");
    s = scanner.next();
     System.out.println("gedrückt wurde :" +s );
     if (s.equals("q") || s.equals("Q"))
{
   System.out.println("Beenden wurde gewählt ");
   break;
}      
String str = s;
String regex = "\\D";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(str);
    
//*************************************************************************
if(matcher.find()){
System.out.println("Nur positive Ganzzahl/en erlaubt.");
a=0;
}                                    
else
    a=Integer.parseInt(s);
System.out.println("Endlich." +s);
//*************************************************************************

    }
 while (a<4);
                
   boolean[] bolPrim =new boolean[a];
    String[] strPrim = new String[a];
    for (int i=0; i<bolPrim.length; ++i) {
    bolPrim=true;
    }
      for (int j=2; j<=(bolPrim.length/2); ++j){
         for (int x=j; x<=(a/2); ++x){
         if (x*j<=(a-1))
         {
        bolPrim[j*x]=false;
        strPrim[j*x]="Die Zahl " + (j*x) + " ist keine Primzahl____" + (j*x);
        }
        }    
    }
        for (c=1; c<=(bolPrim.length-1); ++c){
            if (strPrim[c] ==(null)) {
                strPrim[c]="Die Zahl :" + c + " ist eine Primzahl";
        System.out.println(strPrim[c]); //+ c);
        }
        }
 }
}
 

Jardcore

Top Contributor
Hey hier mal ein paar Umformatierungen, so sieht es ein wenig mehr nach Java aus.
Ich weiß noch nicht genau was dein Programm machen soll, deswegen hab ich an der Logik bisher nichts geändert.

Hier noch ein paar Tipps:
# Die main Methode sollte nur der Einstiegspunkt in dein Programm sein.
Deshalb ist sie oft in einer extra Klasse anzutreffen.
# In deiner Programmklasse hast du dann auch keine statics. Die sind nämlich nichts so gern gesehen. Das führt nur zu unwartbaren Code. Einzige Ausnahme bilde da die Konstanten, die in Java mit "static final" deklariert sind.
# Else Zweige, sowie einzeilige If Bedingungen werden, auch wenn es nicht nötig ist, trotzdem geklammert. Dadurch werden Fehler vermieden.
# Auf der Klasse String (also auf jeden String) kannst du auch direkt matches() aufrufen. Das erspart das Anlegen eines Matchers.
# Variablen Namen sollten sprechend sein. a, c, s und s2 sind keine guten Namen. s2 hast du übrigens nicht verwendet. Statt s, wäre "eingabe" vielleicht ein guter Name.

Hab dir auch mal ein Kommentar im Code hinterlassen, vielleicht findest du ihn?

Java:
public class PrimzahlBeispiel {
    public static void main(String[] args) {
        new Primzahl().start();
    }
}
Java:
public class Primzahl {
 
    private static final NUMBER_REGEX = "\\d+";
 
    private Scanner scanner;
 
    private int a;
    private int c;
    private String s;
 
    public Primzahl() {
        this.scanner = new Scanner(System.in);
    }

    public void start() {
        a = 0;
   
        do {
            System.out.println("Bitte Endzahl eingeben:  (Q beendet)");
            s = scanner.next();
            System.out.println("gedrückt wurde :" +s );
           
            if (s.equals("q") || s.equals("Q")) {
                System.out.println("Beenden wurde gewählt ");
                break;
            }  
         
            //*************************************************************************
            if(s.matches(NUMBER_REGEX)) {
                System.out.println("Nur positive Ganzzahl/en erlaubt.");
                a = 0;
            } else {
                a = Integer.parseInt(s);
            }
             
            System.out.println("Endlich." +s);
            //*************************************************************************

        } while (a < 4);
     
        boolean[] bolPrim = new boolean[a];
        String[] strPrim = new String[a];
     
        // Was macht diese for Schleife ?
        // Möglicherweise willst du hier das Array komplett mit true belegen.
        // Das geht aber anders :)
        // Unten als Kommentar mal hinzugefügt.
        for (int i = 0; i < bolPrim.length; ++i) {
            bolPrim = true;
            //bolPrim[i] = true
        }
     
        for (int j = 2; j <= (bolPrim.length/2); ++j) {
            for (int x = j; x <= (a/2); ++x) {
                if (x*j <= (a-1)) {
                    bolPrim[j*x] = false;
                    strPrim[j*x] = "Die Zahl " + (j*x) + " ist keine Primzahl____" + (j*x);
                }
            }  
        }
     
        for (c = 1; c <= (bolPrim.length-1); ++c) {
            if (strPrim[c] ==(null)) {
                strPrim[c]="Die Zahl :" + c + " ist eine Primzahl";
                System.out.println(strPrim[c]); //+ c);
            }
        }
    }
}

Nächster Schritt wäre Verbesserung des Algorithmus und Auslagern von Codeteilen in extra Methoden.

Beste Grüße
 
M

marlo

Gast
hallo jardcore, vielen dank für deine antwort.
kommentar gefunden ^^ danke, das es mit einem befehl geht, wusste ich nicht.
bei der else hab ich die klammer vergessen.
also, diese übung soll einfach die primzahlen von 1-> usereingabe ausgeben und nur zahlen oder q/Q akzeptieren..
ende der 90er war das mal die erste übung in einem vb kurs den ich besuchte.
deine rausgenommenen pattern und matches standen so in einem tutorial, deswegen hab ich das auch so gemacht, wusste nicht, dass das unnötig ist.
wie gesagt im ersten posting - absoluter neuling in java..ich hab erst letzten montag entschieden, dass ich jetzt java lernen will ^^
nachdem das progrämmchen jetzt macht, was es soll, will ich es optimieren.
das 2te array ist auch überflüssig.
als nächstes wird umgeschrieben, so dass dann nur noch in einer schleife die nichtprimzahlen auf false gesetzt werden, dann schleife für die ausgabe (bolprim=false), weil es sonst doppelmeldungen gibt bei einer einzelnen schleife

naja, wenn das soweit alles läuft, wirds noch erweitert um eine option nicht nur die zahlen 1->eingabe, sondern die ersten "eingabe"-primzahlen zu ermitteln..bsp: primzahlen von 1-1000
oder die ersten 1000
nochmal danke und beste grüsse zurück ;)
martin
 
M

marlo

Gast
hallo nochmal,
wenn ich die verbesserungen übernehme, bekomme ich fehler.
Java:
Number_Regex klappt bei mir nicht. fehler number_regex wird nicht gefunden.
bolPrim = true; //bolPrim[i] = true da ist wohl beim reinkopieren was flöten gegangen. in meinem code steht bolprim[i]..
private static final NUMBER_REGEX = "\\d+"; müsste das nicht \\D+ sein?
if(s.matches(NUMBER_REGEX)) {
System.out.println("Nur positive Ganzzahl/en erlaubt.");
mir raucht der schädel ^^

beim stöbern im web fand ich noch ne regex zur feststellung der primzahlen
Java:
public static void main(string[] args){
if (args.length >= 1)
{
int c = Integer.parseInt(args[0]);
String s = “”;
while (c > 0) {c–; s+=”1″;}
System.out.println(!Pattern.matches(“^1?$|^(11+?)\\1+$”, s));
}}
zu finden falls es jemanden interessiert:
http://www.noulakaz.net/2007/03/18/a-regular-expression-to-check-for-prime-numbers/

da versteh ich allerdings noch weniger ^^
ich geh jetzt erstmal n bisschen bei wow raiden um den kopf frei zu bekommen..
mfg martin
 
Zuletzt bearbeitet von einem Moderator:

mrBrown

Super-Moderator
Mitarbeiter
wenn ich die verbesserungen übernehme, bekomme ich fehler.
Die genaue Fehlermeldung wäre schön ;)

\\d ist richtige, allerdings kannst du in Methoden nichts als static und private deklarieren
im wesentlichen ist das, die Zahl als Strichliste zu schreiben und zu prüfen, ob sich diese in gleich lange Teile teilen lässt
 
M

marlo

Gast
hallo mrbrown, danke für deine antwort.
die fehlermeldung habe ich eigentlich hin geschrieben.
Number_Regex wird nicht gefunden.
und wegen \\d+ und \\D+ - so wie ich das verstanden habe, steht das d für zahlen, D für buchstaben.
bei zahlen soll es ja weiter laufen, bei buchstaben die fehlermeldung bzgl ganzzahlen kommen. ;)
ich habs wieder geändert und es läuft wie gewollt ^^
danke für die erklärung dieser kryptischen regex..ich glaub bevor ich sowas lesen kann kann ich chinesisch ^^
jetzt bin ich beim "optimieren" und erweitern..darf man hier eigentlich ganzen code posten?

Code:
[java]
public class Prim3 {
 static String regex = "\\D";
 static String regex2 = "\\d";
....
public static void main(String[] args) {
// TODO code application logic here
fehler=0;
System.out.println("Sollen die Primzahlen von 2 bis x ermittelt werden?(x/X)\n"
        + "Oder sollen die ersten (zb 1000) Primzahlen ermittelt werden? (n/N)\n"
        + "Q/q beendet");
Quit();
System.out.println(" Tschüss");
System.exit(0);   
}
static void Quit(){      
Scanner scanner = new Scanner(System.in);
    do{
     //System.out.println("Bitte Endzahl eingeben:  (Q beendet)");
    eingabe1 = scanner.next();
     System.out.println("gedrückt wurde :" +eingabe1 );
     if (eingabe1.equals("q") || eingabe1.equals("Q"))
    {
   System.out.println("Beenden wurde gewählt ");
   System.exit(0);
    }  
if (eingabe1.equals("x") || eingabe1.equals("X"))
{
   System.out.println("x/X wurde gewählt ");
   bolEndzahl=true;
   Endzahl();
}
if (eingabe1.equals("n") || eingabe1.equals("N"))
{
System.out.println("n/N wurde gewählt ");   
bolAnzahl=true;
Anzahl();
}
else
{
 System.out.println("Bitte nur x/X n/N oder q/Q eingeben:");  
}
fehler++;
if (fehler==3)
{
    System.out.println("Es wurden 3 unzulässige Eingaben getätigt \nDas Programm wird beendet");
    System.exit(0);
}
    }
 while (fehler<3);   
}
hab das jetzt so gemacht und es geht

noch ein weiter weg vor mir ;)
mfg martin
 
X

Xyz1

Gast
Wenn du jetzt nicht Scanner verwändestest, müsstest du einfach nur prüfen, ob q/Q eingegeben wurde, oder eine Zahl (zwischen 5 und egal), und könntest diese dann "weiterverarbeiten".
Ein Dreizeiler......
 

mrBrown

Super-Moderator
Mitarbeiter
Wenn du jetzt nicht Scanner verwändestest, müsstest du einfach nur prüfen, ob q/Q eingegeben wurde, oder eine Zahl (zwischen 5 und egal), und könntest diese dann "weiterverarbeiten".
Ein Dreizeiler......

Du meinst, das funktionierende Einlesen durch etwas komplexeres und längeres und genauso gut funktionierendes ersetzen? Das ist der beste Tipp den ich seit langem gelesen habe...

Wenn er jetzt noch das sout durch was selbstgebastelte Ersetze, müsst er einfach nur Strings übergeben und könnte einfach weitermachen.
Nur ein Siebenundzwanzigzeiler...
 

Jardcore

Top Contributor
private static final NUMBER_REGEX = "\\d+"
Da ich das einfach nur im notepad geschrieben habe, sind mir ein paar Fehler unterlaufen.
Hier fehlt natürlich der Datentyp. "private static final String NUMBER_REGEX = "\\d+";

Ich würde die Prüfung dann wie folgt verwenden.
Java:
if(eingabe.matches(NUMBER_REGEX)) {
    doTheRightThing();
} else {
    sayThatSomethingWentWrong();
}

\\d+ übrigens einfach aus dem Grund, weil es hier um Zahlen geht. Und deswegen sollte man auf Zahlen prüfen.

P.S.:
private ist der Sichtbarkeitsmodifikator, das heißt, dass das Attribut nur innerhalb der Klasse zu sehen ist.
static heißt, dass das Attribut nur für die bestimmte Klasse gültig ist. Das heißt wiederum, das der Wert für alle Instanzen einer Klasse gleich ist.
Eine Instanz/Objekt einer Klasse erzeugt man übrigens mit dem Schlüsselwort new
Da Java eine objektorientierte Sprache ist, sollte man auch deren Vorteile nutzen.
final heißt, dass das Attribut nach dem initialisieren nicht mehr verändert werden kann.
 
Zuletzt bearbeitet:
M

marlo

Gast
Wenn du jetzt nicht Scanner verwändestest, müsstest du einfach nur prüfen, ob q/Q eingegeben wurde, oder eine Zahl (zwischen 5 und egal), und könntest diese dann "weiterverarbeiten".
Ein Dreizeiler......
moin, wie oben steht, will ich aber dem user die möglichkeit geben, die primzahlen von 1-x ODER die ersten x Primzahlen ausgeben zu lassen.
und, da ich erst seit knapp einer woche java spiele, will ich erstmal das zum laufen bekommen, was ich zum laufen bekommen will. optimierungen, erweiterungen oder sonstiges kommt dann ^^
und da man immer mit einem fehler der drehstuhlschnittstelle rechnen muss, will ich diese gleich von anfang an abfangen.
mfg martin
 
M

marlo

Gast
private static final NUMBER_REGEX = "\\d+"; müsste das nicht \\D+ sein?
if(s.matches(NUMBER_REGEX)) {
System.out.println("Nur positive Ganzzahl/en erlaubt.");
hallo jardcore,
in diesem fall passt aber dann die message nicht mehr ^^

auf jeden fall hab ich es jetzt erstmal am laufen und quäle mich mit dem letzten teil rum. dynamisches array..wenn die ersten x-Primzahlen ausgegeben werden sollen..
bei auswahl die ersten 1000 primzahlen reicht ja n array von 0-1000 oder 2000 nicht unbedingt..muss ja dann erweitert werden..hab schon gefunden, dass arraylist gehen soll..aber wie bau ich das jetzt in schleifen ^^
wird wohl ne schwerere geburt ;) aber was solls, einfach kann jeder
wenn alles klappt, würde ich mich freuen, wenn bei der optimierung geholfen wird.
mfg martin
 

Jardcore

Top Contributor
Hier mal ein kleines Beispiel für eine ArrayList, die Integer akzeptiert.
Java:
public static void main(String[] args) {
    // Eine ArrayList die Objekte vom Typ Integer erlaubt. Integer ist ein Wrapper um den Datentyp int
    // Mit new wird hier eine neue Instanz des ArrayList Objekts erzeugt und in der Variable primList
    // gespeichert.
    // Die Liste ist zusätzlich auch noch generisch, zu sehen an den <> Klammern, hier kannst du bestimmen, welcher Datentyp in der Liste erlaubt ist.
    List<Integer> primList = new ArrayList<Integer>();

    // mit der add()-Methode kann man werte hinzufügen. Es sind für die Liste nur Integer erlaubt.
    primList.add(5);
    primList.add(7);

    // Die Schleife, auch forEach genannt geht die List durch und schreibt den aktuellen Wert in die Variable prim
    for(int prim : primList) {
        System.out.println(prim);
    }
}
 
M

marlo

Gast
danke hab schon ^^
jetzt bastel ich an den schleifen..
arraylist wird gefüllt, dann die nichtprimzahlen rausgeworfen,
nur bekomm ich die schleifen noch nicht hin, dass die liste dann vom neuen size bis zur nutzereingabe befüllt wird
zur erneuten prüfung, bereinigung...bis size dann ==nutzereingae ist.

also bsb:
arraylist aryPrimzahl wird einmal von 0 bis n(benutzereingabe) befüllt
schleife multipliziert x*j bis aryPrimzahl.get(aryPrimzahl(size-1)) erreicht wird
alles x*j wird in liste arykeinPrim geadded
nach der schleife aryPrimzahl.removeAll(arykeinPrim);
funzt

jetzt soll ab neuem aryPrim.size befüllt werden, mit der letzten zahl+1 als startwert
kopf raucht..
 
M

marlo

Gast
hier mal der code
Java:
 a=0;
    n=100;
      ArrayList<Integer> intPrimzahl = new ArrayList<Integer>();
      ArrayList<Integer> keinPrim = new ArrayList<Integer>();
do
{
    intPrimzahl.add(a,a);   
a++;
}
while ( a<=n);
j=2;
k=2;
for (int j=2; j<=(intPrimzahl.size()/2); ++j){
 for (int k=2; k<=(intPrimzahl.size()/k); k++){
    if(j*k<=(intPrimzahl.get(intPrimzahl.size()-1)))
 {
  keinPrim.add(j*k);   
 }
 }
}
intPrimzahl.removeAll(keinPrim);
System.out.println(" Primzahlen\n "+intPrimzahl +"\n");
jetzt muss ich ne schleife darum bauen, die den neuen intPrimzahl(size) bis n (der gewünschten Anzahl der Primzahlen) wieder auffüllt.
wieder in die auswertung geht, wieder alle nichtprimzahlen kickt, wieder auffüllt..bis n erreicht ist..
 
M

marlo

Gast
sooo...jetzt blick ich nicht mehr durch:
Java:
  public static void main( String[] args )
  {
   a=0;
    n=100;
      ArrayList<Boolean> bolPrimzahl = new ArrayList<Boolean>();
      ArrayList<Integer> intPrimzahl = new ArrayList<Integer>();
      ArrayList<String> primAusgabe = new ArrayList<String>();
      ArrayList<Integer> keinPrim = new ArrayList<Integer>();
do
{
    intPrimzahl.add(a,a); 
a++;
}
while ( a<=n);
a=0;
do
{
j=2;
k=2;
for (int j=2; j<=(intPrimzahl.size()); ++j){
 for (int k=2; k<=(intPrimzahl.size()); k++){
    if(j*k<=(intPrimzahl.get(intPrimzahl.size()-1)))
 {
  keinPrim.add(j*k); 
 }
 }
}
intPrimzahl.removeAll(keinPrim);
//...............................
do
{
x=(intPrimzahl.get(intPrimzahl.size()-1));
x++;
intPrimzahl.add(intPrimzahl.size(),x);
keinPrim.clear();
}
while(intPrimzahl.size()<=n);
x=0;
a++;
}
while(a<=n) ;
System.out.println(" Primzahlen \n "+intPrimzahl +"\n");
}
jetzt klappts mit dem befüllen bis n
aber, es bleiben 2-3 nichtprimzahlen stehen
zb 206, 214, und folgende...vorher siehts eigentlich gut aus...
finde den fehler aber auch nicht...
mfg martin
ahhh doch klar...primzahl.size..und nicht den letzten wert..is klar..
also beim testen und rauskicken geh ich ja auf size und nicht den wert der da steht..mööp..alter mann träumt ^^
 
M

marlo

Gast
hmm...doch nicht..nach kleiner änderung werden 468, 474, 478 immer noch als primzahl ausgegeben...find den fehler nicht...
 

Flown

Administrator
Mitarbeiter
Darf ich dir einen naiveren Algorithmus vorschlagen? Du lässt eine Schleife von [2, n] laufen und prüfst jede Zahl ob sie prim ist. Wenn ja fügst du sie der Liste hinzu, wenn nein, dann ab zur nächsten Iteration.
 
M

marlo

Gast
hallo flown danke für deine antwort.
ich versteh kein wort ^^
also ich hab dieses ding geschrieben um die primzahlen von 1-n zu ermitteln, das klappt..und der codeauszug zuletzt ist nur zum testen, weil ich auch die ersten n primzahlen haben will..und dabei klemmts
also die pz von 1-100(zb) läuft,
die ersten (zb100) pz läuft - bis zur 467,468(234*2) wird als primzahl geadded...und da find ich den fehler nicht..also 468,470,474
klar 0,1 muss ich dann später noch rauskicken..
 

Flown

Administrator
Mitarbeiter
Ich habe mir deinen Algorithmus ehrlich gesagt nicht angesehen, da es bei mir Schmerzen in den Augen hervorruft, aber es sieht so aus als ob du ein Sieb des Eratosthenes programmieren wolltest.
Hier mal mein Vorschlag:
Java:
import java.util.Arrays;

public class PrimeUtils {
  
  public static void main(String... args) {
    System.out.println(Arrays.toString(PrimeUtils.getPrimesTo(100)));
    System.out.println(Arrays.toString(PrimeUtils.getNPrimes(100)));
  }
  
  public static int[] getNPrimes(int n) {
    int[] primes = new int[n];
    int primeCount = 0;
    for (int i = 2; primeCount < n; i += i == 2 ? 1 : 2) {
      if (isPrime(i)) {
        primes[primeCount++] = i;
      }
    }
    return primes;
  }
  
  public static int[] getPrimesTo(int n) {
    int[] primes = new int[n];
    int primeCount = 0;
    for (int i = 2; i < n; i += i == 2 ? 1 : 2) {
      if (isPrime(i)) {
        primes[primeCount++] = i;
      }
    }
    return Arrays.copyOf(primes, primeCount);
  }
  
  public static boolean isPrime(int n) {
    if (n < 2) {
      return false;
    }
    final int sqrt = (int) (Math.sqrt(n) + 1);
    for (int i = 2; i < sqrt; i += i == 2 ? 1 : 2) {
      if (n % i == 0) {
        return false;
      }
    }
    return true;
  }
}
 
M

marlo

Gast
lies bitte noch mal meinen eingangspost...ich will java lernen - seit 1 woche...
dann überleg mal, ob du nach 1 woche deinen code verstehen würdest - ohne erklärungen..
und komplett alles neucoden hilft mir jetzt nicht wirklich weiter - ich will ja den fehler finden..
schön coden kann ich, wenn ich schön coden kann..
jetzt bin ich froh, dass das was ich will zum grössten teil klappt..
verstehst was ich meine?
danke für deinen code, aber
es hilft mir nichts, wenn ein anderer code da ist, denn ich will ja den fehler in meinem finden und verstehen, warum das ein fehler ist und dann beheben.
erstmal das ziel erreichen und den weg verstehen, dann lernen, wie ich es optimieren kann..
mfg martin
 

VfL_Freak

Top Contributor

Jardcore

Top Contributor
Quintessenz aus Flowns Aussage ist, wenn du nur Primzahlen in der Liste haben möchtest, dann füge auch nur welche hinzu, statt sie hinterher raus zu schmeißen.
 

Flown

Administrator
Mitarbeiter
lies bitte noch mal meinen eingangspost...ich will java lernen
Ich habe deinen Eingangspost gelesen. Du hast schon mal Progammiererfahrung gesammelt und kennst grundsätzliche Sachen. Hab ich verstanden.
- seit 1 woche...
dann überleg mal, ob du nach 1 woche deinen code verstehen würdest - ohne erklärungen..
Ich weiß nicht wie intensiv du dich mit Java in einer Woche beschäftigt hast, aber nachdem du ja mit RegEx, Listen usw. herumhantierst hätte ich mehr erwartet.
Zwecks der Erklärung: Google oder frag doch einfach was du nicht verstehst?! Oder ist das aus der Mode?
und komplett alles neucoden hilft mir jetzt nicht wirklich weiter - ich will ja den fehler finden..
Manchmal hilft es, wenn man alles über Board wirft und noch mal von Neuem beginnt. Denn deinen Code den du gepostet hast zu verstehen dauert länger, als ihn ordentlich zu coden.
jetzt bin ich froh, dass das was ich will zum grössten teil klappt..
verstehst was ich meine?
danke für deinen code, aber
es hilft mir nichts, wenn ein anderer code da ist, denn ich will ja den fehler in meinem finden und verstehen, warum das ein fehler ist und dann beheben.
Weißt du überhaupt den Grund warum das es den "kleinen" Fehler gibt?
erstmal das ziel erreichen und den weg verstehen, dann lernen, wie ich es optimieren kann..
Ist der falsche Ansatz mMn. Du solltest erst dein Problem verstehen, eine Lösung/Algorithmus entwickeln und dann zu Code verarbeiten - evtl. auch noch optimieren. Nicht umgekehrt!
 
M

marlo

Gast
hallo flown, ich hatte ursprünglich deinen letzten beitrag kommentiert, aber ich lass mal meine kommentare auf deine zitate weg.zitate sprechen so für sich ;)
bin baujahr 66, habe in den 90er mal mit basic/vb gespielt, it-kaufmann gelernt, und seit fast 20 jahren nichts mehr mit der materie zu tun gehabt.
wie gesagt im ersten posting - absoluter neuling in java..ich hab erst letzten montag entschieden, dass ich jetzt java lernen will ^^
beim stöbern im web fand ich noch ne regex zur feststellung der primzahlen da versteh ich allerdings noch weniger ^^
dynamisches array..wenn die ersten x-Primzahlen ausgegeben werden sollen..hab schon gefunden, dass arraylist gehen soll..aber wie bau ich das jetzt in schleifen
Ich weiß nicht wie intensiv du dich mit Java in einer Woche beschäftigt hast, aber nachdem du ja mit RegEx, Listen usw. herumhantierst hätte ich mehr erwartet.
Zwecks der Erklärung: Google oder frag doch einfach was du nicht verstehst?! Oder ist das aus der Mode?
hallo flown danke für deine antwort.
ich versteh kein wort ^^
Ist der falsche Ansatz mMn. Du solltest erst dein Problem verstehen, eine Lösung/Algorithmus entwickeln und dann zu Code verarbeiten - evtl. auch noch optimieren. Nicht umgekehrt!
nur das noch:
wir sind da ja konform.
problem -anzahl n primzahlen ermitteln.
algorithmus entwickeln, coden und dann stellt man fest - huch da ist ein denkfehler drin..darum geht es..ob mein code jetzt schön ist oder nicht, völlig wurst. solange das problem - die aufgabenstellung-erfüllt wird.aber der fehler mit den 3 falschausgaben ..dass es 1000 verschiedene wege gibt ist unstrittig.
und man, je mehr man gelernt hat auch mehr möglichkeiten kennt - ohne frage.
ich will nicht nur wissen wie es klappt, sondern AUCH warum es nicht klappt..sonst könnt ich mir auch die millionen beispiele aus den diversen webangeboten mit copy&paste in meinen code einfügen und mich freuen.
aber schliessen wir an dieser stelle mal unseren dialog.
mfg martin
 

Jardcore

Top Contributor
Es geht immer darum, das der Code "schön" (wartbar) ist. Schöner Code hilft Probleme schnell zu finden.
Das heißt, wenn dein Code manchmal nicht das macht was er soll, sollte man versuchen den Code so zu strukturieren, dass man ihn schnell begreift.
Und zur Not kann man auch den Debugger benutzten und Step für Step durch den Code gehen. Wenn man das Problem dann gefunden hat, kann man den Code drum herum wieder "schön" machen :)
 
M

marlo

Gast
hallo jardcore, danke für deinen beitrag.
an dieser stelle auch noch n dank an klaus weiter oben.
Es geht immer darum, das der Code "schön" (wartbar) ist. Schöner Code hilft Probleme schnell zu finden.
also ohne regex oder wie hiess das noch? boolesche operatoren? ;)
Das heißt, wenn dein Code manchmal nicht das macht was er soll, sollte man versuchen den Code so zu strukturieren, dass man ihn schnell begreift.
Und zur Not kann man auch den Debugger benutzten und Step für Step durch den Code gehen. Wenn man das Problem dann gefunden hat, kann man den Code drum herum wieder "schön" machen :)
is schon klar. ich arbeite dran...hab wieder alles gelöscht und bau neu.
da mein ursprünglicher lösungsweg ja 3 fehler ausgab...warum auch immer...ich geb jedenfalls erst ruhe, wenns läuft..naja vorher poste ich hier aber auch nix mehr glaub ich..wenn ok, dann schick ich dir dann mal den code im private..
mfg martin
 

Jardcore

Top Contributor
Das hilft leider niemanden außer dir, es wäre schön wenn die Endlösung auch hier stehen würde. Wenn man deutschen JavaCode sucht verweist Google zu 98% auf java-forum.org.

Btw. kann man schön auf https://www.compilejava.net/ den Code von Flown testen, einfach dort einfügen und schauen was passiert. Vielleicht wäre es auch hilfreich, wenn du den Code von Flown analysierst.
Bei Fragen zum Verständnis der JavaSyntax, kannst du gerne hier die Fragen stellen.
 
M

marlo

Gast
hallo jardcore, klar hab ich den code von flown probiert..hab ja auch als mann 1 x-chromosom und bin deshalb neugierig. der klappt wunderbar..
for (int i = 2; i < n; i += i == 2 ? 1 : 2) { // --???? regex? versteh nur die hälfte glaub ich..
// int i = 2; i < n; i += i dürfte zum hochzählen sein
if
(isPrime(i)) { // ---da wird wohl auf true/false geprüft..oder?
primes[primeCount++] = i;
 

Jardcore

Top Contributor
Ich muss zugeben, das ist bisschen technisch gewählt. Das würde bei uns kein Review überleben.
i == 2 ? 1 : 2 ist die Kurzschreibweise für eine If-Bedigung.
Java:
for (int i = 2; i < n; i += i == 2 ? 1 : 2) {
}
// das gleiche wie
for(int i = 2; i < n; i += getIncreaseValue(i)) {
}

// "wert += 1" ist die Kurzschreibweise für "wert = wert + 1"

// kurzschreibweise in methode ausgelagert.
private int getIncreateValue(int i) {
    if(i == 2) {
        return 1;
    }
    return 2;
}

isPrime().. ist eine Methode die Flown eingeführt hat um den Code ein wenig leserlicher zu gestallten.
Sie gibt zurück ob die Zahl i eine Primzahl ist oder nicht.
Java:
      if (isPrime(i)) {
    // hier wird in das Array primes an der Stelle primeCount der Wert i hineingeschrieben. Dann wird
    // primeCount um 1 erhöht.
        primes[primeCount++] = i;
      }
 

Flown

Administrator
Mitarbeiter
Ich habe mich jetzt an deinem Programm versucht und kann nicht nachvollziehen, was du machen möchtest, darum kann ich dir auch deinen "kleinen" Fehler nicht benennen. Aber was du entwickelt hast, nennt sich Sieb des Eratosthenes und ich würde dir raten erst mal die Grundlagen verstehen (evtl. auch mal Wikipedia: HIER nachschlagen) und dann drauf loszulegen. Ich hab dir da mal was zurechtgelegt und kannst es vielleicht als Muster nehmen, denn beide Programme verfolgen den selben Gedanken. Bei Unklarheiten bitte Fragen:
Java:
import java.util.Arrays;

public class EratostheneSieve {
  public static void main(String... args) {
    EratostheneSieve sieve = new EratostheneSieve();
    System.out.println(Arrays.toString(sieve.getNPrimes(100)));
  }
  
  private int m = 10;
  private static final int FACTOR = 10;
  private int[] primes;
  
  public int[] getNPrimes(int n) {
    if (primes == null) {
      primes = sieve(m);
    }
    while (primes.length < n) {
      m *= FACTOR;
      primes = sieve(m);
    }
    return Arrays.copyOf(primes, n);
  }
  
  private int[] sieve(int n) {
    int[] prime = new int[n];
    int nrOfPrimes = 0;
    boolean[] isNotPrime = new boolean[n];
    int i;
    for (i = 2; i * i < n; i++) {
      if (!isNotPrime[i]) {
        prime[nrOfPrimes++] = i;
      }
      for (int j = i * i; j < n; j += i) {
        isNotPrime[j] = true;
      }
    }
    for (i++; i < n; i++) {
      if (!isNotPrime[i]) {
        prime[nrOfPrimes++] = i;
      }
    }
    
    return Arrays.copyOf(prime, nrOfPrimes);
  }
}
 
M

marlo

Gast
habs fertig
Java:
ArrayList<Integer> l = new ArrayList<Integer>();
 n=500;
 a=2;
 while (l.size()!=n)      // so wird anzahl ermittelt // while a<n  ermittelt die zahlen von 2 bis zb 10
 {
 bolteilbar=false;
 for(int i = 0; i < l.size(); i++) // listeninhalt wird durchlaufen und variable
 {                                 // a wird auf modulo mit listinhalt geprüft
  if (a%l.get(i)==0)
  {
      bolteilbar=true;              //zu adende variable a ist durch listeinhalt teilbar
      break;                        //verlassen der prüfschleife
 }
 }
 if (bolteilbar==false)             //wenn zu addende a nicht durch liste teilbar
 {
     l.add(a);                      //adde a zur liste
 }
 a++;                               //hochsetzen der zu addenden variable
}
System.out.println(l);        // hier ist die ausgabe mies, kann man das formattieren?so dass es mit
                                        //zeilenumbruch ausgegeben wird? die reihenausgabe wird bei 1000 zahlen
                                        //eng
}
}
hoffe die kommentierung hilft beim nachvollziehen
mfg martin
der fehler bei der alten version müsste daran liegen, dass nach dem rauskicken der teilbaren zahlen die nächst höhere von size geadded wurde und a hochgezählt..habs jetzt nicht mehr um zu prüfen aber da kann ich mir ein überspringen der zu testenden zahlen vorstellen.
 
Zuletzt bearbeitet von einem Moderator:
Ähnliche Java Themen
  Titel Forum Antworten Datum
iAmFaiinez Primzahlen Tester ohne Array Java Basics - Anfänger-Themen 4
sserio Wieso werden nicht alle Primzahlen bis 1000 in meine Liste gepackt ? Java Basics - Anfänger-Themen 8
B Primzahlen bis 100 addieren Java Basics - Anfänger-Themen 16
H Primzahlen finden - Zeit optimieren Java Basics - Anfänger-Themen 34
S Primzahlen in Array ausgeben Java Basics - Anfänger-Themen 14
M Array auf Primzahlen prüfen Java Basics - Anfänger-Themen 7
D Primzahlen Rechner nach Eratostenes von Kyrene Algorithmus Java Basics - Anfänger-Themen 2
fendix Compiler-Fehler Algorithmus zur Bestimmung von Primzahlen Java Basics - Anfänger-Themen 7
P Methode die ausgibt wie viele Primzahlen es zwischen 2 und n gibt Java Basics - Anfänger-Themen 10
G Primzahlen von Rekursiv nach Iterativ Java Basics - Anfänger-Themen 6
M Rekursives Programm zum Anzeigen von Primzahlen Java Basics - Anfänger-Themen 3
P Primzahl mit Angabe der höchsten Primzahl und Angabe der Anzahl von Primzahlen bis 100 Java Basics - Anfänger-Themen 8
Java The Hutt Primzahlen - die ersten 100 Java Basics - Anfänger-Themen 17
N Erste Schritte Primzahlen-ArrayIndexOutOfBounds Java Basics - Anfänger-Themen 23
R Primzahlen Zähler Programm / Benachbarte Primzahlen Java Basics - Anfänger-Themen 30
D Klassen Primzahlen überprüfen Java Basics - Anfänger-Themen 3
I Primzahlen Java Basics - Anfänger-Themen 17
Z Rekursion Primzahlen Java Basics - Anfänger-Themen 1
S Primzahlen berechnen funktioniert nicht richtig Java Basics - Anfänger-Themen 1
R primzahlen im array Java Basics - Anfänger-Themen 33
M Primzahlen, nur jede 2te ausgeben Java Basics - Anfänger-Themen 11
T Primzahlen Fehler Java Basics - Anfänger-Themen 4
K Primzahlen Java Basics - Anfänger-Themen 6
L Primzahlen im Array ausgeben Java Basics - Anfänger-Themen 3
P Primzahlen Java Basics - Anfänger-Themen 3
A Methoden Primzahlen erstellen von 1 bis 100-Codeprobleme Java Basics - Anfänger-Themen 2
H Variablenverfolgung - Primzahlen Java Basics - Anfänger-Themen 7
G Primzahlen Java Basics - Anfänger-Themen 6
D Primzahlen und Rekursive Liste Java Basics - Anfänger-Themen 29
S Primzahlen bis 1000 ausgeben Java Basics - Anfänger-Themen 3
K Methoden Primzahlen Java Basics - Anfänger-Themen 33
S Input/Output Primzahlen Datenbank Java Basics - Anfänger-Themen 11
F Primzahlen in Zahlenblöcken ausgeben Java Basics - Anfänger-Themen 9
M Primzahlen - es werden alle Nicht-Primzahlen ausgegeben Java Basics - Anfänger-Themen 5
M primzahlen Java Basics - Anfänger-Themen 4
S Programm zu Ermittlung von Primzahlen Java Basics - Anfänger-Themen 14
E Programm zum Primzahlen ausgeben-Fehler Java Basics - Anfänger-Themen 12
X Primzahlen Java Basics - Anfänger-Themen 7
S Primzahlen Java Basics - Anfänger-Themen 12
B Programmierobjekt - Primzahlen Java Basics - Anfänger-Themen 2
D Primzahlen ausgeben. Wo liegt der Fehler? Java Basics - Anfänger-Themen 4
N Primzahlen Java Basics - Anfänger-Themen 5
I Primzahlen check, String prüfen lassen. Java Basics - Anfänger-Themen 6
A OOP Programm zum bestimmen von Primzahlen, OutofBoundsException Java Basics - Anfänger-Themen 10
apple987123 Primzahlen Java Basics - Anfänger-Themen 12
A Primzahlen: ein paar offene Fragen Java Basics - Anfänger-Themen 2
T Primzahlen Java Basics - Anfänger-Themen 6
G Primzahlen Java Basics - Anfänger-Themen 18
B Primzahlen berechnen - Wieso unterschiedliche Java Basics - Anfänger-Themen 3
B Primzahlen Algorithmus - wo ist der Fehler ? Java Basics - Anfänger-Themen 2
E Primzahlen Java Basics - Anfänger-Themen 5
B Primzahlen mit Array errechnen! Java Basics - Anfänger-Themen 13
H Miller Rabin Test Primzahlen werden teilweise nicht gefunden Java Basics - Anfänger-Themen 5
M Wer kann mir bei Primzahlen helfen ? Java Basics - Anfänger-Themen 4
G Frage zur Primzahlen berechnung Java Basics - Anfänger-Themen 11
kulturfenster Primzahlen berechnen Java Basics - Anfänger-Themen 11
D Primzahlen Java Basics - Anfänger-Themen 4
N Zerlegung in Primzahlen Java Basics - Anfänger-Themen 7
F Programm Primzahlen Java Basics - Anfänger-Themen 5
J Primzahlen errechnen.ArrayLists abgleichen Java Basics - Anfänger-Themen 2
M Primzahlen Java Basics - Anfänger-Themen 6
C Primzahlen Java Basics - Anfänger-Themen 7
C Primzahlen Java Basics - Anfänger-Themen 2
S Primzahlen Java Basics - Anfänger-Themen 49
F wie kann ich die Position des letzten Vokals innerhalb einer Zeichenkette ermitteln? Java Basics - Anfänger-Themen 5
S Bildgröße ermitteln & setSize() übergeben Java Basics - Anfänger-Themen 6
B Anzahl Nullen uns Einsen in String ermitteln Java Basics - Anfänger-Themen 3
R Hangman-Spiel-zufälliges Wort ermitteln Java Basics - Anfänger-Themen 4
H Häufigkeit von Zahlen ermitteln Java Basics - Anfänger-Themen 23
H Palindrom ermitteln Java Basics - Anfänger-Themen 21
J Datum ermitteln ? Java Basics - Anfänger-Themen 14
M Beliebtesten Film ermitteln Java Basics - Anfänger-Themen 6
C Größte Zahl aus einem Array ermitteln(als statische Methode) Java Basics - Anfänger-Themen 31
H Bei forEach Index des Elements ermitteln Java Basics - Anfänger-Themen 17
B DHCP-Server Adresse ermitteln Java Basics - Anfänger-Themen 4
hello_autumn Klassen Anzahl sowie die Anzahl der Junit Tests ermitteln? Java Basics - Anfänger-Themen 8
J Ein Wort aus einer Datei zufällig ermitteln Java Basics - Anfänger-Themen 3
V Erste Schritte Potenzen b^n mittels Schleife ermitteln Java Basics - Anfänger-Themen 7
B Anzahl von Stunden / Tage von zwei Datumswerten ermitteln Java Basics - Anfänger-Themen 1
C Laufzeit eines Sortier-Algorithmus ermitteln Java Basics - Anfänger-Themen 4
O 2 Maximalwerte und Minimalwerte aus Array ermitteln Java Basics - Anfänger-Themen 9
L Fortschritt ermitteln Java Basics - Anfänger-Themen 18
N Erste Schritte HSV color space - schwarz und weiß nur anhand von Saturation oder Multiplikator ermitteln Java Basics - Anfänger-Themen 14
N Wahrscheinlichkeiten ermitteln Java Basics - Anfänger-Themen 2
L Objekt Typ zur Laufzeit ermitteln Java Basics - Anfänger-Themen 1
J Schwierigkeitsgrad eines Wortes mit Morsecode ermitteln Java Basics - Anfänger-Themen 18
J Best Practice Datum Differenz aus zwei Strings ermitteln Java Basics - Anfänger-Themen 8
G Größten und kleinsten Wert im Array ermitteln? Java Basics - Anfänger-Themen 7
G Wie kann ich diesen Wert ermitteln? Java Basics - Anfänger-Themen 4
T Rekursiv Tiefe eines binären Suchbaums ermitteln Java Basics - Anfänger-Themen 22
D Maximale Teilsumme ermitteln Java Basics - Anfänger-Themen 6
MiMa Jüngstes Datum ermitteln Java Basics - Anfänger-Themen 4
S Compiler-Fehler im array Maximum ermitteln Java Basics - Anfänger-Themen 6
V Querprodukt ermitteln Java Basics - Anfänger-Themen 6
L Array: Summe aller geraden und ungeraden Zahlen ermitteln Java Basics - Anfänger-Themen 9
Joew0815 Int to string und primzahle ermitteln Java Basics - Anfänger-Themen 2
F Jalousie Positionen ermitteln Java Basics - Anfänger-Themen 4
C Klassen aus einem Package ermitteln und per Laufzeit laden Java Basics - Anfänger-Themen 17
C Datei mit Daten einlesen und höchsten wert der zweiten Spalte ermitteln Java Basics - Anfänger-Themen 1
L Aus Datum Millisekunden ermitteln ohne Zeitzonen-Berücksichtigung Java Basics - Anfänger-Themen 6

Ähnliche Java Themen

Neue Themen


Oben