Zahlenreihenfolge mit 4 Zahlen ordnen und anzeigen lassen?

[Mexbuild]

Auf anweisung eines Moderators mache ich jetzt einen Thread für eine andere Frage auf, als in dem Thread mit Namen: Einige Anfängerfragen

Also Problem ist folgendes:
Wir sollen ein Programm erstellen, wo man drei Eingabefenster hat (+anderes) in die man drei beliebige Zahlen eingibt. Wenn man der Bitbtn betätigt wird soll das Programm die 3 Zahlen der Reihe nach ordnen, und dann in einem Label so anzeigen:

Die Reihenfolge lautet: 5, 432, 43242 (Oder was auch immer)

Dazu kommt noch ein Button der das Programm zurücksetzt. (Das kann ich aber schon :wink: )Das Programm funktioniert auch, aber wir sollen jetzt ein schritt weiter gehen.
Das gleiche mit 4 Zahlen. Also vier Eingabefelder und 2 Variablen mehr. (zahl4 und mittelgroesste) Näheres könnt ihr dem Programmtext entnehmen! Wichtig ist, dass ich das o.g mit 4 Zahlen machen kann, möglichst ohne komplizierte und Profisachen anwenden zu müssen.

Delphi-Quellcode:

unit reihe;

interface

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

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

var
  Form1: TForm1; zahl1, zahl2, zahl3, gross, mittel, klein: integer; /// Hier müssten meines Wissens noch "zahl4" und "mittelgroesste" eingetragen werden

implementation

{$R *.dfm}

procedure TForm1.BitBtn1Click(Sender: TObject);
begin
zahl1:=strtoint(edit1.Text);
zahl2:=strtoint(edit2.Text);
zahl3:=strtoint(edit3.Text);
if
zahl1>zahl2
then begin
gross:=zahl1
end
else begin
gross:=zahl2
end;
if
zahl3>gross
then begin
gross:=zahl3
end;
if
zahl1<zahl2
then begin
klein:=zahl1
end
else begin
klein:=zahl2
end;
if
zahl3<klein
then begin
klein:=zahl3
end;
if (zahl1 > klein) and (zahl1<gross) then begin mittel:=zahl1
end;
if (zahl2 > klein) and (zahl2<gross) then begin mittel:=zahl2
end;
if (zahl3 > klein) and (zahl3<gross) then begin mittel:=zahl3
end;
label1.caption:='Die Reihenfolge lautet:'+inttostr(klein)+', '+inttostr(mittel)+', '+inttostr(gross) /// Hier müsste noch "mittelgroesste" nachgetragen werden!
end;

end.

[Klaus01]

Schau Dir einmal diesen Beitrag #5 an.

Du müßtest Deine Zahlen nur noch in ein Array packen.

Grüße
Klaus

[Corpsman]

Also einen So Komplizierten SortierAllgo hab ich noch nie Gesehn.

Ich Empfehle dir Ein Sortieren Sample.

und das Speichern der Zahlen in Arrays

[Mexbuild]

@Klaus01
Habe ich schon bevor ich den Betrag geschreiben habe. Aber es sollte ungefähr so sein, wie mein Text, nur halt erweitert. Ich kenne nur vielleicht 2-4% von Delphibefehlen. Gibt es villeicht noch ne andere möglichkeit. Weil als ich letztes nur den größsten Wert ermittelt habe mittels "max" und "math" (max(max zahl1, zahl2),zahl3). Da hatte meine lehrerin zwar etwas längeres geschrieben, jedoch nur mit einfachsten Mitteln. ( < und > und = )

@Corpsman
Oh mein Gott. Was ist das denn? :| Ich lerne mit Delphi erst seit 2 Monaten. Ich kenne nur die Sachen, die mein Lehrer mir sagt. Von diesen Arrys etc. habe ich keinen Blassen Schimmer.

[Corpsman]

