Werteverlaufstabelle

system · 16. Dezember 2013 um 04:43

Hallo liebe Community, wir sollen aus einem gegebenen Quellcode eine Werteverlaufstabelle anfertigen, allerdings werden mir die Werte die die Variablen annehmen kaum klar, hier mal der Code:

int i = 10;	while (i > 0){
		i++;
		if (i > 10)
			i -= 2;
		for (int j = 10; j > i; j--){
			if (j%3==0)
				i -= 2;
		}
		if (i <= 10){
			i *= 0.5;
		}
		switch (i * 2){
		case -12:
			i -=3;
		case -2:
			i *= -1;
			break;
		case 2:
			i--;	
		}
}```

In der Tabelle ist der Wert i natürlich mit 10 vorgegeben, bei j steht gar nichts.
Ich habe i einfach mal mit System.out.println ausgeben lassen, da kommen die Werte 4,1,9,5,0 raus, allerdings komme ich da wenn ich mir den Quellcode anschaue, überhaupt nicht drauf.
Wäre toll, wenn vielleicht jemand einen Denkanstoß für mich hätte oder einen Hinweis, wie ich jetzt auf die Lösung komme.

Danke im Voraus

Tomate_Salat · 16. Dezember 2013 um 04:56

Da musst du einfach Schritt für Schritt mitgehen. Z.B. für die erste “Runde”:


i = 10
i = i + 1 => i = 11
i ist größer als 10, also wird i um 2 vermindert: i = 9
Eintritt in die Schleife
   die Schleife zieht für jeden Wert, der durch 3 ohne Rest teilbar ist 2 ab - solange wie j größer als i ist.
Ende der der Schleife
i ist nach wie vor 9
i ist kleiner als 10, also wird der Wert halbiert (*0.5) => 4.5. Da i ein Integer ist, wird der dezimalwert ignoriert: i = 4
kein Case aus dem Switch trifft zu
Resultat nach der ersten Runde: i ergibt 4

system · 16. Dezember 2013 um 05:04

Okay, das hab ich schonmal verstanden, zum Ende der Schleife bin ich auch gekommen ^^
Bei j ist es doch so, dass j einfach nur runterzählt, also sprich bei jedem Durchlauf -1, also 10,9,8,7 … das müssten ja dann die korrekten j-Werte sein.
Danke erstmal für deine ausführlich Erklärung und deine Mühe, jetzt blicke ich auch mehr durch.

Tomate_Salat · 16. Dezember 2013 um 05:11

Ja von j wird mit jedem durchlauf 1 abgezogen. Aber nur solange, wie es größer als i ist. Für den ersten durchlauf wäre das also:

i = 9, j = 10 => j%3 = 1 es wird nichts abgezogen. 
Neue Runde und j wird um 1 vermindert
i = 9, j ist 9. j ist nicht mehr größer als i deswegen wird die Schleife nicht erneut durchgegangen.

system · 16. Dezember 2013 um 05:13

Alles klar super, jetz blicke ich durch. Vielen Dank

system · 16. Dezember 2013 um 05:57

Ich habe doch noch ein Problem ^^

int i = 10;	while (i > 0){
		i++;
		if (i > 10)
			i -= 2;
		for (int j = 10; j > i; j--){
			if (j%3==0)
				i -= 2;
		}
		if (i <= 10){
			i *= 0.5;
		}
		switch (i * 2){
		case -12:
			i -=3;
		case -2:
			i *= -1;
			break;
		case 2:
			i--;	
		}
}```

Der erste int-Wert, der rauskommt ist 4. 
So weit so gut.
Nun setze ich also int i = 4 und rechne mit diesem Wert weiter, dann kommt 1 raus, ebenfalls richtig laut Ausgabe
Aber wenn ich jetzt mit 1 weiterrechne, passiert folgendes:
i = 1
1 ist größer als 0, also i++ , jetzt ist i also 2
2 ist nicht größer als 10, also wird das if übersprungen
Nun kommt die Schleife mit j=8
8%3 == 0 ist falsch, also weiter zur nächsten if-Anweisung
2 ist kleiner (oder gleich) 10, also 2*0.5 = 1

So jetzt kommt das Problem:
Setze ich i in den switch ein, dann trifft case 2 zu, weil 1 * 2 = 2
Nun wird i um 1 verringert, also 2-1 = 1
So, jetzt fange ich also wieder mit 1 an zu rechnen, das geht endlos so weiter.
Als nächstes sollte eigentlich 9 rauskommen laut Ausgabe, keine Ahnung wie das gehen soll.

Vielleicht wisst ihr ja wo mein Denkfehler liegt.

_Michael · 16. Dezember 2013 um 06:16

[quote=Unregistered]Nun kommt die Schleife mit j=8
8%3 == 0 ist falsch, also weiter zur nächsten if-Anweisung[/quote]
?? die Schleife beginnt bei j=10 und läuft solange j>i ist, wobei i unter bestimmten Bedingungen während des Schleifendurchgangs kleiner wird.
Klar ist 8%3==0 nicht erfüllt, aber die Schleife läuft viel länger als bis j==8

