Lista 005 - Extra

📖 Orientações

Em todos os exercícios desta lista, quando houver leitura de dados com leia, mantenha um escreva antes de cada entrada.

Nesta versão extra, você deve completar o código que já começou pronto, usar o fluxograma como guia para entender o caminho do programa e conferir a tabela de rastreio para ver o valor de cada variável a cada volta do laço.

Leia o enunciado e veja o que já está pronto no código.
Complete apenas as partes faltantes.
Use o fluxograma para entender o caminho que o programa percorre.
Confira a tabela de rastreio para ver o valor das variáveis a cada repetição.
Nos exercícios do nível prata, complete o acumulador antes de calcular o resultado final.
Nos exercícios do nível ouro, complete as partes do laço decrescente e as condições do se.

🥉 Nível Bronze: Primeiras Repetições com `enquanto`

Exercício 1: Aquecimento antes da partida

Complete o programa abaixo inicializando o contador e escrevendo a condição do enquanto.

programa {
    funcao inicio() {
        inteiro exercicio

        // Complete a inicialização do contador
        exercicio =

        // Complete a condição: o laço repete enquanto o exercício for <= 5
        enquanto ( ) {
            escreva("Exercício " + exercicio + " concluído.")
            exercicio = exercicio + 1
        }
    }
}

flowchart TD
    A((Início)) --> B[exercicio = 1]
    B --> C{exercicio <= 5?}
    C -- Sim --> D[Escreva Exercício N concluído]
    D --> E[exercicio = exercicio + 1]
    E --> C
    C -- Não --> F((Fim))

Volta	`exercicio`	Condição (`exercicio <= 5`)?	Saída
1ª	1	Sim	Exercício 1 concluído.
2ª	2	Sim	Exercício 2 concluído.
3ª	3	Sim	Exercício 3 concluído.
4ª	4	Sim	Exercício 4 concluído.
5ª	5	Sim	Exercício 5 concluído.
6ª	6	Não	(sai do laço)

Exercício 2: Contagem regressiva da torcida

Complete o programa abaixo inicializando o contador em 10 e escrevendo a condição do enquanto.

programa {
    funcao inicio() {
        inteiro contador

        // Complete a inicialização: a contagem começa em 10
        contador =

        // Complete a condição: o laço repete enquanto o contador for >= 1
        enquanto ( ) {
            escreva(contador)
            contador = contador - 1
        }
    }
}

flowchart TD
    A((Início)) --> B[contador = 10]
    B --> C{contador >= 1?}
    C -- Sim --> D[Escreva contador]
    D --> E[contador = contador - 1]
    E --> C
    C -- Não --> F((Fim))

Volta	`contador`	Condição (`contador >= 1`)?	Saída
1ª	10	Sim	10
2ª	9	Sim	9
3ª	8	Sim	8
…	…	…	…
10ª	1	Sim	1
11ª	0	Não	(sai do laço)

Exercício 3: O narrador não para de gritar

Complete o programa abaixo com a condição do enquanto.

programa {
    funcao inicio() {
        inteiro vezes
        inteiro contador

        escreva("Quantas vezes o narrador vai gritar? ")
        leia(vezes)

        contador = 1

        // Complete a condição: repete enquanto o contador não passou do limite
        enquanto ( ) {
            escreva("GOL!")
            contador = contador + 1
        }
    }
}

flowchart TD
    A((Início)) --> B[/Leia vezes/]
    B --> C[contador = 1]
    C --> D{contador <= vezes?}
    D -- Sim --> E[Escreva GOL!]
    E --> F[contador = contador + 1]
    F --> D
    D -- Não --> G((Fim))

Exemplo com vezes = 4:

Volta	`contador`	`vezes`	Condição (`contador <= vezes`)?	Saída
1ª	1	4	Sim	GOL!
2ª	2	4	Sim	GOL!
3ª	3	4	Sim	GOL!
4ª	4	4	Sim	GOL!
5ª	5	4	Não	(sai do laço)

Exercício 4: Jogadores entrando em campo

Complete o programa abaixo com a condição do enquanto.

programa {
    funcao inicio() {
        inteiro total
        inteiro jogador

        escreva("Quantos jogadores vão entrar em campo? ")
        leia(total)

        jogador = 1

        // Complete a condição: repete enquanto ainda há jogadores para entrar
        enquanto ( ) {
            escreva("Jogador " + jogador + " entrou em campo.")
            jogador = jogador + 1
        }
    }
}

