Repeat-Until Schleife X^n

[301200]

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

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

[301200]

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

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)
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 von 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)
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 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)