Lösungen - Lehr- und Forschungsgebiet Informatik 2

RHEINISCH-
WESTFÄLISCHE
TECHNISCHE
HOCHSCHULE
AACHEN
LEHR- UND FORSCHUNGSGEBIET
INFORMATIK 2
RWTH Aachen · D-52056 Aachen · GERMANY
http://programmierung.informatik.rwth-aachen.de
LuFG
Informatik II
Prof. Dr. Jürgen Giesl
Carsten Fuhs, Peter Schneider-Kamp, Stephan Swiderski
Übung Programmierung WS 2007/08 - Blatt 3
(Lösungsvorschlag)
Aufgabe 1
a) Ja. Eine Schleife der Form
while (B) {
P
}
lässt sich gleichwertig in die Form
if (B) {
do {
P
} while (B);
}
überführen.
b) Ja. Eine Schleife der Form
do {
P
} while (B);
lässt sich gleichwertig in die Form

{
}
P;
for ( ; B; ) {
P
}
überführen.

Aufgabe 2
Listing 1: Fibfor.java
1 /∗ Das Programm berechnet zur Eingabe n die n−te Fibonacci −Zahl .
2 ∗ Dabei werden ausser for −Schleifen keine anderen Schleifentypen
3 ∗ verwendet .
4 ∗
5 ∗ Autor : Antje Nowack , Carsten Fuhs
6 ∗ Erst ellt : 05.11.2001
7 ∗ Letzte Aenderung : 05.11.2007
8 ∗/
9
10 public class Fibfor {
11
12 public static void main (String [ ] arguments ) {
13
14 // Eingabe
15 System .out .println (” Bitte geben Sie eine natuerliche Zahl ein : ” ) ;
16 int n = IO .readInt ( ) ;
17
18 // a0 und a1 enthalten jeweils aufeinanderfolgende Fibonacci −Zahlen .
19 int a0 = 0;
20 int a1 = 1;
21
22 // res wird zum Zwischenspeichern benutzt und enthaelt am Ende
23 // das Ergebnis
24 int res = 0;
25
26 if (n == 1) {
27 res = 1;
28 }
29
30 // n − 1 Schleifendurchlaeufe
31 for ( int j = 1; j < n ; ++j) {
32
33 // a0 enthaelt jeweils die zu j − 1 gehoerige Fibonacci −Zahl ,
34 // a1 enthaelt die zu j gehoerige Fibonacci −Zahl , und
35 // res enthaelt die zu j + 1 gehoerige Fibonacci −Zahl .
36 res = a0 + a1 ;
37
38 a0 = a1 ;
39 a1 = res ;
40 }
41
42 // Ausgabe
43 System .out .println (”Die ” + n + ”−te Fibonacci−Zahl i s t ” + res ) ;
44 }
45 }

Listing 2: Fibwhile.java
1 /∗ Das Programm berechnet zur Eingabe n die n−te Fibonacci −Zahl .
2 ∗ Dabei werden ausser while −Schleifen keine anderen Schleifentypen
3 ∗ verwendet .
4 ∗
5 ∗ Autor : Antje Nowack , Carsten Fuhs
6 ∗ Erst ellt : 05.11.2001
7 ∗ Letzte Aenderung : 05.11.2007
8 ∗/
9
10 public class Fibwhile {
11
12 public static void main (String [ ] arguments ) {
13
14 // Eingabe
15 System .out .println (” Bitte geben Sie eine natuerliche Zahl ein : ” ) ;
16 int n = IO .readInt ( ) ;
17
18 // a0 und a1 enthalten jeweils aufeinanderfolgende Fibonacci −Zahlen .
19 int a0 = 0;
20 int a1 = 1;
21
22 // res wird zum Zwischenspeichern benutzt und enthaelt am Ende
23 // das Ergebnis
24 int res = 0;
25
26 if (n == 1) {
27 res = 1;
28 }
29
30 // Laufvariable
31 int j = 1;
32
33 // n − 1 Schleifendurchlaeufe
34 while (j < n) {
35
36 // a0 enthaelt jeweils die zu j − 1 gehoerige Fibonacci −Zahl ,
37 // a1 enthaelt die zu j gehoerige Fibonacci −Zahl , und
38 // res enthaelt die zu j + 1 gehoerige Fibonacci −Zahl .
39 res = a0 + a1 ;
40
41 a0 = a1 ;
42 a1 = res ;
43
44 // Laufvariable um 1 erhoehen .
45 ++j ;
46 }
47
48 // Ausgabe
49 System .out .println (”Die ” + n + ”−te Fibonacci−Zahl i s t ” + res ) ;

50 }
51 }

