Nur auf Docsity: Lade Java-Übungen (mit Lösungen) und mehr Übungen als PDF für Programmieren in Java herunter!
Ergänzung zum Buch
"Java ist eine Sprache"
von Ulrich Grude,
Vieweg-Verlag 2005
Diese Übungen kann man z. B. in kleinen Gruppen unter Anleitung eines Betreuers oder auch allein (im
Selbststudium) bearbeiten.
Hinweise auf Fehler, Verbesserungsvorschläge oder Berichte über Erfahrungen mit diesen Übungen
sind jederzeit wilkommen, am liebsten per e-mail an die Adresse [email protected].
Inhaltsverzeichnis
- Übung if:....................................................................................................................................................................................
- Lösung if:....................................................................................................................................................................................
- Übung ÜberAus 1:....................................................................................................................................................................
- Lösung ÜberAus 1:....................................................................................................................................................................
- Übung Schleifen (ausführen) 1:...............................................................................................................................................
- Lösung Schleifen (ausführen) 1:.............................................................................................................................................
- Übung Schleifen (programmieren) 2:...................................................................................................................................
- Lösung Schleifen (programmieren) 2:...................................................................................................................................
- Übung Methoden 1:................................................................................................................................................................
- Lösung Methoden 1:................................................................................................................................................................
- Übung Reihungen 1:...............................................................................................................................................................
- Lösung Reihungen 1:...............................................................................................................................................................
- Übung Reihungen 2:...............................................................................................................................................................
- Lösung Reihungen 2:...............................................................................................................................................................
- Übung Reihungen 3:...............................................................................................................................................................
- Lösung Reihungen 3:...............................................................................................................................................................
- Übung Bojen (ausführliche und vereinfachte) 1:................................................................................................................
- Lösung Bojen (ausführliche und vereinfachte) 1:................................................................................................................
- Übung Bojen (von Reihungen) 2:..........................................................................................................................................
- Lösung Bojen (von Reihungen) 2:..........................................................................................................................................
- Übung Klassen 1:....................................................................................................................................................................
- Lösung Klassen 1:....................................................................................................................................................................
- Übung Deutsch 1:...................................................................................................................................................................
- Lösung Deutsch 1:...................................................................................................................................................................
- Übung Klassen 2:....................................................................................................................................................................
- Lösung Klassen 2:....................................................................................................................................................................
- Übung Klassen 3:....................................................................................................................................................................
- Lösung Klassen 3:....................................................................................................................................................................
- Übung Strings 1:.....................................................................................................................................................................
- Lösung Strings 1:.....................................................................................................................................................................
- Übung Ausnahmen 1:.............................................................................................................................................................
- Lösung Ausnahmen 1:.............................................................................................................................................................
- Übung Ausnahmen 2:.............................................................................................................................................................
- Lösung Ausnahmen 2:.............................................................................................................................................................
- Übung Methoden 2:................................................................................................................................................................
- Lösung Methoden 2:................................................................................................................................................................
- Übung Punkt, Quadrat, Rechteck, Kreis.............................................................................................................................
- Lösung Punkt, Quadrat, Rechteck, Kreis.............................................................................................................................
- Übung Oberklassen/Unterklassen.........................................................................................................................................
- Lösung Oberklassen/Unterklassen.........................................................................................................................................
- Übung Bitfummeln.................................................................................................................................................................
- Lösung Bitfummeln.................................................................................................................................................................
- Übung Einfach boolean..........................................................................................................................................................
- Lösung Einfach boolean..........................................................................................................................................................
Das Programm If01:
1 // Datei If01.java 2 /* ------------------------------------------------------------------------ 3 Verschiedene Varianten der if-Anweisung (if, if-else, if-else-if ...). 4 ------------------------------------------------------------------------ */ 5 class If01 { 6 static public void main (String[] s ) { 7 p("A If01: Eine Ganzzahl n? "); 8 int n = EM.liesInt(); 9 10 // if-Anweisunge mit und ohne geschweifte Klammern: 11 if (n > 0) pln("B n ist positiv!"); 12 if (n < 0) {pln("C n ist negativ!");} 13 14 // if-Anweisung mit mehreren Anweisungen darin: 15 if ((-9 <= n) && (n <= +9)) { 16 n = 2 * n; 17 pln("D n war einstellig und wurde"); 18 pln("E verdoppelt zu " + n); 19 } 20 21 // if-else-Anweisung: 22 if (n % 2 == 0) { 23 pln("F n ist eine gerade Zahl!"); 24 } else { 25 pln("G n ist eine ungerade Zahl!"); 26 } 27 28 // if-else-if-else-Anweisung: 29 if (n % 3 == 0) { 30 pln("H n ist durch 3 teilbar!"); 31 } else if (n % 4 == 0) { 32 pln("I n ist durch 4 teilbar!"); 33 } else if (n % 5 == 0) { 34 pln("J n ist durch 5 teilbar!"); 35 } else { 36 pln("K n ist nicht durch 3, 4 oder 5 teilbar!"); 37 } 38 39 // Manchmal geht es besser ohne if-Anweisungen: 40 boolean nIstEinstellig = ( -9 <= n) && (n <= +9); 41 boolean nIstZweistellig = (-99 <= n) && (n <= +99) && !nIstEinstellig; 42 pln("L Ist n einstellig? " + nIstEinstellig); 43 pln("M Ist n zweistellig? " + nIstZweistellig); 44 45 pln("N If01: Das war's erstmal!"); 46 } // main 47 } // class If
Lösung if:
1 // ---------- Teilaufgabe 1. ---------------------------------------- 2 if (n1 < 0) n1 = 0; 3 // ---------- Teilaufgabe 2. ---------------------------------------- 4 Wenn man Prozentrechnungen mit Ganzzahlen (z.B. int-Werten) durchführt, 5 sollte man die Reihenfolge der Operationen so wählen, dass die Rundungs- 6 fehler möglichst klein bleiben. Um z.B. 110 % von n2 zu berechnen ist 7 n2 * 110 / 100 besser als n2 / 100 * 110 oder n2 + n2/10 etc. 8 9 if (n2 > 0) { 10 n2 = n2 * 110 / 100; // Nicht n2 + n2/10 !! 11 pln("Der Wert von n2 ist jetzt gleich " + n2); 12 } 13 // ---------- Teilaufgabe 3. ---------------------------------------- 14 if (n3 % 2 == 0) { 15 n3 = n3 / 2; // oder abgekuerzt: n3 /= 3; 16 } else { 17 n3 = n3 * 2; // oder abgekuerzt: n3 = 2; 18 } 19 // ---------- Teilaufgabe 4. ---------------------------------------- 20 8 / 3 ist gleich 2. 2 * 3 ist gleich 6. Die Differenz zwischen 6 und 21 der Ausgangszahl 8 ist der Rest (der Division von 8 durch 3). 22 Allgemein: dend % dor ist gleich dend - dend/dordor. 23 24 if (n3 - (n3 / 2) * 2 == 0) { 25 n3 = n3 / 2; // oder abgekuerzt: n3 /= 2; 26 } else { 27 n3 = n3 * 2; // oder abgekuerzt: n3 *= 2; 28 } 29 // ---------- Teilaufgabe 5. ---------------------------------------- 30 if (n1 <= n2) { 31 pln("n1: " + n1); 32 pln("n2: " + n2); 33 } else { 34 pln("n2: " + n2); 35 pln("n1: " + n1); 36 } 37 // ---------- Teilaufgabe 6. ---------------------------------------- 38 Obwohl der Aufgabentext mit "Wenn n1 gleich 0 ist ..." beginnt, sollte 39 die Lösung nicht mit if (n1 == 0) ... beginnen, denn unter dieser 40 Bedingung soll ja nichts gemacht werden. 41 42 Lösung 1: 43 44 if (n1 < 0) { 45 n1 = n1 + 1; 46 } else if n1 > 0 { 47 n1 = n1 - 1; 48 } 49 50 Lösung 2 (leichter lesbar?): 51 52 if (n1 < 0) n1 = n1 + 1; 53 if (n1 > 0) n1 = n1 - 1; 54 // ---------- Teilaufgabe 7. ---------------------------------------- 55 Hier muss nicht zwischen positiven und negativen n1 unterschieden 56 werden: 57 58 if (n1 != 0) n1 = n1 - 1; 59 // ---------- Teilaufgabe 8. ---------------------------------------- 60 Analogie: Fußballmeisterschaft der Mannschaften n1, n2, n3 nach dem 61 k.o-Verfahren (Ausscheiden nach der ersten Niederlage). Die Variable 62 max ist "das Siegerpodest". Es enthält anfangs eine willkürlich ge- 63 wählte Mannschaft, dann immer den "vorläufigen Sieger" und am Ende 64 den "endgültigen Sieger". max verliert gegen n wenn max < n. 65 66 max = n1; 67 if (max < n2) max = n2;
Übung ÜberAus 1:
Wie man Programme mit Papier und Bleistift ausführen kann, wird im Kapitel 3 des Buches erläutert.
1. Führen Sie das Programm If01 (siehe vorige Übung) mit Papier, Bleistift und Radiergummi aus
und nehmen Sie dabei an, dass der Benutzer den Wert 6 eingibt (siehe Zeile 8 des Programms). Erzeu-
gen Sie insbesondere alle Variablen auf ihrem Papier. Was steht nach Ausführung des Programms auf
dem Bildschirm?
2. Wie die vorige Übung, aber mit Eingabe -.
3. Wie die vorige Übung, aber mit Eingabe 10.
4. Sie (in der Rolle des Benutzers ) möchten, dass das Programm If01 unter anderem die Meldung
Ist n einstellig? true
ausgibt (siehe Zeile 40 und 42 des Programms). Welche Zahlen dürfen Sie dann (für den Lesebefehl in
Zeile 8) eingeben? Berücksichtigen Sie dabei auch den Befehl in Zeile 16!
5. Beantworten Sie die folgenden Fragen mit je einem kurzen bzw. mittellangen Satz:
5.1. Was ist eine Variable?
5.2. Was ist ein Typ?
5.3. Was ist ein Modul?
6. Geben Sie von jedem der folgenden Befehle an, zu welcher Art von Befehlen er gehört ( Anweisung ,
Ausdruck oder Vereinbarung , siehe dazu den Abschnitt 1.5 im Buch) und übersetzen Sie den Befehl ins
Deutsche (oder ins Englische, wenn Sie wollen):
1 int mirko = 3; 2 String sascha = " Pickelheringe"; 3 mirko + sascha 4 mirko + 14 5 sascha = mirko + sascha; 6 mirko = mirko + sascha.length(); 7 if (mirko > 16) mirko = mirko - 1;
7. Führen Sie die folgende Befehlsfolge (mit Papier und Bleistift) aus. Welche Werte werden der Varia-
blen n "im Laufe der Zeit" nacheinander zugewiesen? Welche Zahl wird zum Schluss als Ergebnis aus-
gegeben?
8 int zaehler = 0; 9 int n = 13; 10 while (n != 1) { 11 if (n % 2 == 0) { 12 n = n / 2; 13 } else { 14 n = 3 * n + 1; 15 } 16 zaehler = zaehler + 1; 17 } 18 pl("Ergebnis: " + zaehler);
Lösung ÜberAus 1:
1. Die Ausgabe des Programms If01 für die Eingaben 6:
1 If01: Eine Ganzzahl n? 6 2 n ist positiv! 3 n war einstellig und wurde 4 verdoppelt zu 12 5 n ist eine gerade Zahl! 6 n ist durch 3 teilbar! 7 Ist n einstellig? false 8 Ist n zweistellig? true 9 If01: Das war's erstmal!
2. Die Ausgabe des Programms If01 für die Eingaben -9:
10 If01: Eine Ganzzahl n? - 11 n ist negativ! 12 n war einstellig und wurde 13 verdoppelt zu - 14 n ist eine gerade Zahl! 15 n ist durch 3 teilbar! 16 Ist n einstellig? false 17 Ist n zweistellig? true 18 If01: Das war's erstmal!
3. Die Ausgabe des Programms If01 für die Eingaben 10:
19 If01: Eine Ganzzahl n? 10 20 n ist positiv! 21 n ist eine gerade Zahl! 22 n ist durch 5 teilbar! 23 Ist n einstellig? false 24 Ist n zweistellig? true 25 If01: Das war's erstmal!
4. Genau dann wenn der Benutzer eine Zahl zwischen -4 und 4 (einschliesslich) eingibt, gibt das Pro-
gramm If01 (unter anderem) die Meldung Ist n einstellig? true aus.
5. Antworten auf Fragen:
5.1. Eine Variable ist ein Behälter für Werte (ein Wertebehälter).
5.2. Ein Typ ist ein Bauplan für Variablen (für Wertebehälter).
5.3. Ein Modul ist ein Behälter für Variablen, Unterprogramme, Typen und andere Dinge, der aus ei-
nem sichtbaren und einem unsichtbaren Teil besteht.
6. Befehle klassifizieren und übersetzen:
6.1. Vereinbarung: Erzeuge eine Variable namens mirko vom Typ int mit dem Anfangswert 3.
6.2. Vereinbarung: Erzeuge eine Variable namens sascha vom Typ String und gib ihr den An-
fangswert (eigentlich: Anfangszielwert) "Pickelheringe".
6.3. Ausdruck: Berechne den Wert des Ausdrucks mirko + sascha.
6.4. Ausdruck: Berechne den Wert des Ausdrucks mirko + 14.
6.5. Anweisung: Berechne den Wert des Ausdrucks mirko + sascha und tue ihn in den Werte-
behälter mirko (oder: weise ihn der Variablen mirko zu).
6.5. Anweisung: Berechne den Wert des Ausdrucks mirko + sascha.length() und weise ihn
der Variablen sascha zu.
6.5. Berechne den Wert des Ausdrucks mirko > 16. Wenn dieser Wert gleich true ist, dann be-
rechne den Wert des Ausdrucks mirko - 1 und weise ihn der Variablen mirko zu.
7. Der Variablen n werden nacheinander die folgenden Werte zugewiesen:
In der Variablen zaehler steht nach Ausführung aller Befehle der Wert 9.
Lösung Schleifen (ausführen) 1:
1. Die anna-Schleife
MAX2: 5 Bildschirm: ++
i1: 1 2 3 4 5 6 ++++++
i2: 1 2 ++++++++++
i2: 1 2 3
i2: 1 2 3 4
i2: 1 2 3 4 5
i2: 1 2 3 4 5 6
2. Die berta-Schleife
3. Die celia-Schleife
4. Die dora-Schleife
5. Die MAX1-Schleife
6. Die MAX2-Schleife
anna: 7 3 1 0 Bildschirm: 7 3 1
berta: 7 3 1 0 Bildschirm: -> 3 -> 1 -> 0
celia: -3 -1 1 3 5 Bildschirm: -2 2 6 10
dora: 3 2 1 0 -1 -2 Bildschirm: 3 2 1 0 -
MAX1: 3 Bildschirm: ******
i1: 1 2 3 4 ******
i2: 1 2 3 4 5 6 7
i2: 1 2 3 4 5 6 7
i2: 1 2 3 4 5 6 7
Übung Schleifen (programmieren) 2:
Einfache Schleifen werden in in den Abschnitten 4.2.4 bis 4.2.7 des Buches behandelt.
Einige der folgenden Übungsaufgaben hängen zusamme , d.h. die Lösung der einen kann zu einer Lö-
sung der anderen „ausgebaut“ werden. Das ist manchmal leichter, als „alles neu zu programmieren“.
Bei Zahlenfolgen (z.B. -5 -2 1 4 7 etc.) ist häufig die Differenzenfolge (3, 3, 3, 3 etc.) hilfreich.
1. Programmieren Sie eine Schleife, die die Ganzzahlen von 1 bis 10 (alle auf einer Zeile, durch je ein
Blank voneinander getrennt) zum Bildschirm ausgibt, etwa so:
2. Programmieren Sie eine Schleife, die alle durch 3 teilbaren Ganzzahlen zwischen 10 und 40 zur
Standardausgabe ausgibt, etwa so:
Ist Ihre Lösung effizient oder haben Sie dem Ausführer viele unnötige Befehle gegeben?
Programmieren Sie vier Schleifen, die die folgenden Zahlenfolgen zur Standardausgabe ausgeben:
- 1 2 4 8 16 32 64 128 256 512 1024 2048 4096 (siehe Anmerkung nach 6.)
- 3 4 6 10 18 34 66 130 258 514 1026 2050 4098
- 1 2 4 7 11 16 22 29 37 46 56 67 79 92
Anmerkung zu 4.: Einen Potenzoperator oder eine Potenzfunktion für Ganzzahlen gibt es in Java
nicht.
Für die folgenden Aufgaben nehmen Sie bitte an, dass eine Ganzzahlvariable namens norbert ver-
einbart und mit einer Zahl größer als 0 initialisiert wurde, etwa so:
int norbert = EM.liesInt(); // Der Benutzer gibt eine positive Zahl ein!.
7. Befehlen Sie dem Ausführer, den größten Teiler von norbert (der kleiner als norbert ist) aus-
zugeben. Falls norbert eine Primzahl ist, soll 1 ausgegeben werden.
8. Befehlen Sie dem Ausführer, den kleinsten Teiler von norbert (der größer als 1 ist) auszugeben.
Falls norbert eine Primzahl ist, soll norbert selbst ausgegeben werden.
9. Befehlen Sie dem Ausführer, die Meldung "norbert ist prim" bzw. "norbert ist
nicht prim" auszugeben, je nachdem, ob die Variable norbert eine Primzahl enthält oder nicht.
Für die folgenden Aufgaben nehmen Sie bitte an, dass eine Stringvariable namens sara vereinbart
wurde, etwa so:
String sara = EM.liesString();
Die wichtigsten String-Befehle (z.B. sara.length(), sara.charAt(i) etc.) werden im Ab-
schnitt 10.1 Die Klasse String des Buches erläutert.
10. Befehlen Sie dem Ausführer zu zählen, wie oft das Zeichen 'x' in sara vorkommt. Wenn er da-
mit fertig ist, soll er die Anzahl der 'x' ausgeben.
11. Befehlen Sie dem Ausführer die Dezimalziffern ('0', '1', ... '9') in sara zu zählen und diese
Anzahl auszugeben. Zur Erinnerung: char ist ein Ganzzahltyp (ähnlich wie int und long etc.).
12. Befehlen Sie dem Ausführer die Buchstaben in sara zu zählen und diese Anzahl auszugeben. Als
Buchstaben sollen alle Zeichen von 'a' bis 'z' und von 'A' bis 'Z' gelten.
13. Befehlen Sie dem Ausführer, die Anzahl der führenden Nullen in sara zu zählen und diese Anzahl
auszugeben.
14. Befehlen Sie dem Ausführer zu zählen, wie oft in sara ein Zeichen 'a' unmittelbar vor einem
Zeichen 'b' steht. Auch diese Anzahl soll der Ausführer ausgeben.
20 int kandidat = 2; 21 while (norbert % kandidat != 0) kandidat++; 22 pln("Der kleinste Teiler von norbert ist " + kandidat);
9. Enthält norbert eine Primzahl oder nicht?
23 for (int kandidat = 2; kandidat < norbert/2; kandidat++) { 24 if (norbert % kandidat == 0) { 25 meldung = "norbert ist nicht prim!"; 26 break; 27 } 28 } 29 pln("norbert ist prim!");
Schnellere Lösungen für dieses Problem werden auch heute noch im Rahmen von Forschungsprojekten
und Doktorarbeiten entwickelt.
10. Wie oft kommt 'x' in sara vor? Eine Methode wie sara.length() aufzurufen ist relativ teu-
er. Wiederholte Aufrufe kann man vermeiden, etwa so:
30 int anzahl_x = 0; 31 for (int i =sara.length()-1; i >= 0; i--) { 32 if (sara.charAt(i) == 'x') anzahl_x++; 33 } 34 pln("Anzahl 'x' in sara: " + anzahl_x);
oder so:
35 for (int max =sara.length(), i =0; i<max; i++) { 36 if (sara.charAt(i) == 'x') anzahl_x++; 37 }
11. Wieviele Dezimalziffern kommen in sara vor?
38 int anzahlZiffern = 0; 39 for (int i=sara.length()-1; i >= 0; i--) { 40 char c = sara.charAt(i); 41 if ('0' <= c && c <= '9') anzahlZiffern++; 42 } 43 pln("Anzahl Ziffern in sara: " + anzahlZiffern);
12. Wieviele Buchstaben kommen in sara vor?
44 int anzahlBuchstaben = 0; 45 for (int i=sara.length()-1; i >= 0; i--) { 46 char c = sara.charAt(i); 47 if (('a' <= c && c <= 'z') || 48 ('A' <= c && c <= 'Z')) anzahlBuchstaben++; 49 } 50 pln("Anzahl Buchstaben in sara: " + anzahlBuchstaben);
13. Wieviele führende Nullen kommen in sara vor?
51 int anzahlFuehrendeNullen = 0; 52 int i = 0; 53 while (sara.charAt(i) == '0') anzahlFuehrendeNullen++; 54 pln("Anzahl fuehrender Nullen: " + anzahlFuehrendeNullen);
14. Wie oft kommt 'a' unmittelbar vor 'b' in sara?
55 int anzahlAvorB = 0; 56 int i = 0; 57 int laenge = sara.length(); 58 while (i <= laenge - 2) { 59 if (sara.charAt(i) == 'a' && sara.charAt(i+1) == 'b') { 60 anzahlAvorB++; 61 i += 2; 62 } else { 63 i += 1; 64 } 65 }
Übung Methoden 1:
Unterprogramme (oder: Methoden) werden in den Abschnitten 1.4.3 und 2.1 bis 2.2 des Buches kurz
eingeführt und im Kapitel 8 gründlicher behandelt.
Zur Erinnerung: Methoden mit dem Rückgabetyp void werden auch als Prozeduren bezeichnet. Alle
anderen Methoden ("Methoden mit einem richtigen, von void verschiedenen Rückgabetyp") werden
auch als Funktionen bezeichnet.
1. Ergänzen Sie das folgende "Skelett einer int-Funktion" zu einer int-Funktion, indem Sie die Aus-
lassung "..." durch geeignete Befehle ersetzen:
1 static public int summe (int n1 , int n2 ) { 2 // Liefert die Summe von n1 und n2 als Ergebnis. 3 ... 4 }
2. Programmieren Sie eine static-public-Prozedur namens gibAus, die drei Parameter vom Typ
int hat. Die Prozedur soll ihre drei Parameter in lesbarer Form (mit kleinen Texten verziert) zur Stan-
dardausgabe ausgeben. Die verzierenden Texte können Sie ganz nach Ihrem Geschmack wählen.
3. Programmieren Sie eine static-public-int-Funktion namens hochZwei mit einem int-Pa-
rameter namens grundzahl. Als Ergebnis soll das Quadrat der grundzahl (d.h. grundzahl^2 ) ge-
liefert werden.
4. Programmieren Sie eine static-public-int-Funktion namens zweiHoch mit einem int-Pa-
rameter namens exponent. Falls der exponent kleiner oder gleich 0 ist, soll als Ergebnis der Wert
1 geliefert werden. Sonst soll die entsprechende Potenz von 2 (d.h. 2
exponent
) als Ergebnis geliefert wer-
den.
5. Programmieren Sie eine static-public-int-Funktion namens hoch mit zwei int-Parametern
namens grundzahl und exponent. Falls der exponent kleiner oder gleich 0 ist, soll als Ergebnis
die Zahl 1 geliefert werden. Sonst soll die entsprechende Potenz der grundzahl (d.h. die Ganzzahl
grundzahl
exponent
) als Ergebnis geliefert werden.
6. Programmieren Sie ein static-public-boolean-Funktion namens istPrim mit einem int-
Parameter namens n. Falls n eine Primzahl ist, soll die Funktion das Ergebnis true liefern und sonst
das Ergebnis false.
7. Eine Primzahl-Doublette besteht aus zwei Primzahlen, deren Differenz gleich 2 ist (z.B. 3 und 5 oder
11 und 13 oder 1019 und 1021 etc.). Programmieren Sie eine int-Funktion namens primDoublet-
te mit einem int-Parameter namens min. Diese Funktion soll von der Zahl min an aufwärts nach ei-
ner Primzahl-Doublette suchen. Falls sie eine findet, soll sie die kleinere Primzahl der Doublette als
Ergebnis liefern. Falls es im Bereich zwischen min und der groessten Zahl des Typs int (Inte-
ger.MAX_VALUE) keine Primzahl-Doublette gibt, soll die Funktion primDoublette den Wert 0
als Ergebnis liefern.
8. Programmieren Sie eine parameterlose Prozedur namens alleRechtwinkligen, die alle Ganz-
zahltripel (a, b, c) zur Standardausgabe ausgibt, für die gilt:
8.1. Jede der drei Ganzzahlen a, b und c liegt zwischen 1 und 100 (einschliesslich).
8.2. a ist größer oder gleich b und b ist größer oder gleich c.
8.3. Die drei Ganzzahlen repräsentieren die Seiten eines rechtwinkligen Dreiecks , d.h. es gilt "der Py-
thagoras" a
2
= b
2
+ c
2
45 // damit der Ausfuehrer unten in der for-Schleife 46 // Math.sqrt(n) nur einmal berechnen muss. 47 48 if (n <= 1) return false; // Alle zu kleinen Zahlen erledigen. 49 if (n == 2) return true; // Einzige gerade Primzahl. 50 if (n%2 == 0) return false; // Alle anderen geraden Zahlen sind nicht prim! 51 52 for (int kandidat =3; kandidat < Math.sqrt(n); n+=2) { 53 if (n % kandidat == 0) return false; 54 } 55 return true; 56 } // istPrim
In Zeile 35 steht kandidat < n/2, in Zeile 52 steht statt dessen kandidat < Math.sqrt(n).
Wieviel schneller ist die Lösung 6b im Vergleich zu 6a allein dadurch geworden?
n n/2 Math.sqrt(n) Beschleunigungsfaktor
6c. Eine Funktion namens istPrim (noch effizientere Version):
57 static public boolean istPrim (final int n ) { 58 // Liefert true , falls n prim ist, und sonst false. 59 // Prueft nur Zahlen bis zur Quadratwurzel aus n als Teiler. 60 // Behandelt durch 2 und durch 3 teilbare Zahlen "vorweg" und 61 // ueberspringt dann beim Suchen nach einem Teiler alle durch 62 // 2 und alle durch 3 teilbaren Teiler (das sind 2/3 aller Zahlen). 63 64 // Ein paar Sonderfaelle erledigen: 65 if (n <= 1) return false; // alle zu kleinen Zahlen erledigen 66 if (n == 2) return true; 67 if (n == 3) return true; 68 if (n % 2 == 0) return false; // alle durch 2 teilbaren Zahlen erledigt 69 if (n % 3 == 0) return false; // alle durch 3 teilbaren Zahlen erledigt 70 71 // Und jetzt den allgemeinen Fall bearbeiten: 72 int teiler = 5; 73 while (teiler < Math.sqrt(n)) { 74 if (n % teiler == 0) return false; 75 teiler += 2; // eine gerade Zahl ueberspringen 76 if (n % teiler == 0) return false; 77 teiler += 4; // eine durch 3 teilbare und zwei gerade Zahlen ueberspring. 78 } 79 return true; 80 } // istPrim
7. Die Funktion primDoublette:
81 static public int primDoublette (int minimum ) { 82 if (minimum <= 3) return 5; // kleinste Prim-Doublette 83 if (minimum % 2 == 0) minimum++; // minimum ungerade machen 84 for (int n=minimum; n<=Integer.MAX_VALUE-2; n += 2) { 85 if (istPrim(n) && istPrim(n+2)) return n; 86 } 87 return 0; 88 } // primDoublette
8. Eine Prozedur namens alleRechtwinkligen:
89 static public void alleRechtwinkligen () { 90 // Gibt alle Ganzzahltripel (a, b, c) aus fuer die gilt: 91 // 1. a, b und c liegen zwischen 1 und MAX (einschliesslich) 92 // 2. a ist groesser/gleich b und b ist groesser/gleich c 93 // 3. aa ist gleich bb + cc (Pythagoras) 94 95 final int MAX = 100; 96 int nr = 0; 97 98 for (int a =1; a <= MAX; a++) { 99 for (int b =1; b <= a; b++) { 100 for (int c =1; c <= b; c++) { 101 if (aa == bb + cc) { 102 nr++; 103 pln("Nr. " + 104 nr + ": " + 105 a + ", " + 106 b + ", " + 107 c + "." 108 ); 109 } // if 110 } // for c 111 } // for b 112 } // for a 113 } // alleRechtwinkligen
Lösung Reihungen 1:
1 // Datei Ueb_Reihungen1.java 2 /* ------------------------------------------------------------------------ 3 Methoden zum Bearbeiten einstufiger Reihungen. 4 Von einigen Methoden gibt es zwei Varianten, z. N. minA und minN. 5 Die A -Version enthaelt eine alte for-Schleife (seit Java 1.0) 6 Die N -Version enthaelt eine neue for-Schleife (seit Java 5) 7 ------------------------------------------------------------------------ */ 8 class Ueb_Reihungen1 { 9 // --------------------------------------------------------------------- 10 public static void printRA (int[] ir ) { 11 // Gibt die Reihung ir in lesbarer Form zur Standardausgabe aus. 12 // Hinweis: Auf jeden Fall muessen auch leere Reihungen "lesbar" 13 // ausgegeben werden. Ob auch eine Nullreferenz ir "lesbar" aus- 14 // gegeben werden sollte oder eine NullPointerException ausloesen 15 // sollte, kann man diskutieren. 16 pln("---------------------------------------------"); 17 18 if (ir == null) { 19 pln("printRA: ir zeigt nicht auf eine Reihung!"); 20 return; 21 } 22 pln("Eine Reihung mit int-Komponenten:"); 23 if (ir.length == 0) { 24 pln("Die Reihung besteht aus 0 Komponenten!"); 25 return; 26 } 27 for (int i=0; i<ir.length; i++) { 28 pln("Index " + i + ", Komponente " + ir[i]); 29 } 30 } // printRA 31 // --------------------------------------------------------------------- 32 public static void printRN (int[] ir ) { 33 // Gibt die Reihung ir in lesbarer Form zur Standardausgabe aus. 34 // Hinweis: Auf jeden Fall muessen auch leere Reihungen "lesbar" 35 // ausgegeben werden. Ob auch eine Nullreferenz ir "lesbar" aus- 36 // gegeben werden sollte oder eine NullPointerException ausloesen 37 // sollte, kann man diskutieren. 38 pln("---------------------------------------------"); 39 40 if (ir == null) { 41 pln("printRN: ir zeigt nicht auf eine Reihung!"); 42 return; 43 } 44 pln("Eine Reihung mit int-Komponenten:"); 45 if (ir.length == 0) { 46 pln("Die Reihung besteht aus 0 Komponenten!"); 47 return; 48 } 49 for (int n: ir) { 50 pln("Komponente " + n); 51 } 52 } // printRN 53 // --------------------------------------------------------------------- 54 public static int minA (int[] ir ) { 55 // Liefert die kleinste Komponente von ir, 56 // bzw. Integer.MAX_VALUE falls ir aus 0 Komponenten besteht. 57 int erg = Integer.MAX_VALUE; 58 for (int i =0; i<ir.length; i++) { 59 if (erg > ir[i]) erg = ir[i]; 60 } 61 return erg; 62 } // minA 63 // --------------------------------------------------------------------- 64 public static int minN (int[] ir ) { 65 // Liefert die kleinste Komponente von ir, 66 // bzw. Integer.MAX_VALUE falls ir aus 0 Komponenten besteht. 67 int erg = Integer.MAX_VALUE; 68 for (int n : ir) { 69 if (erg > n) erg = n;
71 return erg; 72 } // minN 73 // --------------------------------------------------------------------- 74 public static boolean mindEineGeradeA (int[] ir ) { 75 // Liefert true, wenn ir mindestens eine gerade Zahl enthaelt und 76 // sonst false. 77 for (int i =0; i<ir.length; i++) { 78 if (ir[i] % 2 == 0) return true; 79 } 80 return false; 81 } // mindEineGeradeA 82 // --------------------------------------------------------------------- 83 public static boolean mindEineGeradeN (int[] ir ) { 84 // Liefert true, wenn ir mindestens eine gerade Zahl enthaelt und 85 // sonst false. 86 for (int n : ir) { 87 if (n % 2 == 0) return true; 88 } 89 return false; 90 } // mindEineGeradeN 91 // --------------------------------------------------------------------- 92 public static boolean alleGeradeA (int[] ir ) { 93 // Liefert true, wenn alle Komponenten von ir gerade Zahlen sind und 94 // sonst false. 95 for (int i =0; i<ir.length; i++) { 96 if (ir[i] % 2 != 0) return false; 97 } 98 return true; 99 } // alleGeradeA 100 // --------------------------------------------------------------------- 101 public static boolean alleGeradeN (int[] ir ) { 102 // Liefert true, wenn alle Komponenten von ir gerade Zahlen sind und 103 // sonst false. 104 for (int n : ir) { 105 if (n % 2 != 0) return false; 106 } 107 return true; 108 } // alleGeradeN 109 // --------------------------------------------------------------------- 110 public static boolean kommtVorA (int dieserWert , int[] inDieserReihung ) { 111 // Liefert true, wenn dieserWert als Komponente in der Reihung 112 // namens inDieserReihung vorkommt und sonst false. 113 for (int i =0; i<inDieserReihung.length; i++) { 114 if (dieserWert == inDieserReihung[i]) return true; 115 } 116 return false; 117 } // kommtVorA 118 // --------------------------------------------------------------------- 119 public static boolean kommtVorN (int dieserWert , int[] inDieserReihung ) { 120 // Liefert true, wenn dieserWert als Komponente in der Reihung 121 // namens inDieserReihung vorkommt und sonst false. 122 for (int n : inDieserReihung) { 123 if (dieserWert == n) return true; 124 } 125 return false; 126 } // kommtVorN 127 // --------------------------------------------------------------------- 128 public static int index (int n, int[] ir ) { 129 // Liefert den kleinsten Index i fuer den gilt n == ir[i] bzw. -1, 130 // falls es keinen solchen Index gibt (d.h. falls n in ir nicht vor- 131 // kommt. 132 for (int i =0; i<ir.length; i++) { 133 if (n == ir[i]) return i; 134 } 135 return -1; 136 } // index 137 // --------------------------------------------------------------------- 138 public static void oAlleDurch2 (int[] ir ) { 139 // Teilt jede Komponente von ir durch 2 (o wie "Originalparameter") 140 for (int i =0; i<ir.length; i++) {
