Repeat-Until Schleife X^n

[301200]

Hallo,

meine Aufgabe ist es eine Repeat-Until Schleife zu programmieren, bei der man den X Wert eingeben muss und beim Betätigen eines Buttons muss die Schleife diese Zahl X^n rechnen. In der Schelife läuft dann dieses n durch.
Das Ergebnis soll in einem Memofeld ausgegben werden.

Kann mir da eine rhelfen?Bin neu und habe überhaupt gar keine Vorstellung wie das laufen soll.

[Deep-Sea]

Was hast du denn bis jetzt schon programmiert?

[p80286]

Delphi-Quellcode:

...
count:=1;
if X>1 then
  repeat
    x:=x*x;
    count:=count+1;
  until count>=n;

Gruß
K-H

[Deep-Sea]

@p80286:
Learning by doing copy&paste? :roll:

[301200]

Danke. Ich versuche das schon zu verstehen, aber mein Problem ist, dass ich seit 2 Wochen krank bin und den Stoff in der Schule nicht mitverfolge. Trotzdem will ich für morgen meine Hausaufgaben machen. Ich habe schon 2 Sachen davor programmiert, die waren aber beide nicht richtig...

Danke sehr.

[301200]

Zitat:

Zitat von p80286 (Beitrag 1093666)

Delphi-Quellcode:

...
count:=1;
if X>1 then
  repeat
    x:=x*x;
    count:=count+1;
  until count>=n;

Gruß
K-H

Ok den Teil hab ich soweit. Aber welche Variablen müsste ich oben meinen Feldern zuweisen?
Was ist denn das count genau?

[gammatester]

Zitat:

Zitat von 301200 (Beitrag 1093683)

Zitat:

Zitat von p80286 (Beitrag 1093666)

Delphi-Quellcode:

...
count:=1;
if X>1 then
  repeat
    x:=x*x;
    count:=count+1;
  until count>=n;

Gruß
K-H

Ok den Teil hab ich soweit. Aber welche Variablen müsste ich oben meinen Feldern zuweisen?
Was ist denn das count genau?

Du solltest allerdings auch beachten, daß der Teil mindestens zwei logische Fehler enthält! Vielleicht mit Absicht eingebaut?

[301200]

Zitat:

Zitat von gammatester (Beitrag 1093685)

Zitat:

Zitat von 301200 (Beitrag 1093683)

Zitat:

Zitat von p80286 (Beitrag 1093666)

Delphi-Quellcode:

...
count:=1;
if X>1 then
  repeat
    x:=x*x;
    count:=count+1;
  until count>=n;

Gruß
K-H

Ok den Teil hab ich soweit. Aber welche Variablen müsste ich oben meinen Feldern zuweisen?
Was ist denn das count genau?

Du solltest allerdings auch beachten, daß der Teil mindestens zwei logische Fehler enthält! Vielleicht mit Absicht eingebaut?

Mir fällt so auf, dass das mit dem X vielleicht nicht so hinhaut und das das count, welches sich bei jedem durchlauf um 1 erhöht, nichts mit dem X zu tun hat.

Ich habe mal eine Vermutung:

x:=m
repeat
m:= m*x
x:=x+1
until x >= Ende

Ist dort ein fehler?

[Sir Rufo]

Komisch, mir hat man im Matheunterricht beigebracht, dass bei

x^n

x n-mal mit sich selber multipliziert wird

Aber ist ja auch schon lange her, möglicherweise ist das heute anders.

[shmia]

Lass dein Programm doch einfach mal rechnen.
x = 4 n = 3
Das wäre also 4^3 und das sind 4*4*4 = 64.
Wenn dein Programm dann aber 256 als Ergebnis auswirft, dann weisst du das deine Schleife einmal zu oft durchlaufen wurde.
Überleg' dir auch mal, ob du vielleicht nicht eine eigene Variable y für das Ergebnis brauchst.
Es ist immer blöd, wenn man sich die Inputvariablen überschreibt...

[301200]

Zitat:

Zitat von Sir Rufo (Beitrag 1093700)

Komisch, mir hat man im Matheunterricht beigebracht, dass bei

x^n

