Primzahlen in Zahlenblöcken ausgeben

[Future_Warrior]

Guten Morgen !
Bin noch ein kompletter Anfänger und soll folgende Aufgabe lösen.
Es sollen alle Primzahlen von 3-501 in einem Zahlenblock ausgegeben werden.
In dem Muster:

3 5 7 9
11 13 15 17
u.s.w

Zudem soll die Anzahl aller Primzahl angezeigt werden.
Jedoch funktioniert es hier mit "prime.length" nicht. Worin liegt der Fehler?
Mein Ansatz wäre folgender:

[Java]


public class Java {

/**
* @param args
*/
public static void main(String[] args)
{

//Erste Variante
for ( int i = 0 ; i < 502; i++)

for ( int prime : new int[]{ i} )
if (i!=1)
if (i % 2 ==1)
System.out.println(prime);
System.out.println();
// System.out.println(prime.length); --> Ausgabe der Primzahl Menge

}

}


[/code]

 

[jgh]

Dein Ansatz funktioniert nicht, weil [c]prime[/c] ein int ist, und kein int-Array und somit keine Methode der Länge anbietet. Folgender Code -geklaut von wikibooks.org sollte funktionieren

public class Primzahlen {
	public static void main(String[] args) {
		int anzahlPrimzahlen = 0;
		int blockAusgabe = 1;
		int limit = 501;
		int zahl; // Zu überprüfende Zahl
		int zaehler; // Durch diese Zahl soll geteilt werden
		int teiler; // Anzahl der möglichen Teiler
		int zahl2; // Rest bei der Division
		for (zahl = 3; zahl <= limit; zahl++) // zahl <= x ist der zu
												// überprüfende Zahlenraum
		{

			teiler = 0;
			for (zaehler = 1; zaehler <= zahl; zaehler++) // Es empfiehlt
															// sich den
															// Terminationswert
															// auf zahl zu
			// setzen und nicht auf limit, da die Berechnung von Primzahlen
			// bis zu Milliardenbeträgen sonst nur äußerst langsam
			// funktioniert. Die Teilung durch Zahlen, die größer sind als
			// die zu überprüfende Zahl selbst ist ohne hin obsolet.

			{
				zahl2 = zahl % zaehler; // Division der Ausgangszahl durch
										// eine weitere und ablegen in der
										// Variabel zahl2
				if (zahl2 == 0) // Falls der Rest gleich 0 ist ist ein
								// Teiler gefunden
					teiler++;

			}
			if (teiler == 2) { // Wenn die Zahl genau 2 Teiler hat ist sie
								// eine Primzahl
				anzahlPrimzahlen++;
				if (blockAusgabe < 4) {
					System.out.print(zahl + " ");
					blockAusgabe++;
				} else {
					System.out.println(zahl + " ");
					blockAusgabe = 0;
				}
			}
			/*
			 * else // Andernfalls ist sie keine Primzahl
			 * System.out.println(zahl+" ist KEINE Primzahl");
			 */
		}
		System.out.println("\n Es sind ingesant " + anzahlPrimzahlen
				+ " Primzahlen vorhanden.");
	}
}

 

[Future_Warrior]

Hey !

Mein Entwurf, funktioniert ja theoretisch das heißt ich kann ermitteln, ob eine Zahl eine Primzahl ist oder nicht. Genauso wie der Wikipedia Code funktioniert, nur etwas ausführlicher.

Die Hauptfrage ist aber, wie kriege ich jetzt die Zahlen als Block dargestellt.
Mein Ansatz wäre, ich erstelle ein Mehrdimensionales Array, lese dort alle Zahlen bis 501 ein und ermittle mit einer If-Anweisung ob es eine Primzahl ist oder nicht und gebe die Zahlen in einem Block aus . Ich habe schon in Handbüchern nachgeschlagen, ich verwende "Java ist auch eine Insel" und "Javabuch.de", nur stand nirgendwo drin wie ich ein Array mit einer Schleife befülle oder ich bin blind ^.^

Zu mir, ich bin im Moment Mathe-Leistungskurs mit sehr guten Noten, und progge erst seit 2 Wochen und sucke dermaßen. Mein Hauptproblem ist, ich kenne theoretisch die Ansätze, nur fällt es mir sehr schwer es in der jeweiligen Sprache umzusetzen.

