Avaliação Substitutiva e Resultados

O artigo 111 do Regulamento de Graduação da UFPA estabelece que "A Avaliação Substitutiva é uma oportunidade oferecida ao discente que não obteve conceito à aprovação na atividade curricular, mas com frequência mínima de setenta e cinco por cento". Com isso, observando os conceitos e frequências dos alunos da turma de Programação de 2º período de 2010, informo que os alunos da lista a seguir poderão solicitar tal Avaliação. A referida avaliação será realizada na próxima sexta-feira, após a entrega de resultados da última avaliação; e terá como conteúdo, todo o apresentado durante o período.

Lista de Alunos

AZAURI DOS SANTOS FIGUEIRA
BENNY ALVES DOS SANTOS
CAMILA LORENA DE SOUSA COSTA
DARLAN FERREIRA FERREIRA
GRACIELE CASTRO MEIRELES
KENNEDY WILDSON FIGUEIRA LAURIDO
NEIVA ROSANA GOMES DOS SANTOS
PAULA ANDREA VIANA FERNANDES
SAMUEL KEYTON PEREIRA
THIAGO LUIS DE MELO ANDRADE
WALMIR ALVES DOS SANTOS

Aproveito também para informar que:

• Os alunos que quiserem receber o resultado da última avaliação, assim como o seu conceito final, deverão comparecer em sala de aula nesta sexta, as 19:00 hs.
• De forma geral, avalio o rendimento geral da turma como satisfatório, já que foram 10 conceitos BOMs, 27 REGulares, 11 INSuficientes aptos para avaliação substitutiva, e apenas 5 INSuficientes já reprovados.
  

Algoritmo da Avaliação Final - 2010/2

A sequência de Fibonacci é caracterizada pelo seguinte:

• O primeiro numero é sempre 0.
• O segundo numero é sempre 1.
• Os próximos números são o resultado da soma de seus dois predecessores.
• Exemplo: 0, 1, 1, 2, 3, 5, 8, 13, ...

Faça um algoritmo para calcular os 30 primeiros números da sequência de Fibonacci. Ao final deste processo o algoritmo deverá exibir, na ordem inversa do seu cálculo, os números de Fibonacci que forem múltiplos de 17, assim como a média aritmética destes.

____________________________

Uma solução possível usando codificação para Visualg. Observa-se que existem várias soluções, usando, ou não, um vetor para a sequência; e a solução com o vetor foi usada apenas para demonstração de uso, já que na maioria dos casos é desnecessário. Para efeito de avaliação serão considerados os seguintes elementos:

• Laço de controle de processamento.
• Cálculo dos números de Fibonacci.
• Calculo dos múltiplos de 17 e da média destes.
• Exibição dos Resultados.
• Controles de saída dos dados.

var
...declare fibonacci[ 30 ], multi[ 30 ], i, n, t, soma, media: real
inicio
...n <- 0
...i <- 3
...fibonacci[ 1 ] <- 0
...fibonacci[ 2 ] <- 1
...enquanto i <= 30 faca
......fibonacci[ i ] <- fibonacci[ i - 1 ] + fibonacci[ i - 2 ]
......t <- fibonacci[ i ]
......se t mod 17 = 0 entao
.........n <- n + 1
.........multi[ n ] <- fibonacci[ i ]
.........soma <- soma + multi[ n ]
......fimse
......i <- i + 1
...fimenquanto
...se n > 0 entao
......i <- n
......enquanto i >= 1 faca
.........escreva multi[ i ]
.........i <- i - 1
......fimenquanto
......media <- soma / n
......escreva media
...senao
......escreva "Não existem múltiplos"
...fimse
fimalgoritmo

Próxima Avaliação de Programação

Atendendo algumas solicitações (inclusive as relacionadas ao jogo da seleção) e com o objetivo de dar um maior tempo para o estudo e desenvolvimento de exercícios de algoritmos, estou adiando a nossa próxima avaliação da disciplina de Programação, que seria realizada no dia 02/07, e agora está sendo marcada para o dia 09/07.

Mais Exercícios de Programação

1º - Dado um vetor de 10 posições do tipo literal faça uma algoritmo que permita que o usuário digite 10 letras, e que estas letras sejam colocadas nas respectivas posições dentro do vetor. O algoritmo no entanto não poderá permitir que seja digitada uma letra menor (ordem alfabética crescente) que a letra que foi digitadas anteriormente, ou seja a letra que será colocada na posição 2 deverá ser maior ou igual que a letra colocada na posição 1, a letra colocada na posição 3 deverá ser maior que a letra digitada para a posição 2, e assim sucessivamente até o final do vetor. A primeira letra poderá ser digitada livremente pelo usuário sendo que a regra acima somente se aplica as letras que forem colocadas da segunda posição em diante.

var
...i: inteiro
...declare letras[ 10 ]: literal
inicio
...leia letras[ 1 ]
...i <- 2
...enquanto i <= 10 faca
......leia letras[ i ]
......se letras[ i ] < letras[ i - 1 ] entao
.........escreva "Letra inválida: Menor que a anterior..."
.........i <- i - 1
......fimse
......i <- i + 1
...fimenquanto
fimalgoritmo

