Ir ao conteúdo
  • Cadastre-se
danilocc7

Portugol Struct em pseudo codigo

Posts recomendados

boa noite, 

 

estou tentando fazer um programa em pseudo, porém estou bastante perdido. qualquer ajuda será bem-vinda.

 

segue:

 

algoritmo struct reg_alunos

inicio

literal sair = s

const alunos = 5



tipo

reg_aluno = registro

literal: nome[30];

inteiro: serie;

real: freq;

real: nota[2];

real: media;

fim_registro;



procedimento mostrar_dados(var reg_livro: aluno[alunos])

int i;

para i de 1 ate alunos faca

    escrever(“nome:”, aluno.nome);

    escrever(“serie:”, aluno.serie);

    escrever(“frequencia:”,aluno.freq);

    escrever(“notas:”,aluno.nota[1],aluno.nota[2].

fim_para

fim

 

procedimento menu_escolhas()

inteiro opcao = 0;

("controle de alunos\n");

    escrever("-----------------/-------------------");

    escrever("1 - cadastro");

    escrever("2 - consulta");

    escrever("3 - maior e menor media");

    escrever("4 - maior e menor frequencia");

    escrever("5 - alunos acima da media");

    escrever("6 - sair");

    escrever("escolha uma opcao");

 

leia opcao;

escolha(opcao)

repita

enquanto (opcao  != 6);

 

caso 1:

inteiro: i;

literal: aluno;

 escrever(“cadastro de alunos”);

registro_aluno(aluno)              

escrever(“deseja continuar (s/n)”)

leia (sair);

caso 2:

escrever( consulta aluno”);

consulta(aluno, i)

escrever(“deseja continuar (s/n)”)

leia (sair);

 

caso 3:

escrever(“media dos alunos”)

real: m,med,maior;

inteiro:i;

escrever (“a media das turmas:”)

para i de   1 ate alunos faca

 med = media(aluno, real media);

  escrever (“aluno e  medias”, aluno.nome, med) ;

fim para

ordena_maior(aluno, maior);

escrever(“pior e melhor media”,maior[1],maior[alunos]);

escrever (deseja sair (s/n));

leia (sair);

 

caso 4:

escrever (“maior e menor frequencia)”)

int i;

procedimento maior_frequencia(aluno);