flowchart TD
    A((Início)) --> B[/Leia total/]
    B --> C[jogador = 1]
    C --> D{jogador <= total?}
    D -- Sim --> E[Escreva Jogador N entrou em campo]
    E --> F[jogador = jogador + 1]
    F --> D
    D -- Não --> G((Fim))

Exemplo com total = 3:

Volta	`jogador`	`total`	Condição (`jogador <= total`)?	Saída
1ª	1	3	Sim	Jogador 1 entrou em campo.
2ª	2	3	Sim	Jogador 2 entrou em campo.
3ª	3	3	Sim	Jogador 3 entrou em campo.
4ª	4	3	Não	(sai do laço)

🥈 Nível Prata: Contando com `para` e lendo dados

Exercício 5: Chutes no treino

Complete o programa abaixo preenchendo a condição e a atualização do para.

programa {
    funcao inicio() {
        cadeia nome
        inteiro total_chutes

        escreva("Digite o nome do jogador: ")
        leia(nome)
        escreva("Quantos chutes ele vai treinar? ")
        leia(total_chutes)

        // Complete a condição (i <= ?) e a atualização (i?)
        para (inteiro i = 1; ; ) {
            escreva("Chute " + i + " de " + nome + " concluído.")
        }
    }
}

flowchart TD
    A((Início)) --> B[/Leia nome e total_chutes/]
    B --> C[i = 1]
    C --> D{i <= total_chutes?}
    D -- Sim --> E[Escreva Chute i de nome concluído]
    E --> F[i++]
    F --> D
    D -- Não --> G((Fim))

Exemplo com nome = "Ronaldo" e total_chutes = 3:

Volta	`i` (antes)	Condição (`i <= total_chutes`)?	Saída	`i` (depois de `i++`)
1ª	1	Sim	Chute 1 de Ronaldo concluído.	2
2ª	2	Sim	Chute 2 de Ronaldo concluído.	3
3ª	3	Sim	Chute 3 de Ronaldo concluído.	4
4ª	4	Não	(sai do laço)	—

Exercício 6: Chamada dos convocados

Complete o programa abaixo com a mensagem de confirmação de cada jogador.

programa {
    funcao inicio() {
        inteiro total
        cadeia nome

        escreva("Quantos jogadores serão convocados? ")
        leia(total)

        para (inteiro i = 1; i <= total; i++) {
            escreva("Nome do jogador " + i + ": ")
            leia(nome)
            // Complete a mensagem usando a variável nome
            escreva( )
        }
    }
}

flowchart TD
    A((Início)) --> B[/Leia total/]
    B --> C[i = 1]
    C --> D{i <= total?}
    D -- Sim --> E[/Leia nome/]
    E --> F[Escreva Jogador nome confirmado na seleção]
    F --> G[i++]
    G --> D
    D -- Não --> H((Fim))

Exemplo com total = 3 e nomes Vinicius, Rodrygo, Endrick:

Volta	`i`	`nome` lido	Saída
1ª	1	”Vinicius”	Jogador Vinicius está confirmado na seleção.
2ª	2	”Rodrygo”	Jogador Rodrygo está confirmado na seleção.
3ª	3	”Endrick”	Jogador Endrick está confirmado na seleção.
4ª	4	—	(sai do laço)

Exercício 7: Placar das rodadas

Complete o programa abaixo com a linha que acumula os gols a cada rodada.

programa {
    funcao inicio() {
        inteiro rodadas
        inteiro gols
        inteiro total_gols

        escreva("Quantas rodadas foram disputadas? ")
        leia(rodadas)

        total_gols = 0

        para (inteiro i = 1; i <= rodadas; i++) {
            escreva("Gols do Brasil na rodada " + i + ": ")
            leia(gols)
            // Complete a linha que soma gols ao total
            total_gols =
        }

        escreva("Total de gols do Brasil na fase: " + total_gols)
    }
}

flowchart TD
    A((Início)) --> B[/Leia rodadas/]
    B --> C[total_gols = 0, i = 1]
    C --> D{i <= rodadas?}
    D -- Sim --> E[/Leia gols/]
    E --> F[total_gols = total_gols + gols]
    F --> G[i++]
    G --> D
    D -- Não --> H[Escreva total de gols]
    H --> I((Fim))

Exemplo com rodadas = 3 e gols 2, 1, 3:

