ggT und KgV von 2 Zahlen berechnen - absolut keine Ahnung

[mkinzler]

Delphi-Quellcode:

If trunc(b) <> 0 then

[Bummi]

@Wolfgang Mix

ich kann Deiner Aussage nicht folgen, wenn es etwas anderes als 0 eingibt ist die Rechenoperation gültig, ansonsten landet er im Else-Zweig.
Die nicht Initialisiere Variable c auszugeben ist in jedem Fall Blödsinn

[Connor Temple]

Es funktioniert ja jetzt.
Mit Else hab ichs versucht, da werde ich aber nochmal dran arbeiten müssen, da das auch nicht hingehauen hat.

[rollstuhlfahrer]

Punkt 1 - Die Fließkommazahlen: Lehrer behelfen sich da ganz einfach mit Real. Das liegt wohl daran, weil "Delphi for Kids" das eben auch macht. Nur leider ist Real sehr unbestimmt, in Bezug auf die Genauigkeit. Selbst bei D7 kommt die Hilfe bei Real nicht auf den Punkt, auf wie viele Stellen man sich verlassen kann. Außerdem gibt es neben Real noch den Real48. Um hier aufzuräumen würde ich auch Single, Double und Extended verwenden.

Punkt 2 - Der ELSE-Zweig: Ja bitte, welcher Fehler kommt denn diesmal? - Man wird dir leiden nicht helfen können, wenn man dein Problem nicht kennt. Das ist so ähnlich, wie wenn du zum Arzt gehst und sagst, du hättest Schmerzen. Daran kann auch der allerbeste Arzt leider nicht feststellen, wo deine Schmerzen sind und was du haben könntest. :glaskugel: Das kann von Kopfschmerzen bis Herzinfarkt gehen. Übertragen auf deinen Code heißt das: Du hast entweder einen Syntax-Fehler oder du hast in Delphi einen Bug entdeckt. Wobei ich mir letzteres nicht vorstellen kann.

Zitat:

Zitat von Connor Temple (Beitrag 1062914)

Es funktioniert ja jetzt.

Optimal?
Zu der Frage mit Fließkommazahlen und der Null: Die Null ist ein exakt definierter Wert. Leider ist dieser Wert so exakt definiert, dass man ihn normalerweise nicht genau erreichen kann. Selbst wenn du sagst

Delphi-Quellcode:

Variable := 0.0;

, dann ist diese Variable noch lange noch nicht 0. Sie ist nur auf 22 Nachkommastellen genau 0. Danach ist sie ungleich 0. Deshalb sollte man für Vergleiche auf 0 die Funktion IsZero() verwenden.

Zitat:

Zitat von mkinzler (Beitrag 1062905)

Delphi-Quellcode:

If trunc(b) <> 0 then

Nein, das ist leider nicht richtig. Was ist, wenn du durch 0,5 teilen willst? Trunc(0,5) ist 0 und somit meinst du, du teilst durch 0, was absolut nicht richtig ist.

Bernhard

[Medium]

Real ist, zumindest bei meinem D7, als Double definiert, und somit sehr gut dokumentiert ;). Real48 ist der alte Real aus TP Zeiten, den es rein dafür gibt, damit man Portierungen von altem TP Code der sich auf die 48 Bit verlässt nicht zu arg umschreiben muss, wenn man es nicht will. (Und die meisten Lehrer nehmen denke ich bevorzugt Real, weil sie diesen noch aus TP kennen.)
Man kann per Optionen umschalten als was Real definiert sein soll, Standard ist eben Double. Damit ist es nichts weiter als ein Alias.

[Bummi]

Hat der Thread überhaupt noch was mit dem Titel zu tun??

[Connor Temple]

Ich hab Delphi 3.
Sobald ich es mit Else versucht habe ist es mit ner Fehlermeldung, sobald ich durch null teilen wollte in den Quellcode zurückgegangen, beim nächsten Programmstart stand der auszugebende Text bei einer Division durch null trotzdem im Ergebnisfeld.
Jetzt läuft es optimal.

Jetzt aber, wie mehrfach erwähnt Back to Topic.^^

Da ist halt das Problem, dass ich nicht weiß, wie genau ich anfangen soll, die Textfelder benennen, okay, aber danach?

[Sir Rufo]

Versuche es doch mal mit der umgekehrten Methode aus #31

Schreibe mit einfachen Worten auf, was du machen würdest, wenn du das von Hand löst.
Ausgangspunkt sind die Informationen aus der Form (speziell die Eingabefelder).

