probleme mit for schleife

[chooter696]

ja das ist richtig.

Kleiner tipp. wenn du einen wert um 1 erhöhen oder verringern willst kannst du auch

++ variable;

-- variable;

verwenden. Das sind Inkrement/Dekrement-Operatoren

[voldemort]

und schon haben wir die nächste aufgabe an der ich sitze

*

***

*****

*******

*********

***********

ich habe mir gedacht ich kümmer mich erst einmal um das bild und dann um die leerzeichen. hier denke ich das ich ne dritte schleife brauche.

mein bisheriger code schaut so aus

int zeile, zeichen;

for (zeile=1;zeile<=6; zeile++)

{

     for (zeichen=1;zeichen<=11;zeichen+2)

     {

           printf ("X");

      }

      printf ("\n");

}

[/PHP]

also ab zeile 1 starten (zeile=1) und jeweils eine zeile (zeile++) anhängen bis 6 erreicht sind (zeile<=6).

dann beim ersten zeichen anfangen (zeichen=1) und dann jeweils 2 zeichen pro zeile anhängen (zeichen+2) bis 11 zeichen in der reihe erreicht sind (zeichen<=11).

habe ich in irgendeiner schleife einen denkfehler, oder sind beide müll?

[Klotzkopp]

habe ich in irgendeiner schleife einen denkfehler, oder sind beide müll?

Die äußere Schleife ist in Ordnung.

Deine innere Schleife macht aber in jeder Zeile dasselbe: Sie zählt in Zweierschritten von 1 bis 11.

Du musst für die Steuerausdrücke der inneren Schleife einen Wert benutzen, der sich bei jedem Durchlauf der äußeren Schleife ändert.

[voldemort]

ach genau, ich muss ihn ja mitteilen das er sich die info aus der äußeren schleife holen soll, also ungefähr so:

int zeile, zeichen;

for (zeile=1;zeile<=6; zeile++)

{

     for (zeichen=1;11<=zeile;zeichen=zeichen+2)


     {


           printf ("X");

      }

      printf ("\n"); 

}[/PHP]

so hab ich nun aber nen schwarzen bildschirm.

[Klotzkopp]

Das dürfte daran liegen, dass 11<=zeile niemals wahr sein kann.

[voldemort]

hm, weil er dann 11 zeilen machen möchte?

[Klotzkopp]

hm, weil er dann 11 zeilen machen möchte?

Wer ist "er"?

Zeile nimmt Werte zwischen 1 und 6 an. 11 ist niemals kleiner als einer dieser Werte, daher wird die innere Schleife immer übersprungen.

Schreib doch mal in einer Tabelle auf, in welcher Zeile wieviele Sternchen ausgegeben werden sollen. Dann dürfte klarer werden, wie die innere Schleifenbedingung lauten muss.

[voldemort]

ja stimmt. da hab ich nicht wirklich drüber nach gedacht, oder in mathe nicht aufgepasst.

(mit "er" hab ich den rechner gemeint )

also mit der tabelle du meinst so in etwa?

1 =1 zeichen

2 =3 zeichen

3 =5 zeichen

4 =7 zeichen

5 =9 zeichen

6 =11 zeichen

demnach nehme ich an das aber zeichen=1 und zeichen=zeichen+2 korrekt sind?

[Klotzkopp]

demnach nehme ich an das aber zeichen=1 und zeichen=zeichen+2 korrekt sind?

Bei 1 anzufangen, ist sicher richtig. Immer um 2 zu erhöhen, ist aber Quatsch. Dein Endwert erhöht sich bei jedem Durchlauf der äußeren Schleife um 2. Die Schrittweite der inneren Schleife hat damit nichts zu tun. Wenn du am Ende 11 Sternchen ausgeben willst, musst du von 1 bis 11 zählen, mit Schrittweite 1. Bei Schrittweite 2 zählst du 1, 3, 5, 7, 9, 11: Das werden nur 6 Sternchen.

Versuch doch mal, eine allgemeingültige Regel aufzustellen:

Zeile 1: 1 Sternchen

Zeile 2: 3 Sternchen

Zeile 3: 5 Sternchen

...

Zeile n: ? Sternchen

[voldemort]

ich dachte eigentlich das ich +2 rechnen muss,weil ich beim vorherigen bsp ja +1 pro zeile hoch gerechnet habe. deswegen der gedanke 6 durchläufe + 2 sternchen pro durchlauf=11sternchen am ende.

also muss ich in der inneren schleife schon mal +1 rechnen.

dazu kommt eine neue zusätzliche "formel" um auf die 11 zeichen hoch zu rechnen?

[Klotzkopp]

ich dachte eigentlich das ich +2 rechnen muss,weil ich beim vorherigen bsp ja +1 pro zeile hoch gerechnet habe. deswegen der gedanke 6 durchläufe + 2 sternchen pro durchlauf=11sternchen am ende.