x n-mal mit sich selber multipliziert wird

Aber ist ja auch schon lange her, möglicherweise ist das heute anders.

Es ist immernoch genauso. Ich habe nicht behauptet es zu können, deshalb habe ich nach Hilfe gefragt.

[301200]

Zitat:

Zitat von shmia (Beitrag 1093703)

Lass dein Programm doch einfach mal rechnen.
x = 4 n = 3
Das wäre also 4^3 und das sind 4*4*4 = 64.
Wenn dein Programm dann aber 256 als Ergebnis auswirft, dann weisst du das deine Schleife einmal zu oft durchlaufen wurde.
Überleg' dir auch mal, ob du vielleicht nicht eine eigene Variable y für das Ergebnis brauchst.
Es ist immer blöd, wenn man sich die Inputvariablen überschreibt...

Mein Programm läuft ja leider nicht.

[Sir Rufo]

Damit wollte ich auch nicht sagen, dass du das können mußt, aber erkennen, dass der Ansatz schon falsch ist, das müsstest du.

Zitat:

Delphi-Quellcode:

x:=m
repeat
m:= m*x
x:=x+1
until x >= Ende

Ist dort ein fehler?

1. verwende die Variablen in der gleichen Bedeutung der Formel (sonst gibt es nur Verwirrung)

Delphi-Quellcode:

function Hoch( x, n : integer ) : integer;

2. Wenn wir wissen, das x^n bedeutet, dass x mit sich selber multipliziert wird (Annahme n=3), dann würde das ja wie folgt errechnet:

Code:

0   1   2   3
1 * x * x * x

da sehe ich kein n in der Berechnung, und auch immer das gleiche x
Somit ergibt sich (hier mit einer for Schleife) folgender Code (bei n >= 0)

Delphi-Quellcode:

var
  nidx : integer;
begin
  Result := 1;
  for nidx := 1 to n do
    Result := Result * x;
end;

[301200]

Zitat:

Zitat von Sir Rufo (Beitrag 1093708)

Damit wollte ich auch nicht sagen, dass du das können mußt, aber erkennen, dass der Ansatz schon falsch ist, das müsstest du.

Zitat:

Delphi-Quellcode:

x:=m
repeat
m:= m*x
x:=x+1
until x >= Ende

Ist dort ein fehler?

1. verwende die Variablen in der gleichen Bedeutung der Formel (sonst gibt es nur Verwirrung)

Delphi-Quellcode:

function Hoch( x, n : integer ) : integer;

2. Wenn wir wissen, das x^n bedeutet, dass x mit sich selber multipliziert wird (Annahme n=3), dann würde das ja wie folgt errechnet:

Code:

0   1   2   3
1 * x * x * x

da sehe ich kein n in der Berechnung, und auch immer das gleiche x
Somit ergibt sich (hier mit einer for Schleife) folgender Code (bei n >= 0)

Delphi-Quellcode:

var
  nidx : integer;
begin
  Result := 1;
  for nidx := 1 to n do
    Result := Result * x;
end;

Danke. Das hat mir jetzt erstmal verständlich das Prinzip erklärt.
Könntest du mir vielleicht noch bei der passenden repeat-until Schleife helfen? Ich kann das ja nicht, weil ich gefehlt habe als wir das gemacht haben und ein funktionierendes Beispiel hierbei würde mir wahrscheinlich helfen das Prinzip zu verstehen.

[301200]

Delphi-Quellcode:

var x,m : real
   i,n : integer

begin
 x:=StrToFloat (Edit1.text);
 n:=StrToInt (Edit2.text);
 m:=x;
repeat
m:=m*x;
i:=i+1
until i=n

Kommt das so hin?

[patti]

Also es fehlt auf jeden Fall die Initialisierung deiner Lauf-Variable i, sprich du hast keinen "Start-Wert" für i angegeben. Vor der Schleife solltest du i beispielsweise auf 1 setzen.
Außerdem solltest du folgendes überlegen: Was passiert, wenn n = 1 ist? Die Repeat-Schleife wird - im Gegensatz zur While-Schleife - immer mindestens einmal durchlaufen (nennt sich glaube ich abweisende Schleife o.ä.). Wenn n = 1 ist, dann ist das Ergebnis bei deinem Code aber nicht x^1, sondern x^2...
Und: Schonmal darüber nachgedacht, was passiert, wenn jemand in das Feld für den Exponenten eine negative Zahl eingibt? Stichwort Endlosschleife - als Programmierer muss man auf solche "Fallen" aufpassen...

