zusammenfalten · markieren

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
i,merke : integer;
begin
merke := 1;
memo1.Lines.Clear;
max := strtoint(edit1.Text);
setlength(zahlen, max);

for i := 1 to max do
begin
  zahlen[i] := random(strtoint(edit2.Text));
  if i > merke*10 then merke := merke+1;

  memo1.Lines.Insert(merke-1,(memo1.Lines.Strings[merke-1] + ' ' + inttostr(Zahlen[i]) + ',')) ;

end;
showmessage(inttostr(memo1.Lines.Count));

end;

Hallo ich wollte ein Prgramm schreiben das eine bestimmte Anzahl an Zufallszahlen generiert und diese dann anschließend ein einem Memofeld ausgibt. Bei 10 Zahlen soll es in einer Zeile ausgegeben werden. Anschließend sollen die Zahlen nach dem Bubble Sort Verfahren sortiert(dazu bin ich aber noch ncht gekommen da der erste Teil ja schon Probleme macht). Allerdings macht das Programm jetzt genau so viele Zeilen wie es Zahlen generieren soll und füllt diese mit den ersten 10 Zahlen immer abnehmen so das es wie eine halbe Pyramide ausschaut

Eine Reihe von Zufallszahlen kann man eigentlich ganz nett mit einer TList machen.

zusammenfalten · markieren

Delphi-Quellcode:

procedure GetRandomNumbers(Strings: TStrings; AFrom, ATo: integer);
var
  I, J: integer;
  List: TList;
begin
  List := TList.Create;
  Strings.Clear;
  try
    for I := AFrom to ATo do
      List.Add(Pointer(I));
    while List.Count > 0 do
    begin
      I := Random(List.Count);
      J := Integer(List[I]);
      Strings.Add(IntToStr(J));
      List.Delete(I);
    end;
  finally
    List.Free;
  end;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  GetRandomNumbers(Memo1.Lines, 1, 12);
end;

Die Zahlen im Memo anders unterzubringen solltest du schaffen.

Mit insert machst du eine neue Zeile und verschiebst die bisherige nach unten. Dadurch entsteht die Pyramide. Du must einfach ...Lines[i] = Lines[i]+...+Zahl[i]
oder entsprechend ändern.

Generell wäre es aber sicher einfacher erstmal in einer ersten Schleife die Zahlen zu generieren und in dem Array zu speichern. Anschließend dann die Zahlen aus dem Array ausgeben in einer neuen Schleife, wo man dann einfach erstmal bis zu 10 Zahlen in einen String hängt und den dann nach und nach ausgibt.

Oder man macht es direkt so wie bjoerk es vorschlägt.

Oder man baut sich gleich eine Klasse, die die entsprechende Funktionalität zur Verfügung stellt (braucht man eh öfter). Wenn XE bereits eine TIntegerList hat, dann kann man die Klasse ja auch davon ableiten und entsprechend erweitern.

zusammenfalten · markieren

Delphi-Quellcode:

procedure TIntegerList.Exchange(Index1, Index2: integer);
var
  T: integer;
begin
end;

procedure TIntegerList.Sort;
var
  I, J: integer;
begin
end;

procedure TIntegerList.Assign(List: TIntegerList);
var
  I: integer;
begin
  Clear;
  for I := 0 to List.Count - 1 do
    Add(List[I]);
end;

procedure TIntegerList.Mix;
var
  MixList: TIntegerList;
  I: integer;
begin
  MixList := TIntegerList.Create;
  try
    while FCount > 0 do
    begin
      I := Random(FCount);
      MixList.Add(FItems[I]);
      Del(I);
    end;
    Assign(MixList);
  finally
    MixList.Free;
  end;
end;

procedure TIntegerList.SetStrings(Strings: TStrings; ColCount: integer);
var
  I, J, K, RowCount: integer;
  S: string;
begin
  Strings.BeginUpdate;
  Strings.Clear;
  try
    if FCount mod ColCount = 0 then
      RowCount := FCount div ColCount
    else
      RowCount := FCount div ColCount + 1;
    for I := 0 to RowCount - 1 do
    begin
      S := '';
      for J := 0 to ColCount - 1 do
      begin
        K := I * ColCount + J;
        if K < FCount then
          S := S + IntToStr(FItems[K]) + FSeparator;
      end;
      Strings.Add(S);
    end;
  finally
    Strings.EndUpdate;
  end;
end;

Zitat von Jumpy:

Mit insert machst du eine neue Zeile und verschiebst die bisherige nach unten. Dadurch entsteht die Pyramide. Du must einfach ...Lines[i] = Lines[i]+...+Zahl[i]
oder entsprechend ändern.

Generell wäre es aber sicher einfacher erstmal in einer ersten Schleife die Zahlen zu generieren und in dem Array zu speichern. Anschließend dann die Zahlen aus dem Array ausgeben in einer neuen Schleife, wo man dann einfach erstmal bis zu 10 Zahlen in einen String hängt und den dann nach und nach ausgibt.

Oder man macht es direkt so wie bjoerk es vorschlägt.

Dann wird aber nur eine Zeile angezeigt

Zitat von fox67:

Zitat von Jumpy:

....
Oder man macht es direkt so wie bjoerk es vorschlägt.

Dann wird aber nur eine Zeile angezeigt

Dann Zeig doch mal was Du wirklich in Deinem Programm hast.

Gruß
K-H

Zitat von fox67:

Zitat von Jumpy:

Mit insert machst du eine neue Zeile und verschiebst die bisherige nach unten. Dadurch entsteht die Pyramide. Du must einfach ...Lines[i] = Lines[i]+...+Zahl[i]
oder entsprechend ändern.

Generell wäre es aber sicher einfacher erstmal in einer ersten Schleife die Zahlen zu generieren und in dem Array zu speichern. Anschließend dann die Zahlen aus dem Array ausgeben in einer neuen Schleife, wo man dann einfach erstmal bis zu 10 Zahlen in einen String hängt und den dann nach und nach ausgibt.

Oder man macht es direkt so wie bjoerk es vorschlägt.

Dann wird aber nur eine Zeile angezeigt

Ich zitier mich mal selber:

Zitat:

Anschließend dann die Zahlen aus dem Array ausgeben in einer neuen Schleife, wo man dann einfach erstmal bis zu 10 Zahlen in einen String hängt und den dann nach und nach ausgibt.

zusammenfalten · markieren

Delphi-Quellcode:

s:='';
for i:=Low(Array) to High(Array) do
  begin
  s = s+Array[i];
  if (i mod 10 = 0) or i=High(Array) then
    beginn
    Memo1.Lines.Add(s);
    s:='';
    end
  else
    begin
    s=s+',';
    end;
  end;

Nee nee Ralph, das wird so nicht funzen (für i = 0 ist die mod Bedigung ebenfalls erfüllt).

Na und? dann eben eine Zeile mehr, dieses "nur eine Zeile" stört mich viel mehr.

Gruß
K-H

Aha, na dann..

Warum nicht einfach so?
  if ((I + 1) mod 10 = 0) or (I = High(Array)) then