Autor Beitrag
N00b
Hält's aus hier
Beiträge: 1



BeitragVerfasst: Mi 07.01.04 15:30 
Hallo ihr vom Delphi Forum!
Ich weiß nicht, ob ich jetzt hier richtig bin, aber ich fand es am wahrscheinlichsten :roll:
Ich wäre sehr dankbar, wenn ihr mir Tipps geben könntet, wie und womit ich das Delphi programmieren einfach lernen kann :idea: Ansich bin ich kein Anfänger, allerdings ist der Schulunterricht für mich sehr schwer. Gute, leicht verständliche Bücher? (Grundlagen und Profiwissen vom Hanser Verlag hab ich, ist aber leider so gut wie gar nicht hilfreich :cry:) Lernmethoden? Vorgehensweisen?

Aktuelles Thema sind Arrays, die uns in circa 20 Sätzen in all ihren Formen auf einem Zettel näher gebracht wurden :shock:

:arrow: Aufgabe: Wir sollen ein Array mit einem Index von 1 bis 10 erstellen, in das willkürlich Zahlen oder Buchstaben eingegeben werden (vom PC) und diese Sortiert werden (von groß nach klein, von klein nach groß oder alphabetisch...). Das ganze dann auch noch so, dass die vom Computer gewählten Zahlen/Buchstaben in einem "Memo1" ausgegeben werden und dann in einem "Memo2" diese Zahlen/Buchstaben in sortierter Form ausgegeben werden :!: :?:

Tja verstehen tu ich das ja schon, aber ich habe keine Ahnung wie ich das Programmieren soll. :oops:

Ich hoffe irgend wer kann mir irgend welche Tipps geben, die mir in irgend einer Weise weiterhelfen können. (Delphi muss doch zu schaffen sein *grml*)

Greetz
N00b
maze2k
ontopic starontopic starontopic starontopic starhalf ontopic starofftopic starofftopic starofftopic star
Beiträge: 252

WIN 95, WIN NT 4.0, WIN 98, WIN 98SE, WIN 2000, RedHat Linux 7.3, Mandrake Linux 9.2, Knoppix Linux 3.3
D6 Pers
BeitragVerfasst: Mi 07.01.04 21:59 
Da ich sowieso nichts zu tun habe, hab ich dir mal eben ein schickes kleines Programm geschrieben ;)

Du brauchst ein Memo1, ein Memo2, ein Button1, ein Button2 und einen Button3

Code hier:
Wenn's nicht klappt stell ich dir das Programm online, aber probier's erstmal so...
Bei Fragen, frag einfach ;)

ausblenden volle Höhe Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
unit Unit1;

interface

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

type
  TForm1 = class(TForm)
    Memo1: TMemo;
    Memo2: TMemo;
    Label1: TLabel;
    Label2: TLabel;
    Button1: TButton;
    Button2: TButton;
    Button3: TButton;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
    procedure Button3Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;
  MyArray: Array[1..10] of Integer;
  Sort: Integer;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
var
  i: Integer;
begin
  Sort := 0;
  Memo1.Clear; // Inhalt von Memo1 löschen
  Randomize;
  for i := 1 to 10 do
  begin
    MyArray[i] := random(1000);  // Zufallszahl generieren
    Memo1.Lines.Add(IntToStr(MyArray[i])) // Element i in Memo1 schreiben
  end;
end;

procedure TForm1.Button2Click(Sender: TObject);
var
  i: Integer;
begin
  Sort := 1;
  Memo1.Clear; // Inhalt von Memo1 löschen
  Randomize;
  for i := 1 to 10 do
  begin
    MyArray[i] := 65 + random(26);  // Zufallsbuchstabe generieren
                                         // (65 + [0..25] = A-Z in Ascii)
    Memo1.Lines.Add(Chr(MyArray[i])) // Element i in Memo1 schreiben
  end;
end;

procedure TForm1.Button3Click(Sender: TObject);
var
  i, j, help: Integer;
begin
  Memo2.Clear; // Inhalt von Memo2 löschen
  for i := Low(MyArray) to High(MyArray) - 1 do
    for j := i to High(MyArray) do
      if MyArray[i] > MyArray[j] then
      begin
        help := MyArray[i];
        MyArray[i] := MyArray[j];
        MyArray[j] := help;
      end;

  for i := 1 to 10 do
  begin
    if Sort = 1 then
      Memo2.Lines.Add(Chr(MyArray[i])) // Element i in Memo1 schreiben
    else
      Memo2.Lines.Add(IntToStr(MyArray[i])); // Element i in Memo1 schreiben
  end;
end;

end.