Was dein Lehrer Wollte ist das ihr feststellt das es ein Heuden Aufwand ist das so zu machen.

Wenn du dich in die Materie des Arrays einliest dann kannst das halt viel Leichter machen.

Das Sample das ich gepostet hab ist halt die Intelligente Lösung für einen Anfänger ist die vielleicht etwas heftig.

Such mal unter Bubblesort bei wiki oder so da kannst dann die Einfacheren sachen machen.

[Mexbuild]

Wie sähe das den in meinem Programm aus. (Wie gesagt, tut mir echt Leid, dass ich hier euch nerve aber ich habe echt kaum einen Schwimmer wie es geht.

[Klaus01]

Delphi-Quellcode:

const 
  maxAnzahl = 4;

type
  ZahlenArray = Array [0..maxAnzahl-1] of Integer;
  
var
  meineZahlen: ZahlenArray;


meineZahlen[0]:=StrToInt(Edit1.Text);
meineZahlen[1]:=StrToInt(Edit2.Text);
meineZahlen[2]:=StrToInt(Edit3.Text);
meineZahlen[3]:=StrToInt(Edit4.Text);

procedure sortieren (var zahlen:ZahleArray);
var
  i,j,hilf:integer;
begin
  for i:= length(zahlen)-1 downto 0 do
    for j:= 1 to i do
      begin
        if zahlen[j] < zahlen[j-1] then
          begin
            hilf:= zahlen[j-1];
            zahlen[j-1]:= zahlen[j];
            zahlen[j]:= hilf;
         end;
      end;
end;

//Aufruf:

  sortieren(meinZahlen);

  gross:=meienZahlen[3];
  mittel2:=meineZahlen[2];
  mittel1:=meineZahlen[1];
  klein := meineZahlen[0];

[Mexbuild]

Danke, aber was heißen die Buchstaben in diesem Bereich:

Delphi-Quellcode:

var
  i,j,hilf:integer;
begin
  for i:= length(zahlen)-1 downto 0 do
    for j:= 1 to i do
      begin
        if zahlen[j] < zahlen[j-1] then
          begin
            hilf:= zahlen[j-1];
            zahlen[j-1]:= zahlen[j];
            zahlen[j]:= hilf;
         end;
      end;
end;

Also dieses j,hilf,j-1 und zahlen [j] ?

[Klaus01]

Zitat:

Zitat von Mexbuild

Danke, aber was heißen die Buchstaben in diesem Bereich:

Delphi-Quellcode:

var
  i,j,hilf:integer;
begin
  for i:= length(zahlen)-1 downto 0 do
    for j:= 1 to i do
      begin
        if zahlen[j] < zahlen[j-1] then
          begin
            hilf:= zahlen[j-1];
            zahlen[j-1]:= zahlen[j];
            zahlen[j]:= hilf;
         end;
      end;
end;

Also dieses j,hilf,j-1 und zahlen [j] ?

i und j sind die laufvariablen, sie geben den Index im Array an.

Also wenn i = 1 ist, ist damit gemeint zahlen[1], die zweite Zahl im ZahlenArray.
Die zweite, weil das Array bei 0 beginnt.

hilf ist die Hilfsvariable, sie übernimmt zeitweise einem Wert wenn zwei Werte getauscht werden.

Grüße
Klaus

[Mexbuild]

Wie viele Variablen brauche ich den dafür? Es müssen ja 4 Zahlen sein, die geordnet werden müssen!

[Klaus01]

Die Zahlen packst Du doch in das Array welches sortiert wird:

Delphi-Quellcode:

const
  maxAnzahl = 4;

type
  ZahlenArray = Array [0..maxAnzahl-1] of Integer;
 
var
  meineZahlen: ZahlenArray;


meineZahlen[0]:=StrToInt(Edit1.Text);
meineZahlen[1]:=StrToInt(Edit2.Text);
meineZahlen[2]:=StrToInt(Edit3.Text);
meineZahlen[3]:=StrToInt(Edit4.Text);

Grüße
Klaus

[Mexbuild]

Delphi-Quellcode:

meineZahlen[0]:=StrToInt(Edit1.Text);

Sind das dann bei mir zahl1, zahl2, zahl3 etc...?

Delphi-Quellcode:

            hilf:= zahlen[j-1];
            zahlen[j-1]:= zahlen[j];
            zahlen[j]:= hilf;

Muss dies genauso geschreiben sein, oder muss ich da noch was ergänzen?

[Klaus01]

Edit1.text - da steht Deine Zahl1 drinnen - diese wird in das Array auf Position 0 gesetzt
Edit2.text - da steht Deine Zahl2 drinnen - diese wird in das Array auf Position 1 gesetzt
..

Dsa ist die Vertauschung der Zahlen.

Delphi-Quellcode:

hilf:= zahlen[j-1];
zahlen[j-1]:= zahlen[j];
zahlen[j]:= hilf;

Das Verfahren heißt BubbleSort, da steigen die großen oder kleinen Zahlen nach oben oder sinken nach unten.
Das hängt davon ab, wie Du vergleichst.

Grüße
Klaus

[DeddyH]

Hallo, anstatt 4 Variablen für Deine Zahlen anzulegen, packt Klaus diese in ein Array. Unter einem Array kannst Du Dir eine "Kette" von Variablen vorstellen. Das erste Glied dieser Kette hat den Index 0 (Schreibweise ArrayName[0]). Anstatt also mit verschiedenen Variablen herumzuhantieren, werden einfach die "Kettenglieder" bearbeitet, welche eben Deine Zahlen beinhalten. Da ich mich nicht sooo doll ausdrücken kann, solltest Du mal in der Online-Hilfe nach "Array" schauen, dann wird Dir hoffentlich einiges klarer.

[Mexbuild]

Dsa ist die Vertauschung der Zahlen.

Delphi-Quellcode: markieren

Delphi-Quellcode:

hilf:= zahlen[j-1];
zahlen[j-1]:= zahlen[j];
zahlen[j]:= hilf;

Ich dachte es ist die sortierung nach der Größe?

[Klaus01]

Die ganze Procedure macht die Sortierung.
Damit das Array aber sortiert wird müßen Zahlen von verschiedenen Positionen getauscht werden.
So das z.B. die größte Zahl auf Position 0 steht und die kleinste auf Position 3, oder umgekehrt.

Vielleicht schaust Du mal auf diese Webseite, da ist BubbleSort recht anschaulich erklärt.

Grüße
Klaus

[Mexbuild]

Delphi-Quellcode:

unit reihe;

interface

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

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

var
zahl1, zahl2, zahl3, zahl4: integer;

implementation

{$R *.dfm}

procedure TForm1.BitBtn1Click(var zahlen: zahl1, zahl2, zahl3, zahl4);  /// Hier sagt er: [Fehler] reihe.pas(35): 'zahl1' ist kein gültiger Typenbezeichner
zahl1[0]:=StrToInt(Edit1.Text);
zahl2[1]:=StrToInt(Edit2.Text);
zahl3[2]:=StrToInt(Edit3.Text);
zahl4[3]:=StrToInt(Edit4.Text);
begin
  for i:= length(zahlen)-1 downto 0 do
    for j:= 1 to i do
      begin
        if zahlen[j] < zahlen[j-1] then
          begin
            hilf:= zahlen[j-1];
            zahlen[j-1]:= zahlen[j];
            zahlen[j]:= hilf;
         end;
      end;
end;


end.

Also ich verstehe hier leider nur Bahnhof. Tut mir echt leid, vielleicht sollte ich es leiber sein lassen, bevor ich es noch schlimmer mache... :cry:

Gruß Max

[Klaus01]

Guten Morgen,

Delphi-Quellcode:

unit reihe;

interface

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

type
  TForm1 = class(TForm)
    BitBtn1: TBitBtn;
    Edit1: TEdit;
    Edit2: TEdit;
    Edit3: TEdit;
    Label1: TLabel;
    Button1: TButton;
    Button2: TButton;
    Label2: TLabel;
    Edit4: TEdit;
    procedure BitBtn1Click(Sender: TObject);
    procedure Button1Click(Sender: TObject);
  private
    { Private-Deklarationen }
    zahl1,zahl2,zahl3,zahl4: Integer;
  public
    { Public-Deklarationen }
  end;


implementation

{$R *.dfm}

procedure TForm1.BitBtn1Click(Sender: TObject);
var
  zahlen: Array[0..3] of Integer;
  i,j: Byte;
  hilf: Integer;
begin
  zahlen[0]:=StrToInt(Edit1.Text);
  zahlen[1]:=StrToInt(Edit2.Text);
  zahlen[2]:=StrToInt(Edit3.Text);
  zahlen[3]:=StrToInt(Edit4.Text);

  for i:= length(zahlen)-1 downto 0 do
    for j:= 1 to i do
      begin
        if zahlen[j] < zahlen[j-1] then
          begin
            hilf:= zahlen[j-1];
            zahlen[j-1]:= zahlen[j];
            zahlen[j]:= hilf;
         end;
      end;
 
   zahl1:=zahlen[0];
   zahl2:=zahlen[1];
   zahl3:=zahlen[2];
   zahl4:=zahlen[3];

end;


end.

Grüße
Klaus

[leddl]

Leute, was macht es denn für einen Sinn, ihm auf Teufel komm raus den BubbleSort unterzujubeln? :roll: Er hat doch jetzt schon tausendmal gesagt, dass er von Arrays oder Sortieralgorithmen keinen blassen Schimmer hat und dass er sowieso den vorhandenen Algorithmus umformen soll

Hier mal mein Versuch der Implementierung. Ist nicht getestet, sondern nur schnell runtergeschrieben, wäre also höchstwahrscheinlich nochmal gut, ihn etwas genauer zu testen ;)

