programa {
inclua biblioteca Matematica --> m
funcao inicio() {
real somatoria = 0
inteiro i=1, n
escreva("Qual o indice final da somatória? “)
leia(n)
faca{
escreva(”\nInvalido. Digite um indice valido: “)
leia (n)
}enquanto (n<i)
enquanto(i<=n){
somatoria = somatoria + (1/(i+1))
i++
} escreva(”\nO resultado é: ", m.arredondar(somatoria, 4))
}
}
programa {
funcao inicio() {
inteiro i=0, j=4, a=0, r=0
real nota=0, media = 0, soma=0
enquanto(i<j){
escreva(“Insira a nota do aluno “, i+1, “: “)
leia(nota)
se(nota>=6){
a++
}
soma = soma + nota
i++
}
media = soma/j
r = j - a
escreva(”\nA média das notas é: “, media)
escreva(”\n”, a, " alunos foram aprovados”)
escreva(”\n", r, " alunos foram reprovados")
}
}
programa {
funcao inicio() {
inteiro a, b, c
escreva(“Entre com os números: “)
leia(a, b, c)
escreva(”\n”)
se(a>b){
se(b>c){
escreva(a, " é o maior")
}senao se (a>c){
escreva(a, " é o maior")
}senao {
escreva(c, " é o maior")
}
}senao se (b>c){
escreva(b, " é o maior")
}senao {
escreva(c, " é o maior")
}
}
}

Passo 1

Temos três trechos de programa (três programas separados). Vou listar claramente o que cada um pede e que informações o enunciado fornece para cada um, sem ainda resolver nada.
Programa 1:
  • Entrada: o usuário informa um inteiro n (índice final da somatória).
  • Saída: imprime o valor da somatória acumulada arredondada com 4 casas.
  • Código dado: inicia com i=1 e acumula em \text{somatoria} a cada iteração o termo 1/(i+1) enquanto i\le n. Há uma checagem que repete a leitura se n<i.
Programa 2:
  • Entrada: quatro notas (o código fixa j=4 como número de alunos).
  • Saída: imprime a média das notas, o número de aprovados (condição nota \ge 6) e o número de reprovados.
  • Código dado: usa i=0 até i<j para ler as j notas; incrementa contador a quando aluno aprovado; acumula soma e depois calcula média como \text{soma}/j.
Programa 3:
  • Entrada: três números inteiros a, b, c.
  • Saída: imprime qual é o maior entre os três.
  • Código dado: usa estruturas condicionais aninhadas com comparações estritas > para determinar o maior e imprimir a variável correspondente.
Agora que sabemos exatamente o que cada programa recebe e o que deve produzir, começo a explicar passo a passo o funcionamento de cada um, ensinar os conceitos necessários (laços, condicionais, acumulação, arredondamento, tratamento de empates) e apontar possíveis melhorias ou problemas práticos que você precisa conhecer para a prova.

Passo 2

Programa 1 — objetivo e expressão matemática do que está sendo calculado.
O programa calcula a soma (somatória)
\sum_{i=1}^{n}\frac{1}{i+1}.
Explicando essa expressão: para cada inteiro i começando em 1 até n, você adiciona o número \frac{1}{i+1} à variável acumuladora \text{somatoria}. Um exemplo explícito: se n=3 os termos somados são \frac{1}{2}, \frac{1}{3}, \frac{1}{4}.

Passo 3

Programa 1 — como o laço funciona e por que a checagem de validade existe.
O código inicializa i=1. Em pseudocódigo:
  • Pergunta o n.
  • Enquanto n<i (ou seja, enquanto n<1) repete a leitura de n. Isso garante que o usuário não entre com um n menor que 1.
  • Depois usa um laço do tipo “enquanto” (while) com condição i\le n. A cada iteração:
    • calcula o termo \frac{1}{i+1} e soma em \text{somatoria},
    • incrementa i (ou seja i \leftarrow i+1).
Conceito importante: acumulação. Temos uma variável que começa em 0 e, a cada passo, somamos um valor novo. Isso é a base para somatórias em programação.

Passo 4

Programa 1 — atenção com tipos e divisão.
Dica para a prova: sempre garanta que a divisão seja feita em ponto flutuante (real). Se você escrever algo como 1/(i+1) em linguagem que trate 1 e i como inteiros, pode ocorrer divisão inteira (resultado truncado). Portanto:
  • Garanta que pelo menos um dos lados seja real (ex.: 1.0/(i+1) ou converter i para real).
    No pseudocódigo enviado parece que \text{somatoria} é real, então a soma aceitará reais; só confirme que a expressão de divisão é real.

Passo 5

Programa 1 — cálculo numérico de exemplo passo a passo.
Pegando n=3:
  • Iteração i=1: termo =\dfrac{1}{1+1}=\dfrac{1}{2}=0{,}5. \text{somatoria}=0{,}5.
  • Iteração i=2: termo =\dfrac{1}{2+1}=\dfrac{1}{3}\approx0{,}3333. \text{somatoria}\approx0{,}8333.
  • Iteração i=3: termo =\dfrac{1}{3+1}=\dfrac{1}{4}=0{,}25. \text{somatoria}\approx1{,}0833.
    Depois o programa arredonda para 4 casas decimais e imprime 1{,}0833.

Passo 6

Programa 1 — sugestões de melhoria e armadilhas na prova.
Melhorias/observações que costumam cair em prova:
  • Validação: a estrutura de repetições usada garante n\ge1. Está OK, mas seria bom também verificar se n não é excessivamente grande (dependendo da questão).
  • Guardar a fórmula: às vezes a prova pede pensar em aproveitar relações. Por exemplo, \sum_{i=1}^n \dfrac{1}{i+1} = \left(\sum_{k=2}^{n+1} \dfrac{1}{k}\right) — é só uma reindexação. Mas normalmente em programação você implementa o laço direto.
  • Use arredondamento apenas na saída; internamente trabalhe com máximo de precisão para evitar acúmulo de erros.

Passo 7

Programa 2 — objetivo e variáveis usadas.
O objetivo é ler j=4 notas e retornar:
  • média das j notas,
  • número de aprovados (nota \ge 6),
  • número de reprovados.
Variáveis:
  • i usado como índice de leitura (vai de 0 a j-1),
  • a contador de aprovados,
  • \text{soma} acumulador das notas (tipo real),
  • r é calculado depois por r=j-a.

Passo 8

Programa 2 — funcionamento do laço e condição de aprovação.
Laço:
  • Começa i=0.
  • Enquanto i<j (ou seja, 4 iterações) faz:
    • pede a nota do aluno i+1,
    • se \text{nota}\ge6 incrementa a,
    • soma a nota em \text{soma},
    • incrementa i.
      Depois calcula \text{media}=\dfrac{\text{soma}}{j}.
Conceito explicado: contador de ocorrências (aqui aprovados) é uma técnica padrão: inicializa em zero e incrementa quando a condição é verdadeira. Para média, soma total dividido pela quantidade de elementos.

Passo 9

Programa 2 — exemplo numérico passo a passo.
Exemplo de 4 notas: 7{,}0,\\\ 5{,}0,\\\ 6{,}0,\\\ 8{,}0.
  • Iterações:
    • i=0: soma =7; a=1 (aprovado).
    • i=1: soma =12; a=1 (5 é reprovado).
    • i=2: soma =18; a=2 (6 é aprovado).
    • i=3: soma =26; a=3 (8 é aprovado).
  • Média: \text{media}=\dfrac{26}{4}=6{,}5.
  • Reprovados: r=4-3=1.
    O programa imprime esses valores.

Passo 10

Programa 2 — cuidados e melhorias para a prova.
Pontos importantes:
  • Validação das notas: idealmente verifique se a nota está num intervalo válido (ex.: 0 a 10). Se uma nota inválida entrar, a média e a contagem ficam erradas.
  • Tipo: garanta que \text{soma} e \text{nota} são reais; dividir por j (inteiro) resulta em real se a linguagem fizer coerção correta, mas é bom converter explicitamente.
  • Arredondamento: se precisarem de resultado com 2 casas, arredonde a média na impressão.
  • Alternativa mais clara: usar um laço “para” (for) para controlar iterações quando o número de entradas é fixo.

Passo 11

Programa 3 — objetivo e leitura do algoritmo dado.
O programa quer imprimir qual dos três inteiros a, b, c é o maior. O código usa condicionais aninhados com comparações > (estritamente maior).
Estrutura lógica resumida:
  • Se a>b então:
    • se b>c então imprime a
    • senao se a>c imprime a
    • senao imprime c
  • Senao se b>c imprime b
  • Senao imprime c

Passo 12

Programa 3 — análise de casos, empates e comportamento.
Temos que analisar o comportamento quando há empates (iguais). Como o código usa apenas > (e não \ge), veja alguns casos:
  • Todos iguais, a=b=c. Então a>b é falso, b>c é falso, cai no último “senao” e imprime c. Isso é aceitável (imprime um dos iguais) mas não deixa explícito que houve empate.
  • Dois iguais e maiores, por exemplo a=b>c. Aqui a>b é falso (porque a=b), entra no ramo b>c que é verdadeiro e imprime b (valor correto).
  • Dois iguais e menores, por exemplo a=b<c. Aqui a>b é falso, b>c é falso, imprime c (correto).
    Conclusão: o algoritmo imprimirá um valor que seja realmente um valor máximo, mas pode escolher arbitrariamente uma das variáveis quando há empate — isso normalmente não é problema, a menos que a questão exija dizer explicitamente “empate”.

Passo 13

Programa 3 — versão alternativa mais simples e robusta (estratégia a preferir na prova).
Uma estratégia mais direta e fácil de justificar é manter uma variável m com o máximo atual:
  • Inicialize m=a.
  • Se b>m então m\leftarrow b.
  • Se c>m então m\leftarrow c.
  • No fim, imprima m.
Explicação didática: você começa assumindo que a é o maior. Depois verifica se b é maior que o atual maior; se for, atualiza; e faz o mesmo para c. Essa técnica se estende facilmente a listas com mais elementos (é o padrão para encontrar máximo).

Passo 14

Dicas finais de prova e comportamento dos três programas (motivação e checklist rápido).
  • Sempre leia os tipos das variáveis: inteiro vs real. Para somas com divisão, preferir real.
  • Valide entradas quando for razoável (ex.: índices, notas).
  • Para contagens e médias: use acumuladores e contadores padrão.
  • Para máximo: a técnica do “máximo atual” é a que eu usaria na prova (clara e fácil de provar por indução).
  • Teste mentalmente com casos pequenos e com casos de fronteira (valores mínimos, máximos e empates).
    Você está indo bem por pedir para ver passo a passo — continua assim, que com prática isso fica natural. Força aí, falta pouco!

Resposta

Programa 1: calcula \displaystyle\sum_{i=1}^{n}\frac{1}{i+1}. Ex.: para n=3 o resultado é 1{,}0833 (arredondado 4 casas). Validação de n\ge1 está presente; garanta divisão real na expressão.
Programa 2: lê 4 notas, calcula \text{média}=\dfrac{\text{soma}}{4}é, conta aprovados ( \text{nota}\ge6) e reprovados ( 4-aprovados). Ex.: notas 7,5,6,8 → média 6{,}5, aprovados 3, reprovados 1. Sugestão: validar intervalo das notas e arredondar saída se preciso.
Programa 3: imprime o maior entre a,b,c usando condicionais aninhadas (funciona mas pode escolher arbitrariamente uma variável em caso de empate). Sugestão preferida: usar variável m=a; se b>m então m=b; se c>m então m=c; imprimir m.

Exercícios relacionados