Volta	`i`	`gols` lido	`total_gols` antes	`total_gols` depois
1ª	1	2	0	2
2ª	2	1	2	3
3ª	3	3	3	6
Fim	—	—	—	6

Exercício 8: Média de passes por jogo

Complete o programa abaixo com a acumulação de passes e o cálculo da média.

programa {
    funcao inicio() {
        inteiro jogos
        inteiro passes
        inteiro total_passes
        inteiro media

        escreva("Quantos jogos foram analisados? ")
        leia(jogos)

        total_passes = 0

        para (inteiro i = 1; i <= jogos; i++) {
            escreva("Passes certos no jogo " + i + ": ")
            leia(passes)
            // Complete a linha que soma passes ao total
            total_passes =
        }

        // Complete o cálculo: divida o total pelo número de jogos
        media =
        escreva("Média de passes por jogo: " + media)
    }
}

flowchart TD
    A((Início)) --> B[/Leia jogos/]
    B --> C[total_passes = 0, i = 1]
    C --> D{i <= jogos?}
    D -- Sim --> E[/Leia passes/]
    E --> F[total_passes = total_passes + passes]
    F --> G[i++]
    G --> D
    D -- Não --> H[media = total_passes / jogos]
    H --> I[Escreva média de passes]
    I --> J((Fim))

Exemplo com jogos = 3 e passes 40, 55, 48:

Volta	`i`	`passes` lido	`total_passes` antes	`total_passes` depois
1ª	1	40	0	40
2ª	2	55	40	95
3ª	3	48	95	143
Fim	—	—	—	143

Cálculo final: media = 143 / 3 = 47 (divisão inteira)

🥇 Nível Ouro: Contadores variados com decisões dentro do laço

Exercício 9: Contagem regressiva com aviso

Complete o programa abaixo com a atualização decrescente (i--) e a condição do aviso do último minuto.

programa {
    funcao inicio() {
        inteiro minutos

        escreva("Quantos minutos faltam? ")
        leia(minutos)

        // O para começa em minutos e vai até 1
        // Complete a terceira parte: use i-- para decrementar
        para (inteiro i = minutos; i >= 1; ) {
            escreva("Faltam " + i + " minutos.")
            // Complete a condição: quando é o último minuto?
            se ( ) {
                escreva("ATENÇÃO: último minuto!")
            }
        }

        escreva("Apito final! Fim de jogo!")
    }
}

flowchart TD
    A((Início)) --> B[/Leia minutos/]
    B --> C[i = minutos]
    C --> D{i >= 1?}
    D -- Sim --> E[Escreva Faltam i minutos]
    E --> F{i == 1?}
    F -- Sim --> G[Escreva ATENÇÃO: último minuto!]
    F -- Não --> H[i--]
    G --> H
    H --> D
    D -- Não --> I[Escreva Apito final! Fim de jogo!]
    I --> J((Fim))

Exemplo com minutos = 3:

Volta	`i`	Condição (`i >= 1`)?	Saída	`i == 1`?	Aviso?
1ª	3	Sim	Faltam 3 minutos.	Não	—
2ª	2	Sim	Faltam 2 minutos.	Não	—
3ª	1	Sim	Faltam 1 minutos.	Sim	ATENÇÃO: último minuto!
4ª	0	Não	(sai do laço)	—	—

Depois do laço: Apito final! Fim de jogo!

Exercício 10: Disputa de pênaltis

Complete o programa abaixo com a condição que decide se a cobrança foi gol ou defendida.

programa {
    funcao inicio() {
        inteiro resultado
        inteiro total_gols

        total_gols = 0

        // O para vai de 5 até 1 (as 5 cobranças, de trás para frente)
        para (inteiro i = 5; i >= 1; i--) {
            escreva("Cobrança " + i + ":")
            escreva("Gol (1) ou defendido (0)? ")
            leia(resultado)
            // Complete a condição: quando resultado é 1, foi gol
            se ( ) {
                escreva("GOL!")
                total_gols = total_gols + 1
            } senao {
                escreva("Defendido!")
            }
        }

        escreva("Total de gols convertidos: " + total_gols)
    }
}

flowchart TD
    A((Início)) --> B[i = 5, total_gols = 0]
    B --> C{i >= 1?}
    C -- Sim --> D[Escreva Cobrança i]
    D --> E[/Leia resultado/]
    E --> F{resultado == 1?}
    F -- Sim --> G[Escreva GOL! Soma 1 ao total]
    F -- Não --> H[Escreva Defendido!]
    G --> I[i--]
    H --> I
    I --> C
    C -- Não --> J[Escreva total de gols convertidos]
    J --> K((Fim))

