# Primzahlen



## stormtide (9. Sep 2004)

Wieder mal ein dickes Problem...
Diesmal ist die Aufgabenstellung, alle Primzahlen bis zu einem definierten Wert rauszusuchen.
Im Beispiel ist dieser Wert 10000.
Als Prinzip gilt:
2 Wird zuerst ins Array abgelegt, sozusagen als Basis für alles.
Jede weitere Zahl wird geprüft, ob sie durch irgendeine Zahl im Array teilbar ist.
Ist dies nicht der Fall, ist es eine Primzahl und kommt auch in's Array.
Was habe ich übersehen?


```
public class primzahl
{
public static void main(String[] args)
	{
		// Deklaration der Konstanten ANZAHL
		final int ANZAHL=100000;	// Anzahl der zu durchsuchenden Primzahlen
		
		// Definition der Variablen
		int[] prim=new int[ANZAHL];	// Array zur Speicherung der Primzahlen
		int temp;			// Speichert den Rest der Berechnugn als Zwischenwert
		int i;				// Zähler 1
		int j;				// Zähler 2
		
		// 2 als Basis in PRIM[0] schreiben
		prim[0]=2;
		
		// Primzahlen rausfiltern
		for (i=3; i<=ANZAHL; i++) {
			for (j=0; j<=ANZAHL; j++) {
				temp = i % prim[j];
				if (temp == 0) {
				
				}else{
					prim[j+1]=i;
				}
			}
		}
		
		// Ausgabe der Primzahlen
		for (i=0; i<=ANZAHL; i++) {
			System.out.print (prim[i]);
		}
	}
}
```


----------



## Beni (9. Sep 2004)

falls _sqrt( prim[j] ) > i_ ist, kanns du abbrechen. (Wieso? Selber rätseln :wink: :bae: )


----------



## stormtide (9. Sep 2004)

zeile 20...
ich weiss was du meinst...
aber hast du auch eine idee wie ich mein programm wenigstens so zum laufen bringen kann, dass es die primzahlen bis 10000 sucht?


----------



## meez (9. Sep 2004)

Warum so kompliziert...?
Hier:


```
public class primzahl {	
	public static void main(String[] args) {
		boolean isprim;
		for (int n=2;n<=10000;n++) {
  			isprim = true;
  			for (int i=2;i<n;i++) {
   	 			if ((n % i) == 0) {
       					isprim = false;
       					break;    
    				}  
  			}
   			if (isprim)
     				System.out.println(n);     
		}
	}
}
```


----------



## foobar (9. Sep 2004)

```
import java.util.*;
import java.util.Vector;
public class Prim
{
	private int amount;
	private Vector prims;
	public Prim(int amount)
	{
		this.amount = amount;
		this.prims = new Vector();
		this.compute();
		this.showOutput();
	}
	
	private void compute()
	{
		for (int i = 2; i < this.amount; i++)
		{
			if (isPrim(i))
			{
				this.prims.add(new Integer(i));
			}
		}
	}
	
	private boolean isPrim(int value)
	{
		for (int i = 2; i < value-1;i++)
		{
			if (value % i == 0) return false; 
		}
		return true;
	}
	
	private void showOutput()
	{
		Iterator it = prims.iterator();
		while (it.hasNext())
		{
			System.out.println(">>" + it.next());
		}
	}
```


----------



## stormtide (9. Sep 2004)

öhm danke...
aber kannst du mir mal grob sagen, was dein tool genau macht?
verstehe den sinn hinter "ispirim" nicht ganz...


----------



## meez (9. Sep 2004)

Meinst du meine Var oder foobars Methode?


EDIT: Ich kanns ja mal sagen...
isprim wird auf true gesetzt...soweit klar...Danach wird für die Zahl, welche gerade an der Reihe ist (Zähler n) getestet, ob sie nur durch sich selbst teilbar ist...Wenn nicht, wird isprim auf false gesetzt und die Zahl wird nicht angezeigt.

EDIT2: Manchmal ist es einfacher ein Resultat zu wiederlegen, als zu beweisen, dass es stimmt..


----------



## stormtide (9. Sep 2004)

deine meez


