Unterschied zwischen Denkweisen

[Sirmeabe]

Hallo zusammen,
Wollte mit einer while Schleife die gerade Zahlen zwischen 0 und 20 ausgeben lassen.
Meine Lösung:

Int a = 0;
int b = 0;
while(a<=10){
if((b%2)==0){System.out.println(b);
b = b + 2;
}
a++;
}

Und eine Lösung die ich im Internet gefunden habe.

int a = 0;
int i = 0;
while((a<=10) && ((i%2)==0)) {
System.out.println(i);
a++;
i=i+2;
}

Ist da ein Unterschied? Wenn ja, wo? Welche Lösung würdet ihr bevorzugen?
Viele Grüße

 

[Staarfightaar]

es ist wenig unterschied... man hat halt mehr in eine zeile gestopft

((i%2)==0)

wann soll denn das mal falsch sein ?

falls dein start wert ungerade ist => musst du aufhören
ansonsten => lässt du die while durchlaufen ohne i%2 zu prüfen weil es nicht mehr passieren kann

public void GeradeZahlenAusgeben(int start,int ende)
if(start%2 != 0 || ende%2 != 0) return;
    while(start < ende)
    {
        System.out.println(start);
        a = a+2;
    }
}

sowas in der art denk ich mir

wenn du objekte noch nicht hattest usw kannst du auch

public static void ...

schreiben, dann kannst du die Methode in deiner Main klasse aufrufen

 

[mihe7]

Wollte mit einer while Schleife die geraden Zahlen zwischen 0 und 20 ausgeben lassen.

Äh:

for (int i = 0; i < 20; i+=2) {
    System.out.println(i);
}

 

[Sirmeabe]

Vielen Dank für eure Antworten,
Vielleicht habe ich mich nicht richtig ausgedrückt. Ich wollte keine Lösungsvorschläge erhalten. Ich habe gehofft dass mir einer den Unterschied zwischen meiner Denkweise und die der anderen erklären könnte.
Vielen Dank.

 

[Sirmeabe]

Danke trotzdem für eure Lösungen,
Jetzt ist mir klar dass es auch noch anders zu lösen ist. Ich kenne aber erst nur while und if. Deswegen bin ich damit am üben.

 

[mihe7]

Beide "Denkweisen" sind Unsinn.

Fangen wir mal hier an:

int a = 0;
int b = 0;
while(a<=10){
    if((b%2)==0){
        System.out.println(b);
        b = b + 2;
    }
    a++;
}

Du zählst a von 0 bis inkl. 10. Wenn b ist gerade Zahl ist (und das ist b hier immer), zählst Du zwei drauf. Das if ist völlig überflüssig, genauso wie das a.

Bei Dir würde wenigstens noch a bis zum Ende untersucht, in der zweiten Lösung wird sofort abgebrochen, wenn keine gerade Zahl gefunden wurde.

 

[mihe7]

Jetzt ist mir klar dass es auch noch anders zu lösen ist. Ich kenne aber erst nur while und if. Deswegen bin ich damit am üben.

Die for-Schleife kannst Du genauso als while-Schleife schreiben:

{
    int b = 0;
    while (b <= 20) {
        System.out.println(b);
        b += 2;
    }
}

ist nichts anderes als

for (int b = 0; b <= 20; b+= 2) {
    System.out.println(b);
}

 

[KonradN]

Also bei den Denkweisen Unterschiede heraus zu suchen ist erst einmal nicht wiklich zielführend.

Die Denkweise bei Deinen beiden Lösungen entspricht in etwa dem Vorgehen: "Du kaufst Dir ein Seil um Dich damit so doll zu erschiessen, dass die Messerspitze hinten heraus schaut." - und nun willst Du diskutieren, ob dazu ein Seil aus Kunststoff oder doch besser ein Hanf sein zu nutzen ist....