Delphi-Quellcode:

procedure Sortieren;
begin
   zahl1 := StrToInt(Edit1.Text);
   zahl2 := StrToInt(Edit2.Text);
   zahl3 := StrToInt(Edit3.Text);
   zahl4 := StrToInt(Edit4.Text);

   //Zahl1 und Zahl2 sortieren
   if zahl1 > zahl2 then
   begin
      gross := zahl1;
      klein := zahl2;
   end
   else
   begin
      gross := zahl2;
      klein := zahl1;
   end;

   //Zahl3 sortiert einfügen
   if zahl3 > gross then
   begin
      //Nach unten verschieben
      mittelgross := gross;
      gross := zahl3
   end
   else
   begin
      if zahl3 > klein then
         mittelgross = zahl3;
      else
      begin
         //Nach unten verschieben
         mittelgross = klein;
         klein := zahl3;
      end;
   end;

   //Zahl4 sortiert einfügen
   if zahl4 > gross then
   begin
      //Nach unten verschieben
      mittel := mittelgross;
      mittelgross := gross;
      gross := zahl4;   
   end
   else
   if zahl4 > mittelgross then
   begin
      //Nach unten verschieben
      mittel = mittelgross;
      mittelgross := zahl4;
   end
   else
   if zahl4 > klein then
      mittel := zahl4;
   else
   begin
      //Nach oben verschieben
      mittel := klein;
      klein := zahl4;
   end;

   label1.caption := 'Die Reihenfolge lautet: ' + inttostr(klein) + ', ' + inttostr(mittel) + ', '
            + inttostr(mittelgross) + ', ' + inttostr(gross);