Hier mal ein Beispiel für einen Wecker, wo die Weckzeit in einem Edit-Feld

Delphi-Quellcode:

WeckZeit

steht.

Code:

Umwandeln der Eingabe in WeckZeit in eine Uhrzeit, das merke ich mir in TempZeit
Ist TempZeit = AktuelleZeit dann 
  Schreie ich den User an

In Delphi sieht das so aus

Delphi-Quellcode:

TempZeit := StrToTime( WeckZeit.Text );
if TempZeit = Trunc( now ) then
  ShowMessage( 'WECKEN!' );

Wenn man erst mit dieser Pseudo-Programmierung in Textform anfängt, dann kann man sehr schön den Ablauf definieren ohne einen Delphi-Befehl zu kennen.
Bei der Umsetzung brauche ich dann nur zu recherchieren, wie man z.B. die aktuelle Zeit bekommt.

Delphi-Quellcode:

now

liefert mir den aktullen Zeitpunkt mit Datum und Zeit

Wir brauchen aber nur die aktuelle Zeit, das Datum würde uns hier stören.
Wenn man jetzt weitersucht, dann bekommt man den Hinweis, dass ein Datum in Delphi aus einem Gleitkommawert besteht. Die Zahl vor dem Komma Zeit den Tag an, die Zahl hinter dem Komma die Uhrzeit.

Ah, sehr schön, wir benötigen also nur den Nachkommaanteil von

Delphi-Quellcode:

now

und den bekommt man mit

Delphi-Quellcode:

Trunc( X : Real )

Beide Informationen zusammengeführt ergeben

Delphi-Quellcode:

Trunc( now )

liefert mir die aktuelle Uhrzeit

Genauso geht man bei der Programmierung vor.
Nur dann ist man in der Lage eine konkrete Frage zu stellen.

[Klaus01]

Zitat:

Beim euklidischen Algorithmus wird in aufeinanderfolgenden Schritten jeweils eine Division mit Rest durchgeführt, wobei der Rest im nächsten Schritt zum neuen Divisor wird. Der Divisor, bei dem sich Rest 0 ergibt, ist der größte gemeinsame Teiler der Ausgangszahlen. Beispiel:
1071 : 1029 = 1 Rest 42
1029 : 42 = 24 Rest 21
24 : 21 = 2 Rest 0
Somit ist 21 der größte gemeinsame Teiler von 1071 und 1029.

Aus der Erklärung: "in aufeinanderfolgenden Schritten"
Hört sich nach Schleife an.
Wir wissen aber nicht wie viele Schleifendurchgänge notwendig sind.
Daher kommt die

Delphi-Quellcode:

For to

Schleife nicht in Betracht.

Bleiben die

Delphi-Quellcode:

repeat until

und die

Delphi-Quellcode:

while do

Schleifen zu Auswahl.

Da wir mindestens einmal etwas berechnen müssen bietet sich die

Delphi-Quellcode:

 repeat until

Schleife an.
Die Abbruchbedingung wird hier erst nach einem Schleifendurchlauf ermittelt.

Abbruchbedingung, aus der Erklärung "bei dem sich Rest 0 ergibt".

Delphi-Quellcode:

repeat

until rest = 0;

Was soll gemacht werden: "eine Division mit Rest durchgeführt"
Die Funktion die das in Delphi macht nennt sich mod.

Delphi-Quellcode:

rest := zahl1 mod zahl 2;

Die Berechnung bauen wir dann in die Schleife ein;

Delphi-Quellcode:

repeat
  rest := zahl1 mod zahl2;
until rest = 0;

Im nächsten Schritt soll dann zahl2 durch den rest geteilt werden.

Delphi-Quellcode:

repeat
  rest := zahl1 mod zahl2;
  zahl1 := zahl2;
  zahl2 := rest;
until rest = 0;

Bauen wir das Ganze nun in eine Funktion ein:

Delphi-Quellcode:

function ggt(zahl1,zahl2: Integer):Integer;
var
  rest : Integer;
begin
  repeat
    rest := zahl1 mod zahl2;
    zahl1 := zahl2;
    zahl2 := rest;
  until rest = 0;  
end;

Nun benötigt die Funktion noch eine Ausgabe/Rückgabewert.

Wir benötigen den Divisior wenn die Division (zahl1 mod zahl2) den Rest 0 ergibt.
Wir merken uns immer den Divisior (zahl2), wenn der rest = 0 ist
wird result nicht mehr überschrieben.

