| 04.11.2011, 10:18 |
Math1986 |
Auf diesen Beitrag antworten » |
| Zitat: |
Original von Dennis2010
Guten Morgen, ich habe das noch mal ein bisschen Revue passieren lassen und hier meine Ideen zu den einzelnen Methoden: |
Bisher sieht das ganz gut aus.
du musst bei der insert(..) Methode natürlich den darüberstehenden Kommentar beachten:
| Zitat: |
/**
* Fuege ein Element in die Menge ein
*
* @param elem Nummer des Elements, welches in die Menge einzufuegen ist
* Wenn das Element bereits in der Menge enthalten ist,
* hat die Operation keine Wirkung. Wenn das Element nicht im Wertebereich * 0..31 liegt, wird dies still ignoriert.
*/ |
Wobei ich mir gerade nicht sicher bin, ob das technisch wirklich nötig wäre.
Allgemein ist die Kurzschreibwerse für Operatoren, die mit sich selbst verknüpft werden, sehr nützlich:
Anstelle von setState=setState | (1<<elem); also kurz setState |= (1<<elem); und bei anderen analog.
Den code für hasElement kannst du dir aus der Methode card() kopieren. 
Ansonsten musst du in der zweiten Klasse die main(..) Methode ausführen, dann testet er dein Programm. |
| 04.11.2011, 13:27 |
Gast11022013 |
Auf diesen Beitrag antworten » |
| Zitat: |
Original von Math1986
du musst bei der insert(..) Methode natürlich den darüberstehenden Kommentar beachten:
| Zitat: |
/**
* Fuege ein Element in die Menge ein
*
* @param elem Nummer des Elements, welches in die Menge einzufuegen ist
* Wenn das Element bereits in der Menge enthalten ist,
* hat die Operation keine Wirkung. Wenn das Element nicht im Wertebereich * 0..31 liegt, wird dies still ignoriert.
*/ |
Wobei ich mir gerade nicht sicher bin, ob das technisch wirklich nötig wäre.
|
Das hört sich für mich so an, als müsste man eine if-Bedingung davorschalten:
Wenn die einzufügende Zahl kleiner als 32 ist, dann führe das aus.^
Das bedeutet doch, daß elem kleiner als 2^(32) sein muss? Also kleiner als (1<<32)? Stimmt das?
Wenn ja, würde ich den Code dann so abändern:
| code: |
1:
2:
3:
4:
5:
6:
7:
|
public void insert(int elem)
{
if(elem<(1<<32))
setState=setState | (1<<elem);
}
|
|
Ist das korrekt?
| Zitat: |
Original von Math1986
Den code für hasElement kannst du dir aus der Methode card() kopieren.
|
Was soll mit dieser Methode erreicht werden?
Das habe ich aufgrund der nicht vorhandenen Anweisung noch nicht verstanden und bevor ich wieder blöd rumprogrammiere, frage ich diesmal lieber mal gleich.
Meine Idee ist, daß man überprüfen soll, ob ein bestimmtes Element in der Menge ist und dafür muss ja an der zugehörigen Bitstelle eine 1 stehen, daher wäre meine Idee:
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
|
public boolean hasElem(int elem) {
return(((setState & (1<<elem))!=0);
}
|
|
| Zitat: |
Original von Math1986
Ansonsten musst du in der zweiten Klasse die main(..) Methode ausführen, dann testet er dein Programm. |
Ja, ich habe das ausführen lassen und wenn alles stimmen würde, müsste überall "Pass" stehen". Bis jetzt steht aber nur an drei Stellen "Pass". Daher habe ich meine Lösungen auch gepostet, weil ich keine Fehler sah.
Ausgegeben wird:
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
|
C:\projekte>java Uebung1
PASS: b0.empty()
PASS: b0.card() == 0
FAIL: b0.elem(31)
b0: { }
b1: { }
Fail: b1.card() == 7
b0: { }
b1: { }
PASS: b0.empty()
FAIL: !b0.empty()
b0: { }
b1: { }
FAIL: b0.toString() equals {1, 23}
b0: {}
b1: {} |
|
Und ich weiß nicht wirklich, was ich nun falsch gemacht habe.
Ich muss nochmal um Hilfe bitten. |
| 04.11.2011, 15:27 |
Gast11022013 |
Auf diesen Beitrag antworten » |
Hab mir nochmal die Methode angeguckt, die die Klasse am Ende testen soll und so, wie ich das sehe, hängt ganz viel von der Methode insert ab.
Da muss ich immer noch irgendwas falsch haben, was die ganzen anderen Fehler nach sich zieht.
Weiß jemand, was? |
| 04.11.2011, 15:35 |
Wetal |
Auf diesen Beitrag antworten » |
| Zitat: |
| code: |
1:
2:
3:
4:
5:
6:
7:
|
public void insert(int elem)
{
if(elem<(1<<32))
setState=setState | (1<<elem);
}
|
|
Ist das korrekt? Ist das korrekt? |
hier vergleichst du ein element "elem" mit einer menge die die zahl 32 enthält, die in keiner relation stehen sollten. |
| 04.11.2011, 15:37 |
Gast11022013 |
Auf diesen Beitrag antworten » |
Dann vielleicht
| code: |
1:
2:
3:
4:
|
....
if(elem<32)
... |
|
?
Habe ich auch getestet, scheint nichts zu ändern. |
| 04.11.2011, 15:48 |
Gast11022013 |
Auf diesen Beitrag antworten » |
Jedenfalls scheinen die Knackpunkte bei den beiden Methoden
insert und hasElem zu sein. |
| Anzeige | |
|
|
| 04.11.2011, 15:52 |
Wetal |
Auf diesen Beitrag antworten » |
jo, schon besser. was ist eigentlich mit deiner union methode? (falls du das noch nicht verändert hast)
| code: |
1:
2:
3:
4:
|
public void union(MyBitSet theOtherSet)
{
setState=setState | theOtherSet;
} |
|
da hast eine operation auf "integer | MyBitSet", welche so nicht klappen sollte.
zu der methode insert solltest du mal testen ob es an der syntax leigt.
| code: |
1:
2:
3:
|
if ( .... ) {
...;
} |
|
|
| 04.11.2011, 16:02 |
Gast11022013 |
Auf diesen Beitrag antworten » |
Muss ich da explizit casten? Also ein (int) davorschreiben?
| code: |
1:
2:
3:
4:
5:
|
...
setState=(int) setState | theOtherSet
... |
|
?
Die Klammerung bei der Methode insert ändert leider nichts.
|
| 04.11.2011, 16:15 |
Gast11022013 |
Auf diesen Beitrag antworten » |
Allerdings frage ich mich, ob es wirklich Probleme mit den Typen gibt, denn da steht ja:
/**
* Der sogenannte Copy-Konstruktor liest die Attribute
* eines Referenzobjektes desselben Typs und kopiert die Werte auf
* die Attribute des neu erzeugten Objektes
Ansonsten bin ich jetzt mit meinem Latein am Ende.
Ich sehe einfach nicht, was da falsch sein soll bei insert und hasElem. |
| 04.11.2011, 16:55 |
Math1986 |
Auf diesen Beitrag antworten » |
| Zitat: |
Original von Dennis2010
Muss ich da explizit casten? Also ein (int) davorschreiben?
| code: |
1:
2:
3:
4:
5:
|
...
setState=(int) setState | theOtherSet
... |
|
?
Die Klammerung bei der Methode insert ändert leider nichts.
|
Das Problem bei den Typen ist, dass du nicht zwichen dem Attribut setState (int) umd dem Objekt der Klasse selbst (MyBitSet) unterscheidest.
Richtig wäre:
| code: |
1:
2:
3:
4:
5:
|
...
setState=setState | theOtherSet.toInt();
... |
|
oder kürzer:
| code: |
1:
2:
3:
4:
5:
|
...
setState |= theOtherSet.toInt();
... |
|
Der selbe Fehler hat sich auch schon bei union(...) u.a. eingeschlichen.
PS: hasElem(...) und intert(...) sehen soweit korrekt aus. |
| 04.11.2011, 16:56 |
Math1986 |
Auf diesen Beitrag antworten » |
| Zitat: |
Original von Dennis2010
Allerdings frage ich mich, ob es wirklich Probleme mit den Typen gibt, denn da steht ja:
/**
* Der sogenannte Copy-Konstruktor liest die Attribute
* eines Referenzobjektes desselben Typs und kopiert die Werte auf
* die Attribute des neu erzeugten Objektes |
Was willst du uns damit sagen?
PS: Bitte editiere deine beiträge anstatt mehrere Postings zu erstellen. |
| 04.11.2011, 17:01 |
Ibn Batuta |
Auf diesen Beitrag antworten » |
| Zitat: |
Original von Math1986
Richtig wäre: return (this.setState==0), alternativ könnte man auch die Funktion card() verwenden. |
Und noch richtiger wäre:
| Zitat: |
public boolean empty() {
boolean isEmpty = true;
if(!(toInt() == 0))
isEmpty = false;
return isEmpty;
} |
Dann hätte auch die -Methode ihre Legitimation.
Ibn Batuta |
| 04.11.2011, 17:02 |
Gast11022013 |
Auf diesen Beitrag antworten » |
Ich wollte damit sagen, daß die Typen evtl. gar nicht unterschiedlich sind, aber das war natürlich falsch.
Okay, wenn ich das richtig sehe, muss ich das also bei den Methoden
union
intersextion
setMinus
korrigieren.
Das habe ich gemacht. Immer noch wird nur bei 3 Stellen das "Pass" angezeigt. |
| 04.11.2011, 17:07 |
Math1986 |
Auf diesen Beitrag antworten » |
| Zitat: |
Original von Ibn Batuta
| Zitat: |
Original von Math1986
Richtig wäre: return (this.setState==0), alternativ könnte man auch die Funktion card() verwenden. |
Und noch richtiger wäre:
| Zitat: |
public boolean empty() {
boolean isEmpty = true;
if(!(toInt() == 0))
isEmpty = false;
return isEmpty;
} |
Dann hätte auch die -Methode ihre Legitimation. |
Was heißt hier "noch richtiger"?
Inwiefern ist deiner "noch richtiger" ? (wobei ich mich frage, wie man "richtig" steigern will, entweder etwas ist richtig oder eben nicht, und beide Methoden liefern ein korrektes Ergebnis).
Deinen Code halte ich eher für umständlich, was die Einführung einer weiteren Variablen betrifft.
Man könnte auch schreiben: return (this.toInt()==0), was aber vollkommen äquivalent wäre.
Die Methode toInt() hat so oder so Ihre "Berechtigung". |
| 04.11.2011, 17:09 |
Gast11022013 |
Auf diesen Beitrag antworten » |
Aber ist toInt() hier nicht schon oben anders "definiert" worden?
Oder ist das wieder was Anderes?
--------------------
Ich weiß im Moment nicht weiter.
Ich sehe jetzt bei den einzelnen Methoden keine Fehler mehr, verstehe aber nicht, wieso nur 3 Mal "Pass" angezeigt wird, was ja heißt, daß noch irgendwo was falsch ist. |
| 04.11.2011, 17:15 |
Wetal |
Auf diesen Beitrag antworten » |
| code: |
1:
|
return(((setState & (1<<elem))!=0); |
|
klammer zu viel, oder zu wenig. |
| 04.11.2011, 17:18 |
Gast11022013 |
Auf diesen Beitrag antworten » |
Das hatte ich schon zu
| code: |
1:
|
return((setState & (1<<elem))!==0) |
|
verbessert. Danke aber für den Hinweis trotzdem!
Ich poste einfach nochmal den aktuellen Stand!
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
|
class MyBitSet {
public int setState;
/**
* Konstruktor erzeugt eine leere Menge
*/
MyBitSet() {
setState = 0;
}
/**
* Der sogenannte Copy-Konstruktor liest die Attribute
* eines Referenzobjektes desselben Typs und kopiert die Werte auf
* die Attribute des neu erzeugten Objektes
*/
public MyBitSet(MyBitSet theOtherSet) {
setState = theOtherSet.toInt();
}
public MyBitSet(int m) {
setState = m;
}
/**
* Gibt true zurueck, falls die Menge leer ist
*/
public boolean empty( )
{
return(setState==0);
}
/**
* Gib die Anzahl der Elemente ("Kardinalität") in der Menge zurück,
* die vom Objekt repräsentiert wird
*/
public int card(int a)
{
int numElements=0;
for(int i=0;i<32;i++)
{
if((setState & (1<<i))!=0)
numElements++;
}
return numElements;
}
/**
* Gib den Zustand der Menge als Integer zurück
*/
public int toInt() {
return setState;
}
/**
* Mache das Objekt zur leeren Menge
*/
public void erase()
{
setState=0;
}
/**
* Fuege ein Element in die Menge ein
*
* @param elem Nummer des Elements, welches in die Menge einzufuegen ist
* Wenn das Element bereits in der Menge enthalten ist,
* hat die Operation keine Wirkung. Wenn das Element nicht im Wertebereich
* 0..31 liegt, wird dies still ignoriert.
*/
public void insert(int elem)
{
if(elem<32){
setState=setState | (1<<elem);
}
}
/**
* Vereinige die durch das Objekt repräsentierte Menge
* mit einer zweiten Menge, die als Parameter übergeben wird.
*
* @param theOtherSet Objektinstanz vom Typ MyBitSet.
* Es wird die Vereinigung aus setState und theOtherSet gebildet.
*/
public void union(MyBitSet theOtherSet) {
setState=setState | theOtherSet.toInt();
}
/**
* Bilde aus dem aktuellen Objekt den Durchschnitt mit der als Parameter
* mit gegebenen zweiten Menge
*/
public void intersection(MyBitSet theOtherSet) {
setState=setState & theOtherSet.toInt();
}
/**
* Bilde aus dem aktuellen Objekt O1 die Mengendifferenz
* O1 \ theOtherSet mit der als Parameter eingegebene Menge
*/
public void setMinus(MyBitSet theOtherSet) {
setState=setState & ~theOtherSet.toInt();
}
public boolean hasElem(int elem) {
return((setState & (1<<elem))!=0);
}
/**
* Repräsentiere die Menge als String, in der üblichen Notation
*/
public String toString() {
String theSetAsString;
boolean isFirst = true;
theSetAsString = "{ ";
for ( int i = 0; i < 32; i++ ) {
if ( (setState & (1 << i)) != 0 ) {
if ( ! isFirst )
theSetAsString = theSetAsString + ", ";
isFirst = false;
Integer e = new Integer(i);
String theElemAsString = new String(e.toString());
theSetAsString = theSetAsString + theElemAsString;
}
}
theSetAsString = theSetAsString + " }";
return theSetAsString;
}
}
class Uebung1 {
public static void tassert(String aStr, boolean a, MyBitSet b0, MyBitSet b1) {
if ( a ) {
System.out.println("PASS: " + aStr);
}
else {
System.out.println("FAIL: " + aStr);
System.out.println("b0: " + b0.toString());
System.out.println("b1: " + b1.toString());
}
}
/**
* Methode zum Test der eigentlich zu entwickelnden Klasse
*/
public static void main(String[] args) {
MyBitSet b0 = new MyBitSet();
MyBitSet b1 = new MyBitSet();
tassert("b0.empty()",b0.empty(),b0,b1);
tassert("b0.card() == 0",b0.card() == 0,b0,b1);
b0.insert(31);
tassert("b0.elem(31)",b0.hasElem(31),b0,b1);
b1.insert(0);
b1.insert(10);
b1.insert(320);
b1.insert(31);
b1.insert(20);
b1.insert(17);
b1.insert(19);
b1.insert(3);
tassert("b1.card() == 7", b1.card() == 7, b0, b1);
b0.setMinus(b1);
tassert("b0.empty()",b0.empty(),b0,b1);
b0.insert(31);
b0.insert(17);
b0.insert(23);
b0.insert(1);
b0.setMinus(b1);
tassert("!b0.empty()",!b0.empty(),b0,b1);
tassert("b0.toString() equals { 1, 23 }",b0.toString().equals("{ 1, 23 }"),b0,b1);
}
} |
|
|
| 04.11.2011, 17:19 |
Ibn Batuta |
Auf diesen Beitrag antworten » |
| Zitat: |
Original von Math1986
Was heißt hier "noch richtiger"?
Inwiefern ist deiner "noch richtiger" ? (wobei ich mich frage, wie man "richtig" steigern will, entweder etwas ist richtig oder eben nicht, und beide Methoden liefern ein korrektes Ergebnis). |
Arbeitet man sorgfältig nach Design Patterns, ist es gute Konvention, dass man die getter-Methoden verwendet, auch wenn sie im Konstruktor gesetzt werden. Dazu aber weiter unten noch etwas.
| Zitat: |
Original von Math1986
Deinen Code halte ich eher für umständlich, was die Einführung einer weiteren Variablen betrifft.
|
Eine weitere Variable?
Wo möchtest du eine weitere Variable einführen und wie verwenden ohne großartig in rumzuhacken?
| Zitat: |
Original von Math1986
Die Methode toInt() hat so oder so Ihre "Berechtigung". |
Welche Berechtigung hat denn die -Methode?
Die Variable ist (sogar!) und wird in jedem Konstruktor der Klasse gesetzt. Wozu also dann diese Methode?
Ibn Batuta |
| 04.11.2011, 17:19 |
Wetal |
Auf diesen Beitrag antworten » |
das muss eher so aussehen:
| code: |
1:
|
return((setState & (1<<elem))!=0); |
|
edit: nvm, hast es anders im code als vorhin angegeben |
| 04.11.2011, 17:21 |
Gast11022013 |
Auf diesen Beitrag antworten » |
Achso, ja, das Semikolon hatte ich oben nur vergessen, im Code habe ich es.
Edit: Ja, oben hatte ich es mit zwei == aus Versehen geschrieben.
Naja, mein Resultat habe ich ja jetzt gepostet, das ist der aktuelle Stand und mir ists schleierhaft, wieso das nicht funktioniert. |
| 04.11.2011, 17:33 |
Wetal |
Auf diesen Beitrag antworten » |
vllt weil du
| code: |
1:
|
public int card(int a) |
|
umgeschrieben hast, so dass es eine integer zahl a erwartet? |
| 04.11.2011, 17:36 |
Gast11022013 |
Auf diesen Beitrag antworten » |
Oh, danke.
Aber wieder tut sich bei der Überprüfung nichts.
Kann vielleuicht es mal jemand bei SICH testen, ob da echt nur drei Mal "Pass" angezeigt wird? Mir kommt das langsam verdächtig vor, dass ich solche wichtigen Dinge ändere und sich nichts tut und das Testergebnis immer das Gleiche ist... |
| 04.11.2011, 17:41 |
Wetal |
Auf diesen Beitrag antworten » |
compilierst du denn auch jedes mal neu? |
| 04.11.2011, 17:42 |
Math1986 |
Auf diesen Beitrag antworten » |
| Zitat: |
Original von Ibn Batuta
| Zitat: |
Original von Math1986
Deinen Code halte ich eher für umständlich, was die Einführung einer weiteren Variablen betrifft.
|
Eine weitere Variable?
Wo möchtest du eine weitere Variable einführen und wie verwenden ohne großartig in rumzuhacken? . |
Du hast in deiner Methode eine zusätzliche Variable eingeführt, die ich für unnötig halte:
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
|
public boolean empty() {
boolean isEmpty = true;
if(!(toInt() == 0))
isEmpty = false;
return isEmpty;
} |
|
Ich rede von der isEmpty Variable, die ist unnötig.
Wir können uns aber einigen auf
| code: |
1:
2:
3:
4:
|
public boolean empty() {
return return (this.toInt()==0);
} |
|
mir war nur nicht klar, auf welchen Teilaspekt du hinauswolltest.
Dass setState public ist ist mir nicht aufgefallen - da ist aber eher toInt() redundant.
Intern ist es durchaus gerechtfertigt, direkt die Variable zu lesen, aber lassen wir die Frage, wessen Methode "richtiger" ist, damit ruhen, um Dennis nicht noch mehr zu verwirren. |
| 04.11.2011, 17:42 |
Gast11022013 |
Auf diesen Beitrag antworten » |
Ich hoffe ich mache mich jetzt nicht zum Gespött:
Ich habe immer nur neu
java Uebung1
eingeben.
Ist das Compilieren? |
| 04.11.2011, 17:43 |
Wetal |
Auf diesen Beitrag antworten » |
nein, mach javac Uebung1.java |
| 04.11.2011, 17:57 |
Gast11022013 |
Auf diesen Beitrag antworten » |
Oh man, wie peinlich ist das denn! 
Jetzt geht's...
Ausgegeben wird:
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
|
C:\projekte>java Uebung1
PASS: b0.empty()
PASS: b0.card() == 0
PASS: b0.elem(31)
PASS: b1.card() == 7
PASS: b0.empty()
PASS: !b0.empty()
PASS: b0.toString() equals { 1, 23 } |
|
Voilá.
Wenn ich das richtig interpretiere, ist's damit geschafft.
Ich möchte mich erstens ganz, ganz herzlich bei Euch bedanken, daß ihr so geduldig mit mir gewesen seid und so hilsbereit! Insbesondere Math1986 und Wetal möchte ich herzlich danken!!
Und zweitens möchte ich mich gerne dadfür entschuldigen, daß ich an so einem elementaren Fehler hing und quasi damit Eure Zeit gestohlen habe.
Edit: An den Tutor, der das Internet vielleicht durchforstet: Das war ein hartes Stück Arbeit. Von Ideenklau und Abschreiben kann wohl wirklich nicht die Rede sein. 
|
| 16.11.2011, 00:19 |
Gast11022013 |
Auf diesen Beitrag antworten » |
Hi, nochmal eine Java-Frage, bei deren Lösung ich zwar eigentlich sehr sicher bin, daß ich richtig liege, aber: Vertrauen ist gut, Kontrolle besser. 
Also gegeben ist eine Methode, die eine for-Schleife verwendet:
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
|
public int forSchleifeVerwenden(int k)
{
int j=1;
for(int i=1; i<k; i++){
j*=i+1;
}
return j;
} |
|
Und die Aufgabe besteht nun darin, eine andere Methode doWhileVerwenden() zu schreiben, die bei der gleichen Eingabe den gleichen Wert zurückgibt, jedoch eine do-while-Schleife benützt.
Meine Lösung:
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
|
public int doWhileVerwenden(int k)
{
int i=0;
int j=1;
do{
j*=i+1;
i++;
}while(i<k);
return j;
} |
|
Ein kurzes Feedback wäre schön!
Danke!
Dennis |
| 16.11.2011, 06:19 |
Calvin |
Auf diesen Beitrag antworten » |
Es kommt das gleiche Ergebnis raus. Allerdings wird deine Do-While-Schleife einmal mehr durchlaufen. Warum ist das so? Warum wirkt sich das in deinem Fall nicht auf das Ergebnis aus? Wie kann man das verhindern?
Versuche die Fragen zu beantworten, damit das in einem anderen Beispiel nicht zu Problemen führt
Gruß
Calvin |
| 16.11.2011, 11:02 |
Gast11022013 |
Auf diesen Beitrag antworten » |
Ich glaube, ich weiß, wie man das ändern kann.
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
|
public int doWhileVerwenden(int k)
{
int i=1;
int j=1;
do{
j*=i+1;
i++;
} while(i<k);
return j;
} |
|
Jetzt besser?
-------------------------
Dann habe ich nochmal eine weitere Frage. Die Aufgabe lautet so:
Sei bAusdruck ein beliebiger boolescher Ausdruck und die Methoden doIf() und doElse() gegeben. Formuliere nur mit while-Schleifen einen äquivalenten Ausdruck zu
| code: |
1:
2:
3:
4:
5:
6:
|
if(bAusdruck){
doIf();
}else{
doElse();
} |
|
Soll man hier jetzt ganz allgemein versuchen, diesen Ausdruck mit while-Schleifen auszudrücken? Also ohne zu wissen, wie der boolesche Ausdruck und die beiden Methoden konkret eigentlich aussehen?
Meine Idee:
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
|
while(true || false)
{
while(true)
{doIf();
break;}
while(false)
{doElse();
break;}
break;
} |
|
Falls es unklar ist, was ich damit meine mal ein Beispiel:
Ursprünglicher Code:
| code: |
1:
2:
3:
4:
5:
6:
|
if(a>b){
doIf();
}else{
doElse();
} |
|
Dann wäre nach meiner Idee äquivalent:
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
|
while(a>b || a<=b)
{
while(a>b)
{doIf();
break;}
while(a<=b)
{doElse();
break;}
break;
} |
|
Liege ich richtig?
(Da mögliche Veränderungen, die die Methoden doIf() und doElse() an a oder b vornehmen nur lokal (in dem Block der jeweiligen while-Schleife) gelten, müsste das doch so funktionieren?)
Kann man eigentlich allgemein Schleifen durch if-else-Anweisungen darstellen?
Ich würde sagen ja. Aber wir sollen unsere Antwort begründen...
Ich versuche es mal:
Im Grunde sind doch Schleifen nichts Anderes als das mehrfache Ausführen einer if-else-Anweisung? Es wird überprüft, ob etwas stimmt: Wenn ja, wird der Anweisungsblock ausgeführt, wenn nicht, geht's nach dem Anweisungsblock weiter. Demnach würde ich meinen, daß man allgemein eine Schleife auch als (sehr oft ineinander verschachtelte) if-else-Anweisungen ausdrücken könnte. Würde aber vermutlich niemand machen, wofür gibt es Schleifen?!
Wäre das eine Begründung?! |
| 16.11.2011, 15:22 |
Math1986 |
Auf diesen Beitrag antworten » |
| Zitat: |
Original von Dennis2010
Ich glaube, ich weiß, wie man das ändern kann.
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
|
public int doWhileVerwenden(int k)
{
int i=1;
int j=1;
do{
j*=i+1;
i++;
} while(i<k);
return j;
} |
|
Jetzt besser?! |
Dieser Teil ja.
Die andere Aufgabe verstehe ich nicht, weder die Aufgabenstellung noch deine Begründung dazu. |
| 16.11.2011, 15:29 |
Gast11022013 |
Auf diesen Beitrag antworten » |
Ich verstehe das so, daß es darum geht, eine if-else-Anweisung durch while-Schleifen auszudrücken.
Ich habe mir nochmal ein Beispiel dazu ausgedacht.
Einmal kann man ja schreiben:
| code: |
1:
2:
3:
4:
5:
|
if(a>b){
a=a+b;}
else{
a=a*b:} |
|
Stattdessen kann man wohl aber auch schreiben:
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
|
while(a>b){
a=a+b;
break;
}
while(a<=b){
a=a*b;
break;} |
|
Vielleicht ist es ja so gemeint...
Was meinst Du? |
| 16.11.2011, 15:31 |
Math1986 |
Auf diesen Beitrag antworten » |
Das wäre zumindest äquivalent. |
| 16.11.2011, 15:38 |
Gast11022013 |
Auf diesen Beitrag antworten » |
Wie kann ich das nun schaffen anstatt der a=a+b und a=a*b
das als Methoden doIf() und doElse() einzubauen?
Also wenn ich mir mal eine Klasse überlege und es versuche, scheitert es irgendwie...
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
|
public class aufgabe2{
public static int doIf(int a,intb){
a=a+b:
return a;
}
public static int doElse(int a, int b){
a=a*b;
return a;
}
public static int expression(int a, int b){
while(a>b){
doIf(a,b);
break;
}
while(a<=b){
doElse(a,b);
break;
}
return a;
}
} |
|
Klappt aber nicht...
Wenn ich jetzt in einer anderen Klasse mal das hier mache:
| code: |
1:
2:
3:
4:
5:
6:
|
public class TestAufgabe2{
public static void main(String[] args){
System.out.println(aufgabe2.expression(1,8));
|
|
möchte ich ja gerne, daß 8 herauskommt, aber es kommt 1 heraus...#
Wer kann mir helfen das so zu ändern, daß auch das Gewünschte angezeigt wird?
Ich habe da den Durchblick gerade verloren., |
| 16.11.2011, 16:19 |
Math1986 |
Auf diesen Beitrag antworten » |
| Zitat: |
Original von Dennis2010
Wie kann ich das nun schaffen anstatt der a=a+b und a=a*b
das als Methoden doIf() und doElse() einzubauen? |
Das Problem ist, dass du den Rückgabewert nicht abspeicherst:
Porbier mal
| Zitat: |
public static int expression(int a, int b)
{
while(a>b)
{
a=doIf(a,b);
break;
}
while(a<=b)
{
a=doElse(a,b);
break;
}
return a;
}
} |
Wenn du einem Funktionsparameter was zuweist, dann ändert der sich in der aufrufenden Funktion nicht.
In google findest du hierzu unter dem Stichwort "call by value" einige brauchbare Infos. |
| 16.11.2011, 16:43 |
Gast11022013 |
Auf diesen Beitrag antworten » |
Klappt! Wie steht es mit der anderen Frage, ob man im Allgemeinen Schleifen durch if-else.Anweisungen beschreiben/ ausdrücken kann?
Ich hatte diese Frage ja mit JA beantwortet und meine Begründung war, daß Schleifen nichts Anderes sind als mehrfache und verschachtelte if-else-Anweisungen. Was wäre eine bessere Begründung?
Die Frage, die ich mir jetzt noch zu dieser Aufgabe stelle, ist, ob wir uns so ein konkretes Beispiel ausdenken sollen. Aber da muss ich wohl den Tutor fragen.
Allgemein (für einen beliebigen booleschen Ausdruck...) kann man sowas ja nicht programmieren, oder?
--------------------------
Und gleich noch eine Frage.
Man hat folgende Methode:
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
|
public int mitDoWhile(int b) {
int a=0;
do{
if (b>0){
a=a+3*b;
} else {
a=a-2*b;
}
} while (a<b);
return a;
} |
|
Es ist gefragt, ob es einen Wert für b gibt, sodaß die do-while-Schleife nie verlassen wird.
Das ist m.E. mit NEIN zu beantworten, denn man muss ja nur die möglichen Fälle betrachten und bedenken, daß der erste Durchgang bei einer do-while-Schleife IMMER ausgeführt wird.
1. Fall ist ja, daß .
Da ist nach dem ersten Durchgang und damit ist die Schleife auch schon beendet.
2. Fall:
1. : Dann ist nach dem ersten Durchlauf und da false ergibt, endet die Schleife.
2. : Dann kommt für a nach dem ersten Durchgang ein Wert größer 0 heraus und damit endet die Schleife auch hier.
Und dann soll man noch eine Methode implementieren, die äquivalent ist zu der obigen Methode, aber eine while-Schleife benutzt. Die Methode darf genau eine if-else-Anweisung enthalten.
Ich frage mich, ob es erlaubt ist, daß eine if-else-Anweisung zweimal vorkommt oder ob die Formulierung meint, daß man insgesamt nur einmal if und einmal else verwenden darf?
Meine Idee:
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
|
public int mitWhile(intb){
if(b>0){
a=a+3*b;
} else {
a=a-2*b;
}
while(a<b)
{if(b>0){
a=a+3*b;
} else {
a=a-2*b;
}
}
} |
|
Also für mich benutzt man hier eine if-else-Anweisung. Nur diese eben zwei Mal.
Wäre das so okay? |
| 16.11.2011, 18:29 |
Math1986 |
Auf diesen Beitrag antworten » |
| Zitat: |
Original von Dennis2010
Klappt! Wie steht es mit der anderen Frage, ob man im Allgemeinen Schleifen durch if-else.Anweisungen beschreiben/ ausdrücken kann?
Ich hatte diese Frage ja mit JA beantwortet und meine Begründung war, daß Schleifen nichts Anderes sind als mehrfache und verschachtelte if-else-Anweisungen. Was wäre eine bessere Begründung?
Die Frage, die ich mir jetzt noch zu dieser Aufgabe stelle, ist, ob wir uns so ein konkretes Beispiel ausdenken sollen. Aber da muss ich wohl den Tutor fragen.
Allgemein (für einen beliebigen booleschen Ausdruck...) kann man sowas ja nicht programmieren, oder? |
Ja, das kann man so sagen
| Zitat: |
--------------------------
Und gleich noch eine Frage.
Man hat folgende Methode:
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
|
public int mitDoWhile(int b) {
int a=0;
do{
if (b>0){
a=a+3*b;
} else {
a=a-2*b;
}
} while (a<b);
return a;
} |
|
Es ist gefragt, ob es einen Wert für b gibt, sodaß die do-while-Schleife nie verlassen wird.
Das ist m.E. mit NEIN zu beantworten, denn man muss ja nur die möglichen Fälle betrachten und bedenken, daß der erste Durchgang bei einer do-while-Schleife IMMER ausgeführt wird.
1. Fall ist ja, daß .
Da ist nach dem ersten Durchgang und damit ist die Schleife auch schon beendet.
2. Fall:
1. : Dann ist nach dem ersten Durchlauf und da false ergibt, endet die Schleife.
2. : Dann kommt für a nach dem ersten Durchgang ein Wert größer 0 heraus und damit endet die Schleife auch hier. |
Ja
| Zitat: |
Und dann soll man noch eine Methode implementieren, die äquivalent ist zu der obigen Methode, aber eine while-Schleife benutzt. Die Methode darf genau eine if-else-Anweisung enthalten.
Ich frage mich, ob es erlaubt ist, daß eine if-else-Anweisung zweimal vorkommt oder ob die Formulierung meint, daß man insgesamt nur einmal if und einmal else verwenden darf?
Meine Idee:
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
|
public int mitWhile(intb){
if(b>0){
a=a+3*b;
} else {
a=a-2*b;
}
while(a<b)
{if(b>0){
a=a+3*b;
} else {
a=a-2*b;
}
}
} |
|
Also für mich benutzt man hier eine if-else-Anweisung. Nur diese eben zwei Mal.
Wäre das so okay? |
Ich denke, du darfst nur eine if/else anweisung verwenden, das sollte auch machbar sein, wenn du auch die Schleifenbedingung modifizierst (gerade keine Zeit, mir das genauer anzusehen) |
| 16.11.2011, 18:47 |
Gast11022013 |
Auf diesen Beitrag antworten » |
Hm, ich komme nicht darauf, wie man es mit wirklich nur einer einzigen if-else-Anweisung machen könnte.
Ich frage mich, ob in dem Innenteil der While-Schleife überhaupt etwas stehen muss, denn wenn ich wie oben while(a<b) verwende, bricht es m.E. sowieso immer ab bzw. der Innenteil wird sowieso nie durchlaufen...
Also könnte man vielleicht einfach das wie oben machen, nur den Innenteil der while-Schleife weglassen...
Also:
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
|
public int mitWhile(int b){
int a=0;
if(b>0){
a=a+3*b;
} else {
a=a-2*b;
}
while (a<b){
}
} |
|
Oder was meintest Du mit "Bedingung modifizieren"? |
| 16.11.2011, 19:02 |
Calvin |
Auf diesen Beitrag antworten » |
| Zitat: |
Original von Math1986
| Zitat: |
Original von Dennis2010
Ich glaube, ich weiß, wie man das ändern kann.
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
|
public int doWhileVerwenden(int k)
{
int i=1;
int j=1;
do{
j*=i+1;
i++;
} while(i<k);
return j;
} |
|
Jetzt besser?! |
Dieser Teil ja.
Die andere Aufgabe verstehe ich nicht, weder die Aufgabenstellung noch deine Begründung dazu. |
Nein, das passt nicht. Grund ist, dass die doWhile-Schleife mindestens einmal durchlaufen wird. Mit Startwert i=0 ist das egal, weil j mit 1 multipliziert wird.
Damit es "immer" klappt, muss die Bedingung vorher einmal abgeprüft werden
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
|
public class Beispiel {
public static void main(String[] args) {
Beispiel bsp = new Beispiel();
System.out.println("forSchleifeVerwenden(1) gibt folgenden Wert zurück: "
+ bsp.forSchleifeVerwenden(1));
System.out.println("doWhileVerwenden(1) gibt folgenden Wert zurück: "
+ bsp.doWhileVerwenden(1));
System.out.println("doWhileKorrektVerwenden(1) gibt folgenden Wert zurück: "
+ bsp.doWhileKorrektVerwenden(1));
}
public int forSchleifeVerwenden(int k) {
int j = 1;
for (int i = 1; i < k; i++) {
j *= i + 1;
}
return j;
}
public int doWhileVerwenden(int k) {
int i = 1;
int j = 1;
do {
j *= i + 1;
i++;
} while (i < k);
return j;
}
public int doWhileKorrektVerwenden(int k) {
int i = 1;
int j = 1;
if (i < k) {
do {
j *= i + 1;
i++;
} while (i < k);
}
return j;
}
} |
|
Die andere Frage habe ich beim Überfliegen nicht verstanden. |
| 16.11.2011, 19:06 |
Gast11022013 |
Auf diesen Beitrag antworten » |
Sorry, Calvin, aber ich verstehe nicht, was Du meinst.
Also ich weiß, daß bei der do-while-Schleife mindestens einmal ausgeführt wird.
Aber wieso muss ich denn die if-Bedingung vorschalten?
Das will mir nicht so richtig in den Sinn. |