end;

[bitsetter]

Moin moin,

hier noch eine andere Variante ohne Array:

Delphi-Quellcode:

procedure VertauscheZahlen(var zahlA, zahlB: integer);
var
  Puffer: integer;
begin
  Puffer := zahlA;
  zahlA := zahlB;
  zahlB := Puffer;
end;

procedure VergleicheZahlen(var zahlA, zahlB: integer);
begin
  if zahlB < zahlA then
    VertauscheZahlen(zahlA, zahlB);
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  zahl1, zahl2, zahl3, zahl4: integer;
begin
  zahl1 := StrToInt(Edit1.Text);
  zahl2 := StrToInt(Edit2.Text);
  zahl3 := StrToInt(Edit3.Text);
  zahl4 := StrToInt(Edit4.Text);

  VergleicheZahlen(zahl1, zahl2);
  VergleicheZahlen(zahl1, zahl3);
  VergleicheZahlen(zahl1, zahl4);

  VergleicheZahlen(zahl2, zahl3);
  VergleicheZahlen(zahl2, zahl4);

  VergleicheZahlen(zahl3, zahl4);

  label1.caption := 'Die Reihenfolge lautet: ' + inttostr(zahl1) + ', ' + inttostr(zahl2) + ', '
    + inttostr(zahl3) + ', ' + inttostr(zahl4);
