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")
}
}
}
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))
}
}
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")
}
}
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
(índice final da somatória). - Saída: imprime o valor da somatória acumulada arredondada com 4 casas.
- Código dado: inicia com
e acumula em a cada iteração o termo enquanto . Há uma checagem que repete a leitura se .
Programa 2:
- Entrada: quatro notas (o código fixa
como número de alunos). - Saída: imprime a média das notas, o número de aprovados (condição nota
) e o número de reprovados. - Código dado: usa
até para ler as notas; incrementa contador quando aluno aprovado; acumula soma e depois calcula média como .
Programa 3:
- Entrada: três números inteiros
, , . - 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)
Explicando essa expressão: para cada inteiro
começando em
até
, você adiciona o número
à variável acumuladora
. Um exemplo explícito: se
os termos somados são
.
Passo 3
Programa 1 — como o laço funciona e por que a checagem de validade existe.
O código inicializa
. Em pseudocódigo:
- Pergunta o
. - Enquanto
(ou seja, enquanto ) repete a leitura de . Isso garante que o usuário não entre com um menor que . - Depois usa um laço do tipo “enquanto” (while) com condição
. A cada iteração: - calcula o termo
e soma em , - incrementa
(ou seja ).
- calcula o termo
Conceito importante: acumulação. Temos uma variável que começa em
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
em linguagem que trate
e
como inteiros, pode ocorrer divisão inteira (resultado truncado). Portanto:
- Garanta que pelo menos um dos lados seja real (ex.:
ou converter para real).
No pseudocódigo enviado parece queé 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
:
- Iteração
: termo . . - Iteração
: termo . . - Iteração
: termo . .
Depois o programa arredonda para 4 casas decimais e imprime.
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
. Está OK, mas seria bom também verificar se não é excessivamente grande (dependendo da questão). - Guardar a fórmula: às vezes a prova pede pensar em aproveitar relações. Por exemplo,
— é 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
notas e retornar:
- média das
notas, - número de aprovados (nota
), - número de reprovados.
Variáveis:
-
usado como índice de leitura (vai de a ), -
contador de aprovados, -
acumulador das notas (tipo real), -
é calculado depois por .
Passo 8
Programa 2 — funcionamento do laço e condição de aprovação.
Laço:
- Começa
. - Enquanto
(ou seja, 4 iterações) faz: - pede a nota do aluno
, - se
incrementa , - soma a nota em
, - incrementa
.
Depois calcula.
- pede a nota do aluno
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:
.
- Iterações:
- i=0: soma
; (aprovado). - i=1: soma
; (5 é reprovado). - i=2: soma
; (6 é aprovado). - i=3: soma
; (8 é aprovado).
- i=0: soma
- Média:
. - Reprovados:
.
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.:
a ). Se uma nota inválida entrar, a média e a contagem ficam erradas. - Tipo: garanta que
e são reais; dividir por (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
,
,
é o maior. O código usa condicionais aninhados com comparações
(estritamente maior).
Estrutura lógica resumida:
- Se
então: - se
então imprime - senao se
imprime - senao imprime
- se
- Senao se
imprime - Senao imprime
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
), veja alguns casos:
- Todos iguais,
. Então é falso, é falso, cai no último “senao” e imprime . Isso é aceitável (imprime um dos iguais) mas não deixa explícito que houve empate. - Dois iguais e maiores, por exemplo
. Aqui é falso (porque ), entra no ramo que é verdadeiro e imprime (valor correto). - Dois iguais e menores, por exemplo
. Aqui é falso, é falso, imprime (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
com o máximo atual:
- Inicialize
. - Se
então . - Se
então . - No fim, imprima
.
Explicação didática: você começa assumindo que
é o maior. Depois verifica se
é maior que o atual maior; se for, atualiza; e faz o mesmo para
. 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
. Ex.: para
o resultado é
(arredondado 4 casas). Validação de
está presente; garanta divisão real na expressão.
Programa 2: lê
notas, calcula
, conta aprovados (
) e reprovados (
aprovados). Ex.: notas
→ média
, aprovados
, reprovados
. Sugestão: validar intervalo das notas e arredondar saída se preciso.
Programa 3: imprime o maior entre
usando condicionais aninhadas (funciona mas pode escolher arbitrariamente uma variável em caso de empate). Sugestão preferida: usar variável
; se
então
; se
então
; imprimir
.