[Sir Rufo]

Generell muss man sagen, dass für diese Lösung

Delphi-Quellcode:

repeat until

ungeschickt ist (schönen Gruß an den Lehrer) und

Delphi-Quellcode:

while do

erheblich besser geeignet ist.
Weiterhin ist x^n auch für n<0 definiert.

Und generell gesehen sollte man dafür eine

Delphi-Quellcode:

function

definieren und diese dann benutzen.
EVA (die Frau des Programmierers)

Delphi-Quellcode:

var
  x, e : Extended;
  n : Integer;
begin

  // Eingabe

  x := StrToFloatDef( EditX.Text, 0 );
  n := StrToIntDef( EditN.Text, 0 );

  // Verarbeitung

  e := Hoch( x, n );  // Aufruf der eigentlichen Funktion

  // Ausgabe

  EditE.Text := FloatToStr( e );
end;

StrToFloatDef
StrToIntDef

Hier mal die Realisierung mit einer While-Schleife:

Delphi-Quellcode:

function Hoch( x : Extended; n : integer ) : Extended;
var
  nidx : integer;
begin
  Result := 1;  // x^0 ist 1
  nidx := 0;  // Zähler initialisieren

  // Zähler mit dem Absolutwert von n vergleichen
  while nidx < Abs( n ) do
    begin
      Inc( nidx );  // Zähler um 1 erhöhen

      // Fallunterscheidung für positive/negative n
      if n > 0 then
        Result := Result * x
      else
        Result := Result / x;
    end;
end;

Hier noch ein kleiner Exkurs um ein

Delphi-Quellcode:

for to

in ein

Delphi-Quellcode:

while do

und dann in ein

Delphi-Quellcode:

repeat until

zu überführen:

Delphi-Quellcode:

for i := 0 to 9 do
  foo;

// geht mit "while do" so

i := 0;
while i <= 9 do
  begin

    foo;

    Inc( i );
  end;

// und mit "repeat until"

i := 0;
if ( i <= 9 ) then
  repeat

    foo;

    Inc( i );
  until not ( i <= 9 );

und hier eine generische Umwandlung von

Delphi-Quellcode:

while do

nach

Delphi-Quellcode:

repeat until

Delphi-Quellcode:

while EinLogischerAusdruck do
  foo;

// mit "repeat unitl"

if EinLogischerAusdruck then
  repeat

    foo;

  until not EinLogischerAusdruck;

Andersherum von

Delphi-Quellcode:

repeat until

nach

Delphi-Quellcode:

while do

ist es komplizierter

Delphi-Quellcode:

repeat

  foo;

until EinLogischerAusdruck;

// mit "while do"

FirstGoFlag := True;

while FirstGoFlag or not EinLogischerAusdruck do
  begin
    FirstGoFlag := False;

    foo;

  end;

Das sollte eigentlich reichen, damit du das obige Konstrukt mit einem

Delphi-Quellcode:

repeat until

umschreiben kannst :)

[Deep-Sea]

Ich möchte noch - hauptsächlich für den TE - etwas zu Sir Rufos sehr schöner Erklärung Anmerken:
Der Grund, warum das Umwandeln so umständlich ist und die While-do- und Repeat-until-Schleifen hier so kompliziert und aufgeblasen wirken liegt daran, dass es eben schon einen Sinn hat, warum es drei verschiedene Schleifenarten gibt: Jede hat ihre speziellen Anwendungsfälle und das nutzen der "falschen" Schleife macht den Code eben unnütz kompliziert. :)

[Maik81ftl]

Zitat:

Zitat von Deep-Sea (Beitrag 1093865)