end;

[DeddyH]

Und hier eine Variante zum Vertauschen zweier ganzer Zahlen ohne Puffer-Variable.

Delphi-Quellcode:

procedure VertauscheZahlen(var a,b: integer);
begin
  a := a xor b;
  b := b xor a;
  a := a xor b;
end;

[Mexbuild]

@Bitsetter
Diese Methode ist sehr gut. Könntest du mir deine Version erläutern, wie sie im genaueren Funktioniert?

U.a:

Delphi-Quellcode:

procedure VertauscheZahlen(var zahlA, zahlB: integer);
var
  Puffer: integer;
begin
  Puffer := zahlA;
  zahlA := zahlB;
  zahlB := Puffer;
end;

und...

procedure VergleicheZahlen(var zahlA, zahlB: integer);
begin
if zahlB < zahlA then
VertauscheZahlen(zahlA, zahlB);
end;

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
  zahl1, zahl2, zahl3, zahl4: integer;
begin
  zahl1 := StrToInt(Edit1.Text);
  zahl2 := StrToInt(Edit2.Text);
  zahl3 := StrToInt(Edit3.Text);
  zahl4 := StrToInt(Edit4.Text);

  VergleicheZahlen(zahl1, zahl2);
  VergleicheZahlen(zahl1, zahl3);
  VergleicheZahlen(zahl1, zahl4);

  VergleicheZahlen(zahl2, zahl3);
  VergleicheZahlen(zahl2, zahl4);

  VergleicheZahlen(zahl3, zahl4);

Was passiert bei "VergleicheZahlen"? Wird dort das gleiche wie bei "max" gemacht? Und was hat es mit dem Puffer aus sich? (Erste zitierte Prozedur)

[bitsetter]

Zitat:

Zitat von Mexbuild

Wird dort das gleiche wie bei "max" gemacht?(Erste zitierte Prozedur)

EDIT: Nein

Zitat:

Zitat von Mexbuild

Und was hat es mit dem Puffer aus sich? (Erste zitierte Prozedur)

Um die Zahlen tauschen zu können muss ich zahlA zwischenspeichern.

Delphi-Quellcode:

zahlA := zahlB; 
zahlB := zahlA;

So könnte ich die Zahlen nicht vertauschen.


Im Endeffekt möchte ich, dass zahl1 die kleinste Zahl und zahl4 die größte Zahl wird. Dazu muss ich alle Zahlen systematisch miteinander vergleichen:

Delphi-Quellcode:

procedure VergleicheZahlen()

.
Wenn zum Beispiel

Delphi-Quellcode:

   
  zahl1 := 5;
  zahl4 := 1;
  VergleicheZahlen(zahl1, zahl4);

dann würde daraus zahl1 = 1 und zahl4 = 5 werden.
Der Code ist natürlich noch nicht optimal aber er funktioniert.