Delphi-Quellcode:

function ggt(zahl1,zahl2: Integer):Integer;
var
  rest : Integer;
begin
  repeat
    result := zahl2;
    rest := zahl1 mod zahl2;
    zahl1 := zahl2;
    zahl2 := rest;
  until rest = 0;  
end;

Da eine Division durch Null nicht zulässig ist,
muss zahl2 auf 0 geprüft werden.

Delphi-Quellcode:

function ggt(zahl1,zahl2: Integer):Integer;
var
  rest : Integer;
begin
  if zahl2 > 0 then
    repeat
      result := zahl2;
      rest := zahl1 mod zahl2;
      zahl1 := zahl2;
      zahl2 := rest;
    until rest = 0
  else
    result := 0;
end;

Ich hoffe der Lösungsweg ist einigermaßen verständlich.

Grüße
Klaus

[wolfgang_SV]

Du haßt hier was vergessen, was sehr wichtig ist !

Man muß sicherstellen,dass der Divisor die kleinere Zahl ist.
Auf Null überprüfen reicht nicht.

PS. braucht man doch nicht .. mod ist in dem Sinne keine echte Division...
Sie liefert ja lediglich die Restklasse ....

[gammatester]

Zitat:

Zitat von Klaus01 (Beitrag 1063067)

Ich hoffe der Lösungsweg ist einigermaßen verständlich.

Mag ja sein, aber leider ist er ziemlich falsch. Deine Funktion bietet noch nicht einmal die Symmetrie ggt(a,b)=ggt(b,a), wie man leicht an ggt(2,-2) = 0 und ggt(-2,2) = 2 sieht. Außerdem werden leider wieder einmal völlig falsche Werte für negative Zahlen geliefert, einerseits mit voller Absicht: ggt(a,b) = 0 für b <= 0! (Warum das ganze?). Andererseits (wohl) aus Unkenntnis der mod-Funktion: ggt(-5,2) = -1. Eine verbesserte Version könne so aussehen:

Delphi-Quellcode:

 function ggt(zahl1,zahl2: integer): integer;
var
  rest: integer;
begin
  zahl1 := abs(zahl1);
  zahl2 := abs(zahl2);
  while zahl2>0 do begin
    rest := zahl1 mod zahl2;
    zahl1 := zahl2;
    zahl2 := rest;
  end;
  ggt := zahl1;
end;

[wolfgang_SV]

@gammatester

das was du nun erzählst ist völlig daneben..

nimm die funktion aus meinem ersten Programmbeispiel ..#5

ggt(a,b) liefert dasgleiche wie ggt(b,a)

sollten a oder b negativ sein , was von der mathematischen definition
bez. modulo gar nicht vorgesehen ist ( hier unterscheidet sich mal wieder Mathematik von programmier-sprachen)

dann sollte man so vorgehen :
c:=abs(ggt(a,b));

[wolfgang_SV]

Delphi-Quellcode:

unit Unit1;

interface

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

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

var
  Form1: TForm1;

implementation

{$R *.DFM}

function ggt(a,b : integer) : integer;
  var r : integer;
  begin
 
  repeat
  r:= a mod b;
  a:=b;
  b:=r;
  until r=0;

  result:=a;
  end;

procedure TForm1.Button1Click(Sender: TObject);
  var a,b,c : integer;
  begin
  a:=strtoint(edit1.text);
  b:=strtoint(edit2.text);

  c:=abs(ggt(a,b));

  label1.caption:=inttostr(c);
  end;

end.

mehr sag ich jetzt nicht...
weil so geht es...
und wenn man jetzt für a oder b den wert 0 eingibt...
ok.. dann kann man das ja abfangen...

[gammatester]

Zitat:

Zitat von wolfgang_SV (Beitrag 1063124)

@gammatester

das was du nun erzählst ist völlig daneben..

Was ist völlig daneben? Ein fehlerhaftes Ergebnis meiner Funktion würde mir reichen.

Zitat:

Zitat von wolfgang_SV (Beitrag 1063124)

nimm die funktion aus meinem ersten Programmbeispiel ..#5

ggt(a,b) liefert dasgleiche wie ggt(b,a)

Wie man leicht sieht, beziehe ich mich auf Klaus (wer lesen kann, ist klar im Vorteil).

Zitat:

Zitat von wolfgang_SV (Beitrag 1063124)