2º - Um número de CPF é formado por 9 dígitos, mas 2 dígitos verificadores que ficam no final. Estes dígitos verificadores são calculados de acordo com os outros 9 dígitos do CPF e servem para verificar a validade do CPF.

Apresentamos aqui uma forma simplificada para o calculo destes dígitos: Somar os produtos de cada um dos dígitos do CPF, pela sua respectiva posição, e pegar o resto da divisão inteira desta soma por 11. este resultado será o digito verificador 1. Para calcular o digito verificador 2 , repetir o processo, somente alterando a multiplicação dos dígitos pela sua posição, de forma que as posições fiquem invertidas.

Faça um algoritmo capaz de, uma vez informado os 9 dígitos de um CPF qualquer, informar os 2 dígitos verificadores deste CPF.

var
...i: inteiro
...declare dv1, dv2, cpf: inteiro
inicio
...dv1 <- 0
...dv2 <- 0
...i <- 1
...enquanto i < 10 faca
......leia cpf
......dv1 <- dv1 + i * cpf
......dv2 <- dv2 + ( 10 - i ) * cpf
......i <- i + 1
...fimenquanto
...dv1 <- dv1 mod 10
...dv2 <- dv2 mod 10
...escreva dv1
...escreva dv2
fimalgoritmo

Observações.

• Em 2 dias as respostas serão acrescentadas a esta postagem.
• Quaisquer dúvidas devem ser especificadas através de comentários a esta postagem, não sendo respondido nenhum questionamento via e-mail.
• O enunciado da 2ª questão especifica resto da divisão por 11, o que daria valores de 0 a 10, e cada dígito verificador deve ser de 0 a 9. Com isso, acho que houve um erro no enunciado, devendo o valor 11 ser substituído por 10.
  

Algoritmo da 2ª Avaliação - 2010/2

Um curso de Sistemas de Informação calcula o conceito dos alunos da turma de Programação da seguinte forma:

• Insuficiente: Aqueles com Médias inferiores a 5,0;
• Regular: Aqueles com Médias variando de 5,0 a 6,9;
• Bom: Aqueles com Médias variando de 7,0 a 8,9;
• Excelente: Aqueles com Médias entre 9,0 e 10,0; inclusive.

Um professor da disciplina avaliou sua turma em 3 momentos diferentes, aplicando provas com notas de 0 (zero) a 10,0. A média final do aluno é calculada através da média aritmética das 3 avaliações.

Observa-se ainda que, após 60 horas de aula, o aluno é considerado aprovado se sua frequência for maior que 75% e o seu conceito não for Insuficiente.

Faça um algoritmo que permita a digitação dos nomes, suas respectivas notas nas 3 avaliações e número de faltas; e que ao serem digitados os dados de cada aluno seja informado o conceito e a frequência do mesmo. Após a digitação dos dados do último aluno, o algoritmo deverá informar a quantidade de alunos reprovados, a quantidade de alunos com conceito Excelente, e a média geral da turma.

Como não foi especificado o número de alunos da turma, o algoritmo deverá solicitar dados enquanto o nome do aluno digitado seja diferente de "FIM".

__________________________________

Uma solução possível usando codificação para Visualg. Para efeito de avaliação serão considerados os seguintes elementos:

• Laço de controle de leituras e processamento.
• Leitura de dados dos alunos.
• Calculo das médias e frequência.
• Calculo dos conceitos, número de alunos reprovados e com conceito excelente.
• Controle da saída dos dados pós leituras.

var
...nome: literal
...nota1, nota2, nota3: real
...faltas, nrAlunos, nrReprovados, nrExcelentes: inteiro
...media, frequencia, mediaGeral: real
inicio
...mediaGeral <- 0
...nrAlunos <- 0
...nrReprovados <- 0
...nrExcelentes <- 0
...leia nome
...enquanto nome <> "fim" faca
......leia nota1
......leia nota2
......leia nota3
......leia faltas
......media <- ( nota1 + nota2 + nota3 ) / 3
......frequencia <- ( 60 - faltas ) / 60 * 100
......mediaGeral <- mediaGeral + media
......nrAlunos <- nrAlunos + 1
......se media < 5 entao
.........escreva "Reprovado"
......nrReprovados <- nrReprovados + 1
......senao
.........se frequencia > 75 entao
............se media < 7 entao
...............escreva "Regular"
............senao
...............se media < 9 entao
..................escreva "Bom"
...............senao
..................escreva "Excelente"
...............fimse
............fimse
.........senao
............escreva "Reprovado por Falta"
.........fimse
.........se media >= 9 entao
............nrExcelentes <- nrExcelentes + 1
.........fimse
......fimse
......leia nome
...fimenquanto
...se nrAlunos <> 0 entao
......escreva "Media Geral: ", mediaGeral / nrAlunos
......escreva "Nr de Reprovados: ", nrReprovados
......escreva "Nr de Excelentes: ", nrExcelentes
...senao
......escreva "Inserir Pelo Menos os Dados de 1 Aluno"
...fimse
fimalgoritmo

