Informatik B von Adrian Neumann

Transkript

1 Musterlösung zum 7. Aufgabenblatt vom Montag, den 25. Mai 2009 zur Vorlesung Informatik B von Adrian Neumann 1. Java I Schreiben Sie ein Java Programm, das alle positiven ganzen Zahlen 0 < a < b < 1000 bestimmt und und auf dem Bildschirm ausgibt, für die (a 2 + b 2 + 1)/(ab) ganzzahlig ist. Diese Aufgabe wurde zwar korrigiert, aber wir stellen dennoch eine Musterlösung bereit. 1 c l a s s Aufgabe1 { 2 public s t a t i c void main ( String [] args ) { 3 aufgabe1 (); 4 } 5 public s t a t i c void aufgabe1 () { 6 for ( int a =1; a <999; ++a) 7 for ( int b=a +1; b <1000; ++b) 8 i f ((a*a+b*b +1) % (a*b) == 0) 9 System. out. println (a+" "+b); 10 } 11 } Zwei verschachtelte for Schleifen generieren uns alle Paare a, b. Dabei sorgen wir bei der Initialisierung der zweiten Schleife dafür, dass b stets größer als a ist. Dann brauchen wir nur noch zu testen, ob a 2 +b 2 +1 ohne Rest durch a b teilbar ist und eine entsprechende Ausgabe zu machen. Einige Abgaben haben statt a*a a^2 geschrieben. Leider bedeutet das in Java nicht a 2, da der ^ Operator bereits für bitweises XOR reserviert ist. 2. Java II Schreiben Sie ein Java Programm, das für eine ganzzahlige Eingabe > 1899 entscheidet, ob es sich um eine Jahreszahl eines Schaltjahres handelt und dies mit einer entsprechenden Bildschirmausgabe mitteilt. Ein Jahr ist ein Schaltjahr, wenn es durch 4 teilbar ist, es sei denn es ist durch 100 teilbar, es sei denn es ist durch 400 teilbar. Das braucht man einfach nur als boolschen Ausdruck aufzuschreiben. 1 public s t a t i c boolean schaltjahr ( int jahr ) { 2 return ( jahr % 400 == 0 ( jahr % 100!= 0 && jahr % 4 == 0)); 3 } Jetzt kann man die Funktion schaltjahr in seinen if Abfragen benutzen. Wir müssen jetzt noch Eingaben von der Tastatur einlesen. Dazu gibt es dutzende Methoden, wir zeigen hier nur eine davon. 4 public s t a t i c void main ( String [] args ) throws Exception { 5 BufferedReader b = new BufferedReader (

2 6 new InputStreamReader ( System. in) 7 ); 8 9 // s o l a n g e E i n l e s e n, b i s e i n v a l i d e s J a h r e i n g e g e b e n wurde 10 int input ; 11 do { 12 input = Integer. parseint (b. readline ()); 13 i f ( input < 1900) { 14 System. out. println (" Gib ein Jahr nach 1899 ein "); 15 } e l s e { 16 break; 17 } 18 } while ( true ); // t e s t e n, ob d a s J a h r e i n S c h a l t j a h r i s t 21 i f ( schaltjahr ( input )) 22 System. out. println (" Das ist ein Schaltjahr!"); 23 e l s e 24 System. out. println (" Das ist kein Schaltjahr!"); 25 } Damit die Klassen BufferedReader und InputStreamReader zur Verfügung stehen, muss man am Anfang seiner Datei noch import java.io.*; schreiben. Natürlich braucht man auch noch eine Klasse in der die beiden Methoden dann stehen. Das Übersetzen der Eingabe in Zeile 12 von String nach int kann natürlich fehlschlagen. Die NumberFormatException könnte man noch fangen und entsprechend behandeln. 3. Java III Schreiben Sie ein Java Programm, das für eine ganzzahlige Eingabe 20 > n > 0 die ersten n Zeilen des Pascalschen Dreiecks der Binomialkoeffizienten auf dem Bildschirm linksbündig ausgeben. Die einzelnen Einträge sollen durch Kommata getrennt sein.hinweis: Rekursion benutzen! Es gab grundsätzlich zwei Arten, wie man die Aufgabe verstehen konnte. Entweder man berechnet die Binomialkoeffizienten rekursiv, oder man berechnet die Zeilen des Pascalschen Dreiecks rekursiv. Was auf jeden Fall nicht so gut funktionierte, war die Binomialkoeffizienten über die Fakultäten auszurechnen, da die sehr schnell sehr groß werden und nicht mehr in int Variablen hineinpassen. Mit long Variablen konnte man sich allerdings einen für die Aufgabe ausreichenden Zahlenbereich reservieren. Nichtsdestotrotz wäre eine solche Lösung falsch gewesen, da sie nicht im Sinne der Aufgabe ist. Zunächst die Variante, bei der die Binomialkoeffizienten rekursiv berechnet werden. Wenn man nicht mehr weiß, wie die Rekursionsgleichung lautet, kann man in der Wikipedia nachschlagen. ( ) n = k ( ) ( ) n 1 n 1 + k 1 k

3 1 public s t a t i c int binom ( int n, int k) { 2 // E r s t d i e A b b r u c h k r i t e r i e n 3 i f (n<k) return 0; 4 i f (k ==0 k==n) return 1; 5 i f (k ==1) return n; 6 // dann d e r r e k u r s i v e A u f r u f 7 return binom (n -1,k -1) + binom (n -1,k); 8 } Wenn man die Binomialkoeffizienten hat, braucht man nur n und k durch zwei Schleifen zu generieren, um das Pascalsche Dreieck ausgeben zu können 9 public s t a t i c void pascal ( int nmax ) { 10 // d i e ä u ß e r e S c h l e i f e g e h t d i e Z e i l e n d u r c h 11 for ( int n =0; n< nmax ; n ++) { 12 / i n d e r i n n e r e n S c h l e i f e machen w i r k immer 13 g r ö ß e r und b e r e c h n e n mit u n s e r e r binom 14 F u n k t i o n den p a s s e n d e n B i n o m i a l k o e f f i z i e n t 15 d a b e i gehen w i r n u r b i s k=n 1, d a m i t w i r 16 k e i n Komma ganz am Ende d e r Z e i l e machen / 17 for ( int k =0; k<n; k ++) 18 System. out. print ( binom (n,k)+", "); 19 / Die l e t z t e Z a h l s o l l k e i n Komma haben. H i e r 20 k ö n n t e man auch g l e i c h 1 ausgeben, 21 n ü b e r n i s t j a s t e h t s 1. / 22 System. out. println ( binom (n,n)); 23 } 24 } Etwas komplizierter ist es, das Pascalsche Dreieck rekursiv über die Zeilen zu berechnen. Das Prinzip bleibt aber gleich. Wir berechnen weiterhin die Binomialkoeffizienten nach der obigen Rekursionsgleichung, allerdings benutzen wir die Beobachtung, dass wir die für die Addition benötigten Binomialkoeffizienten bereits in der Zeile darüber ausgerechnet haben und die ganze Arbeit folglich nicht nochmal machen brauchen. Wir schreiben uns also eine Funktion, die uns eine ganze Zeile als int Array zurückgibt. 1 public s t a t i c int [] pascalzeilen ( int zeile ) { 2 // I n d e r e r s t e n Z e i l e s t e h t n u r d i e 1 3 i f ( zeile ==1) { 4 System. out. println (1) ; // d i e geben w i r g l e i c h a u s 5 return new int [] {1}; 6 } 7 8 // F a l l s w i r e i n e a n d e r e Z e i l e haben w o l l e n, 9 // r e c h n e n w i r uns e r s t d i e Z e i l e d r ü b e r a u s 10 i n t [] zeiledrueber = pascalzeilen ( zeile -1) ; // dann machen w i r uns P l a t z f ü r d i e neue Z e i l e und 13 // s e t z e n g l e i c h d i e b e i d e n Werte, d i e w i r kennen 14 int [] binoms = new int [ zeile ]; 15 binoms [0]=1;

4 16 binoms [ binoms. length -1] = 1; / i n d i e s e r S c h l e i f e r e c h n e n w i r j e t z t immer d i e 19 B i n o m i a l k o e f f i z i e n t e n a u s. 20 Dabei b e n u t z e n w i r d i e Symmetrie um uns d i e H ä l f t e 21 d e r B e r e c h n u n g e n zu s p a r e n. 22 B e i e i n e r u n g e r a d e n Z e i l e n l ä n g e w i r d d a s E l e m e n t i n 23 d e r M i t t e z w e i m a l g e s e t z t, w e i l i dann b i s d o r t h i n g e h t. 24 Deswegen auch d a s e t w a s s e l t s a m anmutende A b b r u c h k r i t e r i u m 25 / 26 for ( int i =1; i <( binoms. length +1) /2; i ++) { 27 binoms [i] = zeiledrueber [i]+ zeiledrueber [i -1]; 28 binoms [ binoms. length -1 -i] = binoms [i]; 29 } // dann geben w i r d i e Z e i l e a u s 32 for ( int i =0; i< binoms. length -1; i ++) 33 System. out. print ( binoms [i]+", "); 34 System. out. println ( binoms [ binoms. length -1]) ; // und geben s i e z u r ü c k 37 return binoms ; 38 } Man braucht natürlich wieder eine Klasse mit einer main-methode, die die entsprechenden Funktionen aufruft. 4. Eine Java Methode Betrachten Sie die folgende Definition einer Methode: 1 long mystic ( int n){ 2 long N =1; 3 for ( int i =2; i <= n; i++ ){ 4 int k=i; 5 int j =0; 6 while (k >1) { 7 k=k /2; 8 j ++; 9 } 10 N = N*j; 11 } 12 return N; 13 } Auch diese Aufgabe wurde korrigiert, da aber kaum jemand alles richtig hatte, machen wir auch hier eine Musterlösung. (a) Was berechnet diese Methode? Beschreiben Sie den Rückgabewert mit einer kurzen Formel! Die for Schleife geht alle Zahlen von 2 bis n durch. In der inneren while Schleife wird dann in der Variablen j der diskrete Zweierlogarithmus von i ausgerechnet.

5 In Zeile 10 wird der dann auf einen Akkumulator aufmultipliziert. Damit ergibt sich mystic(n) = n log 2 i (b) Schätzen Sie die Laufzeit (in Abhängigkeit vom Eingabeparameter n) ab, möglichst in der Form t(n) = Θ(...) Praktisch alle Gruppen haben die while Schleife durch log n abgeschätzt. Das ist zu grob zur Bestimmung der Θ Laufzeit! Korrekt wäre folgende Abschätzung gewesen: Die for Schleife in Zeile 3 wird n 1 mal ausgeführt, die while Schleife in Zeile 6 log 2 i mal. Es ergibt sich Das kann man so umformen: T (n) = log 2 i T (n) = log 2 i log 2 i (1) n = log 2 i (2) = log 2 n! (3) ( ( n ) n ) log 2 2πn (4) e = 1 2 log 2 n + log 2 2π + n log 2 n log }{{} 2 e (5) dominiert = Θ(n log n) (6) Zeile 2 rechtfertigt sich aus dem 1. Logarithmusgesetz. In Zeile 4 wird die Fakultät mit der Stirling-Formel abgeschätzt. Für n geht der Fehler dieser Abschätzung gegen 0. Zeile 5 ergibt sich durch die Anwendung der verschiedenen Logarithmengesetze.