Warum verkomplizierst Du dalles so sehr? Die Aufgabe ist doch erst einmal deutlich und einfach:

Wollte mit einer while Schleife die gerade Zahlen zwischen 0 und 20 ausgeben lassen.

Bei so einer Aufgabe frage ich Dich jetzt:
- Wo siehst Du ein a und b? Die Namen sagen absolut nichts aus. Was besagt denn die Aufgabe? Die spricht von geraden Zahlen. Also hast Du eine Variable Zahl oder geradeZahl.
- Wo siehst Du in der Aufgabe eine 10? Das ist wie in dem Vergleich: Du willst Dich eschiessen? Wozu brauchst Du ein Seil? Warum soll dann eine Messerspitze hinten raus schauen? Davon steht da nichts, also wird da sowas in der Lösung auch bitte NIE vorkommen.

Das sind Dinge, auf die sollte man immer achten - von Anfang an!

Und dann ist Die Lösung immer gradlinig:
zahl = Anfangswert
Solange zahl <= Endwert ist:
- Wenn zahl gerade ist, dann gib diese aus.
- Erhöhe zahl.

Also ein:

zahl = 0;
while (zahl <= 20) {
    if (zahl % 2 == 0) System.out.println(zahl);
    zahl++;
}

Oder wenn Du durchschaust, dass die geraden zahlen immer ein +2 bedeutet, dann wird daraus ein:
geradeZahl := Erste Gerade Zahl ab Anfangswert
So lange geradeZahl <= Endwert ist:
- gib geradeZahl aus
- geradeZahl um 2 erhöhen

geradeZahl = 0;
while (geradeZahl <= 20) {
    System.out.println(geradeZahl);
    geradeZahl += 2;
}

Die Aufgabe war also recht deutlich. Komplexer wäre es, wenn die Aufgabenstellung anders formuliert worden wäre. Die Lösung von euch besagt eher etwas wie:
Berechne die ersten n geraden Zahlen ab 0.
Dann hast Du neben der geradenZahl auch noch eine Anzahl - also kommst Du auf so eine Lösung, wie ihr sie da erstellt habt.

Ich hoffe es wird deutlich, dass es nicht komplizierter wird sondern einfacher! Aufgaben (Anforderungen) werden einfach und geradlinig umgesetzt (So diese vrnünftig formuliert sind - also kein "Kauf Dir ein Seil und erschiess Dich damit so dass die Messerspitze hinten raus schaut" - das ist natürlich eine Grundvoraussetzung.)
-> Vernünftige Bezeichner - so behältst Du selbst den Überblick. Wie willst Du bei etwas komplexerem Code sonst bei einem a++ wissen, ob dies richtig ist oder ob da nicht ein b++ ist? Oder ob das ++ nicht eher ein erhöhen um 2 sein müsste. (Daher auch bei den Lösungen einmal ein geradeZahl. Bei geradeZahl++ sieht man sofort, dass da etwas falsch sein muss. Oder eine prüfung: geradeZahl % 2 == 0 wmacht kein Sinn, denn es ist ja bereits eine gerade Zahl. Das würde also nur als Checks einen Sinn ergeben also z.B. bei einem Parameter, der übergeben wird, mache ich eine Validierung um ggf. den Aufrufer zu "verhauen" )
-> Anforderungen einfach und geradlinig implementieren (KISS - Keep It Simple, Stupid)

Oder um die Worte von Grady Booch zu nutzen:

Clean code is simple and direct.
Clean code reads like well-written prose.
Clean code never obscures the designer’s intent but rather is full of crisp abstractions and straightforward lines of control.

Das bitte als Anregung verstehen für zukünftigen Code. Niemand erwartet, dass Anfänger Clean Code am Anfang meistern (Damit wird man erst später gequält) aber es ist so existenziell, so dass man es immer wieder vor Augen geführt bekommen sollte. Daher das nur als eine Abhandlung, die Dein Beispiel einmal aufgreift.

