Comment sauter certaines boucles imbriquées dans Delphi?

Question

Quelqu'un pourrait-il m'aider s'il vous plaît dans ce sujet dans Delphi?

J'ai 5 boucles de blocs "for" imbriquées en itération avec les variables k1, k2 .. k5.
Une autre variable k doit contrôler la profondeur de plus de 5 boucles. Cette variable est définie pendant l'exécution.

Est-il possible d'éliminer l'exécution des k blocs internes 'for' comme s'ils avaient été commentés? Une liste courte d'expliquer le code est ici:

k := 2; 
for k1 := 1 to 100 do begin 
    for k2 := 1 to 100 do begin 
     for k3 := 1 to 100 do begin 
     for k4 := 1 to 100 do begin {want to skip this loop} 
      for k5 := 1 to 100 do begin {want to skip this loop} 
       AnywayDoThat; // must execute anyway 
      end; {k5} 
     end; {k4} 
     end; 
    end; 
end; 

En outre expliquer, comme k est égal à 2, je veux éviter l'exécution de boucles K4 et K5 (lignes de code se terminant par des accolades), ce qui réduit le flux complet de la programme. Bien sûr, proc AnywayDoThat doit exécuter.

J'utilise Delphi 6.

Edit: Désolé pour le mauvais libellé 'éliminé'. L'objectif était d'éviter les itérations inutiles. L'astuce pour passer une boucle en la faisant exécuter une seule fois est parfaite. Ainsi, proc AnywayDoThat est atteint selon k1, k2, k3 seulement.

Answer 1

Vous pouvez utiliser l'astuce suivante

Var 
    Maxes: array [1..5] of integer; 
    Eliminators: array [1..5] of integer; // they have to be of same length 
begin 
    SetArray(Maxes, [100, 100, 100, 100, 100]); 
    SetArray(Eliminators, [1, 1, 1, 1, 1]); 

    // Here you set K 
    K := 2; // you need to make sure K <= 5 

    // Set the Eliminators array 

    for I := 1 to K do 
    begin 
     Eliminators[5-I+1] := Maxes[5-I+1]; 
    end; 

    // Now to the loops 

    for k1 := 1 to Maxes[1] div Eliminators[1] do begin 
    for k2 := 1 to Maxes[2] div Eliminators[2] do begin 
     for k3 := 1 to Maxes[3] div Eliminators[3] do begin 
     for k4 := 1 to Maxes[4] div Eliminators[4] do begin 
      for k5 := 1 to Maxes[5] div Eliminators[5] do begin 
      AnywayDoThat; // must execute anyway 
      end; 
     end; 
     end; 
    end; 
    end; 


end; 

L'idée principale est ici pour passer une boucle en faisant exécuter à la fois. Cela peut être encore modifié pour lui faire sauter une boucle.

Answer 2

Une autre méthode consiste à utiliser la récursivité. Ceci est un exemple assez simplifiée en fonction de votre code qui écrit les indices actuels dans un fichier texte (désolé, pas avoir Delphi 6 pour le test):

var 
    F: Textfile; 

procedure AnywayDoThat(const Index: array of Integer); 
var 
    I: Integer; 
begin 
    for I := Low(Index) to High(Index) do 
    Write(F, Index[I], '.'); 
    Writeln(F); 
end; 

procedure Loop(Level, MaxLevel: Integer; const Index: array of Integer); 
var 
    arr: array of Integer; 
    I: Integer; 
    L: Integer; 
begin 
    if Level < MaxLevel then begin 
    L := Length(Index); 
    SetLength(arr, L + 1); 
    for I := 0 to L - 1 do begin 
     arr[I] := Index[I]; 
    end; 
    for I := 1 to 100 do begin 
     arr[L] := I; 
     Loop(Level + 1, MaxLevel, arr); 
    end; 
    end 
    else begin 
    AnywayDoThat(Index); 
    end; 
end; 

procedure Main(); 
var 
    k: Integer; 
    I: Integer; 
    Index: array of Integer; 
begin 
    AssignFile(F, 'c:\Temp\test.txt'); 
    Rewrite(F); 
    k := 2; 
    SetLength(Index, 1); 
    for I := 1 to 100 do begin 
    Index[0] := I; 
    Loop(1, 5 - k, Index); 
    end; 
    Close(F); 
end;