Aufgabe 3
Listing 3: Mastermind.java
1 /∗ Das Programm simuliert das Spiel Mastermind.
2 ∗ Hierbei erzeugt der Computer z u f aellig ein Geheimwort aus
3 ∗ vier Zeichen , welches der Benutzer raten muss .
4 ∗
5 ∗ Autor : Antje Nowack , Carsten Fuhs , Stephan Swiderski
6 ∗ Erst ellt : 05.11.2001
7 ∗ Letzte Aenderung : 06.11.2007
8 ∗/
9
10 public class Mastermind {
11
12 public static void main (String [ ] args ) {
13 // Laufvariable fuer die do−while −Schleife
14 int j = 1;
15
16 // g1 , g2 , g3 , g4 enthalten spaeter die Zeichen des Geheimwortes
17 char g1 , g2 , g3 , g4 ;
18
19 /∗ eingabe i s t jeweils das geratene Wort ,
20 ∗ und e1 , e2 , e3 , e4 sind seine Zeichen
21 ∗/
22 String eingabe ;
23 char e1 , e2 , e3 , e4 ;
24
25 // erstes Zeichen des Geheimwortes aus dem Wertebereich { ’A’ , . . . , ’H’}
26 g1 = Zufall .zufallszeichen ( ’H’ ) ;
27
28 /∗ Nun wird das zweite Zeichen des Geheimwortes bestimmt . Da g1 und g2
29 ∗ nicht gleich sein duerfen , stehen fuer die Wahl von g2 nur noch
30 ∗ 7 Zeichen zur Verfuegung . Um dies umzusetzen , wird wie f olgt
31 ∗ vorgegangen :
32 ∗ 1. Waehle ein Zeichen aus dem Wertebereich { ’A’ , . . . , ’G’}
33 ∗ 2. Wenn das gewaehlte Zeichen < g1 ist , so i s t dies das zweite
34 ∗ geratene Zeichen .
35 ∗ 3. Sonst wird 1 hinzuaddiert , um das zweite Zeichen zu erhalten
36 ∗ ( Beachte : Z.B. ’A’ + 1 == ’B ’).
37 ∗
38 ∗ Somit wird das zweite Zeichen aus dem Bereich
39 ∗ { ’A’ , . . . , g1 −1, g1+1, . . . , ’H’} gewaehlt .
40 ∗/
41
42 g2 = Zufall .zufallszeichen ( ’G’ ) ;
43 if (g2 >= g1) {
44 ++g2 ;
45 }
46
47 /∗ Das Vorgehen fuer das dri tte Zeichen is t aehnlich dem Vorgehen

48 ∗ fuer das zweite Zeichen . Hier wird zunaechst ein Zeichen aus dem
49 ∗ Wertebereich { ’A’ , . . . , ’F’} gewaehlt . Die moeglichen Zeichen sind
50 ∗ diejenigen aus der Menge
51 ∗ { ’A’ , . . . , g1 −1, g1+1, . . . , g2 −1, g2+1, . . . , ’H’} bzw .
52 ∗ { ’A’ , . . . , g2 −1, g2+1, . . . , g1 −1, g1+1, . . . , ’H ’ }.
53 ∗ Entsprechend muss das vom Zufallsgenerator erhaltene Zeichen
54 ∗ um 1 erhoeht werden fuer den Bereich zwischen min(g1 , g2) und
55 ∗ max(g1 , g2) − 2 ( jeweils einschli esslich ) und um 2 erhoeht
56 ∗ werden fuer den Bereich ab max(g1 , g2) − 1.
57 ∗/
58
59 // kleinstesG = min(g1 , g2) und groesstesG = max(g1 , g2)
60 int kleinstesG , groesstesG ;
61 if (g2 >= g1) {
62 kleinstesG = g1 ;
63 groesstesG = g2 ;
64 }
65 else {
66 kleinstesG = g2 ;
67 groesstesG = g1 ;
68 }
69
70 g3 = Zufall .zufallszeichen ( ’F ’ ) ;
71 if (g3 >= kleinstesG ) {
72 ++g3 ;
73 }
74 if (g3 >= groesstesG ) {
75 ++g3 ;
76 }
77
78 /∗ Das Vorgehen fuer das vierte Zeichen is t nun aehnlich dem Vorgehen
79 ∗ fuer das dritte Zeichen . Hier wird zunaechst ein Zeichen aus dem
80 ∗ Wertebereich { ’A’ , . . . , ’E’} gewaehlt . Die moeglichen Zeichen sind
81 ∗ dann diejenigen aus der Menge { ’A’ , . . . , ’H’} \ {g1 , g2 , g3 }.
82 ∗
83 ∗ Hierfuer s o l l gelten :
84 ∗ {kleinstesG , mittleresG , groesstesG } == {g1 , g2 , g3 } , wobei
85 ∗ kleinstesG = min(g1 , g2 , g3 ) , groesstesG = max(g1 , g2 , g3) und
86 ∗ kleinstesG < mittleresG < groesstesG
87 ∗/
88
89 int mittleresG ;
90 if (g3 > kleinstesG ) {
91 if (g3 > groesstesG ) {
92 mittleresG = groesstesG ;
93 groesstesG = g3 ;
94 }
95 else {
96 mittleresG = g3 ;
97 }

98 }
99 else {
100 mittleresG = kleinstesG ;
101 kleinstesG = g3 ;
102 }
103
104 g4 = Zufall .zufallszeichen ( ’E ’ ) ;
105 if (g4 >= kleinstesG ) {
106 ++g4 ;
107 }
108 if (g4 >= mittleresG ) {
109 ++g4 ;
110 }
111 if (g4 >= groesstesG ) {
112 ++g4 ;
113 }
114
115
116 /∗ Die folgende Schleife i s t die in der Aufgabenstellung geforderte
117 ∗ do−while −Schleife .
118 ∗/
119 do {
120
121 /∗ Speichert , ob die Eingabe genau vier Zeichen aus dem erlaubten
122 ∗ Alphabet enthaelt
123 ∗/
124 boolean korrekteEingabe ;
125
126 /∗ Die folgende do−while −Schleife i s t fuer die Eingabe zustaendig .
127 ∗ Der Benutzer muss genau vier Zeichen eingeben .
128 ∗ Ansonsten wird er zur erneuten Eingabe aufgefordert .
129 ∗ Gleichzeitig wird das eingegebene Wort in seine Zeichen z erlegt .
130 ∗/
131 do {
132 korrekteEingabe = true ;
133 System .out .println (” Bitte geben Sie ein Wort aus vier Zeichen aus”
134 + ” { ’A ’ , ’B ’ , . . . , ’H’} ein ! ” ) ;
135 eingabe = IO .readLine ( ) ;
136
137 // Laenge der Eingabe ueberpruefen
138 if (IO .length (eingabe ) != 4) {
139 System .out .println (” Bitte geben Sie genau vier Zeichen ein ! ” ) ;
140 korrekteEingabe = false ;
141 }
142 else {
143 // ueberpruefen , ob die Eingabe nur erlaubte Zeichen enthaelt
144 for ( int i = 0; i < 4; ++i) {
145 char itesZeichenDerEingabe = IO .charAt (eingabe , i ) ;
146 if ( ! (itesZeichenDerEingabe >= ’A’
147 && itesZeichenDerEingabe

148 System .out . println (” Bitte geben Sie nur Zeichen aus”
149 + ” { ’A ’ , ’B ’ , . . . , ’H’} ein ! ” ) ;
150 korrekteEingabe = false ;
151 break ;
152 }
153 }
154 }
155 }
156 while ( ! korrekteEingabe ) ;
157
158 e1 = IO .charAt (eingabe , 0);
159 e2 = IO .charAt (eingabe , 1);
160 e3 = IO .charAt (eingabe , 2);
161 e4 = IO .charAt (eingabe , 3);
162
163 /∗ In der Variable richtigeStellen wird die Anzahl der an der
164 ∗ richtigen S telle geratenen Zeichen berechnet .
165 ∗/
166 int richtigeStellen = 0;
167
168 if (e1 == g1 ) {
169 ++richtigeStellen ;
170 }
171 if (e2 == g2 ) {
172 ++richtigeStellen ;
173 }
174 if (e3 == g3 ) {
175 ++richtigeStellen ;
176 }
177 if (e4 == g4 ) {
178 ++richtigeStellen ;
179 }
180
181 System .out .println (” Richtige S tellen : ” + richtigeStellen );
182
183 /∗ In der Variable vorkommende wird die Anzahl der geratenen
184 ∗ Zeichen berechnet , die zwar im Geheimwort auftreten ,
185 ∗ jedoch nicht an der geratenen S telle .
186 ∗/
187 int vorkommende = 0;
188
189 if (e1 == g2 | | e1 == g3 | | e1 == g4 ) {
190 ++vorkommende ;
191 }
192 if (e2 == g1 | | e2 == g3 | | e2 == g4 ) {
193 ++vorkommende ;
194 }
195 if (e3 == g1 | | e3 == g2 | | e3 == g4 ) {
196 ++vorkommende ;
197 }

198 if (e4 == g1 | | e4 == g2 | | e4 == g3 ) {
199 ++vorkommende ;
200 }
201
202 System .out .println (”Auftretende Zeichen : ” + vorkommende ) ;
203
204 /∗ Wenn alle Zeichen r ichtig und jeweils an der richtigen St elle
205 ∗ geraten wurden , dann hat der Benutzer das Geheimwort erraten .
206 ∗ Die Schleife wird verlassen .
207 ∗/
208 if (richtigeStellen == 4) {
209 break ;
210 }
211
212 // Die Nummer des Rateversuchs wird um 1 erhoeht .
213 ++j ;
214 }
215 // Der Benutzer darf zwoelfmal raten .
216 while (j

Aufgabe 4
a) 〈n ≥ 0〉
〈n ≥ 0 ∧ 0 = 0〉
i = 0;
〈n ≥ 0 ∧ i = 0〉
〈n ≥ 0 ∧ i = 0 ∧ 0 = 0〉
res = 0;
〈n ≥ 0 ∧ i = 0 ∧ res = 0〉
〈i ≤ n ∧ res = n ∗ i〉
while (i < n) {
〈i ≤ n ∧ res = n ∗ i ∧ i < n〉
〈i < n ∧ res + n = n ∗ i + n〉
res = res + n;
〈i < n ∧ res = n ∗ i + n〉
〈i + 1 ≤ n ∧ res = n ∗ (i + 1)〉
i = i + 1;
〈i ≤ n ∧ res = n ∗ i〉
}
〈i ≤ n ∧ res = n ∗ i ∧ i ≮ n〉
〈res = n 2 〉

) Eine Variante ist V = n − i, denn aus der Schleifenbedingung i < n folgt
n − i ≥ 0. Somit:
res = res + n;
i = i + 1;
〈n − i = m ∧ i < n〉
〈n − (i + 1) < m〉
〈n − (i + 1) < m〉
〈n − i < m〉
Damit ist die Terminierung der einzigen Schleife in P gezeigt.
c) Für n = 46341 nimmt die int-Variable res einen negativen Wert an. Der
Grund dafür ist, dass das eigentlich erwünschte Ergebnis 46341 2 = 2147488281
größer ist als der maximal in einem int darstellbare Wert von 2 31 − 1. Bei der
obigen Verifikation gehen wir jedoch vereinfachend davon aus, dass beliebig
große ganze Zahlen dargestellt werden können.