Repeat-Until Schleife X^n

[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 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