Hallo,
um mal wieder ein bisschen in Delphi reinzukommen, dachte ich mir, dass ich mal ein kleines Programm schreibe, welches mir genau die "perfekten" Zahlen sucht, d.h. bei denen die Summe der Teiler die Zahl selbst ergeben.
Beispiel:

4 -> Teiler sind 1 und 2 : Ergebnis 3, also keine "perfekte" Zahl
6 -> Teiler sind 1, 2 und 3 : Ergebnis 6, also die "erste perfekte Zahl"
die nächste wäre 28 mit 1,2,4,7 und 14 und dann 496 und 8128 usw...

Das Programm zeigt mir die 6 an, jedoch scheint der Computer nicht weiterzurechnen, obwohl die Prozessorauslastung durch den Task 48-50% beträgt und ich kann es auch nicht mehr beenden.
Woran liegt das? Habe ich im u.g. Code einen Fehler oder ist dieser Algorithmus einfach zu aufwendig/anspruchsvoll für den Computer?

Folgenden Algorithmus habe ich geschrieben:

zusammenfalten · markieren

Delphi-Quellcode:

unit uModelView;

interface

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

type
  TForm1 = class(TForm)
    LbAusgabe: TListBox;
    BtnGo: TButton;
    procedure BtnGoClick(Sender: TObject);
    procedure Datenaktualisieren;
    procedure Maskeaktualisieren;
    procedure FormCreate(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;
  Divisor : TDivisor;
  zahl : Integer;

implementation

{$R *.dfm}
//------------------------------------------------------------
//------------------------------------------------------------
procedure TForm1.FormCreate(Sender: TObject);
begin
  Divisor := TDivisor.Create;
  zahl := 2;
end;
//------------------------------------------------------------
procedure TForm1.BtnGoClick(Sender: TObject);
begin
  Datenaktualisieren;
end;
//------------------------------------------------------------
procedure TForm1.Datenaktualisieren;
begin
  while zahl < 10 do
  begin
   inc (zahl);
   Divisor.setZahl(zahl);
   if Divisor.checkSum = true then
   begin
    Maskeaktualisieren
   end;
  end;
end;
//------------------------------------------------------------
procedure TForm1.Maskeaktualisieren;
begin
  LbAusgabe.Items.Add(IntToStr(Divisor.getNumber));
  Application.ProcessMessages;
  if zahl < 10 then
  begin
    Datenaktualisieren;
  end
  else exit;
end;
//------------------------------------------------------------
end.

zusammenfalten · markieren

Delphi-Quellcode:

unit uDivisor;

interface

uses
  Windows, SysUtils;

type
  TDivisor = class (TObject)
  private


  public
      procedure setZahl (a : Integer);
      function getDivisor : integer;
      function getTruth : boolean;
      function getSum : integer;
      function checkSum : boolean;
      function getNumber : integer;

  end;

var
  Zahl : Integer;
  divisor : Integer; //durchlaufende Zahl /Teiler
  checkvar : boolean; //Wenn Teiler, dann true
  temp : integer;
  getSumTemp : integer;

implementation
//------------------------------------------------------------
//------------------------------------------------------------
procedure TDivisor.setZahl(a: Integer);
begin
  temp := 0;
  Zahl := a;
  getDivisor;

end;
//------------------------------------------------------------
function TDivisor.getDivisor;
var
  ergebnis : real;
  str : string;
begin
  divisor := 1;
  checkvar := false;
  while divisor < zahl do
  begin
    repeat
      ergebnis := Zahl / divisor;
      str := FloatToStr(ergebnis);
      if length(str)=1 then
      begin
        checkvar := true;
        getSumTemp := getSum;
      end;
    until checkvar = true ;
    inc(divisor);
  end;
  checkSum;
  if length(str)=1 then
  begin
    Result := StrToInt(str);
  end
  else Result := 0;

end;
//------------------------------------------------------------
function TDivisor.getTruth;
begin
  if getsum = zahl then
    Result := true
end;
//------------------------------------------------------------
function TDivisor.getSum;
begin
  temp := temp + divisor;
  Result := temp;
end;
//------------------------------------------------------------
function TDivisor.checkSum;
begin
  if getSumTemp = Zahl then
  begin
    Result := true;
  end
    else Result := false;
end;
//------------------------------------------------------------
function TDivisor.getNumber;
begin
  Result := Zahl;
end;
//------------------------------------------------------------
end.

Vielen Dank!

Also Folgendes stört mich ungemein in deiner GetDivisor Methode:

markieren

Delphi-Quellcode:

    repeat
      ergebnis := Zahl / divisor;
      str := FloatToStr(ergebnis);
      if length(str)=1 then
      begin
        checkvar := true;
        getSumTemp := getSum;
      end;
    until checkvar = true ;

Was machst du da? Was bewirkt das length(str)=1 ?

Ein paar Anmerkungen zu deinem Code, dir sicherlich sinnvoll sind:

• Du solltest nicht innerhalb einer Klasse mit globalen Variablen arbeiten, denn damit machst du dir das ganze Klassenkonzept kaputt.
• Um den Restwert einer Division zu bestimmen solltest du MOD benutzen. Die Umrechnung in Floats durch eine Division kann zu Rundungsfehlern führen. Das würde mir z.B. erklären warum im obigen Code deine if-Bedingung nicht greift.

Hallo,

hier mal kurz, wie ich es machen würde:

zusammenfalten · markieren

Delphi-Quellcode:

Procedure TForm1.Button1Click(Sender: TObject);
Var
   i: Integer;
   iZahl: Integer;
   iSumme: Integer;

const
   iEnde = 10000;
Begin
   For iZahl := 1 To iEnde Do Begin

      i := 1;
      iSumme := 0;

      While i <= (iZahl Div 2) Do Begin
         If iZahl Mod i = 0 Then
            Inc(iSumme, i);

         Inc(i);
      End;

      If iSumme = iZahl Then
         Memo1.Lines.Add(IntToStr(iZahl));

   End;
End;

Sicherlich optimierungsbedürftig, aber funktioniert - auf den ersten Blick *g*

Edit: habe hier kein Augenmerk auf schönen Stil gelegt - sollte nur schnell zum Ergebnis kommen.

Vielen Dank für die Antworten

Habe den Algorithmus von s-off getestet und er funktioniert...sofort

Schon ein bisschen deprimierend, wenn ich sehe wie einfach das geht und wieviel Arbeit ich mir gemacht habe