Menu

Loops Aninhados

Parte da seção Fundamentos do Journey de GO da Coddy. Lição 49 de 109.

Laços aninhados são laços colocados dentro de outro laço. O laço interno é executado completamente a cada iteração do laço externo.

Vamos criar uma tabuada para os números de 1 a 3 usando loops aninhados:

rows := 3
cols := 3
for i := 1; i <= rows; i++ {
    for j := 1; j <= cols; j++ {
        fmt.Printf("%d×%d=%d\t", i, j, i*j)
    }
    fmt.Println()
}

Após executar este código, obtemos uma tabuada em que cada linha representa um valor da variável do loop externo (i) multiplicado por todos os valores da variável do loop interno (j). A saída será exibida na tela:

1×1=1   1×2=2   1×3=3   
2×1=2   2×2=4   2×3=6   
3×1=3   3×2=6   3×3=9

Vamos entender como isso funciona passo a passo:

Primeiro, o loop externo define i=1 e o loop interno é executado completamente:

i=1, j=1: prints "1×1=1"
i=1, j=2: prints "1×2=2"
i=1, j=3: prints "1×3=3"

Depois que o loop interno termina, imprimimos uma nova linha com fmt.Println().

Em seguida, o loop externo define i=2 e o loop interno recomeça, com j voltando a 1:

i=2, j=1: prints "2×1=2"
i=2, j=2: prints "2×2=4"
i=2, j=3: prints "2×3=6"

Por fim, o loop externo define i=3 e o loop interno é executado uma última vez:

i=3, j=1: prints "3×1=3"
i=3, j=2: prints "3×2=6"
i=3, j=3: prints "3×3=9"

Cada loop tem seu próprio contador (i e j), e rows e cols nunca mudam: eles apenas indicam aos loops quando parar. Esse padrão é muito útil para trabalhar com tabelas de dados ou criar estruturas semelhantes a grades.

Desafio

Iniciante

Neste desafio, você vai praticar o uso de loops aninhados para imprimir um padrão simples. O loop externo percorrerá as linhas, e o loop interno percorrerá as colunas para criar uma pequena grade de caracteres.

Complete os loops aninhados para imprimir uma grade 3x3 de asteriscos (*). Cada asterisco deve ser seguido por um espaço, então cada linha deve ficar assim: * * * (com um espaço no final). A saída esperada é:

* * * 
* * * 
* * *

Use um contador novo para cada loop (por exemplo, i para as linhas e j para os asteriscos em uma linha) e compare-o com rows ou columns. Não altere rows e columns: cada linha precisa de columns novamente.

Experimente você mesmo

package main

import "fmt"

func main() {
	// Número de linhas e colunas na nossa grade
	rows := 3
	columns := 3
	
	// TODO: Crie um loop aninhado para imprimir uma grade de asteriscos (*)
	// O loop externo deve percorrer as linhas
	// O loop interno deve percorrer as colunas
	for i := 0; i < rows; i++ {
		// Adicione seu loop interno aqui para imprimir asteriscos em cada coluna
		
		// Isso imprime uma nova linha após cada linha da grade
		fmt.Println()
	}
}

Teste seus conhecimentos

Esta lição inclui um quiz rápido. Comece a lição para respondê-lo e acompanhar seu progresso.

Todas as lições de Fundamentos

1Introdução ao Go

O que é Go?Hello World Println Comentários em Go

4Operadores de Comparação e Lógicos

Operadores de Comparação - Parte 1 Operadores de Comparação - Parte 2 Operador Lógico AND Operador Lógico OR Operador Lógico NOT Fundamentos de Precedência de Operadores Recapitulação - Fazendo Comparações

7Fluxo de Controle: Loops

O Loop `for` Explicado Loop For - Básico Loop For - Apenas Condição A Palavra-chave `break`A Palavra-chave `continue`Loops AninhadosRecapitulação - Repetindo Ações

10Tipos Compostos: Arrays

Introdução a Arrays Declarando Arrays Inicializando Arrays Acessando Elementos de um Array Tamanho do Array com `len`Iterando sobre Arrays Arrays Multidimensionais

13Tipos Compostos: Structs

Definindo Tipos Personalizados Criando Instâncias de Structs Acessando Campos de Structs Ponteiros para Structs Inicializando Structs Structs Incorporadas Structs Anônimas Recapitulação - Estruturas de Dados Personalizadas

2Variáveis e Tipos de Dados Básicos

O que é uma variável Inferência de Tipo com `:=`Inteiros (int)Números de Ponto Flutuante Booleanos Strings Valores Zero Constantes Convenções de Nomenclatura Recapitulação - Variáveis e Tipos

5Entrada/Saída Básica

Saída Formatada Verbos de Formatação Imprimindo Tipos Obtendo Entrada Básica do Usuário Recapitulação - Entrada e Saída

8Funções

Entendendo Funções Declarando uma Função Chamando Funções Parâmetros de Função Retornando um Único Valor Retornando Múltiplos Valores Valores de Retorno Nomeados Fundamentos de Escopo de Função Recapitulação - Criando Código Reutilizável

11Tipos Compostos: Slices

Introdução aos Slices Declarando Literais de Slice Criando Slices com `make`Comprimento vs Capacidade de Slices Acessando Elementos de Slices Adicionando Elementos Fatiando Slices/Arrays Existentes Iterando sobre Slices Copiando Slices Recapitulação - Listas Dinâmicas

14Tratamento de Erros Básico

O Conceito de Erros A Interface `error`Funções que Retornam Erros Verificando Erros Criando Erros Simples Criando Erros Formatados Tratamento de Erros Básico Recapitulação - Lidando com Problemas

3Operadores Básicos

Operadores Aritméticos Operador de Divisão O Operador Módulo Operador de Atribuição Operadores de Atribuição Composta Incremento e Decremento Recapitulação - Cálculos

6Fluxo de Controle: Condicionais

A Instrução `if`A Palavra-chave `else`A Palavra-chave `else if`Sombreamento de Variáveis no `if`Inicializando Variáveis A Instrução `switch`Switch com Expressões Switch sem Expressão A Palavra-chave `fallthrough`Recapitulação - Tomando Decisões

9Ponteiros

O que é um Ponteiro?Declarando Variáveis de Ponteiro O Operador de Endereço Desreferenciando Ponteiros Usando Ponteiros em Funções Ponteiros Nil Recapitulação - Entendendo Ponteiros

12Tipos Compostos: Mapas

Introdução a Mapas Declarando Literais de Mapas Criando Mapas com `make`Adicionando e Atualizando Chave-Valor Acessando Valores de Mapas Verificando a Existência de Chaves Deletando Entradas de Mapas Tamanho do Mapa Iterando sobre Mapas Recapitulação - Armazenamento Chave-Valor

Pratique por conta própria: Compilador de Go online