Algoritmo — concurso público.

Morgtuns · 20 de abril de 2017

"Em um concurso público inscreveram-se 5000 candidatos para 100 vagas. Cada candidato fez três provas, tendo cada uma pesos 2,3 e 5 respectivamente, na ordem em que foram feitas. Fazer um algoritmo que leia nome, matrícula e os pontos obtidos pelos candidatos em cada prova; apresentar a classificação, a matrícula e o nome dos candidatos aprovados, ordenados pela classificação. "

Olá! Gente, estou com um problema nesse algoritmo em que não consigo ler todas as maiores notas para que o programa defina como as melhores notas dos candidatos. Por exemplo, tendo como exemplo as respectivas notas de 5 candidatos (que é o número que mínimo de candidatos que usei no algoritmo para testar):

• Notas: 50, 40, 78, 70, 60 .

Num suposto concurso onde há apenas 3 vagas, os aprovados seriam os que tem notas iguais a: 78, 70 e 60 respectivamente. O meu programa só está lendo a primeira e a segunda nota.

Como eu poderia consertar isso? fazendo com que o programa leia as melhores notas normalmente, respeitando os limites de vagas, etc?

Obg

DiF · 20 de abril de 2017

Caro usuário,

Seja bem-vindo ao Fórum do Clube do Hardware.

No intuito de servir como fonte de pesquisa no caso de instituições de ensino, informamos que incorrer no resolvimento por completo de questões relacionadas a disciplinas escolares de cursos técnicos e faculdades podem ser revistas e removidas pela Equipe de Moderação do Clube do Hardware.

Para sanar dúvidas sobre esse tipo de problema, por gentileza, publique o passo a passo do desenvolvimento da questão, projeto, monografia ou conteúdo em dúvida para que possamos analisar se a resposta está correta ou não, ou para que possa ser auxiliado com a dúvida no desenvolvimento do exercício.

Infelizmente, não há como resolver os trabalhos pelos usuários. O objetivo do Fórum do Clube do Hardware é auxiliar seus usuários a encontrar soluções para que possam sanar suas dúvidas, e não de trazer soluções prontas para seus usuários.. Além disso, copiar e colar respostas que não são de autoria própria do qualquer usuário é considerado plágio, o que é ilegal.

Esperamos que compreenda.

Atenciosamente,

Equipe Clube do Hardware

Morgtuns · 20 de abril de 2017

Então.. meu código está assim no momento:

var
    nome: Vetor[1..5] de Caractere
    mat: Vetor[1..5] de Inteiro
    pontos, maiorp: Vetor[1..5] de Real
    i, vagas, class,c: Inteiro
    n1, n2, n3 : Real
    maiorp1, menorp: Real
inicio
vagas <- 3
     Para i de 1 ate 5 faca
      Escreva("Nome: ")
      leia(nome[i])
      Escreva("Matrícula: ")
      leia(mat[i])
      Escreva("NOTA 01: ")
      leia(n1)
      Escreva("NOTA 02: ")
      leia(n2)
      Escreva("NOTA 03: ")
      leia(n3)
      pontos[i] <- (n1*2) + (n2*3) + (n3*5)
       Se (i = 1) então
        maiorp1 <- pontos[i]
        menorp <- pontos[i]
       FimSe
        Se (pontos[i] >= maiorp1) então
         class <- class + 1
         maiorp[class] <- pontos[i]
        FimSe
     FimPara
     
     Para i de 1 ate 5 faca
      Escreva(pontos[i])
     FimPara

     Escreval("")
     Para i de 1 ate vagas faca
      Para c de i +1 ate class faca
       Se (maiorp[i] > maiorp[c]) então
        Escreva(maiorp[i])
       FimSe
      FimPara
     FimPara   
fimalgoritmo

Morgtuns · 21 de abril de 2017

Bom, dei uma repensada aqui e acabei dando uma melhorada no programa. Porém, eu ainda não consegui ordenar por ordem de maior nota os candidatos aprovados:

var
    nome: Vetor[1..5] de Caractere
    mat: Vetor[1..5] de Inteiro
    pontos, maiorp: Vetor[1..5] de Real
    i, vagas, class,c: Inteiro
    n1, n2, n3 : Real
    aux: Real
    auxc: Caractere
inicio
vagas <- 4
     Para i de 1 ate 5 faca
      Escreva("Nome: ")
      leia(nome[i])
      Escreva("Matrícula: ")
      leia(mat[i])
      Escreva("NOTA 01: ")
      leia(n1)
      Escreva("NOTA 02: ")
      leia(n2)
      Escreva("NOTA 03: ")
      leia(n3)
      pontos[i] <- (n1*2) + (n2*3) + (n3*5)
     FimPara
     
     Escreval("")
     Para i de 1 ate 3 faca
      Para c de 2 ate 5 faca
       Se (pontos[i] < pontos[c]) então
        aux <- pontos[i]
        pontos[i] <- pontos[c]
        pontos[c] <- aux
        auxc <- nome[i]
        nome[i] <- nome[c]
        nome[c] <- auxc
       FimSe
      FimPara
     FimPara
     
     Para i de 1 ate vagas faca
      escreval(nome[i], "", pontos[i])
     FimPara

devair1010 · 21 de abril de 2017

@Morgtuns seu código está quase certo, ali no par de loop i e c um dentro do

outro, é quase isso mesmo mas será melhor se você colocar o loop i para ir de 1 ate