Du machst aber nicht "+2 sternchen pro durchlauf".

Der grundsätzliche Aufbau ist doch der:

for(INIT; CONDITION; STEP)

{

    BODY

}[/code]

Der Ablauf sieht so aus (das solltest du auswendig wissen):


1. INIT ausführen

2. CONDITION prüfen. Wenn falsch, dann Ende

3. BODY ausführen

4. STEP ausführen

5. Gehe zu 2


Wenn deine CONDITION niemals wahr wird, passiert (außer INIT) gar nichts. Und wenn du bei STEP doppelt so große Schritte machst, machst du nur halb so viele. Du überspringst quasi die Ausgabe jedes zweiten Sternchens.


also muss ich in der inneren schleife schon mal +1 rechnen. 

dazu kommt eine neue zusätzliche "formel" um auf die 11 zeichen hoch zu rechnen?
Das ist keine "zusätzliche" Formel. Du hast auch im ersten Programm die Anzahl der Sternchen aus der Zeilennummer berechnet, nur war dort die Formel einfacher:


Zeile 1: 1 Sternchen

Zeile 2: 2 Sternchen

Zeile 3: 3 Sternchen

...

Zeile n: n Sternchen


Deswegen lautete die CONDITION: zeichen < zeile+1 (bzw. zeichen <= zeile).


Du musst jetzt mit der Tabelle die Formel für den allgemeinen Fall des neuen Problems finden, um daraus die richtige CONDITION zu formulieren.

[voldemort]

so weit bin ich schon mal

int zeile, zeichen;

for (zeile=1;zeile<=6; zeile++)

{

     for (zeichen=1;zeichen<=zeile;zeichen=zeichen+1)


     {


           printf ("X");

      }

      printf ("\n");

}[/PHP]

6 zeilen und pro zeile +1 zeichen.

jetzt heißt es die formel für die lösung zu finden.

wenn ich nun deine und meine tabelle kombiniere muss ich beim jetzigen programm ab der zweiten zeile schauen das ich fortlaufend die zahlen folge 1,2,3,4 und 5 hinbekomme um an diie lösung kommen. richtig?

[oxygen]

Ich hab deinen Denkprozess bei deinem letzten Satz nachvollziehen können, aber ich geb dir mal nen Tip, der dich voll auf die Lösung bringen könnte:

da deine Anzahl der Sterne hier ungleich der "Zeilenzahl" ist, brauchst du nochmal einen anderen Wert, der dir die Anzahl der Sterne festlegt und da dieser sich mit jeder Zeile ändert, solltest du ihn auch bei jeder Zeile und nicht bei jedem Zeichen verändern (so langsam sollte klar sein: die äußere Schleife bestimmt die Zeile, die innere das Zeichen).

[flashpixx]

Versuche doch einmal bitte ein Konzept zu entwickeln und Dir hier nicht jeden Schritt "absegnen" zu lassen. Schau Dir an was eine For-Schleife macht und überlege Dir, wie Du das Problem umsetzt.

Zum Problem: Du solltest eine Pyramide zeichnen, d.h. Du hast in jeder Zeile n Zeichen (Leerzeichen + Sterne). In der untersten 0 Leerzeichen und n Sterne, in der vorletzten 2 Leerzeichen und n-2 Sterne, in der ersten n-1 Leerzeichen und 1 Stern. Die Sterne sollen nun genau Mittig positioniert werden, d.h. von der Mitte her gesehen hast Du nach links bzw rechts je die Hälfte Sterne.

Beachte aber, Du hast hier eine Folge von ungeraden natürlichen Zahlen

[voldemort]

zum konzept. es ist ja nicht so das ich mich an den rechner setze irgendwas rumfummel und es dann hier rein stell und hilfe schrei.

also bevor ich irgendwas hier veröffentlich,oder frage, sind schon einige sachen passiert. ich arbeite mittlerweile hier mit verschiedene tabellen und rechnungen.

ich hab das problem das ich "noch"nicht heraus gefunden hab wie ich das umsetzen soll. zB hab ich es nun so verstanden das ich pro zeile ein zeichen anhängen muss d.h. wiederum ich müsse an die äussere schleife?

nach meiner ersten übung und nach lesen meiner lektüre habe ich nun ganz verstanden wie sie funktioniert. jedoch möchte mir die idee bzw formel nicht einfallen.

ich wollte ja erstmal nur schauen das ich die anzahl der zeichen in der pyramide hinbekomme, bevor ich mich dran begebe und die leerzeichen einfüge. es bringt mir ja auch wiederum nichts,wenn ich aufeinmal zwei sachen habe die nicht funktionieren es sei denn es bleibt mir nichts anderes übrig.