Crian · 16. Dezember 2013 um 06:25

Warum baust du dir nicht einfach Ausgaben ein?


public class Werteverlaufstabelle {

    public static void main(String[] args) {
        int i = 10;
        while (i > 0) {
            System.out.println("
while-Start, i=" + i);
            i++;
            System.out.println("i wird erhhöht, i=" + i);
            if (i > 10) {
                i -= 2;
                System.out.println("i wird verringert, i=" + i);
            }
            for (int j = 10; j > i; j--) {
                System.out.println("j-Schleife, j=" + j);
                if (j % 3 == 0) {
                    i -= 2;
                    System.out.println("in j-Schleife, i wird verringert, i=" + i);
                }
            }
            if (i <= 10) {
                i *= 0.5;
                System.out.println("i wird halbiert, i=" + i);
            }
            switch (i * 2) {
                case -12:
                    i -= 3;
                    System.out.println("switch-case -12: von i wird 3 abgezogen, i=" + i);
                case -2:
                    i *= -1;
                    System.out.println("switch-case -2: das Vorzeichen von i wird vertauscht, i=" + i);
                    break;
                case 2:
                    i--;
                    System.out.println("switch-case 2: i wird um 1 verringert, i=" + i);
            }
        }
    }

}

Ausgabe
[spoiler]
while-Start, i=10
i wird erhhöht, i=11
i wird verringert, i=9
j-Schleife, j=10
i wird halbiert, i=4

while-Start, i=4
i wird erhhöht, i=5
j-Schleife, j=10
j-Schleife, j=9
in j-Schleife, i wird verringert, i=3
j-Schleife, j=8
j-Schleife, j=7
j-Schleife, j=6
in j-Schleife, i wird verringert, i=1
j-Schleife, j=5
j-Schleife, j=4
j-Schleife, j=3
in j-Schleife, i wird verringert, i=-1
j-Schleife, j=2
j-Schleife, j=1
j-Schleife, j=0
in j-Schleife, i wird verringert, i=-3
j-Schleife, j=-1
j-Schleife, j=-2
i wird halbiert, i=-1
switch-case -2: das Vorzeichen von i wird vertauscht, i=1

while-Start, i=1
i wird erhhöht, i=2
j-Schleife, j=10
j-Schleife, j=9
in j-Schleife, i wird verringert, i=0
j-Schleife, j=8
j-Schleife, j=7
j-Schleife, j=6
in j-Schleife, i wird verringert, i=-2
j-Schleife, j=5
j-Schleife, j=4
j-Schleife, j=3
in j-Schleife, i wird verringert, i=-4
j-Schleife, j=2
j-Schleife, j=1
j-Schleife, j=0
in j-Schleife, i wird verringert, i=-6
j-Schleife, j=-1
j-Schleife, j=-2
j-Schleife, j=-3
in j-Schleife, i wird verringert, i=-8
j-Schleife, j=-4
j-Schleife, j=-5
j-Schleife, j=-6
in j-Schleife, i wird verringert, i=-10
j-Schleife, j=-7
j-Schleife, j=-8
j-Schleife, j=-9
in j-Schleife, i wird verringert, i=-12
j-Schleife, j=-10
j-Schleife, j=-11
i wird halbiert, i=-6
switch-case -12: von i wird 3 abgezogen, i=-9
switch-case -2: das Vorzeichen von i wird vertauscht, i=9

while-Start, i=9
i wird erhhöht, i=10
i wird halbiert, i=5

while-Start, i=5
i wird erhhöht, i=6
j-Schleife, j=10
j-Schleife, j=9
in j-Schleife, i wird verringert, i=4
j-Schleife, j=8
j-Schleife, j=7
j-Schleife, j=6
in j-Schleife, i wird verringert, i=2
j-Schleife, j=5
j-Schleife, j=4
j-Schleife, j=3
in j-Schleife, i wird verringert, i=0
j-Schleife, j=2
j-Schleife, j=1
i wird halbiert, i=0[/spoiler]

Tomate_Salat · 16. Dezember 2013 um 06:27

Dein Denkfehler liegt bei der for-schleife:

i = 2, j = 10. Nachfolgend zähle ich nur die Treffer für j%3 == 0 auf:
j = 9:   i = 0;
j = 6:   i = -2;
j = 3:   i = -4;
j = 0:   i = -6;
j = -3:  i = -8;
j = -6:  i = -10;
j = -9:  i = -12;

Danach geht das gewohnte Spiel weiter: -12 wird halbiert => -6
im switch trifft dann der case -12 zu und dein i ist -9
da danach kein break folgt, wird auch die Anweisung i *= -1 ausgeführt => dein i ist jetzt also 9

system · 16. Dezember 2013 um 06:40

Achso klar ich hab die Schleife viel zu kurz laufen lassen ich Idiot, danke an alle. Doofer Fehler, aber bin noch Anfänger. Tut mir leid aber danke für eure Mühe :>