Variablendeklaration/Schleife < C/C++ < Programmiersprachen < Praxis < Informatik < Vorhilfe
|
| Status: |
(Frage) beantwortet  | | Datum: | 19:00 Sa 25.08.2012 | | Autor: | selinaCC |
Hallo ihr Lieben,
ich möchte einen Algorithmus programmieren.
Ich rechne im Laufe dieses Algos mehrere Variablen aus, die beiden mit denen ich Probleme habe, heißen X und X_Strich.
Es läuft folgendermaßen ab: Die Schleife soll verlassen werden, sobald X und X_Strich übereinstimmen. Im Algorithmus selbst wird aber nach jedem Durchgang das neue X = X_Strich gesetzt. Mein Algorithmus soll aber abbrechen, wenn das alte X dem neuen X_Strich entspricht.
Ich habe eine while-Schleife gewählt und nun ist das Problem, dass die Schleife nach dem ersten Durchlauf verlassen wird, da ja drin steht X = X_Strich.
(Die Weitermachbedingung der while-Schleife ist: while(X != X_Strich). )
Als Lösung habe ich mir gedacht, dass ich Zählvariablen einbauen könnte. Nun weiß ich aber nicht wie ich das machen soll.
Muss ich dann noch eine for Schleife einbauen?
Wie muss ich die Variablen deklarieren, dass sie zb [mm] X_i [/mm] heißen und durchgezählt werden?
Oder bin ich völlig falsch und muss das ganz anders lösen?
Viele Grüße
Selina
|
|
| |
|
Hallo Selina,
da gibt es zwar zahlreiche Möglichkeiten, die beiden folgenden sind am einfachsten.
1) Du führst ein "Flag" ein, das vor dem ersten Durchlauf der Schleife z.B. auf 0 steht. Am Ende der Schleife wird das Flag nur dann auf 1 gesetzt, wenn schon x=x_Strich ist, ansonsten wird x=x_Strich gesetzt und das Flag bleibt auf Null.
2) Besser aber ist, Du wählst die fußgesteuerte Schleifenform "do...while". Dann wird immer am Anfang der Schleife x=x_Strich gesetzt und am Ende der Schleife (beim while) geprüft. Das ist definitiv sauberer.
Grüße
reverend
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 22:00 Sa 25.08.2012 | | Autor: | selinaCC |
Dankeschön, ich habe mich nun für die do/while Schleife entschieden. Leider habe ich sie vorher noch nie benutzt. Mein Programm hat wieder nur einen Durchgang gemacht, da es folgendermaßen aussieht:
Bevor man in die do/while Schleife reingeht hat man schon einen Wert für X.
In der do Bedingung wird dann folgendes gemacht:
- wir berechnen ein r (mit Hilfe von dem X)
- wir berechnen X_Strich (mit Hilfe von X)
- wir berechnen ein s (mit Hilfe von X und X_Strich)
- wir berechne U_Dach = U (U haben wir auch schon vor der Schleife)
- wir setzen U = s
- und nun erst ganz zum Schluss setzen wir X = X_Strich
Also um es mal mit Indizes auszudrücken: Wir gehen in die do Schleife mit einem [mm] X_1 [/mm] berechnen dann damit [mm] X_2 [/mm] und setzen dann [mm] X_3 [/mm] = [mm] X_2. [/mm] Im nächsten do-Durchgang berechnen wir dann [mm] X_4 [/mm] und brechen ab, wenn [mm] X_4 [/mm] = [mm] X_3 [/mm] ist. Also kann man salopp sagen, dass das letzte X [mm] (X_3), [/mm] das wir am Ende des ersten Durchgangs berechnen mit dem ersten X [mm] (X_4), [/mm] das wir am Anfang des zweiten Durchgangs berechnen, übereinstimmen soll.
Ich denke mein Programm klappt ja hier wieder nicht, da ich ja am Ende des ersten Durchgangs sage, [mm] X_3 [/mm] = [mm] X_2 [/mm] und dann denkt das Programm: Abbruch, die beiden X stimmen überein.
Wie kann ich dieses Problem beheben?
Viele Grüße,
Selina
|
|
|
| |
|
Hallo Selina,
da hast Du meine erste Antwort nicht ganz gelesen bzw. durchdacht.
> Dankeschön, ich habe mich nun für die do/while Schleife
> entschieden. Leider habe ich sie vorher noch nie benutzt.
> Mein Programm hat wieder nur einen Durchgang gemacht, da es
> folgendermaßen aussieht:
> Bevor man in die do/while Schleife reingeht hat man schon
> einen Wert für X.
Ja, und vorher setzt man auch noch X_Strich=X.
> In der do Bedingung wird dann folgendes gemacht:
Es fängt damit an, dass in der Schleife X=X_Strich gesetzt wird.
> - wir berechnen ein r (mit Hilfe von dem X)
> - wir berechnen X_Strich (mit Hilfe von X)
> - wir berechnen ein s (mit Hilfe von X und X_Strich)
> - wir berechne U_Dach = U (U haben wir auch schon vor der
> Schleife)
> - wir setzen U = s
> - und nun erst ganz zum Schluss setzen wir X = X_Strich
Genau das tun wir nicht, weil die Schleife sonst sofort abbricht.
> Also um es mal mit Indizes auszudrücken: Wir gehen in die
> do Schleife mit einem [mm]X_1[/mm] berechnen dann damit [mm]X_2[/mm] und
> setzen dann [mm]X_3[/mm] = [mm]X_2.[/mm] Im nächsten do-Durchgang berechnen
> wir dann [mm]X_4[/mm] und brechen ab, wenn [mm]X_4[/mm] = [mm]X_3[/mm] ist. Also kann
> man salopp sagen, dass das letzte X [mm](X_3),[/mm] das wir am Ende
> des ersten Durchgangs berechnen mit dem ersten X [mm](X_4),[/mm] das
> wir am Anfang des zweiten Durchgangs berechnen,
> übereinstimmen soll.
> Ich denke mein Programm klappt ja hier wieder nicht, da
> ich ja am Ende des ersten Durchgangs sage, [mm]X_3[/mm] = [mm]X_2[/mm] und
> dann denkt das Programm: Abbruch, die beiden X stimmen
> überein.
>
> Wie kann ich dieses Problem beheben?
Siehe oben.
Grüße
reverend
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 22:51 Sa 25.08.2012 | | Autor: | selinaCC |
Guten Abend Reverend :)
okay, ich habe es so korrigiert, aber jetzt läuft es unendlich weiter, also es bricht nicht mehr ab. Kannst du mir bitte sagen, wieso dies sein könnte?
ich habe die die while Bedingung so formuliert:
while(X != X_Strich);
Viele Grüße
Selina
|
|
|
| |
|
Hallo nochmal,
ich steige langsam nicht mehr durch, was Du da tust.
Schreib doch bitte mal die wesentlichen Teile der Schleife auf.
Das müssen nicht alle Zeilen sein. Es ist z.B. egal, in welcher Weise X_Strich eigentlich berechnet wird. Das kann auch eine Blackbox sein.
Aber in welcher Reihenfolgen stehen nun die Anweisungen, die X und X_Strich betreffen?
> okay, ich habe es so korrigiert, aber jetzt läuft es
> unendlich weiter, also es bricht nicht mehr ab. Kannst du
> mir bitte sagen, wieso dies sein könnte?
>
> ich habe die die while Bedingung so formuliert:
> while(X != X_Strich);
heißt != "ungleich"? In anderen Sprachen wird das <> geschrieben, aber bei C weiß ichs gerade nicht. Für die Struktur ist das aber egal, das geht genauso in Metasprache.
Grüße
reverend
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 00:00 So 26.08.2012 | | Autor: | selinaCC |
hey :)
Genau, in C bedeutet != ungleich.
also gerechnet wird in dieser Reihenfolge:
r = floor((S+X)/U); //floor bedeutet abrunden auf die größte ganze Zahl
P_Strich = (r*U)-X;
s = U_Dach+r*(X-X_Strich);
U_Dach = U;
U = s;
X = X_Strich;
Das ganze habe ich nun so abgeändert:
X = X_Strich;
do
{
X_Strich = X;
r = floor((S+X)/U); //floor bedeutet abrunden auf die größte ganze Zahl
P_Strich = (r*U)-X;
s = U_Dach+r*(X-X_Strich);
U_Dach = U;
U = s;
// das habe ich weggemacht: X = X_Strich;
}
while(X != X_Strich);
und leider bricht mir der Code jetzt nicht mehr ab.
Viele Grüße,
SelinaCC
|
|
|
| |
|
Hallo Selina,
das stimmt doch nach wie vor logisch nicht, ganz unabhängig von der Programmiersprache.
r, S, U, U_Dach, X und X_Strich haben vor dem Beginn dieses Programmauszugs also schon Werte. (Ich denke, X_Strich wird noch keinen Wert haben. Dann klappt das folgende aber nicht)
> r = floor((S+X)/U); //floor bedeutet abrunden auf
> die größte ganze Zahl
>
> P_Strich = (r*U)-X;
>
> s = U_Dach+r*(X-X_Strich);
>
> U_Dach = U;
>
> U = s;
>
> X = X_Strich;
Das war vorhin noch umgekehrt. In der Schleife sollte X einen neuen Wert bekommen. Hier wird also X an die Schleife übergeben, die aber mit X=X_Strich beginnt. Deswegen muss diese Programmzeile genau umgekehrt heißen: X_Strich=X. Damit wird nun X_Strich übergeben, und im ersten Durchlauf der Schleife bekommt X sofort diesen Wert.
> Das ganze habe ich nun so abgeändert:
>
> X = X_Strich;
falsch herum, siehe oben.
> do
> {
>
> X_Strich = X;
Wie hättest Du es denn nun gern? Bisher sagtest Du, in der Schleife wird anhand des vorliegenden X ein neues X_Strich berechnet, und die Schleife solle abbrechen, wenn das (neue) X_Strich gleich dem (alten) X ist.
Wenn das noch so ist, muss auch diese Zeile genau umgekehrt sein, dann passt es auch mit der Zuweisung vor der Schleife zusammen.
> r = floor((S+X)/U); //floor bedeutet abrunden auf
> die größte ganze Zahl
>
> P_Strich = (r*U)-X;
>
> s = U_Dach+r*(X-X_Strich);
Wo kommt denn hier jetzt X_Strich her? Die Klammer ist so doch immer gleich Null. Oder ist einfach P_Strich ein Tippfehler?
> U_Dach = U;
>
> U = s;
>
> // das habe ich weggemacht: X = X_Strich;
> }
In dieser Schleife wird doch gar kein X_Strich neu berechnet. ![[haee]](/images/smileys/haee.gif "[haee]")
> while(X != X_Strich);
>
> und leider bricht mir der Code jetzt nicht mehr ab.
Wieso nicht? Die Schleife sollte so überhaupt nicht wiederholt werden.
Im übrigen musst Du bei der Computerprogrammierung immer Ungenauigkeiten mit annehmen. Wenn Du z.B. eine Schleife abbrechen willst, wenn y=2 ist, dann kannst du nicht sicher davon ausgehen, dass aus der Berechnung y=sqrt(4) auch wirklich x=2 folgt. Eher wahrscheinlich ist, dass das Ergebnis um etwa [mm] 10^{-12} [/mm] davon abweicht.
Insofern ist es meistens klüger, bei Vergleichsuntersuchungen diesen Fehler mit einzubeziehen, also z.B. [mm] Epsilon=10^{-11} [/mm] zu setzen, und dann statt x=y die Bedingung abs(x-y)<Epsilon zu prüfen.
Das scheint hier aber bisher nicht das Problem zu sein, sondern nur, dass die Struktur nicht stimmt.
Hier einmal ganz knapp eine richtige Struktur, ohne obige Korrektur von Genauigkeitsfehlern:
'Zuweisung aller benötigten Variablen incl. X
X_Strich=X
do
X=X_Strich
'Neuberechnung von X_Strich
while X!=X_Strich
Grüße
reverend
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 08:59 So 26.08.2012 | | Autor: | selinaCC |
Guten Morgen Referend,
> Hallo Selina,
>
> das stimmt doch nach wie vor logisch nicht, ganz
> unabhängig von der Programmiersprache.
>
> r, S, U, U_Dach, X und X_Strich haben vor dem Beginn dieses
> Programmauszugs also schon Werte. (Ich denke, X_Strich wird
> noch keinen Wert haben. Dann klappt das folgende aber
> nicht)
Doch alle haben schon Werte, auch X_Strich! Es gibt vor meiner Problemschleife eine while Schleife. In ihr steht das gleiche, wie auch in dieser Schleife steht, nur dass die while schleife abbricht, falls U eine Quadratzahl ist.
Und jetzt soll das ganze nochmal in eine Schleife gepackt werden und abbrechen sobald X = X_Strich entspricht.
>
> > r = floor((S+X)/U); //floor bedeutet abrunden auf
> > die größte ganze Zahl
> >
> > P_Strich = (r*U)-X;
Das soll X_Strich heißen, also X_Strich = (r*U) - X;
> >
> > s = U_Dach+r*(X-X_Strich);
> >
> > U_Dach = U;
> >
> > U = s;
> >
> > X = X_Strich;
>
> Das war vorhin noch umgekehrt. In der Schleife sollte X
> einen neuen Wert bekommen. Hier wird also X an die Schleife
> übergeben, die aber mit X=X_Strich beginnt. Deswegen muss
> diese Programmzeile genau umgekehrt heißen: X_Strich=X.
> Damit wird nun X_Strich übergeben, und im ersten Durchlauf
> der Schleife bekommt X sofort diesen Wert.
>
> > Das ganze habe ich nun so abgeändert:
> >
> > X = X_Strich;
>
> falsch herum, siehe oben.
>
> > do
> > {
> >
> > X_Strich = X;
>
> Wie hättest Du es denn nun gern? Bisher sagtest Du, in der
> Schleife wird anhand des vorliegenden X ein neues X_Strich
> berechnet,
Genau und am Ende der Schleife wird dieser Wert gleich X gesetzt.
und die Schleife solle abbrechen, wenn das
> (neue) X_Strich gleich dem (alten) X ist.
Genau
> Wenn das noch so ist, muss auch diese Zeile genau
> umgekehrt sein, dann passt es auch mit der Zuweisung vor
> der Schleife zusammen.
>
> > r = floor((S+X)/U); //floor bedeutet abrunden auf
> > die größte ganze Zahl
> >
> > X_Strich = (r*U)-X;
> >
> > s = U_Dach+r*(X-X_Strich);
>
> Wo kommt denn hier jetzt X_Strich her? Die Klammer ist so
> doch immer gleich Null.
Nein, da altes X - neues X_Strich gerechnet wird.
> Oder ist einfach P_Strich ein
> Tippfehler?
Ja war ein Tippfehler.
>
> > U_Dach = U;
> >
> > U = s;
> >
> > // das habe ich weggemacht: X = X_Strich;
> > }
>
> In dieser Schleife wird doch gar kein X_Strich neu
> berechnet.
es wird ein neues X_Strich berechnet, an zweiter Stelle: X_Strich = (r*U)-X;
>
> > while(X != X_Strich);
> >
> > und leider bricht mir der Code jetzt nicht mehr ab.
>
> Wieso nicht? Die Schleife sollte so überhaupt nicht
> wiederholt werden.
>
> Im übrigen musst Du bei der Computerprogrammierung immer
> Ungenauigkeiten mit annehmen. Wenn Du z.B. eine Schleife
> abbrechen willst, wenn y=2 ist, dann kannst du nicht sicher
> davon ausgehen, dass aus der Berechnung y=sqrt(4) auch
> wirklich x=2 folgt. Eher wahrscheinlich ist, dass das
> Ergebnis um etwa [mm]10^{-12}[/mm] davon abweicht.
> Insofern ist es meistens klüger, bei
> Vergleichsuntersuchungen diesen Fehler mit einzubeziehen,
> also z.B. [mm]Epsilon=10^{-11}[/mm] zu setzen, und dann statt x=y
> die Bedingung abs(x-y)<Epsilon zu prüfen.
>
> Das scheint hier aber bisher nicht das Problem zu sein,
> sondern nur, dass die Struktur nicht stimmt.
>
> Hier einmal ganz knapp eine richtige Struktur, ohne obige
> Korrektur von Genauigkeitsfehlern:
>
> 'Zuweisung aller benötigten Variablen incl. X
> X_Strich=X
> do
> X=X_Strich
> 'Neuberechnung von X_Strich
> while X!=X_Strich
>
Mich verwirrt, dass ich doch, wenn ich X_Strich = X und dann in der do-Schleife X = X_Strich schreibe, dann verliere ich doch meine ursprünglichen Werte von X_Strich, da ich ihm ja vor der do Schleife X zuordne? Oder verstehe ich das falsch??? Und das was ich eig am Ende machen sollte, also X = X_Strich habe ich ja an den Anfang verschoben, dann stimmt doch auch die Rechnung nicht mehr?
Kann man das nicht irgendwie mit Zählvariablen machen? Weil es soll ja abbrechen sobald [mm] X_{i} [/mm] = [mm] X_{i+1}.
[/mm]
Oder man könnte auch als Abbruchbedingung schreiben, dass das alte X_Stich dem neuen X_Strich entsprechen soll.... X soll ja am Ende der Schleife sowieso den Wert von X_Strich haben..
Viele Grüße
SelinaCC
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig  | | Datum: | 10:17 So 26.08.2012 | | Autor: | Valerie20 |
Hi!
Um ehrlich zu sein, finde ich es ziemlich verwirrend was du da machst.
Könntest du die Aufgabenstellung mal hier rein schreiben (falls denn
eine existieren sollte)?
Es wäre auch hilfreich, wenn du deinen ganzen Code mal posten könntest.
Vielleicht machst du vorher schon einen Fehler.
Valerie
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig | | Datum: | 13:39 So 26.08.2012 | | Autor: | selinaCC |
Hallo,
ich habe es hinbekommen und es funktioniert jetzt endlich :))))))
Vielen Dank an Referend für die Tipps, die haben mich weitergebracht!
Wünsche euch noch ein schönes Restwochenende!!
Viele Grüße,
Selina
|
|
|
|