----------



## meez (9. Sep 2004)

Siehe letztes Post...


----------



## foobar (9. Sep 2004)

Meine Methode isPrim macht genau das selbe, wie folgender Code von meez:

```
if ((n % i) == 0) 
{
   isprim=false;
   break;
}
```
Ein Wert wird durch alle seine Vorgänger modulo Dividiert. Wenn das Ergebnis 0 ist , wird die Methode verlassen, denn es kann keine Primzahl sein. Wird das Ende der For-Schleife erreicht wird true zurück gegeben. Also ist es eine Primzahl.


----------



## guenni81 (9. Sep 2004)

Hier, deins nochmal ein wenig abgeändert...

```
public class primzahl
{
	public static void main(String[] args)
   {
	      // Deklaration der Konstanten ANZAHL
	      final int ANZAHL=100;   // Anzahl der zu durchsuchenden Primzahlen
	      
	      // Definition der Variablen
	      int[] prim=new int[ANZAHL];   // Array zur Speicherung der Primzahlen
	      int temp;         // Speichert den Rest der Berechnugn als Zwischenwert
	      int i;            // Zähler 1
	      int j=1;            // Zähler 2
	      int ArrayCounter = 2;
	      int restWert = 0;
	      boolean primzahl = true;
	      
	      prim[0] = 1;
	      prim[1] = 2;
	      prim[2] = 3;
	      
	      // Primzahlen rausfiltern
	      for (i=3; i<=ANZAHL; i++)
	      {
	      	while(j <= ArrayCounter )
	        {
	        	restWert = i % prim[j];
	        	if(restWert >= 1)
	        		primzahl = true;
	        	else
	        	{
	        		primzahl = false;
	        		break;
	        	}
	        	j++;	        	
	        }
	        
	        if(primzahl == true)
	        {
	        	ArrayCounter++;
	        	prim[ArrayCounter] = i;
	        }
	        j = 1;
	      }
      
	      // Ausgabe der Primzahlen
	      for (i=0; i<=ArrayCounter; i++)
		  {
	      	System.out.println("Primzahl: " + prim[i]);
		  }
	   }
	}
```


----------



## foobar (9. Sep 2004)

Bitte deklariert eure Variablen immer nur dort, wo ihr sie auch braucht und nicht 20 Zeilen darüber.

```
for (int i=0; i<=ArrayCounter; i++)
{
     System.out.println("Primzahl: " + prim[i]);
}
```
Das macht das ganze viel leichter zu debuggen.


----------



## meez (9. Sep 2004)

foobar hat gesagt.:
			
		

> Bitte deklariert eure Variablen immer nur dort, wo ihr sie auch braucht und nicht 20 Zeilen darüber.


Für diesen Satzt hätte dich mein ehemaliger Prof gelyncht...
Das kommt halt noch von Pascal...


----------



## foobar (9. Sep 2004)

> Für diesen Satzt hätte dich mein ehemaliger Prof gelyncht...
> Das kommt halt noch von Pascal..


Warum? Wo soll da der Vorteil sein?


----------



## guenni81 (9. Sep 2004)

Der Vorteil ist, dass ich alle Variablen am Anfang der Methode anschauen kann und mich nicht erst durch den Quellcode quälen muss um herauszufinden wo die Variable deklariert wurde.


----------



## stormtide (9. Sep 2004)

Zurück zum Thema:
Ich habe meinen Code nun gemäss Beispiel angepasst.
Weiss jetzt echt nicht mehr warum's nicht geht...
Bitte kompiliert mal, vielleicht weiss es ja jemand...

```
public class primzahl {
	public static void main(String[] args) {
		
		// Definition der Konstanten Anzahl
		final int ANZAHL=10000;
		
		// Definition der Variablen
		int[] prim = new int[ANZAHL];	// Enthält die Primzahlen
		int i;							// Zähler 1
		int j;							// Zähler 2
		int k;							// Zähler 3
		boolean test;					// Primzahl oder nicht
		
		// 2 als Basis in prim[0] schreiben
		prim[0] = 2;
		
		// Primzahlen suchen
		for (i=3; i<=ANZAHL; i++) {
			test = true;
			for (j=0; j<=ANZAHL; j++) {
				if (i % prim[j] == 0) {
					test = false;
				}
			}
			if (test = true) {
				prim[j+1] = i;
			}
		}
		
		// Ausgabe der im Array gespeicherten Primzahlen
		for (k=0; k<=ANZAHL; k++) {
			System.out.print (prim[k]+", ");
		}
	}
}
```
Bitte bezieht jetzt alle Statemênts zu diesem Code...


