verschiedene Reihenfolgen ausgeben

[nbng]

moin!

erster post, habe mir die regeln durchgelesen und hier ein bisschen geschaut (und gegooglet). das problem ist, dass ich nicht so recht weiß, was ich googlen soll.. ich vermute die lösung(en) sind super easy, jedoch stehe ich auf dem altbekannten schlauch.

folgendes soll in bluej mit schleifen gelöst werden (arrays hatten wir noch nicht):
es soll eine methode geschrieben werden, die nach den jeweiligen "regeln" die ersten 20 zahlen der reihenfolge ausgeben.
aufgabe 3: 53,58,54,59,55,60 ..
wäre dann ja also: 53,58,54,59,55,60,56,61,67,62,58,63,59,64,60,65,61,66,62

nun habe ich irgendwie versucht in einer for-schleife um 5 zu erhöhen und dann wiederum um 4 zu verringern - kriege ich aber einfach nicht hin.
also habe ich umgedacht und letztendlich sind es ja zwei reihen, die einfach um einen erhöht werden. da weiß ich aber nicht, wie das funktioniert, dass mir die konsole abwechselnd die reihen ausspuckt.

mein versuch ist irgendetwas in dieser form:

public void reihenfolgeAusgeben3()
{

for (int a=53; a<=62; a++)
{
System.out.println(a);
}
for (int b=58; b<=66; b++)
{
System.out.println(b);
}


ich hoffe, dass mir jemand einen anstoß geben kann!
ich danke euch.

 

[nbng]

okay wow. man muss etwas nur noch mal genau für einen forum post aufschreiben, dann kommt man selbst drauf. ich bin nicht darauf gekommen mehrere bedingungen in die schleife zu schreiben (und dass das geht).

public void reihenfolgeAusgeben3()
{

for (int a=53, b=58; a<=62 & b<=67; a++, b++)
{
System.out.println(a);
System.out.println(b);
}
}

 

[httpdigest]

Diese Schleife finde ich noch ziemlich "obfuscated". Man kann nicht klar erkennen, wieviele Zahlen da eigentlich ausgegeben werden. Besser wäre vielleicht:

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

 

[kneitzel]

Ansonsten wäre eine andere Möglichkeit, dass man da von Zahl zu Zahl geht und die Regel ist immer abwechselnd +5 / -4 8 (Wie in dem Post erläutert).

Innerhalb der Schleife kann man dann schauen, was man machen muss, indem man zaehler%2 == 0 prüft.

Also wäre das dann sowas wie:

public class Reihe {

    public static void main(String[] args) {
        int ersterWert = 53;
        int modifierUngerade = 5;
        int modifierGerade = -4;
        int anzahlZahlen = 20;

        // Wir starten mit ersterWert-modifierGerade, da für den ersten Wert zuerst der modifierGerade angewendet wird.
        int wert = ersterWert - modifierGerade;
        for (int zaehler=0; zaehler < anzahlZahlen; zaehler++) {
            wert += zaehler % 2 == 0 ? modifierGerade : modifierUngerade;
            System.out.print(wert + " ");
        }
    }
}

Der Code scheint jetzt erst einmal komplexer als bei der anderen Lösung, bei der einfach immer zwei Werte gespeichert werden, aber das liegt unter anderem auch daran, dass die andere Lösung nur immer ein vielfaches von 2 Zahlen ausgeben kann.
Den Fall mit ungerader Anzahl würde den anderen Code auch etwas aufblähen (ein einfaches if nach der Schleife um dann ggf. noch einen weiteren Wert auszugeben.

Ich würde den Code wählen, der das eigene Verständnis am Besten trifft. Sieht man die Reihe als ein +5 / -4 an, dann wäre diese Version mein Favorit. Sieht man zwei Startzahlen und dann jeweils ein +1, dann wäre die andere Lösung mein Favorit.

Die +5/-4 Lösung war aber vom TE erwähnt, daher wollte ich diese auch einmal zeigen (wie ich diese so ohne viel Nachdenken implementieren würde).

 

[kneitzel]

Ach ja: Falls das mit dem Start mit wert=ersterWert - modifierGerade nicht einleuchtet: Man kann durchaus auch die Ausgabe vor die Wertveränderung nehmen. Und die Namensgebung muss man evtl. noch anpassen (modifierGerade / modifierUngerade) so dass es verständlicher ist. Ist halt die Veränderung, die man auf die n-te Zahl anwenden muss. Damit man nicht mit dem zaehler durcheinander kommt, sollte man den evtl. auch bei 1 starten lassen....

Das sind nur noch ein paar Gedanken, die mir nach dem Posten so gekommen sind. War halt ein Schnellschuss ohne alles zu genau zu durchdenken.

 

[nbng]

ich danke euch beiden!

ja, meine lösung, also das aufzusplitten in +5/-4 ist vllt. eher eine umgehende lösung. ich denke nicht, dass man vorher die komplette reihen errechnen (auch wenn's einfach ist) sollte und dann die schleife vom startwert bis zu dem zwanzigsten wert der reihe durchgehen lässt.
letztendlich muss ich ja ans ziel kommen und habe es so geschafft, wenn auch vielleicht nicht auf dem optimalsten weg.

eure lösungen könnten mir aber für die weiteren aufgaben helfen, an denen ich gerade ein bisschen verzweifel.

die nächste reihe ist wie folgt:
11, 14, 18, 23.. also starten wir bei +3 und der zähler muss nach dem ersten durchgang um +1 erhöht werden. klingt relativ simpel in meinen augen, aber ich kriege es nicht umgesetzt.

mein versuch:

    public void reihenfolgeausgeben4() {
        int startWert = 11;
        int modifikator = 3;
        int anzahlZahlen = 20;

         for (int i=0; i < anzahlZahlen ; i++, modifikator++) {
            int wert = startWert + modifikator;

            System.out.print(wert + " "); 
        }

ich müsste ja eigentlich nur den modifikator bei jedem durchgang erhöhen (modifikator++) oder sehe ich das falsch? ist die variable vllt. nur falsch platziert?

 

[kneitzel]

Also ich sehe hier mehrere Dinge:
a) for Schleife kann man so machen meine ich. Aber es ist unüblich, da andere Variablen als die Zählvariable zu erhöhen. Aber funktionieren tut es.
b) In der Reihe wird immer auf den vorherigen Wert zurück gegriffen und nicht auf den Startwert. Dein Problem ist also, dass Du immer nur den Modifikator zu dem Startwert hinzu addierst.

 

[nbng]

ah. ich glaube ich "weiß", was ich falsch mache und ich weiß worauf ich hinaus muss, aber ich komme nicht dahin. sag mir noch nicht die lösung, ich will's probieren 😛

also, wirres geschwafel: ich sehe, dass durch int wert = startWert + modifikator; letztendlich nie etwas neues geschiehen wird. es wird halt immer wieder mit 11 rechnen. also muss ich eine weitere rechnung(?) einbauen, die nicht startWert verwendet, sondern einen neuen (zwischenWert?) nimmt, welcher 11+3 ist (und dann fortlaufend den neuen wert [14] + modifikator++ rechnet).

vom gedankengang her richtig?

 

[httpdigest]

Neben dem normalen Schleifenzähler `i` benötigst du noch genau eine weitere Variable (hier mal `j` genannt), die du inkrementierst und ausgibst. Aber das Inkrementieren ist nicht einfach nur ein `j++`, sondern hängt unter anderem von `i` ab.

 

[nbng]

mit biegen und brechen und ich komme auf die gewollte zahlenfolge, aber wirkt für mich ein bisschen gemogelt :-D

  public static void reihenfolgeausgeben4() {
        int wert = 11;
        int anzahlZahlen = 19;
    
        System.out.print(wert + " ");
         for (int i=0; i < anzahlZahlen ; i++) {
            wert = i + 3 + wert;
          
            System.out.print(wert + " ");
        }
    }

 

[Xyz1]

Ich würd es nicht so kompliziert, aber etwas systematischer machen:

		for (int i = 0; i < 20 / 2; i++) {
			int x = i * 2;
			System.out.println(53 + i);
			System.out.println(58 + i);
			
		}

Jetzt könnte problemlos eine dritte Zahl hinzukommen oder sich die Rechenoperation ändern oder oder...

 

[kneitzel]

Ich würd es nicht so kompliziert, aber etwas systematischer machen:

        for (int i = 0; i < 20 / 2; i++) {
            int x = i * 2;
            System.out.println(53 + i);
            System.out.println(58 + i);
           
        }

Jetzt könnte problemlos eine dritte Zahl hinzukommen oder sich die Rechenoperation ändern oder oder...

Wozu soll das int x = i *2; dienen?
Ansonsten ist es der gleiche Code wie in #3 außer, dass Du wirklich alle Zahlen nun als magic numbers im code hast und @httpdigest die Anzahl noch in eine Variable N gesteckt hat...

 

[httpdigest]

mit biegen und brechen und ich komme auf die gewollte zahlenfolge, aber wirkt für mich ein bisschen gemogelt :-D

  public static void reihenfolgeausgeben4() {
        int wert = 11;
        int anzahlZahlen = 19;
   
        System.out.print(wert + " ");
         for (int i=0; i < anzahlZahlen ; i++) {
            wert = i + 3 + wert;
         
            System.out.print(wert + " ");
        }
    }

Das sieht doch schon sehr gut aus! 🙂 Wenn du jetzt noch das Inkrementieren von `wert` am Ende des Schleifenrumpfes machst, und somit keinen System.out.println() außerhalb der Schleife brauchst, ist es perfekt.

 

[nbng]

aaaaaah, ich komme nicht drauf! 😡 frustrierend.

ein inkrement erhöht doch den wert einer variablen, richtig?
'am Ende des Schleifenrumpfes' würde ja bedeuten unter System.out.print(wert + " "); , richtig?

das bringt mir doch gar nichts.. mein einziges problem ist ja momentan, dass er mir 11 nicht ausspuckt (deswegen die umgehung, dass er mir 11 einfach so ausspuckt). wenn ich dann zusätzlich den wert erhöhe, wäre das ja kontraproduktiv von dem was ich vorhabe.

edit: habe es jetzt so gelöst (ist vllt nicht, das was du mit perfekt meinst, aber wäre ja schon mal cleaner, haha):

 public static void reihenfolgeausgeben4() {
        int wert = 9;
        int n = 20;
     
     
         for (int i=0; i < n ; i++) {
           
            wert = i + 2 + wert;
           
            System.out.print(wert + " ");
           
           
        }
    }

letztendlich wird in der klausur jede lösung akzeptiert, hauptsache das ergebnis ist das gefragte (außer es wird explizit nach einer schleife gefragt und man benutzt nur print..)

 

[httpdigest]

mein einziges problem ist ja momentan, dass er mir 11 nicht ausspuckt (deswegen die umgehung, dass er mir 11 einfach so ausspuckt). wenn ich dann zusätzlich den wert erhöhe, wäre das ja kontraproduktiv von dem was ich vorhabe.

Deswegen sollst du ja auch das Inkrement von `wert` ans Ende des Schleifenrumpfes verschieben.
Hier mal dein exakter Code mit einfach nur dem Inkrement ans Ende des Schleifenrumpfes verschoben, wie vorgeschlagen:

int wert = 11;
int anzahlZahlen = 20;
for (int i=0; i < anzahlZahlen ; i++) {
  System.out.print(wert + " ");
  wert = i + 3 + wert;
}
// -> 11 14 18 23 29 36 44 53 63 74 86 99 113 128 144 161 179 198 218 239

Ist das etwa nicht, was du willst?

 

[nbng]

oh wow. mein hirn hat darauf beharrt, dass das "inkrementieren von wert" ein neues inkrement (wert++ o.ä.) sein sollte. dass "wert = i + 3 + wert; " ebenfalls ein inkrement ist, ist mir nicht klar geworden.

das macht jetzt SEHR viel sinn, ich danke dir! 🙂