Exemplo com resultados 1, 0, 1, 1, 0:

Volta	`i`	`resultado`	`resultado == 1`?	Saída	`total_gols`
1ª	5	1	Sim	GOL!	1
2ª	4	0	Não	Defendido!	1
3ª	3	1	Sim	GOL!	2
4ª	2	1	Sim	GOL!	3
5ª	1	0	Não	Defendido!	3
6ª	0	—	(sai do laço)	—	3

Exercício 11: A torcida cresce a cada fase

Complete o programa abaixo com a linha que dobra a torcida e a condição do estádio lotado.

programa {
    funcao inicio() {
        inteiro torcedores
        inteiro atual

        escreva("Quantos torcedores no início? ")
        leia(torcedores)

        atual = torcedores

        // O para percorre as 4 fases eliminatórias
        para (inteiro i = 1; i <= 4; i++) {
            // Complete a linha que dobra o valor de atual
            atual =

            se (i == 1) {
                escreva("Oitavas de final: " + atual + " torcedores.")
            } senao se (i == 2) {
                escreva("Quartas de final: " + atual + " torcedores.")
            } senao se (i == 3) {
                escreva("Semifinal: " + atual + " torcedores.")
            } senao {
                escreva("Final: " + atual + " torcedores.")
            }

            // Complete a condição: mais de 50000 torcedores?
            se ( ) {
                escreva("O estádio está lotado!")
            }
        }
    }
}

flowchart TD
    A((Início)) --> B[/Leia torcedores/]
    B --> C[atual = torcedores, i = 1]
    C --> D{i <= 4?}
    D -- Sim --> E[atual = atual * 2]
    E --> F[Escreva nome da fase e atual torcedores]
    F --> G{atual > 50000?}
    G -- Sim --> H[Escreva O estádio está lotado!]
    G -- Não --> I[i++]
    H --> I
    I --> D
    D -- Não --> J((Fim))

Exemplo com torcedores = 5000:

Volta	`i`	`atual` antes	`atual = atual * 2`	Fase	`atual > 50000`?
1ª	1	5000	10000	Oitavas de final	Não
2ª	2	10000	20000	Quartas de final	Não
3ª	3	20000	40000	Semifinal	Não
4ª	4	40000	80000	Final	Sim → O estádio está lotado!

Exercício 12: Treino de velocidade em campo

Complete o programa abaixo com a linha que dobra a velocidade e a linha que para o laço.

Nesta versão, usamos uma variável logico chamada continuar para controlar quando o laço deve parar, tornando a condição de saída explícita e fácil de identificar.

programa {
    funcao inicio() {
        inteiro limite
        inteiro vel
        logico continuar

        escreva("Qual é a velocidade máxima do jogador? ")
        leia(limite)

        vel = 1
        continuar = verdadeiro

        enquanto (continuar) {
            escreva("Sessão em " + vel + " km/h.")
            se (vel >= limite) {
                escreva("Velocidade máxima atingida!")
                // Complete a linha para parar o laço
                continuar =
            } senao {
                // Complete a linha que dobra a velocidade
                vel =
            }
        }
    }
}

flowchart TD
    A((Início)) --> B[/Leia limite/]
    B --> C[vel = 1, continuar = verdadeiro]
    C --> D{continuar?}
    D -- Sim --> E[Escreva Sessão em vel km/h]
    E --> F{vel >= limite?}
    F -- Sim --> G[Escreva Velocidade máxima atingida!]
    G --> H[continuar = falso]
    F -- Não --> I[vel = vel * 2]
    H --> D
    I --> D
    D -- Não --> J((Fim))

Exemplo com limite = 10:

Volta	`vel`	`continuar`	Saída	`vel >= limite`?	Ação
1ª	1	verdadeiro	Sessão em 1 km/h.	Não	vel = 2
2ª	2	verdadeiro	Sessão em 2 km/h.	Não	vel = 4
3ª	4	verdadeiro	Sessão em 4 km/h.	Não	vel = 8
4ª	8	verdadeiro	Sessão em 8 km/h.	Não	vel = 16
5ª	16	verdadeiro	Sessão em 16 km/h. + Velocidade máxima atingida!	Sim	continuar = falso
6ª	—	falso	(sai do laço)	—	—