Bekanntlich macht ja Übung den Meister !
Gib es spezielle Vorgehensweisen wie man programmieren konstant und effektiv üben kann?

 

[Gossi]

Die Hauptfrage ist aber, wie kriege ich jetzt die Zahlen als Block dargestellt.

Nicht schön:

int breite = 3;
int line = 0;
int num = 0;
int[][] block = new int[80][3]; 
     //Die 3, da du immer 3 Zahlen auf eins haben willst und die 80
     // da 501/3 = 167 167 / 2 = 83,5 nun ist aber nicht jede zweite
     //Zahl eine Primzahl, also können wir noch wa abziehen

for(int i = 0; i <= 501; i++) {
     //Primcheck
     if(primzahl) {
          block[line][num] = i;
          num ++;
          if(num >= 3) {
               num = 0;
               line ++;
          }
     }
}

Anschließend musste nurnoch das Array entsprechend auslesen...

bzw. etwas schöner:

int breite = 3;     //Angabe wieviele Zahlen in einer Reihe stehen sollen
int line = 0;
int num = 0;
int[][] block = new int[((501 / breite) / 2)][breite]; 

for(int i = 0; i <= 501; i++) {
     //Primcheck
     if(primzahl) {
          block[line][num] = i;
          num ++;
          if(num >= breite) {
               num = 0;
               line ++;
          }
     }
}

 

[turtle]

Mein Ansatz wäre, ich erstelle ein Mehrdimensionales Array, lese dort alle Zahlen bis 501 ein und ermittle mit einer If-Anweisung ob es eine Primzahl ist oder nicht und gebe die Zahlen in einem Block aus .

Ich verstehe nicht warum Du der Meinung bist ein mehrdimensionales Array zu benötigen? Weiterhin warum möchtest Du Zahlen einlesen?

Ich glaube, dass Du einfach die Primzahlen bis 501 in einem Array berechnen solltest. Die Anzeige dieser Zahlen ist davon überhaupt nicht betroffen. Ich habe mal folgenden Code geschrieben. Dabei werden NICHT alle Primzahlen gespeichert, oder überprüft, aber es zeigt den blockweisen Output. Hier werden 4 Zahlen in einer Zeile dargestellt.

	public static void main(String[] args) {
		int[] primes = new int[] { 1, 3, 5, 7, 11, 13, 15, 17, 19,20,21,22,23,24 };
		int zeile = -1;
		for (int prime : primes) {
			if (++zeile%4 == 0) // 4 Zahlen pro Zeile
				System.out.println("");
			System.out.print(String.format("%4d ", prime));
		}
	}

gibt als Output:

   1    3    5    7 
  11   13   15   17 
  19   20   21   22 
  23   24

 

[langhaar!]

3 5 7 9
11 13 15 17

Mathe LK mit sehr guten Noten?
Das 9 und 15 keine Primzahlen sind, ist dir aber hoffentlich bewusst.
Dein Programm prüft mit % 2 == 1 nicht auf Primzahlen.

 

[turtle]

ch glaube, dass Du einfach die Primzahlen bis 501 in einem Array berechnen solltest.

Deswegen hatte ich gesagt, die Zahlen sollten in einem Array berechnet werden. Mein Ansatz gibt also "nur" wenige richtige und manche falsche Primzahlen aus, um die Blockausgabe zu demonstrieren. Wenn das Array aber richtig gefüllt wäre...

Die Modulo-Operation ist nur drin um einen Zeilenvorschub nach 4 Zahlen zu erzwingen, damit der Output "schön" blockmässig erscheint.

 

[Firephoenix]

Block muss ja nicht array bedeuten, man kann die Zahlen auch direkt bei der berechnung Blockweise ausgeben, dann muss man allerdings mitzählen wieviele Primzahlen bereits in der Zeile stehen und festlegen wieviele in eine Zeile sollen.
Das Mitzählen von gefundenen Primzahlen ist dann auch nicht mehr wirklich das Problem.

-> Auf die schnelle hingeklatscht, keine Garantie auf Korrekteit und Schönheit