vagas-1, e o segundo loop para c ir de i+1 ate vagas, e pegue o valor dos vetores

pontos e nome e mat na posição i, antes de entrar no loop c aí depois dentro do

loop c veja se pontos na posição i é maior que pontos na posição c, se for então

trocar eles de lugar, coloca em pontos i o que está em pontos c, e faça o mesmo

com os vetores mat e nome. aí escrever na tela o nome do candidato, sua matricula,

e a classificação

Morgtuns · 21 de abril de 2017

@devair1010 Obrigado! :DD

Simon Viegas · 24 de abril de 2017

Olá.

Como já está resolvido, dei uma ajustada para demonstrar o uso do método "Bubble Sort". É bem parecido com o método de ordenação utilizando no seu código, mas ajustada para as características específicas do Bubble Sort. (no seu código, ele vai atualizando da posição atual em posição atual, ou seja, primeiro a atualiza a posição 1 com o maior valor, depois atualiza a posição 2 com o maior valor que sobrou, depois a 3... etc.... já no Bubble Sort, o menor valor vai para o fim do vetor, ou seja, a última posição, que eu chamei de "posicaoCHAVE" vai fica com o menor valor do vetor. No próximo loop, a posição chave passa a ser a penúltima, que ficará com o menor valor do que sobrou, por ai vai... "Essa movimentação lembra a forma como as bolhas em um tanque de água procuram seu próprio nível, e disso vem o nome do algoritmo", ou seja, "as posições mais leves vão subindo para o fim do vetor... no final o vetor ficar em ordem decrescente). obs.: se for usar "crescente", bastaria usar a mesma lógica, só que usando uma comparação de "maiores para o fim".

Aproveitei e tentei dar uma reorganizada para demonstrar outros conceitos... que podem ser úteis também para outros usuários, vejam:

algoritmo "Concurso Publico"
var
   //DADOS DOS CANDIDATOS
   nomes  :Vetor[1..5] de Caractere
   mat    :Vetor[1..5] de Inteiro
   pontos :Vetor[1..5] de Real
   n1,n2,n3 :Real
   
   //DADOS DO CONCURSO
   vagas  :Inteiro

   //VARIÁVEIS AUXILIARES
   auxC    :Caractere //usado para trocas de posições do tipo caractere
   auxR    :Real      //usado para trocas de posições do tipo real
   auxI    :Inteiro   //usado para trocas de posições do tipo inteiro
   i       :Inteiro   //usado para controlar os para
   trocado :logico    //flag utilizada no métdo de ordenação Bubble Sort
   posicaoCHAVE :Inteiro //posicao do vetor ainda não ordenada

INICIO
vagas <- 4 //inicializa o número vagas disponíveis

//LER OS DADOS DOS CANDIDATOS
aleatorio on {HABILITA a geração de número aleatórios (PARA FACILITAR OS TESTES)}
para i de 1 ate 5 faca
   escreva("Nome: ")
   leia(nomes[i])
   escreva("Matrícula: ")
   leia(mat[i])
   escreva("NOTA 01: ")
   leia(n1)
   escreva("NOTA 02: ")
   leia(n2)
   escreva("NOTA 03: ")
   leia(n3)
   escreval("")
   pontos[i] <- (n1*2) + (n2*3) + (n3*5) //calcula o número de pontos
fimPara
aleatorio off {DESATIVA a geração de número aleatórios (PARA FACILITAR OS TESTES)}
escreval("")

//ORDENANDO OS VETORES POR "MAIOR PONTOS" (pelo método de ordenação Bubble Sort)
repita
   trocado <- falso //inicializa como "não houve troca"
   posicaoCHAVE <- 5 //inicializa a "posicao a ser ordenada"
   para i de 2 ate posicaoCHAVE faca //para cada posição (da segunda em diante)
      se (pontos[i-1] < pontos[i]) então //se posição anterior é menor que a atual
         //troca de posições os nomes
         auxC       <- nomes[i-1]
         nomes[i-1] <- nomes[i]
         nomes[i]   <- auxC
         //troca de posições as matriculas
         auxI     <- mat[i-1]
         mat[i-1] <- mat[i]
         mat[i]   <- auxI
         //troca de posições os pontos
         auxR        <- pontos[i-1]
         pontos[i-1] <- pontos[i]
         pontos[i]   <- auxR

         trocado <- verdadeiro //atualiza a flag para "houve troca"
      fimse
   posicaoCHAVE <- posicaoCHAVE-1
   fimpara
ate nao trocado //ate não haver mais trocas

escreval("")
para i de 1 ate vagas faca
   escreval("NOMES: ",nomes[i]:6,"  MATRICULA: ",mat[i]:5,"  PONTOS: ",pontos[i]:4:0)
fimPara
leia(auxC)
fimAlgoritmo

Uma maneira bem interessante de estudar o funcionamento dos métodos de ordenação é ir pressionando F8 e ver linha a linha no lado esquerdo do VisuAlgo, e ao mesmo tempo ir analisando a "Área de variáveis de memória" que fica no lado direito do VisuAlg.

Abraços

adicionado 3 minutos depois

ADENDO:
Fiz essa tentativa de demonstração utilizando um "método de ordenação formal", ou seja, de um conceito já existente e especificado (reutilização de conceitos). O método utilizado no seu código também é famoso, mas eu não consegui identificar o nome dele. Quem souber por favor avisa.