Ich möchte noch - hauptsächlich für den TE - etwas zu Sir Rufos sehr schöner Erklärung Anmerken:
Der Grund, warum das Umwandeln so umständlich ist und die While-do- und Repeat-until-Schleifen hier so kompliziert und aufgeblasen wirken liegt daran, dass es eben schon einen Sinn hat, warum es drei verschiedene Schleifenarten gibt: Jede hat ihre speziellen Anwendungsfälle und das nutzen der "falschen" Schleife macht den Code eben unnütz kompliziert. :)

Mich mal deinen Ausführungen anschließe, jedoch mal einen Kleinen, feinen und dennoch waren Einwand zugestehe.

Wenn man die entsprechende Schleife z.b. For nicht nutzten darf, weil zu billig in der Lösung, und daher eine Repeat until nutzen muß, sollte man deren Eigenschaft zu seinem Nutzen machen.

Hab es eben schon mit gelesen. eine repeat until läuft generell einmal durch. ergo? entweder den Schleifencount anpassen oder die Break-Bedingung anpassen.

[Sir Rufo]

Zitat:

Zitat von Maik81ftl (Beitrag 1094050)

Zitat:

Zitat von Deep-Sea (Beitrag 1093865)

Ich möchte noch - hauptsächlich für den TE - etwas zu Sir Rufos sehr schöner Erklärung Anmerken:
Der Grund, warum das Umwandeln so umständlich ist und die While-do- und Repeat-until-Schleifen hier so kompliziert und aufgeblasen wirken liegt daran, dass es eben schon einen Sinn hat, warum es drei verschiedene Schleifenarten gibt: Jede hat ihre speziellen Anwendungsfälle und das nutzen der "falschen" Schleife macht den Code eben unnütz kompliziert. :)

Mich mal deinen Ausführungen anschließe, jedoch mal einen Kleinen, feinen und dennoch waren Einwand zugestehe.

Wenn man die entsprechende Schleife z.b. For nicht nutzten darf, weil zu billig in der Lösung, und daher eine Repeat until nutzen muß, sollte man deren Eigenschaft zu seinem Nutzen machen.

Hab es eben schon mit gelesen. eine repeat until läuft generell einmal durch. ergo? entweder den Schleifencount anpassen oder die Break-Bedingung anpassen.

Damit bekommst du aber das Verhalten der for Schleife nicht nachgebaut. Es muss vorher eine Abfrage erfolgen, ob der effektive Schleifen-Code überhaupt ausgeführt werden soll. Eine Anpassung des Schleifencounts reicht nicht (siehe mein Beispiel 3 Threads zuvor)

[Maik81ftl]

Zitat:

Zitat von Sir Rufo (Beitrag 1094055)

Zitat:

Zitat von Maik81ftl (Beitrag 1094050)

Zitat:

Zitat von Deep-Sea (Beitrag 1093865)

Ich möchte noch - hauptsächlich für den TE - etwas zu Sir Rufos sehr schöner Erklärung Anmerken:
Der Grund, warum das Umwandeln so umständlich ist und die While-do- und Repeat-until-Schleifen hier so kompliziert und aufgeblasen wirken liegt daran, dass es eben schon einen Sinn hat, warum es drei verschiedene Schleifenarten gibt: Jede hat ihre speziellen Anwendungsfälle und das nutzen der "falschen" Schleife macht den Code eben unnütz kompliziert. :)

Mich mal deinen Ausführungen anschließe, jedoch mal einen Kleinen, feinen und dennoch waren Einwand zugestehe.

Wenn man die entsprechende Schleife z.b. For nicht nutzten darf, weil zu billig in der Lösung, und daher eine Repeat until nutzen muß, sollte man deren Eigenschaft zu seinem Nutzen machen.

Hab es eben schon mit gelesen. eine repeat until läuft generell einmal durch. ergo? entweder den Schleifencount anpassen oder die Break-Bedingung anpassen.

Damit bekommst du aber das Verhalten der for Schleife nicht nachgebaut. Es muss vorher eine Abfrage erfolgen, ob der effektive Schleifen-Code überhaupt ausgeführt werden soll. Eine Anpassung des Schleifencounts reicht nicht (siehe mein Beispiel 3 Threads zuvor)

na das versteht sich ja wohl von selber. ein wenig mitdenken muß man da auch schon mal.