Und ganz wichtig: Das geht in keiner Weise gegen Dich oder Deine Position. Es geht nur um den Code. Du bist ganz am Anfang und Ziel von diesem Beitrag soll nicht sein, die da jeden Spass zu verderben sondern genau das Gegenteil: Eine Grundlage zu schaffen, damit Du Spaß an der Sache haben kannst!

Edit: Den Code mit der ganzenZahl++; noch direkt angepasst. Danke für den Hinweis @temi

 

[temi]

Oder wenn Du durchschaust, dass die geraden zahlen immer ein +2 bedeutet, dann wird daraus ein:
geradeZahl := Erste Gerade Zahl ab Anfangswert
So lange geradeZahl <= Endwert ist:
- gib geradeZahl aus
- geradeZahl um 2 erhöhen

geradeZahl = 0;
while (geradeZahl <= 20) {
    System.out.println(geradeZahl);
    geradeZahl += 2; // Zahl um 2 erhöhen
}

Da war ein kleiner, aber entscheidender, (Flüchtigkeits-) Fehler...

 

[KonradN]

geradeZahl = 0;
while (geradeZahl <= 20) {
    System.out.println(geradeZahl);
    geradeZahl += 2; // Zahl um 2 erhöhen
}

Da war ein kleiner, aber entscheidender, (Flüchtigkeits-) Fehler...

Ja, klar. Im Text schreibe ich auch noch, dass man nur so ein Statement sehen muss, um zu sehen, dass es falsch ist. Wenn man im Forum per Copy & Paste sowas macht - ich hatte den Code-Block des ersten Beispiels nur kopiert und dann diese Stelle klar vergessen.

Danke für den schnellen Hinweis - konnte ich direkt noch editieren.

 

[Neumi5694]

Die beste Lösung ist meines Erachtens die, deren Sinn man 7 Jahre später beim Lesen am einfachsten erkennt.
Dabei hilft, für ein einfaches Problem keine komplexen Abfragen zu verwenden.

Ich würde mihe's for-schleife wegen ihrer Schlichtheit bevorzugen und weil sie ohne externe (außerhalb der Schleife sichtbare) Variablen auskommt.


Wenn du hier aber eine gekapselte Funktion schreibst, die du nie wieder anfassen wirst, dann ist es vollkommen wurscht, was du machst, so lange das richtige Ergebnis rauskommt.

 

[KonradN]

Bezüglich der beiden Varianten evtl. noch eine Bemerkung zu dem Unterschied:

a) while (bed1 && bed2) { ... }
b) while (bed1) { if (bed2) { ...} ... }

Der Code macht unterschiedliches: In der ersten Variante bricht die Schleife komplett ab, wenn bed2 einmal nicht mehr zutrifft. Bei der zweiten Variante läuft die Schleife weiter - es wird dann nur eben das, was im if steht, nicht ausgeführt.

Bei deinem Code spielt es aber keine Rolle, denn die Bedingung ist immer wahr und könnte ersatzlos gestrichen werden. Daher machen beide Varianten das Gleiche und beide Varianten haben unnötige Checks und sind unnötig komplex.

 

[Sirmeabe]

Guten Abend,

vielen Dank für eure Antworten. In der Tat habe ich da ziemlich zu viel überlegt wie man das lösen kann.
Einfacher wäre es gewesen: von 0 nach 20 hochzuzählen in 2 er Schritten. Darauf bin ich vorher nicht draufgekommen.
Cooles Beispiel mit dem Erschießen. Hat mich wirklich amüsiert.
Werde demnächst die Aufgabenstellungen aufmerksamer lesen müssen.

 

[Hag2bard]

So ging es mir am Anfang mit dem ausgeben von Primzahlen. Da hatte ich mehrere Schleifen ineinander und mehrere if Bedingungen.
Letztendlich muss man nur wissen wie eine Primzahl definiert ist.