----------



## foobar (9. Sep 2004)

guenni81 hat gesagt.:
			
		

> Der Vorteil ist, dass ich alle Variablen am Anfang der Methode anschauen kann und mich nicht erst durch den Quellcode quälen muss um herauszufinden wo die Variable deklariert wurde.


Das mag bei 50 Zeilen vielleicht noch funktionieren, aber wenn du mal ein etwas größeres Programm mit > 1000 Zeilen schreibst, kommst du mit dieser Methode in Teufelsküche. Hast du schon mal was von Scope(Gültigkeitsbereich) gehört? Wähle den Scope deiner Variablen nach der goldenen Regel:
*So viel wie nötig, so wenig wie möglich*.


----------



## meez (9. Sep 2004)

Was machst du denn da für ein Durcheinander mit dem Array...
Zudem mach keine Arrays, deren Länge du nicht weisst...Nimm dafür Vectoren...
Hab das Prog mal angepasst, da es so überhaupt nicht gelaufen wär....


```
import java.util.*;
public class primzahl {
	public static void main(String[] args) {
		
		// Definition der Konstanten Anzahl
		final int ANZAHL=10000;
		
		// Definition der Variablen
		Vector prim = new Vector();
		int k;							// Zähler 3
		boolean test;					// Primzahl oder nicht
		
				
		// Primzahlen suchen
		for (int i=2; i<=ANZAHL; i++) {
			test = true;
			for (int j=2; j<i; j++) {
				if ((i % j) == 0) {
					test = false;
					break;
				}
			}
			if (test) 
				prim.add(new Integer(i));
			
		}
		
		// Ausgabe der im Array gespeicherten Primzahlen
		for (k=0; k<prim.size(); k++) 
			System.out.print (((Integer) prim.get(n)).intValue() + ", ");
		
	}
}
```


----------



## guenni81 (9. Sep 2004)

@foobar
Scope habe ich schon vom namen gehört. Wo kann man infos darüber nachlesen???

@stormtide
Hab deinen Code mal kompiliert, beim ausführen knallts dann. 
Meiner von den vorherigen Einträgen ging ohne probleme...


----------



## stormtide (9. Sep 2004)

das problem ist ebe diese dass ich keine funktionen verwenden darf, die wir im unterrich noch nicht behandelt haben. so also auch keine vectoren. niemand eine idee? ich bin fast überzeug es ist nur ein kleiner dummer fehler...


----------



## meez (9. Sep 2004)

Hab mal noch aufgeschrieben, warum dein Beispiel oben nicht läuft...
Die Aenderungen hab ich dir ja schon oben beschrieben...

```
//Du machst einen Array mit 10000 Feldern? Ziemlich sicher ist nicht jede Zahl eine Primzahl  
    int[] prim = new int[ANZAHL]; 
   
      //Du fängst bei 3 an...? Alles ab 1 kann ein Primzahl sein...
      for (i=3; i<=ANZAHL; i++) {
         test = true;
         //Du gehst immer wieder bis ANZAHL...Du willst doch aber nur durch die Zahlen teilen, 
         //welche kleiner sind, als die zu testende Zahl (i)
          for (j=0; j<=ANZAHL; j++) {
            //Warum eine Zahl aus dem Array...? Du willst doch i testen...
             if (i % prim[j] == 0) {
               test = false;
   		//Hier brauchts noch ein break, sonst lässt du das Program zuviel arbeiten...
            }
         }
         if (test = true) {
            prim[j+1] = i;
         }
      }
      //Das geht schonmal nicht, weil der ARRAY ja die Länge Anzahl hat, also Anzahl -1 
      //der höchste index ist...
      for (k=0; k<=ANZAHL; k++) {
         System.out.print (prim[k]+", ");
      }
```


