Artykuł dotyczy takiej sytuacji:
for(int i=a1;i<=b1;i++)
for(int j=a2;j<=b2;j++)
...
{
//zrób coś, kod zależy od wartości zmiennych sterujących i,j,...,
}
}
}
Niestety, w czasie pisania programu nie znamy głębokości zagnieżdżenia, nie znamy też zakresów zmiennych sterujących: zmienne a1,b1,a2,...
Mój pomysł jest następujący, korzystamy z dwóch kolekcji:
- `ArrayList<point> ranges`. Rozmiar tej kolekcji to głębokość zagnieżdżenia, każdy element tej kolekcji (obiekt klasy `Point` to para liczb typu __int__) wyznacza zakres pętli.
- `ArrayList<integer> indexes`. Kolekcja ta zawiera wartości zmiennych sterujących.
Do zorganizowania pętli wykorzystujemy tę metodę:
```java
private void doSomething(ArrayList<point> ranges, ArrayList<integer> indexes)
{
if(ranges.size() == 1)
{
Task task = new Task(); //nazwa tej klasy jest całkowicie dowolna
for(int i=ranges.get(0).x;i<=ranges.get(0).y;i++)
{
ArrayList<integer> indexes2 = new ArrayList<integer>(indexes);
indexes2.add(i);
task.run(indexes2); //nazwa tej metody również jest dowolna
}
}
else
{
for(int i=ranges.get(0).x;i<=ranges.get(0).y;i++)
{
ArrayList<point> ranges2 = new ArrayList<point>();
ranges2.addAll(ranges);
ranges2.remove(0);
ArrayList<integer> indexes2 = new ArrayList<integer>(indexes);
indexes2.add(i);
doSomething(ranges2,indexes2);
}
}
}
```
Najpierw tworzymy kolekcję `ranges`. Możemy odpytać użytkownika, możemy losować,...
Potem wywołujemy
```java
doSomething(ranges, new ArrayList<integer>());
```
Jeżeli kod klasy `Task` wygląda tak:
```java
class Task
{
private void run(ArrayList<integer> indexes)
{
int sum = 0;
String txt = "";
int sumOfIndexes = 0;
for(int l:indexes)
{
sum+=l*l;
txt+=l+"^2+";
sumOfIndexes+=l;
}
txt = txt.substring(0,txt.length()-1);
if(sum == 100 && (sumOfIndexes % 2) == 0)
{
System.out.println(txt+"="+sum);
}
}
}
```
to wypisane zostaną wyrażenia postaci `6^2+8^2=100`,`5^2+5^2+5^2+4^2+3^2=100`,...,(suma zmiennych sterujących musi być parzysta, suma ich kwadratów musi być równa 100).