Potenzberechnung mit Hilfe einer Rekursion

[Xbe]

Hallo Leute^^

nach langen hin und her, entschloss ich mich info bis zur 13 durchzuziehen, jedoch verzweifle ich an so einigen Dingen, die Theorie ist meist leicht zu verstehen, jedoch scheiter ich jedesmal bei der Praxis...:( :wall:

Nun zu meiner Frage: Als Hausaufgabe soll ich ein Programm zur Potenzberechnung mit Hilfe einer Rekursion erstellen. Da ich bereits an der einfachen Aufgabe dies mit Hilfe einer Schleife zu machen :oops: , frag ich nun euch!

Danke schon mal im vorraus!

[Wolfgang Mix]

Erstmal herzlich willkommen in der DP :dp:

Es war schon einmal so ein Thread, schau' 'malhier

Gruß

Wolfgang

[Xbe]

Danke schön :D

Hab das auch schon gefunden, das Problem ist das hier praktisch nicht meine Bedingungen erfüllt werden. Bei mir soll es ja nicht mit einer Schleife berechnet werden. Kurz nicht mit einer Iteration sondern Rekursion!

[Wolfgang Mix]

Schau' Dir noch einmal Post #7 von dem Link an.
Da ruft die Funktion Potenz sich innerhalb der Funktion selber auf.
Ich denke, so etwas nennt man rekursiv ;-)
Lies aber noch den Thread einmal komplett.

Gruß

Wolfgang

[Xbe]

ok versteh ich mehr oder minder, nur worüber ich immer steuper ist diese zeile:

function Potenz(Basis, Exponent: Integer): Int64;

...kann damit nix anfangen

Gruß Xbe

[Mithrandir]

:shock:

Das ist der Funktionskopf. :shock: Delphi Grundlagen, ick hör dir trapsen?

[Wolfgang Mix]

:-D
@Xbe

Du übergibst der Funktion mit z.B. Button1 für Basis den Wert 5
und als Exponent den Wert 6. Die Funktion berechnet 5 hoch 6 und gibt als
Ergebnis (Result) de ausgerechneten Wert als (große) Ganzzahl zurück (sh. Int64)
in der OH.

Gruß

Wolfgang

[Xbe]

....*duck

Grundlagen...*pfeif

naja bei uns sieht der Kopf n bissl anders aus (mal nen BSP) ->

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);

[edit=mkinzler]Delphi-Tag eingefügt Mfg, mkinzler[/edit]

[Aphton]

Das ist eine Klassenmethode, deshalb steht auch der Klassename (TForm) dabei.
Lose Methoden werden eben ohne diese Bezeichnung definiert und sind somit nicht einer Klasse angebunden.

Zu deinem Problem:

Code:

 * Routine:
 1. Ist Exponent = 0, dann gebe 1 zurück
 2. Ist Exponent = 1, dann gebe Base zurück
 3. Ansonsten (hier kommt die Rekursion):
    Gebe Base * Routine (mit Exponent - 1)

Beispiel:
  Base: 2
  Exponent: 3

  (3): 2 * Routine( .. 2 ) 
-> 2 * 2 * Routine( ... 1 ) 
-> 2 * 2 * 2 * Routine( ... 0 ) 
-> 2 * 2 * 2 * 1  

Und somit ergibt sich 8

MfG

[mkinzler]

Zitat:

naja bei uns sieht der Kopf n bissl anders aus (mal nen BSP) ->

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);

Das ist eine Methode, grundsätzlich aber sehr ähnlich

[Xbe]

@ Wolfgang

Soweit hab ich das jetzt auch verstanden, aber ich steuper immer noch über die Bedingung Rekursion(Wiederholung durch Selbstaufruf eines Algorithmus).

Wahrscheinlich iset zu einfach um das ichs umsetzen kann...

[Mithrandir]

Zitat:

Zitat von Xbe

Soweit hab ich das jetzt auch verstanden, aber ich steuper immer noch über die Bedingung Rekursion(Wiederholung durch Selbstaufruf eines Algorithmus).

Tut mir Leid,

aber ich versteh nicht, was du uns sagen willst... :gruebel:

[Xbe]

@ Daniel G

hier mal nen Bsp für eine funktionierende Rekursion:

.
.
.

Delphi-Quellcode:

procedureTForm1.umkehren(Sender:TObject);
   var i,j:integer;
   prodedure umkehr(zeichen:char);
      begin 
         i:=i+1;
         zeichen:=wort[i];
         if i<length(wort) then umkehr(wort[i]);
         stringgrid1.cells[j,0]:=zeichen;
         j=j+1;
      end;
   begin
      wort:=edit1.text;
      i:=0;
      j:=1;
      umkehr(wort[i]);
   end;

.
.
.

[edit=MrSpock]Code Tags eingefügt. Mfg, MrSpock[/edit]

[Wolfgang Mix]

@Xbe

Delphi-Quellcode:

function Potenz(Basis, Exponent: Integer): Int64;
begin
  if Exponent = 0 then
    Exit
  else
    Result := Basis * Potenz(Basis, Exponent - 1);
end;

Was ist denn hier grundlegend anders?
Du kennst schon den Unterschied zwischen Procedure und Function?

Gruß

Wolfgang

[Xbe]