----------



## meez (9. Sep 2004)

Ohne Vector:
Version 1:

```
public class primzahl {
	public static void main(String[] args) {
		
		// Definition der Konstanten Anzahl
		final int ANZAHL=10000;
		
		// Definition der Variablen
		boolean test;					// Primzahl oder nicht
		// Primzahlen suchen
		for (int i=2; i<=ANZAHL; i++) {
			test = true;
			for (int j=2; j<i; j++) {
				if ((i % j) == 0) {
					test = false;
 					break;
				}
			}
			if (test) 
				System.out.println(i);
			
		}		
	}
}
```


Oder dann halt wirklich mit einem Array:

Version 2:

```
public class primzahl {
	public static void main(String[] args) {
		
		// Definition der Konstanten Anzahl
		final int ANZAHL=10000;
                int[] prim = new int[ANZAHL];
		int c=0;

		// Definition der Variablen
		boolean test;					// Primzahl oder nicht
		// Primzahlen suchen
		for (int i=2; i<=ANZAHL; i++) {
			test = true;
			for (int j=2; j<i; j++) {
				if ((i % j) == 0) {
					test = false;
					break;
				}
			}
			if (test) 
				prim[c++] = i;
			
		}		
                for (int n=0;n<prim.length;n++)
                          System.out.println(prim[n]);
	}
}
```


----------



## foobar (9. Sep 2004)

Scope => Gültigkeitsbereich einer Variablen


----------



## meez (9. Sep 2004)

foobar hat gesagt.:
			
		

> Scope => Gültigkeitsbereich einer Variablen



Ich sage ja nichts gegen den Scope (bei z.B. Zählern) ...Aber bei mir kommts halt teilweise wirklich noch von meinen Programmieranfängen mit Pascal...Da weigert sich der Kompiler etwas zu tun, wenn du nicht alles am Anfang deklarierst...


----------



## stormtide (9. Sep 2004)

dein beispiel gibt mir alles nullen aus...


----------



## meez (9. Sep 2004)

War auch noch ein kleiner Fehler drin...


```
for (int n=0;n<c;n++)
                          System.out.println(prim[n]);
```


----------



## stormtide (9. Sep 2004)

wow! respect...
du glaubst mir gar nicht, wie unendlich dankbar ich dir dafür bin.
du hast etwas gut bei mir (nur glaube ich nicht, dass ich dir jemals gross helfen könnte...)
liebe grüsse und vielen, vielen dank!


----------



## meez (9. Sep 2004)

Gern geschehen....


----------



## Reality (9. Sep 2004)

Das erste Beispiel von dir meez finde ich gut, aber das mit den Vectoren ist schlecht, da das wrappen und ent-wrappen ziemlich viel Zeit kostet. Bei zeitaufwendigen Programmen würde ich mir eine Klasse schreiben, die native Variablen aufnehmen kann.

Liebe Grüße
Reality


----------



## foobar (9. Sep 2004)

@Reality Ich wollte mit meinem Beispiel nur zeigen wie man auf Primzahlen testen kann. Performance spielt dabei im Moment keine Rolle.


----------



## foobar (10. Sep 2004)

Hier ist das selbe Programm nochmal, diesmal ohne Vector und Wrapperklassen:

```
package demos.prim;
public class Prim2
{
	private int amount;
	private PrimitivArrayList prims;
	public Prim2(int amount)
	{
		this.amount = amount;
		this.prims = new PrimitivArrayList();
		this.compute();
		this.prims.printAll();
	}
	
	private void compute()
	{
		for (int i = 2; i < this.amount; i++)
		{
			if (isPrim(i))
			{
				this.prims.add( i );
			}
		}
	}
	
	private boolean isPrim(int value)
	{
		int max = (int)Math.sqrt(value)+1;
		for (int i = 2; i < max;i++)
		{
			if (value % i == 0) return false; 
		}
		return true;
	}
	
	
	public static void main(String[] args)
	{
		new Prim2(100000);
	}
}


class PrimitivArrayList
{
	private ListElement firstElement, lastElement;
	private int amountElements;
	public PrimitivArrayList()
	{
		this.firstElement = new ListElement(0, -1, null);
		this.lastElement = this.firstElement;
	}
	
	private ListElement getElementAt(int index, int currentpos, ListElement element)
	{
		return currentpos == index ? element : getElementAt(index, ++currentpos, element.getNext());
	}
	
	public int get(int index)
	{
		return index >= this.getSize() ? -1 : getElementAt(index, 0, this.firstElement).getValue();
	}
	
	private void print(ListElement element)
	{
		System.out.println(element.getValue());
		ListElement next = element.getNext();
		if (next != null)
		{
			print(next);
		}
	}
	
	public void add(int item)
	{
		if (firstElement.getValue() == -1)
		{
			firstElement.setValue(item);
		}
		else
		{
			ListElement newElement = new ListElement(lastElement.getPosition() + 1, item, null);
			lastElement.setNext(newElement);
			this.lastElement = newElement;
		}
		amountElements++;
	}
	
	public void printAll()
	{
		print( firstElement );
	}
	
	public int getSize()
	{
		return this.amountElements;
	}
	
	private class ListElement
	{
		private int value;
		private ListElement next;
		private int position;
		public ListElement(int position, int value, ListElement next)
		{
			this.position = position;
			this.value = value;
			this.next = next;
		}
		public ListElement getNext()
		{
			return next;
		}
		public int getValue()
		{
			return value;
		}
		public void setNext(ListElement element)
		{
			next = element;
		}
		public void setValue(int i)
		{
			value = i;
		}
		public int getPosition()
		{
			return position;
		}
		public void setPosition(int i)
		{
			position = i;
		}
		public String toString()
		{
			return this.getClass() + " position " + this.getPosition() + " value " + this.getValue();
		}
	}
}
```


----------



## R-F-E (9. Jun 2005)

kann man in java die Primzahlen auch in eine *.txt schreien lassen..

in dem DOS-Fenster kann man die ja so nicht verwenden..

so wie unter Pascal: http://pascal.philipp-bruck.de/primtext/primtext.txt (< ich weiß, dass hier SEHR viel schnickschnack mit bei ist)

P.S.: wie kann ich in Java sowas wie functionen/proceduren (sowie pascal) deklarieren? (_sind das die Klassen_)
das geht doch bestimmt in Java, oder?


----------



## Wildcard (9. Jun 2005)

Klar kann man. Einfach mit einem Writer in die Datei schreiben.
Äquivalent zu function/procedure sind Methoden.


```
public void fooBar(int blupp)
{
     while(nobodyCares())
     {
          wasteTime(blupp);
     }
}
```

Klassen sind 'Schablonen' für Objekte. Das ist 'mehr' als eine procedure/function/method


----------



## R-F-E (9. Jun 2005)

zu der text:



> Einfach mit einem Writer in die Datei schreiben.



ne für einen anfänger is das überhaupt nich einfach...
was heißt "writer" unter java?
und wie sähe das im quelltext aus?

zu den proceduren:
"public void" steht immer am anfang
dann name mit (parameter in klammern)
dann befehle..
soweit so klar

wie rufe ich die auf?
so:

```
foobar(5);
```
 :?: 

und wie mache ich das bei functionen, die eine rückgabe haben sollen?


----------



## Sky (9. Jun 2005)

R-F-E hat gesagt.:
			
		

> und wie mache ich das bei functionen, die eine rückgabe haben sollen?



public <RückgabeTyp>


```
z.b. public int getCountOfProblems()
public String getName(String vorname)
```

Aufruf:


```
int i = getCountOfProblems();
String s = getName("Fritz");
```


----------



## Wildcard (9. Jun 2005)

Gibt sehr gute Online-Bücher und Tutorials. 
Wenn du mehr brauchst schau mal in der JavaLinkBase vorbei


----------



## R-F-E (11. Jun 2005)

noch ne lösung für die primzahlen:

```
// Primzahl Programm übertragen von Pascal
//Pascal Programm programmiert von: Philipp B. (dankeschön :) )
//Datei: Prim.java

public class prim {
    int nummer;

    static boolean primtest(int zahl){
           int o = 3,r = 1;
           if (((zahl % 2) == 0) &&(zahl != 2)) r++;
           do {
              if (((zahl % o) == 0) &&(zahl != o)) r++;
              o = o+2;
           }
           while (!(o>(zahl/2 + 1) || r>1));
           if (r==1)return true;
           else return false;
    }
    
    /*public int zahlen(int maxi){
      int i,u = 0;

    }*/

    public static void main(String[] args) {
           int max = 2000;
             for ( int i = 2; i<=max; i++ ) {
               if (primtest(i)) System.out.print(i +" ");
             }
           }
}
```

aber ich finde nirgendwo infos, wie ich das jetzt in eine *.txt datei schreiben kann...


----------



## ven000m (11. Jun 2005)

Hallo,

ich habe ein sehr einfaches und schlankes Programm geschrieben, dass die Primzahlen bis zu einer eingegebenen Zahl berechnet.

Wer es noch kompakter hinbekommt, der soll auf diesen Post antworten.  :applaus: 


```
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

	/*
						 * 
						 * (c) ven000m 21:38:25 11.06.2005
						 *  
						 *  
						 *  
						 *	
						 *	Datei: Teilerberechner.java
						 *	Enthalten im Projekt: Objekte 
						 *
						 */


public class Primzahl
{
	
	
	public static void main (String args[]) throws IOException
	{
		BufferedReader din = new BufferedReader(new InputStreamReader(System.in));
		
		System.out.println("Bis wohin sollen Primzahlen errechnet werden?");
		int hoechstgrenze=Integer.parseInt(din.readLine());
		
		boolean teilbar=false;
		
		for(int i=1;i<hoechstgrenze;i++)
		{
			for(int g=2;g<i;g++) {
			if((i%g)==0)
			teilbar=true; }
			
			if(teilbar==false)
			System.out.print(+i+",");			
			teilbar=false; 	
	
		
		
  	}	
	
}
```


----------



## Guest (11. Jun 2005)

ven000m hat gesagt.:
			
		

> Wer es noch kompakter hinbekommt, der soll auf diesen Post antworten.  :applaus:




```
public class Primzahl {
    public static void main(String[] args) throws Exception {
        int hoechstgrenze = Integer.parseInt(args[0]);
        for (int i = 2; i < hoechstgrenze; i++) {
            int r = (int) Math.sqrt(i) + 1;
            for (int g = 2; g <= r; g++) {
                if ((i % g) == 0) {
                    System.out.println(i + ", ");
                    break;
                }
            }
        }
    }
}
```


----------



## ven000m (11. Jun 2005)

Hallo,

naja 7 Zeilen genau wie mein Programm.

Enger schreiben != kompakter. Aber verständlicher find ich es nicht mit der SquareRoot.


----------



## Guest (11. Jun 2005)

ven000m hat gesagt.:
			
		

> Aber verständlicher find ich es nicht mit der SquareRoot.


Egal. Wenn man das nicht versteht, sollte man eh lieber bei McDonald's arbeiten. Ein wenig Optimierung muss einfach sein.


----------



## ven000m (11. Jun 2005)

lol Laberbacke, toller Vergleich :noe: .

Du hast wahnsinnig optimiert 97% deines Codes sind bei mir schon ausgeschrieben. Wie gesagt, enger schreiben != kompakter. Aber halt dich daran nicht auf, er ist nicht soviel anders kleiner.


----------



## Guest (11. Jun 2005)

ven000m hat gesagt.:
			
		

> lol Laberbacke, toller Vergleich :noe: .
> 
> Du hast wahnsinnig optimiert 97% deines Codes sind bei mir schon ausgeschrieben. Wie gesagt, enger schreiben != kompakter. Aber halt dich daran nicht auf, er ist nicht soviel anders kleiner.



1. bin ich nicht klein (1,90m)
2. hat dein Code mehr als 7 Zeilen
3. ja, er ist relativ zu deinem wahnsinnig optimiert, weil du auch in der inneren Schleife trotz Primzahlfund immer weiter testest. Und dann kommt noch die Sache mit der Quadratwurzel.