sollten a oder b negativ sein , was von der mathematischen definition
bez. modulo gar nicht vorgesehen ist ( hier unterscheidet sich mal wieder Mathematik von programmier-sprachen)

dann sollte man so vorgehen :
c:=abs(ggt(a,b));

Ich 'erzähle' nichts, sondern zeige nur die Ergebnis von Klaus's letzter Funktion. Wenn Du meinst, daß ist 'daneben". dann stimmen wird ja überein. Wir stimmen allerdings nicht überein in folgenden Punkten:

- der ggt von negativen Zahlen und mod von negativen Zahlen ist selbstverständlich mathematisch vorgesehen

- Programmiersprachen unterscheiden sich darin nicht: mod ist zumindest in Pascal für negative Zahlen definiert. ggt nicht, muß also selbstgeschrieben werden. Aber möglichst richtig. Pascal mod und mathematisches mod unterscheiden sich leider. Pascal: -5 mod 3 = -2, mathematisch ist -5 mod 3 = 1. Der mathematische Rest a mod b für b > 0 ist nämlich: 0 <= a mod b < b. Was bei Pascal nun mal leider nicht der Fall. Wenn man einen mathematisch korrekten ggt via Euklidischem Algorithmus berechnen will muß man das berücksichtigen.

- c:=abs(ggt(a,b)) ist zwar richtig, aber nur wenn ggt schon halbwegs richtig ist, Klaus ' Funktion liefert ggt(-2,-2)=0.

[Sir Rufo]

Zitat:

Zitat von wolfgang_SV (Beitrag 1063124)

c:=abs(ggt(a,b));

Wieso von einer positiven Zahl noch den Absolutwert ermitteln?
Per Definition liefert ggT ein Ergebnis aus der Menge der natürlichen Zahlen und damit.

Weiterhin gilt:

Code:

ggT( -a, b ) = ggT( a, b )

Somit ist es absolut richtig von beiden Eingangsparametern die Absolutwerte zu nehmen.

Weiterhin gilt auch, dass keiner der Eingangswerte 0 sein darf, denn dann ist ggT nicht definiert.
In dem Falle müsste also korrekterweise eine Exception ausgelöst werden.

[wolfgang_SV]

falsch Sir Rufo..

gib doch einfach mal eine negative Zahl für a oder b ein..

und schau was a mod b dir zurückliefert...

[wolfgang_SV]

@gammatester

ok.. entschuldigung
habe die procedure von klaus01 soweit nicht getestet.
wenn seine funktion für ggt(a,b) einen anderen wert als ggt(b,a) liefert , abgesehen vom vorzeichen , ist sie natürlich schrott!!!

PS. obwohl auch das Vorzeichen müßte gleich sein

[Klaus01]

.. gut, dass ich mal wieder ein schlechtes Beispiel sein durfte..
Klaus

[wolfgang_SV]

@gammatester

bez. Mathematik und natürliche Zahlen

Die Division mit Rest oder der Divisionsalgorithmus ist ein mathematischer Satz aus der Algebra und der Zahlentheorie. Er besagt, dass es zu zwei Zahlen n und m <>0 aus N ( natürliche Zahlen ) eindeutig bestimmte Zahlen a und b gibt für die gilt :

n=a*m +b ; 0<=b<m

[gammatester]

Zitat:

Zitat von wolfgang_SV (Beitrag 1063147)

@gammatester

bez. Mathematik und natürliche Zahlen

Die Division mit Rest oder der Divisionsalgorithmus ist ein mathematischer Satz aus der Algebra und der Zahlentheorie. Er besagt, dass es zu zwei Zahlen n und m <>0 aus N ( natürliche Zahlen ) eindeutig bestimmte Zahlen a und b gibt für die gilt :

n=a*m +b ; 0<=b<m

Wenn Du schon Wiki wörtlich zitierst, dann bitte richtig (Quellenangabe könnte nicht schaden) und ohne verfälschende Zusätze. Da steht eben nicht "(natürliche Zahlen)". Mit diesem von Dir frei erfundenen Zusatz ist der Satz nämlich falsch, wie man leicht an der eindeutigen Darstellung der Division 3 durch 5 sieht: 3 = 0*5 + 3. Aber als nächstes willst Du wahrscheinlich noch sagen, daß 0 natürlich eine natürliche Zahl ist.

[wolfgang_SV]

ok.. da hab ich ein wenig voreilig was zusammengehauen
hier gibt es die mathematischen Definitionen..


