Abgabe: (vor 24 Uhr)

Transkript

1 TECHNISCHE UNIVERSITÄT MÜNCHEN FAKULTÄT FÜR INFORMATIK Lehrstuhl für Sprachen und Beschreibungsstrukturen WS 11/12 Einführung in die Informatik I Übungsblatt 8 Prof. Dr. Helmut Seidl, M. Schwarz, A. Herz, Dr. M. Petter Abgabe: (vor 24 Uhr) Aufgabe 8.1 (P) Rationale Zahlen Implementieren Sie die Klasse Rational zur Repräsentation rationaler Zahlen aus der Vorlesung. Definieren Sie neben einem geeigneten Konstruktor für die Klasse auch Objekt- Methoden für folgende Operationen: Anmerkung: Die Bruchzahl soll stets in gekürzter Form gespeichert werden. a) Addition: Rational add(rational r) b) Subtraktion: Rational sub(rational r) c) Multiplikation: Rational mul(rational r) d) Division: Rational div(rational r) e) Dezimalwert: double decimal() Der Aufruf r.decimal() soll den dezimalen Wert von r berechnen und zurückliefern. f) Vergleich: int compareto(rational r) Der Aufruf r1.compareto(r2) soll 1 zurückliefern falls x 1 < x 2, 0 falls x 1 = x 2 und schließlich 1 falls x 1 > x 2. Dabei sollen x 1 und x 2 die Werte sein, die durch die Objekte r1 und r2 repräsentiert werden. g) Duplizieren: Rational clone() Der Aufruf r.clone() soll eine Kopie von r erstellen und zurückliefern. Lösungsvorschlag 8.1 public class Rational { // D eklaration der Komponenten e i n e r r a t i o n a l e n Zahl private int z a e h l e r, nenner ; / Bestimmung des g r o e s s t e n gemeinsamen T e i l e r s von n und m mit dem e u k l i d s c h e n Algorithmus / private static int ggt ( int n, int m) { i f ( ( n == 0) (m == 0) ) { // Abbruch b e i Eingabe ( mindestens ) e i n e r 0 => t e i l e r f r e i return 0 ; else { while ( n!= m) { // annaehern des ggt durch s u k z e s s i v e s abziehen i f ( n > m) { n = n m; else { m = m n ; // rueckgabe des ggt durch n return n ;

2 2 // E r s t e l l e n e i n e r r a t i o n a l e n z a h l aus zwei ganzen Zahlen public Rational ( int z, int n ) { i f ( n == 0) // Eingabe ueberpruefung throw new IllegalArgumentException ( Division by zero ) ; // zuweisen der Parameter z a e h l e r = z ; nenner = n ; // Entfernen u n n o e t i g e r Vorzeichen und p o s i t i v e n nenner s i c h e r s t e l l e n int s i g n = I n t e g e r. signum ( nenner ) ; z a e h l e r = s i g n z a e h l e r ; nenner = s i g n nenner ; kuerzen ( ) ; // s i c h e r s t e l l e n, dass d i e Zahl g e k u e r z t g e s p e i c h e r t i s t // E r s t e l l e n e i n e r r a t i o n a l e n z a h l aus e i n e r ganzen Zahlen public Rational ( int z ) { this ( z, 1 ) ; // Aufruf des obigen Konstruktors mit Zaehler 1 // addiern von r zur a k t u e l l e n Zahl public Rational add ( Rational r ) { return new Rational ( // rueckgabe des E r g e b n i s s e s a l s neue r a t i o n a l e z a h l z a e h l e r r. nenner + r. z a e h l e r nenner, nenner r. nenner ) ; // e r w e i t e r n und addieren // kuerzen f i n d e t im k o n s t r u c t o r s t a t t // m u l t i p l i z i e r e n von r mit der a k t u e l l e n Zahl public Rational mul ( Rational r ) { return new Rational ( z a e h l e r r. z a e h l e r, nenner r. nenner ) ; // s u b t r a h i e r e n von r von der a k t u e l l e n Zahl durch Addition von r public Rational sub ( Rational r ) { return add ( r. mul (new Rational ( 1) ) ) ; // H i l f s f u n k t i o n f u e r D i v i s i o n. bestimmt Kehrwert der a k t u e l l e n Zahl public Rational r e c i p r o c a l ( ) { return new Rational ( nenner, z a e h l e r ) ; // D i v i s i o n der a k t u e l l e n Zahl durch r durch Mult. mit Kehrwert von r public Rational div ( Rational r ) { return mul ( r. r e c i p r o c a l ( ) ) ; // Umwandlung von z a e h l e r und nenner in eine Gleitkommazahl public double decimal ( ) { return ( double ) z a e h l e r /( double ) nenner ; public int compareto ( Rational r ) { // Voraussetzung : Nenner sind p o s i t i v

3 3 int z1 = z a e h l e r r. nenner ; // i m p l i z i t e s e r w e i t e r n der a k t u e l l e n z a h l int z2 = r. z a e h l e r nenner ; // i m p l i z i t e s e r w e i t e r n von r i f ( z1 < z2 ) {// v e r g l e i c h der e r w e i t e r t e n Zaehler return 1; else i f ( z1 > z2 ) { return 1 ; return 0 ; // weder k l e i n e r noch g r o e s s e r // G l e i c h h e i t s t e s t m i t t e l s compareto public boolean e q u a l s ( Rational r ) { return compareto ( r ) == 0 ; // erzeugen e i n e r neuen r a t i o n a l e n z a h l mit dem z a e h l e r und nenner der a k t u e l l e n z a h l public Rational c l o n e ( ) { return new Rational ( z a e h l e r, nenner ) ; // kuerzen der a k t u e l l e n Zahl durch D i v i s i o n durch den ggt von Zaehler und Nenner public void kuerzen ( ) { // ggt a u f r u f mit dem Betrag des z a e h l e r s und dem ( ohnehin p o s i t i v e n ) Nenner int ggt = ggt ( I n t e g e r. signum ( z a e h l e r ) z a e h l e r, nenner ) ; i f ( ggt > 1) { // kuerzen f a l l s n i c h t t r i v i a l e r ggt vorhanden z a e h l e r = z a e h l e r / ggt ; nenner = nenner / ggt ; // Umwandlung der Zahl in einen ( f o r m a t i e r t e ) S t r i n g d a r s t e l l u n g public S t r i n g t o S t r i n g ( ) { i f ( nenner == 1) return + z a e h l e r ; return z a e h l e r + / + nenner ; Aufgabe 8.2 (P) String-Mengen Ziel dieser Aufgabe ist es, eine Klasse ImmutableSet zur Repräsentation von unveränderbaren Mengen von Strings zu entwickeln. Implementieren Sie die Klasse ImmutableSet mit Hilfe eines Arrays, in dem jedes Element der repräsentierten Menge genau einmal vorkommt. Die Klasse ImmutableSet soll folgende Methoden bereitstellen: a) Einen Konstruktor zur Erzeugung einer leeren Menge. b) Eine Methode boolean istelement(string s), die überprüft, ob der durch s repräsentierte String in der Menge enthalten ist. c) Eine Methode boolean obermengevon(immutableset teilmenge), die überprüft, ob die Menge teilmenge in der Menge enthalten ist, die die Methode bereitstellt. d) Eine Methode boolean equals(immutableset other), die überprüft, ob die Menge

4 4 other die gleichen Elemente enthält, wie die Menge, die die Methode bereitstellt. e) Eine Methode ImmutableSet add(string s), die eine um den String s erweiterte Menge zurückgibt. Das heißt, der Aufruf m1.add(s) gibt eine Menge m2 zurück, die s und alle Elemente von m1 enthält. Falls der String s bereits in der alten Menge enthalten ist, können Sie die alte Menge zurückgeben. Für den anderen Fall erstellen Sie einen zweiten Konstruktor, diesmal einen privaten Konstruktor, der einen String s und eine Menge alt bekommt und daraus eine neue Menge erstellt, die beides enthält. Erinnern Sie sich daran, was Sie über Kopien von Arrays gelernt haben. f) Eine Methode String tostring(), die eine String-Darstellung der Menge erzeugt und zurückliefert. Hinweis: Testen Sie Ihre Klasse mit einer sinnvollen main-methode. Diese sollte alle Methoden testen und auch mögliche Interaktionen zwischen den einzelnen Methoden berücksichtigen. Lösungsvorschlag 8.2 public class ImmutableSet { // E n t h a e l t d i e Elemente des Immutable S e t s. private S t r i n g [ ] s e t ; // Konstruktor l e g t ein l e e r e s Array ( der Länge 0) an. public ImmutableSet ( ) { s e t = new S t r i n g [ 0 ] ; // Konstruktor l e g t ein neues Array an, das d i e Elemente des // S e t s o l d und den neuen S t r i n g s enth ä l t. Es wird damit // ein neues ImmutableSet erzeugt, o l d b l e i b t unver ä ndert. private ImmutableSet ( S t r i n g s, ImmutableSet old ) { s e t = new S t r i n g [ old. s e t. length + 1 ] ; System. arraycopy ( old. set, 0, set, 0, old. s e t. length ) ; s e t [ s e t. l e n g t h 1 ] = s ; // add g i b t ein ImmutableSet zur ück, dass a l l e Elemente // des S e t s enth ä l t, auf dem d i e Funktion a u s g e f ü h r t wird und // den neuen S t r i n g s. public ImmutableSet add ( S t r i n g s ) { i f ( istelement ( s ) ) {// wenn s schon e n t h a l t e n i s t,... return this ; // kann das Set zur ü ckgegeben werden, // auf dem add a u f g e r u f e n wurde else { return new ImmutableSet ( s, this ) ; // a n d e r n f a l l s wird ein // neues passendes ImmutableSet a n g e l e g t und zur ü ckgegeben // T e s t e t ob s in diesem ImmutableSet e n t h a l t e n i s t. public boolean istelement ( S t r i n g s ) {

5 5 // Dafür wird das Array einmal d u r c h l a u f e n for ( int i = 0 ; i < s e t. length ; i ++) { i f ( s e t [ i ]. e q u a l s ( s ) ) { return true ; return f a l s e ; // T e s t e t ob d i e s e s ImmutableSet eine Obermenge von t e i l m e n g e i s t. public boolean obermengevon ( ImmutableSet teilmenge ) { boolean r e t = true ; // Dafür wird geguckt, ob j e d e s Element von Teilmenge in diesem // Set e n t h a l t e n i s t. for ( int i = 0 ; i < teilmenge. s e t. length ; i++) { r e t &= istelement ( teilmenge. s e t [ i ] ) ; return r e t ; // T e s t e t ob o t h e r und d i e s e s ImmutableSet d i e g l e i c h e n Elemente e n t h a l t e n public boolean e q u a l s ( ImmutableSet other ) { // Sie sind j e w e i l s Obermengen von einander. return obermengevon ( other ) && other. obermengevon ( this ) ; // Zur sch önen Ausgabe des S e t s public S t r i n g t o S t r i n g ( ) { S t r i n g r e t = [ ; i f ( s e t. l e n g t h > 0) { r e t += s e t [ 0 ] ; for ( int i = 1 ; i < s e t. length ; i ++) { r e t +=, + s e t [ i ] ; r e t += ] ; return r e t ; Aufgabe 8.3 [10 Punkte] (H) Waschsalon Implementieren Sie mit Java geeignete Datenstrukturen zur Simulation eines Waschsalons. In unserem Szenario finden Sie: den Waschsalon, der drei Waschmaschinen (der Marken Gründlich, Mühle und Busch) beherbergt Pfennig-Münzen in den Werteinheiten 1, 5, 10, 50, 100. Jede Münze hat eine Methode, die sie in ein entsprechendes Array von Münzen der nächst kleineren Einheit umwandelt, sofern möglich, sowie eine Methode, die Auskunft über den Wert der Münze als Zahl zurückgibt. Socken mit der Sockengröße als Ganzzahl, und einer Gleitkommazahl, die den Grauwert als Farbe der Socke darstellt. 0 entspricht dabei Weiß und 1 entspricht dabei Schwarz.

6 6 Waschmaschinen mit einer maximalen Kapazität und einem Preis pro Waschgang. Waschmaschinen geben bei Überzahlung passend zurück in Form eines Münzenarrays. Implementieren Sie die Marken: Mühle mit Platz für bis zu 8 Socken zum Preis von 79 Pfennig pro Waschgang Busch mit Platz für bis zu 9 Socken zum Preis von 11 Pfennig pro Socke Gründlich mit Platz für bis zu 10 Socken zum Preis 87 Pfennig pro Waschgang. Gründlich-Waschmaschinen tendieren mit einer Warscheinlichkeit von 10% dazu, eine Socke aus dem Waschgang zu fressen. Diese Socken werden aus dem Waschgang entfernt, und bleiben statt dessen in der Maschine, um zukünftige Waschgänge durch ihre Farbe zu beeinflussen, so lange bis ihre Größe unter den Wert 2 fällt, d.h. sie klein genug sind, um durch den Abfluß zu entkommen, d.h. sie verschwinden aus der Maschine. Waschen von Socken lässt Socken um eine Nummer einlaufen, und ändert den Farbwert der Socke auf den Durchschnitt aller gewaschenen Socken. Implementieren Sie diesen Waschsalon mit allen notwendigen Methoden. Beachten Sie dabei, die Interna der beteiligten Objekte vor unvorgesehenem Zugriff durch andere Objekte zu schützen. Testen Sie Ihre Simulation mit einem geeigneten main()-programm. Lösungsvorschlag 8.3 public class Busch { public Muenze [ ] waschen ( Muenze m, Socke [ ] waschgang ) { i f ( waschgang. length >9 m. getwert ( ) <100) return new Muenze [ ] { m ; double d u r c h s c h n i t t =0; int nsocken =0; d u r c h s c h n i t t+=s. getfarbe ( ) ; nsocken++; d u r c h s c h n i t t/=nsocken ; s. waschen ( d u r c h s c h n i t t ) ; int p r e i s = 11 nsocken ; return wechsleauf (new Muenze [ ] {m, p r e i s ) ; public static Muenze [ ] wechsleauf ( Muenze [ ] m, int p r e i s ) { int i =0; while (m. length >i && p r e i s >m[ i ]. getwert ( ) ) p r e i s =m[ i ++]. getwert ( ) ; i f ( p r e i s!=m[ i ]. getwert ( ) ) { Muenze [ ] restgeld = wechsleauf (m[ i ]. wechsleklein ( ), p r e i s ) ; Muenze [ ] rueckgabe = new Muenze [ restgeld. length+m. length i 1]; for ( int j =0; j<restgeld. l ength ; j++) rueckgabe [ j ]= restgeld [ j ] ; for ( int j =0; j<m. length i 1; j++) rueckgabe [ j+restgeld. l e n g t h ]=m[ j+i ] ;

7 7 return rueckgabe ; else { Muenze [ ] rueckgabe = new Muenze [m. length i 1]; for ( int j=i +1; j<m. length ; j++) rueckgabe [ j i 1]=m[ j ] ; return rueckgabe ; public static void main ( S t r i n g [ ] args ) { System. out. p r i n t l n ( java. u t i l. Arrays. deeptostring ( wechsleauf (new Muenze [ ] {Muenze. hundertpfennig ( ),77) ) ) ; public class Muehle { public Muenze [ ] waschen ( Muenze m, Socke [ ] waschgang ) { i f ( waschgang. length >8 m. getwert ( ) <100) return new Muenze [ ] { m ; double d u r c h s c h n i t t =0; int nsocken =0; d u r c h s c h n i t t+=s. getfarbe ( ) ; nsocken++; d u r c h s c h n i t t/=nsocken ; s. waschen ( d u r c h s c h n i t t ) ; return new Muenze [ ] { Muenze. pfennig ( ), Muenze. zehnpfennig ( ), Muenze. zehnpfennig ( ) ; public class Gruendlich { // aus der Resize Array Hausaufgabe private static Socke [ ] r e s i z e A r r a y ( Socke [ ] source, int newsize ) { Socke [ ] r e s u l t = new Socke [ newsize ] ; System. arraycopy ( source, 0, r e s u l t, 0, Math. min ( newsize, source. l e n g t h ) ) ; return r e s u l t ; private static boolean f r e s s e ( ) { return Math. random ( ) >0.9; private Socke [ ] r e s e r v o i r = new Socke [ 0 ] ; public Muenze [ ] waschen ( Muenze m, Socke [ ] waschgang ) { i f ( waschgang. length >10 m. getwert ( ) <100) return new Muenze [ ] { m ; double d u r c h s c h n i t t =0; int nsocken =0; // Waschgang untersuchen

8 8 d u r c h s c h n i t t+=s. getfarbe ( ) ; nsocken++; // Sockenspeicher durchsuchen for ( Socke s : r e s e r v o i r ) { d u r c h s c h n i t t+=s. getfarbe ( ) ; d u r c h s c h n i t t/=nsocken+r e s e r v o i r. length ; // Waschgang f a e r b e n s. waschen ( d u r c h s c h n i t t ) ; // Reservoir f a e r b e n & a u s s o r t i e r e n int r e s e r v o i r g r o e s s e = r e s e r v o i r. length ; for ( int i = 0 ; i < r e s e r v o i r g r o e s s e ; i ++){ r e s e r v o i r [ i ]. waschen ( d u r c h s c h n i t t ) ; i f ( r e s e r v o i r [ i ]. getgroesse ( ) <3){ r e s e r v o i r [ i ]= r e s e r v o i r [ r e s e r v o i r g r o e s s e ] ; r e s e r v o i r [ r e s e r v o i r g r o e s s e 1]=null ; r e s e r v o i r=r e s i z e A r r a y ( r e s e r v o i r, r e s e r v o i r g r o e s s e ) ; // b e i 10% Reservoir f u e l l e n i f ( f r e s s e ( ) && nsocken >0) { Socke socke ; do{ int pos = ( int ) (Math. random ( ) waschgang. length ) ; socke=waschgang [ pos ] ; waschgang [ pos ]= null ; while ( socke==null ) ; r e s e r v o i r=r e s i z e A r r a y ( r e s e r v o i r, r e s e r v o i r. length +1) ; r e s e r v o i r [ r e s e r v o i r. length 1]= socke ; return new Muenze [ ] { Muenze. zehnpfennig ( ), Muenze. pfennig ( ), Muenze. p f e n n i g ( ), Muenze. pfennig ( ) ; public class Muenze { private int wert ; private Muenze ( int i n i t i a l w e r t ) { wert = i n i t i a l w e r t ; public static Muenze p f e n nig ( ) { return new Muenze ( 1 ) ; public static Muenze zehnpfennig ( ) { return new Muenze (10) ; public static Muenze hundertpfennig ( ) { return new Muenze (100) ; public static Muenze f u e n f P f e n n i g ( ) { return new Muenze ( 5 ) ;

9 9 public static Muenze f u e n f z i g P f e n n i g ( ) { return new Muenze (50) ; public int getwert ( ) { return wert ; public Muenze [ ] wechsleklein ( ) { i f ( wert==1) return new Muenze [ ] { this ; i f ( wert==100 wert == 1 0) return new Muenze [ ] { new Muenze ( wert /2), new Muenze ( wert /2) ; else { Muenze [ ] m = new Muenze [ 5 ] ; for ( int i =0; i <5; i++) m[ i ]=new Muenze ( wert /5) ; return m; public S t r i n g t o S t r i n g ( ) { return Muenze mit Wert +wert ; public class Socke { private int g r o e s s e ; private double f a r b e ; public Socke ( int i n i t g r o e s s e, double i n i t f a r b e ) { g r o e s s e=i n i t g r o e s s e ; f a r b e=i n i t f a r b e ; public double getfarbe ( ) { return f a r b e ; public int getgroesse ( ) { return g r o e s s e ; private void eingehen ( ) { g r o e s s e ; public void waschen ( double neufaerbung ) { f a r b e=neufaerbung ; eingehen ( ) ; public S t r i n g t o S t r i n g ( ) { return Socke der Groesse +g r o e s s e+ und Grauwert +f a r b e ;