Zusammenfassung der Vorwoche Feld (auch Array, Feld- oder Array-Variable) steht für eine nummerierte Folge von Werten (Elemente), der sich im Programmablauf ändern können. Das Feld besitzen einen Typ, der für die einzelnen Elemente gilt. Der Zugang zu Elementen erfolgt über ihren Index. Konzepte für Felder: Vereinbarung, Initialisierung von Größe und Werten, Zuweisung von Größe und Werten, Abfrage von Größe und Werten

Primzahlbestimmung – Sieb des Eratosthenes Vorgehen „Sieb des Eratosthenes“: (1) Schreibe alle natürlichen Zahlen (>1) bis zur Obergrenze als Liste auf. (2) Wähle die erste Zahl z aus. (3) Streiche alle (echten) Vielfachen von z aus der Liste aller Zahlen. (4) Falls das Ende der Liste noch nicht erreicht ist, wähle die nächste nicht gestrichene Zahl als z und beginne bei (3). (5) Sonst ist die Aufgabe erfüllt. Beispiel: Schreibe Zahlen auf (1) 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 Wähle z = 2 und streiche Vielfache ((2) und (3)) 2 3 5 7 9 11 13 15 17 19 21 23 25 Wähle z = 3 und streiche Vielfache ((4) und (3))

Sieb des Eratosthenes Vorstufe zur Primzahlenbestimmung: int obergrenze = 64; int[] zahlen = new int[obergrenze-1]; int zähler = 0; while (zähler < zahlen.length) { zahlen[zähler] = zähler+2; zähler = zähler+1; } int testwert = zahlen[0]; // das ist die 2! zähler = 1; while (zähler < zahlen.length) { // zahlen[zähler] teilbar durch testwert? } Unzureichend: - würde nur für Vielfache von 2 streichen - Kommentar muss in JAVA ausformuliert werden

Teilbarkeit prüfen int testwert = zahlen[0]; // das ist die 2! zähler = 1; while (zähler < zahlen.length) { // zahlen[zähler] teilbar durch testwert? zähler = zähler+1; } Kommentar übersetzen in (1) wenn zahlen[zähler]/testwert keinen Rest ergibt (2) dann ganzzahlig teilbar, also zahlen[zähler] „löschen“, d.h. zahlen[zähler]=0;

Teilbarkeit prüfen in JAVA int testwert = zahlen[0]; zähler = 1; while (zähler < zahlen.length) { if(zahlen[zähler] % testwert == 0) { zahlen[zähler] = 0; } zähler = zähler+1; Neu: if-Anweisung % Operator == Operator

If-Anweisung Syntaktischer Aufbau: if(Bedingung) Anweisung; Semantik (Bedeutung): Führe Anweisung aus, wenn Bedingung wahr ergibt und sonst tue nichts und gehe weiter. Bedingung muss wahr (true) oder falsch (false) liefern.

Modulo-Operator % Liefert den Rest einer ganzzahliger Division! Beispiel: 257 : 4 = 64 Rest 1 in JAVA: int ergebnis = 257 / 4; int rest = 257 % 4; System.out.println(ergebnis + “ Rest “ + rest); Anmerkung: % lässt sich umständlich ersetzen durch 257 - 257 / 4 * 4 (vgl. Übungen)

Vergleichsoperator == Vergleicht alle Arten von Zahlen Vergleicht auch String-Literale “…“ Liefert als Ergebnis einen Wahrheitswert: true, false Typ heißt: boolean Test auf Ungleichheit: != Weitere Vergleichsoperatoren für Zahlen: >, <, >=, <=

Vergleichsoperator == Aber: == vergleicht nicht Felder, d.h. dort Vergleich der Elemente notwendig: boolean gleich = true; int[] f1 = {1,2,3}; int[] f2 = {2,3,4}; gleich = f1.length == f2.length; if (gleich) { int z = 0; while (gleich && z < f1.length) { gleich = f1[z] == f2[z]; z = z+1; }

Bestandsaufnahme – Sieb des Eratosthenes 1. Anlegen eines Feldes mit 63 Zahlen: int obergrenze = 64; int[] zahlen = new int[obergrenze-1]; int zähler = 0; while (zähler < zahlen.length) { zahlen[zähler] = zähler+2; zähler = zähler+1; }

Bestandsaufnahme – Sieb des Eratosthenes 2. Löschen der Vielfachen von 2 int testwert = zahlen[0]; zähler = 1; while (zähler < zahlen.length) { if(zahlen[zähler] % testwert == 0) { zahlen[zähler] = 0; } zähler = zähler+1;

Bestandsaufnahme – Sieb des Eratosthenes 3. Ausgabe des Feldes zähler = 0; while (zähler < zahlen.length) { System.out.print(zahlen[zähler] + “ “); zähler = zähler+1; }

Erinnerung – Sieb des Eratosthenes Index 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 … 22 23 24 Wert 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 24 25 26 Wähle 0 und setze ab 1 (=0+1) alle Vielfachen von zahlen[0]auf 0. Wert 2 3 0 5 0 7 0 9 0 11 0 13 0 15 0 17 0 0 25 0 Wähle 1 und setze ab 2 (=1+1) alle Vielfachen von zahlen[1]auf 0. Wert 2 3 0 5 0 7 0 0 0 11 0 13 0 0 0 17 0 0 25 0 Wähle 2 und tue nichts, da zahlen[2]==0. Wähle 3 und setze ab 4 (=3+1) alle Vielfachen von zahlen[3]auf 0. Wert 2 3 0 5 0 7 0 0 0 11 0 13 0 0 0 17 0 0 0 0

Sieb des Eratosthenes Löschen aller Vielfachen int testzähler = 0; while (testzähler < zahlen.length) { if (zahlen[testzähler] != 0) { zähler = testzähler + 1; while (zähler < zahlen.length) { if (zahlen[zähler] % zahlen[testzähler] == 0) { zahlen[zähler] = 0; } zähler = zähler+1; testzähler = testzähler + 1;

Diskussion des Abbruchkriteriums Äußere Schleife: int testzähler = 0; while (testzähler < zahlen.length) { … } Frage: Sind wirklich length-viele Durchläufe notwendig! Antwort: Nein, da für den zu testenden Wert w alle Kombinationen mit Zahlen kleiner als w schon gelöscht sind. Daher ist das kleinste zu löschende Vielfache von >= w2. Also reicht Durchlauf bis zu ((Wurzel aus dem letzten Wert) +1) -2 (Können wir aber noch nicht!) Und es reicht: zähler = testzähler * testzähler -2

Verbesserung der Ausgabe Unterdrücken der Ausgabe von 0: zähler = 0; while (zähler < zahlen.length) { if (zahlen[zähler] != 0) { System.out.print(zahlen[zähler] + “ “); } zähler = zähler+1;

Verbesserung der Ablage Komprimieren der Primzahlen auf den Anfang des Feldes Index 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 … Wert 2 3 0 5 0 7 0 0 0 11 0 13 0 0 0 17 0 Wert 2 3 5 0 0 7 0 0 0 11 0 13 0 0 0 17 0 Wert 2 3 5 7 0 0 0 0 0 11 0 13 0 0 0 17 0 Wert 2 3 5 7 11 0 0 0 0 0 0 13 0 0 0 17 0 Hausaufgabe!

Zusammenfassung If-Anweisung %-Operator Vergleichsoperatoren ==, !=, <=, >=, <, > Umgang mit Feldern Programm Sieb des Eratosthenes mit Analyse