http://www.iti.fh-flensburg.de/lang/...n/zahlenth.htm

aber hier wird klar, dass a mod b (für a aus Z (ganze Zahlen ) und b aus N ( natürliche Zahlen )) kein negatives Ergebnis liefert
auch wenn a negativ sein sollte.

genauso ist ggt(a,b) per Definition immer positiv..

Ja und die 0 ist natürlich keine natürliche Zahl !!!!

[Amateurprofi]

Zitat:

Zitat von gammatester (Beitrag 1063204)

Zitat:

Zitat von wolfgang_SV (Beitrag 1063147)

@gammatester

bez. Mathematik und natürliche Zahlen

Die Division mit Rest oder der Divisionsalgorithmus ist ein mathematischer Satz aus der Algebra und der Zahlentheorie. Er besagt, dass es zu zwei Zahlen n und m <>0 aus N ( natürliche Zahlen ) eindeutig bestimmte Zahlen a und b gibt für die gilt :

n=a*m +b ; 0<=b<m

Wenn Du schon Wiki wörtlich zitierst, dann bitte richtig (Quellenangabe könnte nicht schaden) und ohne verfälschende Zusätze. Da steht eben nicht "(natürliche Zahlen)". Mit diesem von Dir frei erfundenen Zusatz ist der Satz nämlich falsch, wie man leicht an der eindeutigen Darstellung der Division 3 durch 5 sieht: 3 = 0*5 + 3. Aber als nächstes willst Du wahrscheinlich noch sagen, daß 0 natürlich eine natürliche Zahl ist.

@gammatester:
Kann es sein, daß du dich hier etwas zu weit aus dem Fenster lehnst?
Bei der obigen Definition steht der Zusatz "(natürliche Zahlen)" so zwar nicht in Wiki, trotzdem ist er korrekt. Der Zusatz, so wie er im Text steht, bezieht sich auf die Zahlen n und m (in deinem Beispiel 3 und 5) und nicht auf die Zahlen a und b (in deinem Beispiel 0 und 3).

[Sir Rufo]

Zitat:

Zitat von Sir Rufo (Beitrag 1063132)

Zitat:

Zitat von wolfgang_SV (Beitrag 1063124)

c:=abs(ggt(a,b));

Wieso von einer positiven Zahl noch den Absolutwert ermitteln?
Per Definition liefert ggT ein Ergebnis aus der Menge der natürlichen Zahlen und damit.

Weiterhin gilt:

Code:

ggT( -a, b ) = ggT( a, b )

Somit ist es absolut richtig von beiden Eingangsparametern die Absolutwerte zu nehmen.

Weiterhin gilt auch, dass keiner der Eingangswerte 0 sein darf, denn dann ist ggT nicht definiert.
In dem Falle müsste also korrekterweise eine Exception ausgelöst werden.

Zitat:

Zitat von wolfgang_SV (Beitrag 1063135)

falsch Sir Rufo..

gib doch einfach mal eine negative Zahl für a oder b ein..

und schau was a mod b dir zurückliefert...

Mir ist es doch völlig wurscht, was a mod b zurückliefert, weil es geht hier um die Definition von ggT und da ist die Definition nun mal so.

Ansonsten musst du dir deine eigene Definition von ggT machen (ggT_SV). Da kann dann meinetwegen alles sein, wie du möchtest.
Auch das wäre mir wurscht :mrgreen:

Somit würde die korrekte Version von ggT (nach der gültigen mathematische Definition) wie folgt sein:

Delphi-Quellcode:

function ggT( a, b : integer) : integer;
  var
    aa, ab : integer; 
    r : integer;
  begin

    // ggT( 0, 0 ) ist nicht definiert und somit nicht zulässig

    if ( a = 0 ) and ( b = 0 ) then
      raise Exception.Create( 'Kein Wert darf 0 sein!' );

    // das dürfen wir denn ggT( -a, b ) = ggT( a, b )

    aa := abs( a );

    // auch das dürfen wir, denn es gilt ggT( a, b ) = ggT( b, a )
    // und ggT( -a, b ) = ggT( a, b )
    // daraus folgt ggT( a, -b ) = ggT( a, b )
    // und daraus folgt auch ggT( -a, -b ) = ggT( a, b )

    ab := abs( b );

    if ( aa = 0 ) or ( ab = 0 ) then
      begin
        if ( aa = 0 ) then
          Result := ab
        else
          Result := aa;
      end
    else
      begin
        repeat
          r := aa mod ab;
          aa := ab;
          ab := r;
        until r = 0;

        result := aa;
      end;
  end;