public static void main( String[] args )
    {
        int bereitsInZeileAusgegeben = 0;
        int zahlenProZeile = 4;
        int gefundenePrimzahlen = 0;
        for ( int i = 0; i <= 501; i++ )
        {
            if ( isPrime( i ) )
            {
                System.out.print( i + " " );
                gefundenePrimzahlen++;
                if ( ++bereitsInZeileAusgegeben == zahlenProZeile )
                {
                    bereitsInZeileAusgegeben = 0;
                    System.out.println();
                }
            }
        }
        System.out.println();
        System.out.println( "Primzahlen gesamt: " + gefundenePrimzahlen );
    }

    public static boolean isPrime( int value )
    {
        if ( value < 2 )
        {
            return false;
        }
        for ( int i = 2; i < value; i++ )
        {
            if ( value % i == 0 )
            {
                return false;
            }
        }
        return true;
    }

Ausgabe:

2 3 5 7
11 13 17 19
23 29 31 37
41 43 47 53
59 61 67 71
73 79 83 89
97 101 103 107
109 113 127 131
137 139 149 151
157 163 167 173
179 181 191 193
197 199 211 223
227 229 233 239
241 251 257 263
269 271 277 281
283 293 307 311
313 317 331 337
347 349 353 359
367 373 379 383
389 397 401 409
419 421 431 433
439 443 449 457
461 463 467 479
487 491 499
Primzahlen gesamt: 95

Gruß

 

[Spacerat]

import static java.lang.Math.abs;
import static java.lang.Math.sqrt;
import static java.lang.Math.ceil;
import static java.lang.Math.log10;

public class Primes
{
	private static final int PRIMES_PER_LINE = 4;

	private Primes()
	{
		super();
	}

	public static void main(String[] args)
	{
		listPrimes(3, 501);
	}

	public static boolean isPrime(long value)
	{
		value = abs(value);
		if(value == 2) {
			return true;
		}
		if(value < 2 || value % 2 == 0) {
			return false;
		}
		long max = (long) sqrt(value);
		for(long n = 3; n <= max; n += 2) {
			if(value % n == 0) return false;
		}
		return true;
	}

	public static void listPrimes(long to)
	{
		listPrimes(0, to);
	}

	public static void listPrimes(long from, long to)
	{
		long f = Math.min(from, to);
		long t = Math.max(from, to);
		int l = (int) ceil(log10(t));
		long cntp = 0;
		from = System.currentTimeMillis();
		for(long n = f; n <= t; n++) {
			if(isPrime(n)) {
				cntp++;
				System.out.print(String.format("%" + l + "d,", n));
				if(cntp % PRIMES_PER_LINE == 0) {
					System.out.println();
				} else {
					System.out.print(" ");
				}
			}
		}
		System.out.println();
		System.out.println("Range: " + f + " to " + t);
		System.out.println(String.format("Stats: %3.2f%%", ((double) cntp / (double) (t - f)) * 100.0));
		System.out.println("Count: " + cntp);
		System.out.println("Time: " + (System.currentTimeMillis() - from) + "ms");
	}
}

[EDIT]Ok... bissl zu langsam... des Anpassen von vorhandenem Code an diese Ansprüche hat halt doch länger gedauert [/EDIT]

 

[Andi_CH]

-> Auf die schnelle hingeklatscht, keine Garantie auf Korrekteit und Schönheit

public static void main( String[] args )
    {
        int bereitsInZeileAusgegeben = 0;
        int zahlenProZeile = 4;
        int gefundenePrimzahlen = 0;
        for ( int i = 0; i <= 501; i++ )
        {
            if ( isPrime( i ) )
            {
                System.out.print( i + " " );
                gefundenePrimzahlen++;
                if ( ++bereitsInZeileAusgegeben == zahlenProZeile )
                {
                    bereitsInZeileAusgegeben = 0;
                    System.out.println();
                }
            }
        }
        System.out.println();
        System.out.println( "Primzahlen gesamt: " + gefundenePrimzahlen );
    }

    public static boolean isPrime( int value )
    {
        if ( value < 2 )
        {
            return false;
        }
        for ( int i = 2; i < value; i++ )
        {
            if ( value % i == 0 )
            {
                return false;
            }
        }
        return true;
    }

Der Loop aus Zeile 29 darf schon bei der Wurzel des Wertes stoppen - das spielt dann eine Rolle wenn eher grössere Primzahlen bestimmt werden sollen

for (int x=2; x<Math.sqrt(value); x++)

Es hat noch viel mehr Optimierungspotential, aber das wurde sicher hier schon X-fach besprochen