6, setzen!


----------



## ven000m (11. Jun 2005)

Trotz Primzahlfund immer weiter testest?

Meinst du das:

```
if((i%g)==0) 
         teilbar=true; }
```

Eine Primzahl kann man nicht "finden" höchstens berechnen, indem du alle Teiler berechnest und wenn dann eine Zahl nicht mehr teilbar ist, dann ist das die Primzahl.

Deshalb muss man immer alle Zahlen durchgehen. Ich glaube du verstehst meine Bool Variablen falsch. Jetzt komm nicht mit "break" dann hätte ich wieder eine Zeile mehr. Du hast höchstens 1 Zeile weniger vom Core Code.

Ich habe übrigens 7 Zeilen, für deine 6 bleib mal ganz locker kleiner.



```
for(int g=2;g<i;g++) {
			if((i%g)==0)
			teilbar=true; break; }
			
			if(teilbar==false)
			System.out.print(+i+",");			
			teilbar=false;
```


----------



## Wildcard (12. Jun 2005)

Anstatt sich hier zu streiten wessen Code eine Zeile kürzer ist (was mit Nichten für guten Code spricht, sondern meistens auf das Gegenteil hindeutet) solltet ihr lieber mal am Algorithmus arbeiten. Warum gerade Zahlen testen, nur bis zur Wurzel der Zahl testen usw.
Wenn man Primzahlen bis zu einer Oberschranke berrechnet ist sogar der simple Sieb der Eratosthenes wesentlich geeigneter als hier mit Brute-Force ran zu gehen. :meld: 
Insofern ist IMHO keiner von euch beiden in der Position hier einen Streit vom Zaun zu brechen.


----------



## R-F-E (13. Jun 2005)

Wildcard hat gesagt.:
			
		

> Anstatt sich hier zu streiten wessen Code eine Zeile kürzer ist (was mit Nichten für guten Code spricht, sondern meistens auf das Gegenteil hindeutet) solltet ihr lieber mal am Algorithmus arbeiten.



sehe ich auch so...
oder ihr könntet mir helfen, wie ich die Primzahlen in eine *.txt datei schreiben kann...

das trägt zwar nicht unbedingt dem algorithmus bei, aber es ist benutzerfreundlicher...
denn wenn ich mit den primzahlen von 2-2000 brauche, um mit denen weiterzurechnen hilft es mir reichlich wenig die im DOS-Fenster zu sehen...


----------



## Wildcard (13. Jun 2005)

Wenn du mit denen nur weiterrechnen willst währe es Blödsinn sie in eine Datei zu schreiben  :bahnhof:


----------



## messi (13. Jun 2005)

```
try {
    Writer writer = new OutputStreamWriter(new FileOutputStream("primzahlen.txt"));
    for (int i = 2; i <= 2000; i++) {
        if (isPrim(i)) {
            writer.write(Integer.toString(i));
            writer.write("\r\n");
        }
    }
    writer.close();
} catch (IOException e) {
    e.printStackTrace(System.err);
}
```

Setzt voraus, daß es eine Methode *boolean isPrim(int)* gibt.


----------



## R-F-E (13. Jun 2005)

Wildcard hat gesagt.:
			
		

> Wenn du mit denen nur weiterrechnen willst währe es Blödsinn sie in eine Datei zu schreiben  :bahnhof:



jaa du hast ja recht...

aber halt zum weiterverwenden...
z.B. wenn ich die Liste brauche...
ich kann ja nich die Primzahlen von 2-2000 aus dem Dos-Fenster abschrieben...

zum weiterverwenden wäre eine array das beste, oder?

auf jeden fall: danke


----------



## messi (13. Jun 2005)

R-F-E hat gesagt.:
			
		

> zum weiterverwenden wäre eine array das beste, oder?


Klar! Den kannst du auch gleich beim Primzahltest verwenden. Dann prüfst du nicht jeden Teiler, sondern nur die Primteiler. Am Ende schreibst du das Array in eine Datei und beim nächsten Start liest du diese wieder ein. Bei kleiner Primzahlmenge lohnt sich das aber nicht.


----------