[wolfgang_SV]

Du hast ja vollkommen recht..

das was ich nur zum Ausdruck bringen wollte ist, dass der pascal-befehl
mod negative Ergebnisse liefert, was mathematisch nicht definiert ist.

Deshalb muß der Programm-Code also erweitert werden, damit ein positives Ergebnis herauskommt.

Ob man nun die Eingangsparameter , so wie du es machst, in positive Zahlen umwandelt oder die Ausgabe in eine positive Zahl umwandelt ist eigentlich egal...

Obwohl ich meine Version favorisiere, denn ein Befehl ist weniger als zwei, denn wir wollen doch möglichst ökonomisch programmieren.

[gammatester]

Zitat:

Zitat von Amateurprofi (Beitrag 1063243)

Zitat:

Zitat von gammatester (Beitrag 1063204)

@gammatester:
Kann es sein, daß du dich hier etwas zu weit aus dem Fenster lehnst?
Bei der obigen Definition steht der Zusatz "(natürliche Zahlen)" so zwar nicht in Wiki, trotzdem ist er korrekt. Der Zusatz, so wie er im Text steht, bezieht sich auf die Zahlen n und m (in deinem Beispiel 3 und 5) und nicht auf die Zahlen a und b (in deinem Beispiel 0 und 3).

Ich lehne mich nicht aus dem Fenster, schon gar nicht zu weit. Wiki sprich nur von Zahlen, und wenn nichts weiter gesagt wird, nimmt man doch an, daß alle aus der gleichen Menge sind. Der Zusatz kann sich übrigens nicht sinnvoll auf m beziehen, denn warum solche man extra fordern, daß eine natürliche Zahl ungleich 0 ist.

Aber inzwischen scheint ja Einigkeit zu bestehen, auch der genannte Link ist nach erstem Überfliegen brauchbar und er listet sogar ggt(0,a) = abs(a) und ggt(0,0)=0. Dies sind völlig legale Werte und sollten nicht ad hoc ausgeschlossen werden (wie soeben wieder in einem Parallelbeitrag). Das alles wird in meiner Funktion schon gerücksichtigt. (Sie ist leider trotzdem noch nicht perfekt, da der Wert -Maxint-1 nicht richtig behandelt wird).

[Connor Temple]

Delphi-Quellcode:

unit Unit1;

interface

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

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

var
  Form1: TForm1;

implementation

{$R *.DFM}

procedure TForm1.Button1Click(Sender: TObject);
var Teiler, z1, z2, ggT, kz, gz :Integer;
begin
z1 := StrToInt (Eingabe1.Text);
z2 := StrToInt (Eingabe2.Text);

if z1 < z2
  then
     begin
      kz := z1;          // kleinste und größte Zahl bestimmen
      gz := z2;
     end
  else
    begin
      kz := z2;
      gz := z1;
    end;
  Teiler := kz + 1;      // Teiler Steuervariable

  ggt := 0;
  For Teiler := 1 to kz do
      if (((kz mod Teiler) = 0) and ((gz mod Teiler) = 0))
         then ggT := Teiler;
  Ergebnis.Caption := IntToStr(ggT);

end;

end.

Ist der Code aus der Schule, für den ggT, aber für den KgV, wie müsste ich den da verändern?

[Klaus01]

Delphi-Quellcode:

kgv:= abs(z1*z2) div ggt(z1,z2)

Quelle: http://de.wikipedia.org/wiki/Kleinst...mes_Vielfaches

Aus diesem Grund wäre es auch von Vorteil wenn ggt ein Funktion wäre
und nicht wie in Deinem Code vollständig in der ButtonClick Methode deklariert wird.

Grüße
Klaus

[wolfgang_SV]

@Connor

na das ist ja umständlich...

und auch noch fehlerhaft..

gib mal eine negative Zahl ein....

PS Gruß an deinen Mathelehrer !?

[Sir Rufo]

Zitat:

Zitat von wolfgang_SV (Beitrag 1063307)

@Connor

na das ist ja umständlich...

und auch noch fehlerhaft..

gib mal eine negative Zahl ein....

PS Gruß an deinen Mathelehrer !?

Das wird hier wohl der Info-Lehrer verbrochen haben, was die Sache an sich aber auch nicht besser macht :mrgreen:

[wolfgang_SV]

@Connor