und nun weiter an die arbeit und dem nachdenken

grüße

[flashpixx]

Mache es im Pseudo-Code (Pseudocode ? Wikipedia)

Das Prinzip der Pyramide ist wie das erste Bsp, nur eben, dass Du die Sterne jetzt mittig positionieren musst. Das Prinzip ist aber gleich.

Die verschachtelten Schleifen machen genau das: Ich lasse eine For-Schleife von 1 bis n laufen und innerhalb dieser Schleife eine zweite For-Schleife von 1 bis i. Die innere Schleife wird eben dann n Mal ausgeführt, sprich Die Anweisung in der inneren Schleife n*i Mal => Die äußere Schleife ist für die Zeilen, die innere für die Zeichen. Du weißt in der innere Schleife in welcher Zeile und an welcher Position innerhalb der Zeile Du Dich befindest, somit musst Du dann nur noch entscheiden, ob Du einen Stern oder ein Leerzeichen ausgeben musst. Diese Ausgabe lässt kompakt über eine Bedingung anhand der Position formulieren oder auch über 3 weitere Schleifen (Leezeichen, Sterne, Leerzeichen)

[voldemort]

ein lebenszeichen meinerseits und mit einer lösung im gepäck

hatte viel zu tun und klausuren stehen auch an und los gehts:

	int zeile, leer, zeichen;

	int x = 5;

	int y = 1;

	for (zeile = 0; zeile < 6; zeile++)

	{

		for (leer = x; leer > 0; leer--) 

			{

				printf (" ");

			}


		for (zeichen = y; zeichen > 0; zeichen--)

			{

				printf ("X");

			}			

		printf ("\n");

                x--;

                y+=2;

	}[/PHP]

der tannenbaum schaut schon mal schön aus.

die frage: ist der code so perfekt, oder gibt es verbesserungsvorschläge,oder vereinfacherungen?

beste grüße voldemort

[Klotzkopp]

Du könntest für beide Schleifen dieselbe Laufvariable benutzen, aber das ist meiner Meinung nach nur eine Stilfrage.

Ungewöhnlich ist zumindest, dass deine inneren Schleifen rückwärts zählen. Das ist in diesem Fall zwar völlig egal, weil die Laufvariable im Schleifenrumpf nicht benutzt wird. Aber es fällt eben auf.

Wichtiger finde ich hier, dass du x und y nicht brauchst. Beide kannst du aus dem Wert von zeile berechnen. Darauf wollte ich in meinem Beitrag am 6. September hinaus:

zeile  x  y


    0  5  1

    1  4  3

    2  3  5

    3  2  7

    4  1  9

    5  0 11[/code]


Mit ein wenig mathematischem Verständnis sieht man hier gleich den Zusammenhang:



x = 5 - zeile

y = 2 * zeile + 1



Damit fallen gleich mehrere Zeilen weg:

[code]    int zeile, leer, zeichen; 

    for (zeile = 0; zeile < 6; zeile++) 

    { 

        for (leer = 5 - zeile; leer > 0; leer--)  

            { 

                printf (" "); 

            } 


        for (zeichen = 2 * zeile + 1; zeichen > 0; zeichen--) 

            { 

                printf ("X"); 

            }             

        printf ("\n"); 

    } 

[voldemort]

das schaut natürlich noch besser aus. im unterricht und in meinen lektüren wurde leider nichts davon erwähnt das ich direkt komplexere rechnungen in die schleife mit rein nehmen kann. danke für den hinweis.

habe zwischenzeitlich auch schon andere aufgaben gelöst (fakultätberechnung usw) klappt im moment ganz gut.

aufjedenfall bedanke ich mich bei allen hier für die tollen tipps und hilfe. ich werde wohl die nächsten paar jahre hier auch rumhängen und hoffentlich bald in der lage sein hilfreiche tipps zu geben.

grüße und ein schönen rest sonntag wünscht

voldemort

[Klotzkopp]

im unterricht und in meinen lektüren wurde leider nichts davon erwähnt das ich direkt komplexere rechnungen in die schleife mit rein nehmen kann. danke für den hinweis.

Das Stichwort hier lautet Ausdruck (engl.: Expression). An vielen Stellen ist laut Syntax ein Ausdruck erforderlich. Ein Ausdruck kann ein Literal sein (z.B. 5) oder ein einzelner Bezeichner vom passenden Typ, aber auch ein beliebig komplexes Gebilde aus Operatoren und Funktionsaufrufen. Praktisch überall, wo du etwas Einfaches hinschreiben kannst, kannst du auch etwas Kompliziertes verwenden. Das ist nicht allein auf Zuweisungen beschränkt.

Man sollte das aber nicht zu weit treiben, sonst leidet die Übersichtlichkeit.