@wolfgang
nee deshalb hab ich ja vorhin gefragt, weil wenn das der Kopf wäre ok aber weiterhin muss man ja zb die Variablen wie Exponent auch vorher bestimmen

[Wolfgang Mix]

@Xbe

Ich habe den Code aus dem angegebenen Link einmal ausprobiert, hier der Quälkot:

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
    Button1: TButton;
    Edit1: TEdit;
    procedure Button1Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

function Potenz(Basis, Exponent: Integer): Int64;
begin
  if Exponent = 0 then result:=1
  else
    Result := Basis * Potenz(Basis, Exponent - 1);
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  Edit1.Text:=IntToStr(Potenz(2,3));
end;

end.

Funzt hier soweit

Gruß

Wolgang

[gammatester]

Zitat:

Zitat von Wolfgang Mix

Funzt hier soweit

Gruß

Wolgang

Hier nicht, da Potenz(2,-1) einen Stackoverflow gibt. Besser

Delphi-Quellcode:

function Potenz(Basis, Exponent: Integer): Int64;
begin
  if Exponent<0 then Result := 0
  else if Exponent = 0 then Result := 1
  else Result := Basis * Potenz(Basis, Exponent-1);
end;

oder Basis und Exponent als cardinal deklarieren.

Gruß Gammatester

[Aphton]

@Gammatester - Warum?

x^-y = 1/(x^y)

;)

Delphi-Quellcode:

function Power( Base, Exponent: Integer ): Double;
begin
  if Exponent < 0 then
    Result := 1 / Power( Base, Abs( Exponent ) )
  else
    case Exponent of
      0: Result := 1;
      1: Result := Base;
    else
      Result := Base * Power( Base, Exponent - 1 );
    end;
end;

[Wolfgang Mix]

Perfekt, jetzt muss man nur noch 0 hoch 0 abfangen.

Gruß

Wolfgang

[gammatester]

Zitat:

Zitat von Aphton

@Gammatester - Warum?

x^-y = 1/(x^y)

;)

Richtig. Und was ist 1/x^y für y>0,x>0? Für Integerwerte y>0, x>1 immer 0. Ich wollte in meinem Vorschlag nicht noch mehr Fallunterscheidungen einbringen. Es sollte aber spezifiziert werden, ob Integer oder Float gerechnet werden soll, und aus welchem Bereich die Argument kommen sollen.

Dein Vorschlag ändert unter der Hand die bisher diskutierte Funktionsdeklaration.

[gammatester]

Zitat:

Zitat von Wolfgang Mix

Perfekt, jetzt muss man nur noch 0 hoch 0 abfangen.

Gruß

Wolfgang

:?: :?:
Wieso? Aphtons Code macht's doch schon, und zwar völlig korrekt als 0^0=1!

[Wolfgang Mix]

Leider nein,
Null hoch null ist nicht definiert,
ergibt auch keinen Sinn

[Edit]Die Funktion f1 mit y = f1(x) = x^0 hat an der Stelle x = 0 den Grenzwert 1
Die Funktion f2 mit y = f2(x) = 0^x hat an der Stelle x = 0 den Grenzwert 0 [/Edit]


Gruß

Wolfgang

[gammatester]

Zitat:

Zitat von Wolfgang Mix

Leider nein,
Null hoch null ist nicht definiert,
ergibt auch keinen Sinn

Das ist Deine persönliche Meinung, ich halte es lieber mit Euler und Knuth (siehe zB Knuths Two notes on notation). Weitere Infos What is 0 to the 0 power?

Gruß Gammatester

[Sherlock]

Die Wikipedia hat da auch eine Meinung zu: http://de.wikipedia.org/wiki/Potenz_..._null.E2.80.9C

Sherlock

[Lannes]

Hallo,

Zitat:

Zitat von Xbe

...hier mal nen Bsp für eine funktionierende Rekursion:

Delphi-Quellcode:

procedureTForm1.umkehren(Sender:TObject);
   var i,j:integer;
   prodedure umkehr(zeichen:char);
      begin 
         i:=i+1;
         zeichen:=wort[i];
         if i<length(wort) then umkehr(wort[i]);
         stringgrid1.cells[j,0]:=zeichen;
         j=j+1;
      end;
   begin
      wort:=edit1.text;
      i:=0;
      j:=1;
      umkehr(wort[i]);
   end;

die wird nicht funktionieren :wink: in j=j+1 da wird der Vergleichsoperator bemängelt werden.

Der Code nutzt zur Rekursion eine nested-Prozedur(verschachtelt), hab die Prozedur mal etwas formatiert, damit es ersichtlich wird:

Delphi-Quellcode:

procedureTForm1.umkehren(Sender:TObject);
var i, j: integer;

  //**** nested **************
  {}prodedure umkehr(zeichen: char);
  {}begin 
  {}  i := i +1;
  {}  zeichen := wort[i];
  {}  if i < length(wort) then 
  {}    umkehr(wort[i]);//                <--- rekursiver Aufruf
  {}  stringgrid1.cells[j,0] := zeichen;
  {}  j := j +1;
  {}end;
  //**** ENDE nested **************

begin
  wort := edit1.text;
  i := 0;
  j := 1;
  umkehr(wort[i]);//                      <--- Rekursion starten
end;