sagen wir mal so :
wenn man den euklidischen Algorithmus nicht kennt, dann ist der Ansatz gar nicht mal so verkehrt, wenn man von der rudimentären Vorstellung des ggT ausgeht. Nämlich : Suche die größtmögliche Zahl, die a und b ohne Rest teilt...
Wenn man dann davon ausgeht, dass a und b positive Zahlen sind, ist euer Programm schon in Ordnung..

Nur mit den negativen Zahlen.. Warum habt ihr nicht den Tip von unserem Sir Rufo übernommen ( abs(a) und abs(b) ) ; dann klappt's auch mit negativen Zahlen ..


nach dem Motto :
kaum macht man's falsch, meldet sich Sir Rufu

[Klaus01]

Zitat:

Zitat von gammatester (Beitrag 1063260)

Aber inzwischen scheint ja Einigkeit zu bestehen, auch der genannte Link ist nach erstem Überfliegen brauchbar und er listet sogar ggt(0,a) = abs(a) und ggt(0,0)=0. Dies sind völlig legale Werte und sollten nicht ad hoc ausgeschlossen werden (wie soeben wieder in einem Parallelbeitrag). Das alles wird in meiner Funktion schon gerücksichtigt. ..

Auch wenn ich mich wieder in die Nesseln setze, seis drum.

Laut ggT wiki ist ggt(a,b) = ggt(b,a) somit sollte auch ggt(a,0) = ggt(0,a) = |a| mit (a <> 0) sein.

ggt(0,0) ist nicht definiert.

Grüße
Klaus

[Delphi-Laie]

Zitat:

Zitat von gammatester (Beitrag 1063204)

Aber als nächstes willst Du wahrscheinlich noch sagen, daß 0 natürlich eine natürliche Zahl ist.

Ich wurde zwar nicht angesprochen, doch hier muß ich mich einmischen: Natürlich ist die Null eine natürlich Zahl; natürliche Zahlen sind nämlich die Abstraktion der Anzahl(en) konkreter Objekte, und kein Objekt von irgendetwas (in irgendeinem bestimmten betrachteten Bereich) gibt es natürlich so manches Mal auch in der Natur. Nur weniger als nichts gibt es nicht(s) in der Natur, und dennoch gelten viele Gesetze der Arithmetik auch für ganze (also inkl. der negativen Pendants der natürlichen Zahlen) Zahlen.

Ergänzung: Das, wohin sich diese Diskussion entwickelte, könnte Loriot in Teilen kaum besser sich ausdenken... Auch wenn ich die Bemühungen der Teilnehmer selbstverständlich (um nicht schon wieder "natürlich" zu benutzen) (an)erkenne.

[Bummi]

@Delphi-Laie
#71(Ergänzung):kiss:

[gammatester]

Zitat:

Zitat von Klaus01 (Beitrag 1063389)

Auch wenn ich mich wieder in die Nesseln setze, seis drum.

Laut ggT wiki ist ggt(a,b) = ggt(b,a) somit sollte auch ggt(a,0) = ggt(0,a) = |a| mit (a <> 0) sein.

MM sogar auch für a=0. Aber leider schreibt das deutsche Wiki mal wieder Unsinn: Angeblich soll zB ggt(a,0)=a für ganze Zahlen a sein, natürlich :wink: muß es ggt(a,0)=|a| heißen.

Zitat:

Zitat von Klaus01 (Beitrag 1063389)

ggt(0,0) ist nicht definiert.

Dann sei doch wenigstens konsequent: gcd(0,0)=|0|=0 nach eben Deinem Hinweis. (Und genauso machen's u.a. Knuth, Maple, Pari, Mathematica, engl. Wiki; aber wenn Klaus01 und dt. Wiki anderes sagen, stimmt',s natürlich :wink:).

Zitat:

Zitat von Delphi-Laie (Beitrag 1063395)

Ich wurde zwar nicht angesprochen, doch hier muß ich mich einmischen: Natürlich ist die Null eine natürlich Zahl; natürliche Zahlen sind nämlich die Abstraktion der Anzahl(en) konkreter Objekte, und kein Objekt von irgendetwas (in irgendeinem bestimmten betrachteten Bereich) gibt es natürlich so manches Mal auch in der Natur. Nur weniger als nichts gibt es nicht(s) in der Natur, und dennoch gelten viele Gesetze der Arithmetik auch für ganze (also inkl. der negativen Pendants der natürlichen Zahlen) Zahlen.

