Schleifen-Verschachtelungs-Problem

[TheGame1492]

Ich möchte eine verschachtelte Schleife schreiben, wo die Tiefe der Schleife dynamisch sein soll, also als Beispiel

Delphi-Quellcode:

_begin:=1;
_end:=3;

list := TStringList.Create;

for i := _begin to _end do
  for j := _begin to _end do
    for k := _begin to _end do
      for l := _begin to _end do
        begin
          list.Add(IntToStr(i)+'|'+IntToStr(j)+'|'+IntToStr(k)+'|'+IntToStr(l));
        end;

Ergebnis:
---------

1|1|1|1
1|1|1|2
1|1|1|3
1|1|2|1
1|1|2|2
1|1|2|3
.
.
.

bis

.
.
.
3|3|2|3
3|3|3|1
3|3|3|2
3|3|3|3


Dies wäre eine Tiefe von 4. Dazu benötigt werden 4 For-Schleifen, wie kann ich das jetzt aber machen, wenn ich zB eine Tiefe von 10 haben möchte,


beispiel:
1|1|1|1|1|1|1|1|1|1
1|1|1|1|1|1|1|1|1|2
1|1|1|1|1|1|1|1|1|3
1|1|1|1|1|1|1|1|2|1
1|1|1|1|1|1|1|1|2|2
1|1|1|1|1|1|1|1|2|3
.
.
.


ohne jetz 10 For-Schleifen zu benutzen, irgendwie steh ich da auf dem Schlauch

[wicht]

Was genau hast du denn damit vor?
Dein Problem lässt sich sicherlich lösen, aber der Ansatz ist falsch/nicht der beste, denke ich.

[Wolfgang Mix]

Einfacher als mit For-Schleifen wird es wohl nicht funktionieren.
Alle anderen Schleifentypen sind dafür IMHO umständlicher.

[himitsu]

Am Einfachsten du nutzt ein paar rekursive Aufrufe einer Funktion.

Delphi-Quellcode:

procedure Test(Start, Ende, Rekursion: Integer; SL: TStrings);
  procedure Aufruf(Start, Ende, Rekursion: Integer; SL: TStrings; const S: String);
  var
    i: Integer;
  begin
    if Rekursion <> 0 then
    begin
      for i := Start to Ende do
        Aufruf(Start, Ende, Rekursion - 1, SL, S + IntToStr(i));
    end else
      SL.Add(S);
  end;

begin
  Aufruf(Start, Ende, Rekursion, SL, '');
end;

procedure TForm2.Button1Click(Sender: TObject);
begin
  Test(1, 3, 4, Memo1.Lines);
end;

PS: Bei einem Memo könnte ein BeginUpdate eventuell auch nicht schaden.

[TheGame1492]

Supi thx

mit der rekursion funzt es

[Meflin]

Falls es sich bei dem gezeigten erwünschten Ergebnis nicht nur um ein dahergeholtes Beispiel handelt, geht das ganze auch (ganz unrekursiv) damit .

Delphi-Quellcode:

var 
  BruteForce: TBruteForce; 
begin 
  BruteForce := TBruteForce.Create; 
  BruteForce.NodeCount := 5; // oder 6 oder 7 oder was auch immer... 
  BruteForce.ElementList := BFConstToDynArray(Numeric); 
  
  // über "Ergebnisse" iterieren
  Memo1.Lines.Add(BruteForce.Value); 
  while not BruteForce.Finished do begin 
    Memo1.Lines.Add(BruteForce.NextValue); 
  end; 
end;