Run
/***************************** Collatz.java *********************************/ import AlgoTools.IO; /** Berechnet Collatz-Funktion, d.h. * Anzahl der Iterationen der Funktion g: N -> N * bis die Eingabe auf 1 transformiert ist * mit g(x) = x/2 falls x gerade, 3*x+1 sonst */ public class Collatz { public static void main(String [] argv) { int x, z; // definiere 2 Variablen x = IO.readInt("Bitte eine Zahl: "); // lies einen Wert ein z = 0; // setze z auf 0 while (x != 1) { // solange x ungleich 1 ist if (x % 2 == 0) // falls x gerade ist x = x / 2; // halbiere x else // andernfalls x = 3*x+1; // verdreifache x und add. 1 z = z+1; // erhoehe z um eins } IO.println("Anzahl der Iterationen: " + z); // gib z aus } }
/***************************** Bedingung.java *******************************/ /** Verzweigung durch Bedingung (if-Anweisung, Bedingungsoperator) * * Vergleichsoperatoren: < kleiner * <= kleiner gleich * == gleich * > groesser * >= groesser gleich * != ungleich * * logische Operatoren: && und * || oder * ^ exklusives oder * ! nicht */ import AlgoTools.IO; public class Bedingung { public static void main (String [] argv) { int x = -5, y, m; // definiere 3 Integer-Variablen // davon eine initialisiert if (x < 0) x = -x; // setze x auf Absolutbetrag if (x < 0) y = -x; else y = x; // setze y auf den // Absolutbetrag von x m = IO.readInt("Bitte Monatszahl: "); if ((3 <= m) && (m <= 5)) IO.println("Fruehling"); else if ((6 <= m) && (m <= 8)) IO.println("Sommer"); else if ((9 <= m) && (m <= 11)) IO.println("Herbst"); else if (m==12 || m==1 || m==2) IO.println("Winter"); else IO.println("unbekannte Jahreszeit"); x = x % 2 == 0 ? x/2 : 3*x + 1; // bedingter Ausdruck: // weise der linken Seite // den Ausdruck vor ':' zu, // falls Bedingung vor '?' wahr; } // sonst Ausdruck hinter ':' }
/**************************** Fall.java *************************************/ import AlgoTools.IO; /** Verzweigung durch Fallunterscheidung (switch/case-Anweisung) * */ public class Fall { public static void main (String [] argv) { int zahl = 42; int monat = 11; switch (zahl % 10) {// verzweige in Abhaengigkeit der letzten Ziffer von zahl case 0: IO.println("null "); break; case 1: IO.println("eins "); break; case 2: IO.println("zwei "); break; case 3: IO.println("drei "); break; case 4: IO.println("vier "); break; case 5: IO.println("fuenf "); break; case 6: IO.println("sechs "); break; case 7: IO.println("sieben"); break; case 8: IO.println("acht "); break; case 9: IO.println("neun "); break; } switch(monat) { // verzweige in Abhaengigkeit von monat case 3: case 4: case 5: IO.println("Fruehling"); break; case 6: case 7: case 8: IO.println("Sommer "); break; case 9: case 10: case 11: IO.println("Herbst "); break; case 12: case 1: case 2: IO.println("Winter "); break; default: IO.println("unbekannte Jahreszeit"); } } }
/*************************** Schleife.java **********************************/ import AlgoTools.IO; /** while-Schleife, do-while-Schleife, break, continue, for-Schleife */ public class Schleife { public static void main (String [] argv) { int i, x=10, y=2, summe; // 4 Integer-Variablen while (x > 0) { // solange x groesser als 0 x--; // erniedrige x um eins y = y + 2; // erhoehe y um zwei } do { x++; // erhoehe x um eins y += 2; // erhoehe y um 2 } while (x < 10); // solange x kleiner als 10 IO.println("Bitte Zahlen eingeben. 0 als Abbruch"); summe = 0; // initialisiere summe x = IO.readInt(); // lies x ein while (x != 0) { // solange x ungleich 0 ist summe += x; // erhoehe summe x = IO.readInt(); // lies x ein } IO.println("Die Summe lautet " + summe); do { x=IO.readInt("Bitte 1<= Zahl <=12"); // lies x ein } while (( x < 1) || (x > 12)); // solange x unzulaessig for (i=1; i<=10; i++) IO.println(i*i,6); // drucke 10 Quadratzahlen } }
/*************************** Fakultaet.java *********************************/ import AlgoTools.IO; /** Berechnung der Fakultaet mit for-, while- und do-while-Schleifen * * n! := 1 fuer n=0, * 1*2*3* ... *n sonst * */ public class Fakultaet { public static void main (String [] argv) { int i, n, fakultaet; // 3 Integer-Variablen n = IO.readInt("Bitte Zahl: "); // fordere Zahl an fakultaet = 1; // berechne n! mit for-Schleife for (i = 1; i <= n; i++) fakultaet = fakultaet * i; IO.println(n + " ! = " + fakultaet); fakultaet = 1; // berechne n! mit while-Schleife i = 1; while (i <= n) { fakultaet = fakultaet * i; i++; } IO.println(n + " ! = " + fakultaet); fakultaet = 1; // berechne n! mit do-while-Schleife i = 1; do { fakultaet = fakultaet * i; i++; } while (i <= n); IO.println(n + " ! = " + fakultaet); } }
/*************************** GGT.java ***************************************/ import AlgoTools.IO; /** Berechnung des GGT * * ggt(x,y) = groesster gemeinsamer Teiler von x und y * * x falls x = y * ggt(x,y) = ggt(x-y, y) falls x > y * ggt(x, y-x) falls y > x * * denn wegen x=t*f1 und y=t*f2 folgt (x-y) = t*(f1-f2) * * x falls y = 0 * ggt(x,y) = ggt(y, x mod y) sonst * */ public class GGT { public static void main (String [] argv) { int teiler, a, b, x, y, z; // 6 Integer-Variablen IO.println("Bitte zwei Zahlen: "); a=x=IO.readInt(); b=y=IO.readInt(); // lies 2 Zahlen ein teiler = x; // beginne mit einem teiler while ((x % teiler != 0) || // solange x nicht aufgeht (y % teiler != 0)) // oder y nicht aufgeht teiler--; // probiere Naechstkleineren IO.println("GGT = " + teiler); while (a != b) // solange a ungleich b if (a > b) a = a - b; // subtrahiere die kleinere else b = b - a; // Zahl von der groesseren IO.println("GGT = " + a); while (y != 0) { // solange y ungleich 0 z = x % y; // ersetze x durch y x = y; // und y durch x modulo y y = z; } IO.println("GGT = " + x); } }
/************************** Ueberlauf.java ***********************************/ import AlgoTools.IO; /** Integer-Ueberlauf */ public class Ueberlauf { public static void main (String [] argv) { int n = 1; // initialisiere n while (n > 0) { // solange n positiv ist n = n * 10; // verzehnfache n IO.println(n, 20); // drucke n auf 20 Stellen } // letzter Wert ist negativ ! } }
/************************** Zeichen.java ************************************/ import AlgoTools.IO; /** Umwandlung von Character zur Zahl * Umwandlung von Zahl zum Character */ public class Zeichen { public static void main (String [] argv) { for (int i=0; i<=255; i++) { // fuer den Latin-1-Zeichensatz IO.print(i,7); // drucke laufende Nummer IO.print( " " + (char) i ); // drucke zugehoeriges Zeichen if (i % 8 == 0) IO.println(); // nach 8 Zeichen neue Zeile } IO.println(); char c; do { c = IO.readChar("Bitte ein Zeichen: "); // lies ein Zeichen ein IO.print("Der ASCII-Code lautet : "); // gib den zugehoerigen IO.println((int) c,3); // ASCII-Code aus } while (c != '\n' ); // bis ein Newline kommt } }
/************************** Umwandlung.java *********************************/ import AlgoTools.IO; /** implizite und explizite Typumwandlungen zwischen einfachen Datentypen */ public class Umwandlung { public static void main (String [] argv) { char c = '?'; // das Fragezeichen byte b = 100; // ca. 3 Stellen short s = 10000; // ca. 5 Stellen int i = 1000000000; // ca. 9 Stellen long l = 100000000000000000L; // ca. 18 Stellen float f = 3.14159f; // ca. 6 Stellen Genauigkeit double d = 3.141592653589793; // ca. 15 Stellen Genauigkeit i = s ; // implizite Typumwandlung ohne Verlust i = c ; // implizite Typumwandlung ohne Verlust s = (short) c; // explizite Typumwandlung ohne Verlust s = (short) i; // explizite Typumwandlung mit Verlust d = i; // implizite Typumwandlung ohne Verlust i = (int) d; // explizite Typumwandlung mit Verlust d = f; // implizite Typumwandlung ohne Verlust f = (float) d; // explizite Typumwandlung mit Verlust d = 1/2; // ergibt 0 wegen ganzzahliger Division IO.println(d); d = 1/2.0; // ergibt 0.5 wegen Gleitkommadivision IO.println(d); IO.println(2 * b + c ); // Ausdruck ist vom Typ int, Wert = 263 IO.println(i + 1.5); // Ausdruck ist vom Typ double } }
/************************** Konstanten.java *********************************/ import AlgoTools.IO; /** Einsatz von Konstanten fuer ganze Zahlen, Gleitkomma und Character */ public class Konstanten { public static void main (String [] argv) { final int MAX_GRAD = 360; // Integer-Konstante final double PI = 3.141592653589793; // Double Konstante final char PIEP = (char) 7; // Character-Konstante int grad; double r; IO.print(PIEP); // erzeuge Piep for (grad=0; grad <= MAX_GRAD; grad++) { // fuer jeden ganzzahligen Winkel r = Math.sin (grad/360.0*2*PI); // berechne Sinus vom Bogenmass IO.println(grad + " " + r); // gib Winkel und Sinus aus } } }