Es ist Euch natürlich :wink: unbenommen, über Eure eigene Alternativ-Mathematik zu meditieren, aber erwartet nicht, daß man darauf ernsthaft antwortet.

[wolfgang_SV]

http://www.mathe-online.at/mathint/lexikon/n.html

Hier mal bitte nachlesen zum Thema natürliche Zahlen...

Wie man sieht ist hier der Begriff der natürlichen Zahlen nicht eineindeutig definiert.

Wenn man aber von dem ursprünglichen Begriff der natürlichen Zahlen ausgeht,
der von den Axiomen Peanos stammt dann...
http://www.mathematik.ch/mathematiker/peano.php
bitte hier mal nachschauen..

Daraus folgt :
Laut mathematischer Definition ist Null keine natürliche Zahl...
lieber Delphi-Laie

deine Definition von natürlichen Zahlen entspringt den Anschauungen von
Mathematik-Laien.

[JasonDX]

Zitat:

Zitat von wolfgang_SV (Beitrag 1063433)

Wenn man aber von dem ursprünglichen Begriff der natürlichen Zahlen ausgeht,
der von den Axiomen Peanos stammt dann...
http://www.mathematik.ch/mathematiker/peano.php
bitte hier mal nachschauen..

Daraus folgt :
Laut mathematischer Definition ist Null keine natürliche Zahl...

Wenn wir schon genau sein wollen, dann ist 2 aber auch keine natürliche Zahl. Lediglich 1 ist eine natürliche Zahl, und s(x) ist eine gdw. x eine ist. Nichts anderes ist in den Axiomen definiert.
Die 1 ist hier aber nicht als "Zahl", sondern als beliebiges Symbol zu sehen. Sie hat nichts mit unserer Interpretation der 1 zu tun, wie bspw. "1 Nase" oder eben "2 Ohren".

greetz
Mike

[Delphi-Laie]

wolfgang_SV und gammatester, mit Definitionen kommt man nicht weiter, weil diese willkürlich und reines Menschenwerk sind - wir könn(t)en mithin stundenlang im Internet oder sonstwo stöbern und uns einanderr widersprechende Definitionen an die Köpfe werfen. So kann man z.B. die natürliche Zahl auch erst ab 2 definieren. Tatsächlich wurden in früheren Jahrhunderten "Zahl" und "Menge" (umgangssprachlich) synonym verwandt, sodaß sogar die 1 aus der Prestigezone fiel. So ist das Einschließen der 1, jedoch das Ausschließen der 0 in den Bereich der natürlichen Zahlen m.E. nur eine halbe Sache bzw. ein Stehenbleiben auf halbem Wege - m.a.W.: Die Mathematik ist inzwischen weiterentwickelt.

Ein von keinem von Euch angegriffenes oder gar widerlegtes Argument brachte ich hervor: Die natürliche Zahl ist eine Abstraktion einer Anzahl (konkreter, also realer Objekte) - und die Anzahl null (konkreter, aber auch sogar nichtexistenter Objekte) gibt es in bestimmten Betrachtungsbereichen oder kann es wenigstens geben (wengistens dahingehend werdet Ihr mir hoffentlich noch zustimmen).

[wolfgang_SV]

lieber Delphi-Laie

du bist ja nicht nur Mathematik-Laie , sondern weißt wahrscheinlich gar nicht, was Mathematik ist.
Die Mathematik basiert auf der exakten Definition von Begriffen.
Mit Hilfe dieser Begriffe werden Strukturen entwickelt, in denen dann Aussagen (Sätze) formuliert werden, die Zusammenhänge zwischen den Begriffen aufzeigen.

Ohne eine exakte Definition von Begriffen gäbe es keine Mathematik.

Deine Ausführungen zu den natürlichen Zahlen mögen ja sehr schön sein, sind aber eher philosophischer Natur und haben mit Mathematik nichts zu tun.

[Bummi]

Zitat:

Deine Ausführungen zu den natürlichen Zahlen mögen ja sehr schön sein, sind aber eher philosophischer Natur und haben mit Mathematik nichts zu tun.

Der ganze Thread macht einen sehr philosophischen Eindruck.:stupid:

[Daniel]

A propos "damit nichts zu tun zu haben" ... könnten wir (a) wieder zu einer sachlichen Diskussion zurückfinden und (b) scheint mir die Ausgangsfrage hinreichend erörtert. Fragen die Philosophie oder die grundsätzliche Natur der Mathematik ließen sich auf Wunsch auch per Email fortführen.