escrever( pior e melhor frequencia nas aulas:”, freq[1].aluno, freq[alunos].aluno;

escrever(deseja sair(s/n));

leia (sair);

 

caso 5:

inteiro i;

escrever(“medias acima de  7:”);

procedimento: passou(aluno)

escrever(deseja sair(s/n));

leia (sair);

caso 6:

escrever(“sair”);

 

procedimento registro_aluno(var reg_aluno: aluno[alunos])            

 

    para  i de 1 ate alunos faca

    escrever (“informe o nome do aluno”)

   leia (aluno.nome);

    escrever(“informe a serie”)

    leia (“aluno.serie”)

    escrever (“informe as notas”)

    leia  (aluno.nota[1], aluno.nota[2];

   escrever (“informe a frequencia”)

   leia (“aluno.frequencia”)         

fim

 

procedimento consulta(var reg_aluno: aluno[alunos], inteiro: i )

inteiro: i;

literal: nome, continua = s’;

literal: aluno_pesquisado;

repita

    escrever(“informe o nome do aluno que deseja pesquisar”);

    leia(aluno_pesquisado);

   para i de 1 ate alunos faca

se (aluno_pesquisado  <= aluno.nome ) faca

   mostrar_dados();

senao

escrever(“deseja continuar? (s/n)

leia (continua);

ate continua = n”;

 

fim_se

fim_para

fim

 

funcao real:  media(var reg_aluno: aluno[alunos]; real  aluno_media)

inteiro k,i;

 para k de 1 ate alunos faca

  para i de 1 ate alunos faca

  aluno[k].media =  (aluno.nota[1] + aluno.nota[2] )/ 2;

   fim_para

 fim_para  

retorne media[k];

fim

 

procedimento ordena_maior (var reg_aluno: aluno[alunos]; real maior_media)\

real maior;

inteiro: i,j,aux,k;

para i de 1 ate alunos faca

  para j de 1 ate alunos faca

   se maior < maior[j] entao

       aux = maior;

       maior = maior[j];

       maior[j] = aux;

fim_para

 fim_para         

para k de 1 ate alunos faca

escrever(“medias em ordem da menor para maior”, maior)

fim_para

   fim

 

procedimento ordena_menor(var reg_aluno: aluno[alunos]; real menor_media)

real: menor;

inteiro : i,j, aux;

  para i de 1 ate alunos faca

    para j de 1 ate alunos faca

       se menor>menor[j] entao

          aux=menor;

          menor=menor[j];

          menor[j]=aux;

  fim_para

 fim_para

fim

 

procedimento maior_frequencia(var reg_livro: aluno[alunos])

  inteiro: i,j,aux;

    para i de 1 ate alunos faca

     para j de 1 ate alunos faca

      se aluno.freq< aluno.freq[j] entao

        aux= aluno.freq;

        aluno.freq = aluno.freq[j];

       aluno.freq[j] = aux;

   fim_para ;

 fim_para;

escrever (“frequencia ordenada do menor para maiorfreq.aluno)

fim

 

procedimento: passou(var reg_livro: aluno[alunos])

int i;

para i de 1 ate alunos faca

 se (aluno.media > 7) faca

escrever(“parabens aos alunos: “, aluno.nome);

fim_para

  fim_se

 

inicio principal

int i

repita

menu escolhas()

escrever (“deseja sair:”)

leia (sair)

ate sair = n

fim

 

 

 

obs: exercicio em anexo.ex1.PNG.3c5d47f2e9a7e4022a5f75ffdb5d8637.PNG

 

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

Oi , algoritmo que você fez esta funcionando ? tentou implementar no visualg?

eu faria um switch é faria com as opções de cadastro consulta etc.

Compartilhar este post


Link para o post
Compartilhar em outros sites

 

@danilocc7, qual a linguagem de programação utilizada no seu código? no caso, qual programa usa para interpretar e executar o código?

 

 

Com base no código postado, segue um base inicial feita especificamente para o VisualG.

algoritmo "struct reg_alunos"
const
   MAX = 2
tipo
   reg_aluno = registro
      nome :caractere
      serie :inteiro
      nota1, nota2 :inteiro
      frequencia :inteiro
   fimRegistro

var
   alunos :vetor [1..MAX] de reg_aluno

procedimento mostrar_dados()
   var
      i :inteiro
   inicio
   para i de 1 ate MAX faca
      escreval("Nome : ", alunos[i].nome)
      escreval("Série:", alunos[i].serie)
      escreval("Notas:", alunos[i].nota1, alunos[i].nota2)
      escreval("Frequência:", alunos[i].frequencia)
      escreval("")
   fimPara
fimProcedimento

procedimento registro_aluno()
   var
      i :inteiro
   inicio
   para i de 1 ate MAX faca
      escreva ("Nome: ")
      leia(alunos[i].nome)
      escreva ("Série: ")
      leia(alunos[i].serie)
      escreva ("Notas: ")
      leia(alunos[i].nota1, alunos[i].nota2)
      escreva ("Frequência: ")
      leia(alunos[i].frequencia)
      escreval("")
   fimPara
fimProcedimento
inicio
   registro_aluno()
   mostrar_dados()

fimAlgoritmo

Daí  só continuar mantendo o fluxo.

 

Obs.: o VisualG não aceita receber vetores por parâmetro (muito menos vetores de registros). Nesse caso, uma opção é utilizar as variáveis globais diretamente mesmo.

 

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

Bom dia Simon,

 

Eu estava fazendo em C, porém preciso entregar hoje esse trabalho em pseudocódigo e to meio desesperadao. Eu nao conheco a linguagem que meu professor usa para testar os programas em pseudo... 

 

To com duvida em questao da modularizacao da media, nao sei se faco uma estrutura da media, ou deixo variavel global, ou faco um procedimento só para media, pois, tambem preciso ordena-la

adicionado 0 minutos depois

@Vitor9332 Grande parte na linguagem C estava

Compartilhar este post


Link para o post
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisar ser um membro para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora





Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×
×
  • Criar novo...

Redes de Computadores - Gabriel Torres

PROMOÇÃO DE QUARENTENA

De R$ 39,90 por apenas R$ 9,90 só até as 23h59min desta sexta-feira 03/04/2020

CLIQUE AQUI E COMPRE AGORA MESMO!