Nested Iteration · Iteração Aninhada
| English | Português |
|---|---|
| nested iteration/ˈnestɪd ˌɪtəˈreɪʃn/ | iteração aninhada |
A loop inside a loop
- Nested iteration 嵌套迭代 puts one loop inside another's body.
- The inner loop runs completely for each pass of the outer loop.
- Outer runs
mtimes, inner runsntimes each → the inner body runsm × ntimes. - Nesting handles grids, tables, and all-pairs comparisons.
Um loop dentro de um loop
- Iteração aninhada 嵌套迭代 coloca um loop dentro do corpo de outro.
- O loop interno roda completamente para cada passagem do loop externo.
- Externo roda
mvezes, interno rodanvezes cada → o corpo interno rodam × nvezes. - Aninhamento lida com grids, tabelas e comparações par-a-par.
Rows and columns
- A common use: outer loop for rows, inner loop for columns.
for (int r = 0; r < rows; r++) { for (int c = 0; c < cols; c++) { ... } }- For each row, the inner loop sweeps all columns before the outer advances.
- This visits every cell of a 2-D grid in order.
Linhas e colunas
- Uso comum: loop externo para linhas, loop interno para colunas.
for (int r = 0; r < rows; r++) { for (int c = 0; c < cols; c++) { ... } }- Para cada linha, o loop interno varre todas as colunas antes do externo avançar.
- Isso visita cada célula de uma grade 2-D em ordem.
Tracing the order
- The inner loop finishes all its passes, then the outer takes one step.
- Outer
r=0: innerc=0,1,2; outerr=1: innerc=0,1,2; and so on. - Reset any inner counter at the start of each outer pass.
- Trace slowly — mixing up which loop advances is a common mistake.
Rastreando a ordem
- O loop interno conclui todas as suas passagens, depois o externo dá um passo.
- Externo
r=0: internoc=0,1,2; externor=1: internoc=0,1,2; e assim por diante. - Reinicie qualquer contador interno no início de cada passagem externa.
- Rastreie lentamente — confundir qual loop avança é um erro comum.
Watch the inner variable
- Declare the inner loop's counter inside or reset it each outer pass.
- If you reuse an outer variable in the inner condition, watch for interference.
- The inner and outer counters should be independent unless you intend otherwise.
- A triangle pattern (
cfrom0tor) makes the inner count depend on the outer.
Atenção à variável interna
- Declare o contador do loop interno dentro ou resete-o a cada passagem externa.
- Se reutilizar uma variável externa na condição interna, atenção para interferências.
- Os contadores interno e externo devem ser independentes, a menos que você pretenda o contrário.
- Um padrão triangular (
cde0ar) faz com que a contagem interna dependa da externa.
In nested loops, the inner loop runs FULLY for every single outer pass. So the inner body executes outer × inner times — a 10 × 10 nest runs its inner body 100 times, not 20. Reset the inner counter at each outer pass (declaring it in the inner for header does this automatically), or the second outer pass starts where the first left off.
Em loops aninhados, o loop interno é executado COMPLETAMENTE para cada iteração do loop externo. Portanto, o corpo interno executa outer × inner vezes — uma estrutura de 10 × 10 aninhamento faz com que seu corpo interno seja executado 100 vezes, não 20. Reinicie o contador interno a cada iteração do loop externo (declará-lo no cabeçalho do loop interno for faz isso automaticamente), caso contrário, a segunda iteração do loop externo começa de onde a primeira parou.
Printing a 3×3 grid of stars:
for (int r = 0; r < 3; r++) { for (int c = 0; c < 3; c++) { print("*"); } println(); }- Outer runs
3times; inner runs3each →9stars total. - Each outer pass prints one row of three, then a newline.
Imprimindo uma grade de estrelas 3×3:
for (int r = 0; r < 3; r++) { for (int c = 0; c < 3; c++) { print("*"); } println(); }- As execuções externas ocorrem
3vezes; as internas,3cada → total de9estrelas. - Cada passagem externa imprime uma linha de três asteriscos, seguida de uma nova linha.
Nested iteration puts a loop inside another; the inner loop runs fully for each outer pass, so the inner body executes outer × inner times. It's the pattern for grids (outer = rows, inner = columns). Reset the inner counter each outer pass, and trace carefully — the inner finishes before the outer advances.
Iteração aninhada coloca um loop dentro de outro; o loop interno é executado completamente em cada passada do loop externo, então o corpo interno é executado outer × inner vezes. É o padrão para grades (externo = linhas, interno = colunas). Reinicie o contador interno a cada passada externa e faça o rastreamento com cuidado — o interno termina antes que o externo avance.
Nested loops sweep a grid · Laços aninhados varrem uma grade
Outer = rows, inner = columns; the inner loop fills each row. · Externo = linhas, interno = colunas; o laço interno preenche cada linha.
Outer loop runs 3 times, inner runs 3 times each. How many times does the inner body run? · Laço externo roda 3 vezes, interno roda 3 vezes cada. Quantas vezes o corpo interno roda?
3 × 3 = 9.
In nested loops, the inner loop runs fully for every single pass of the outer loop. · Em laços aninhados, o laço interno roda completamente para cada única passagem do laço externo.
That's why the inner body runs outer × inner times. · É por isso que o corpo interno roda vezes externas × internas.
For a 2-D grid, which loop typically handles the columns? · Para uma grade 2-D, qual laço tipicamente lida com as colunas?
Outer = rows, inner = columns. · Externo = linhas, interno = colunas.
A 10 × 10 nested loop runs its inner body how many times? · Um laço aninhado 10 × 10 roda seu corpo interno quantas vezes?
10 × 10 = 100.
Declaring the inner counter in the inner for-header resets it each outer pass. · Declarar o contador interno no cabeçalho for interno o reseta a cada passagem externa.
A fresh int i in the inner header restarts it each time. · Um int i fresco no cabeçalho interno o reinicia cada vez.