_________________
Wer das Konzept der Unendlichkeit verstehen will, muss nur das Ausmaß menschlicher Dummheit betrachten. (Voltaire)
maze2k
ontopic starontopic starontopic starontopic starhalf ontopic starofftopic starofftopic starofftopic star
Beiträge: 252

WIN 95, WIN NT 4.0, WIN 98, WIN 98SE, WIN 2000, RedHat Linux 7.3, Mandrake Linux 9.2, Knoppix Linux 3.3
D6 Pers
BeitragVerfasst: Mi 07.01.04 22:00 
Noch eine kurze Bemerkung zu den Buttons:
Button1 erstellt die Zahlenliste, Button2 die Buchstabenliste (Ascii-Code, damit ich nur die eine Integerliste brauche), Button3 sortiert.

_________________
Wer das Konzept der Unendlichkeit verstehen will, muss nur das Ausmaß menschlicher Dummheit betrachten. (Voltaire)
Gausi
ontopic starontopic starontopic starontopic starontopic starontopic starofftopic starofftopic star
Beiträge: 8554
Erhaltene Danke: 481

Windows 7, Windows 10
D7 PE, Delphi XE3 Prof, Delphi 10.3 CE
BeitragVerfasst: Mi 07.01.04 22:04 
Zitat:

Wir sollen ein Array mit einem Index von 1 bis 10 erstellen, in das willkürlich Zahlen oder Buchstaben eingegeben werden

Das ist nicht so einfach. Ich fange mal mit Zahlen an.
Da das ganze nur mit 10 Elementen passieren soll, kann man ja auch für jedes Feld im Array ein Eingabeelement nehmen. Ein Teil Quellcode sieht dann so aus: (auf der Hauptform müssen dafür 10 Edits eingefügt werden)
ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
var ZahlenArray : Array[1..10] of integer;

Zahlenarray[1]:=strtoint(edit1.text);
Zahlenarray[2]:=strtoint(edit2.text);
[...]


Die Ausgabe in ein Memo könnte man so machen:
ausblenden Delphi-Quelltext
1:
2:
3:
memo1.lines.add('Folgende Werte sind im Array gespeichert');
for i:=1 to 10 do
    memo1.lines.add(inttostr(i) + '. Element ist: ' + inttostr(Zahlenarray[i]));


Zum Sortieren gibt es verschiedene Möglichkeiten. Eine sehr einfache ist das sogenannte Bubblesort. Dabei wird das Array von vorne nach hinten durchlaufen, und jede Zahl mit der nächsten verglichen. Wenn die linke Zahl größer ist als die rechte, müssen die beiden Zahlen vertauscht werden.
Das Array muss solange aufs neue durchlaufen werden, bis bei einem Durchlauf keine Zahl vertauscht wurde. Dann ist das Array aufsteigend sortiert.

ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
repeat
  vertauscht:=false      
  for i := 1 to 9 do 
  begin  
    if ZahlenArray[i] > ZahlenArray[i+1] then 
    begin 
      tmp    := Zahlenarray[i]; 
      Zahlenarray[i] := Zahlenarray[i+1]; 
      Zahlenarray[i+1] := tmp; 
      vertauscht:=true;
    end; 
  end;
until vertauscht=false;


Und jetzt sehe ich grade, dass da jemand schneller war... egal vielleicht hilfts ja noch .

Moderiert von user profile iconPeter Lustig: Code- durch Delphi-Tags ersetzt

_________________
We are, we were and will not be.
maze2k
ontopic starontopic starontopic starontopic starhalf ontopic starofftopic starofftopic starofftopic star
Beiträge: 252

WIN 95, WIN NT 4.0, WIN 98, WIN 98SE, WIN 2000, RedHat Linux 7.3, Mandrake Linux 9.2, Knoppix Linux 3.3
D6 Pers
BeitragVerfasst: Mi 07.01.04 22:24 
Zur Optimierung hier noch ein optimiertes Bubblesort ;)

ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
  last := 9;
  for i := 9 downto 1 do
    for j := 1 to last do
      if MyArray[j+1] < MyArray[j] then
      begin
        help := MyArray[j+1];
        MyArray[j+1] := MyArray[j];
        MyArray[j] := help;
        last := j;
      end;



einfach statt diesem Block hier nehmen (und die Variable last als Integer deklarieren):

ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
for i := Low(MyArray) to High(MyArray) - 1 do 
    for j := i to High(MyArray) do 
      if MyArray[i] > MyArray[j] then 
      begin 
        help := MyArray[i]; 
        MyArray[i] := MyArray[j]; 
        MyArray[j] := help; 
      end;

_________________
Wer das Konzept der Unendlichkeit verstehen will, muss nur das Ausmaß menschlicher Dummheit betrachten. (Voltaire)