Repeat-Until Schleife X^n

[Sir Rufo]

Generell muss man sagen, dass für diese Lösung repeat until ungeschickt ist (schönen Gruß an den Lehrer) und while do erheblich besser geeignet ist.
Weiterhin ist x^n auch für n<0 definiert.

Und generell gesehen sollte man dafür eine 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 for to in ein while do und dann in ein 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 while do nach repeat until

Delphi-Quellcode:

while EinLogischerAusdruck do
  foo;

// mit "repeat unitl"

if EinLogischerAusdruck then
  repeat

    foo;

  until not EinLogischerAusdruck;

Andersherum von repeat until nach 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 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 von 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.

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 von Maik81ftl:

Zitat von 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.

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 von Sir Rufo:

Zitat von Maik81ftl:

Zitat von 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.

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.