Exercícios de Programação

Com o objetivo de melhor preparar os alunos para a próxima avaliação, são listados os exercícios a seguir.

• Em 2 dias as respostas serão acrescentadas a esta postagem e novos exercícios serão postados.
• Quaisquer dúvidas devem ser especificadas através de comentários a esta postagem, não sendo respondido nenhum questionamento via e-mail.

1º - Desenvolver um algoritmo capaz de calcular a media aritmética simples de uma série de números, sendo que:

• O usuário deve informar a quantidade de números da série.
• Se a quantidade for zero ou negativa o algoritmo não deve aceita-la.
• O usuário deve informar um por um todos os números da série.
• O algoritmo deve mostrar como resultado a media aritmética simples calculada através da formula:

MEDIA = ( X + X1 + X2 + ... XN ) / N

var
...soma, n, v, qtde: inteiro
...media: real
inicio
...n <- 0
...soma <- 0
...leia qtde
...se qtde > 0 entao
......enquanto n < qtde
.........leia( v )
.........soma <- soma + v
.........n <- n + 1
......fimenquanto
......media <- soma / n
......escreva "Média = ", media
...senao
......escreva "Quantidade Inválida"
...fimse
fimalgoritmo

2º - Dado um vetor de 10 posições do tipo inteiro, que deverá ser preenchido pelo usuário, faça um algoritmo capaz de percorrer todo o vetor dobrando todos os numero que forem ímpares e dividindo pela metade todos os numero que forem pares colocando o resultado das operações nas mesmas posições dentro do vetor.

var
...i: inteiro
...declare t, vet[ 10 ]: inteiro
inicio
...para i de 1 ate 10 faca
......leia vet[ i ]
...fimpara
...para i de 1 ate 10 faca
......t <- vet[ i ]
......se t mod 2 = 0 entao
.........vet[ i ] <- vet[ i ] / 2
......senao
.........vet[ i ] <- vet[ i ] * 2
......fimse
...fimpara
fimalgoritmo

Exercício de Programação - Resposta

Ao tentar resolver o exercício proposto observei que o enunciado parecia um pouco confuso quanto ao cálculo do salário, podendo levar a interpretações diferentes para o problema em questão. Dito isto, o algoritmo a seguir tem a minha interpretação quanto ao especificado.

Para o melhor entendimento da solução, esta será apresentada através das fases do seu desenvolvimento. Aconselho que usem esta metodologia na prova.

Fase 1 - Laço geral de controle e leitura de dados dos funcionários.

var
...nrFunc, qtde: inteiro
...nome: literal
inicio
...nrFunc <- 1
...enquanto nrFunc <= 10 faca
......leia "Nome de Funcionário: ", nome
......leia "Quantidade de peças no mês", qtde
......nrFunc <- nrFunc + 1
...fimenquanto
fimalgoritmo

Fase 2 - Classificação e contagem dos integrantes for classe.

var
...nrFunc, qtde: inteiro
...nome: literal
...nrClasA, nrClasB, nrClasC: inteiro
inicio
...nrFunc <- 1
...enquanto nrFunc <= 10 faca
......leia "Nome de Funcionário: ", nome
......leia "Quantidade de peças no mês", qtde
......se qtde <= 100 entao
.........nrClasA <- nrClasA + 1
......senao
.........se qtde <= 200 entao
............nrClasB <- nrClasB + 1
.........senao
............nrClasC <- nrClasC + 1
.........fimse
......fimse
......nrFunc <- nrFunc + 1
...fimenquanto
fimalgoritmo

Fase 3 - Calculo da produção (fase 3.1) e do salário total (fase 3.2).

var
...nrFunc, qtde: inteiro
...nome: literal
...nrClasA, nrClasB, nrClasC: inteiro
...producao: inteiro
...salario, salTot: real
inicio
...producao <- 0
...nrFunc <- 1
...enquanto nrFunc <= 10 faca
......leia "Nome de Funcionário: ", nome
......leia "Quantidade de peças no mês", qtde
......producao <- producao + qtde
......salario <- 450
......se qtde <= 100 entao
.........nrClasA <- nrClasA + 1
......senao
.........se qtde <= 200 entao
............nrClasB <- nrClasB + 1
............salario <- salario + 0.10 * ( qtde - 100 )
.........senao
............nrClasC <- nrClasC + 1
............salario <- salario + 0.15 * 100
............salario <- salario + 0.20 * ( qtde - 200 )
.........fimse
......fimse
......salTot <- salTot + salario
......nrFunc <- nrFunc + 1
...fimenquanto
...escreva "Funcionários Classe A: ", nrClasA
...escreva "Funcionários Classe B: ", nrClasB
...escreva "Funcionários Classe C: ", nrClasC
...escreva "Produção Total: ", producao, " peças."
...escreva "Salário Total: R$", salTot
fimalgoritmo