Usamos cookies para medir audiência e melhorar sua experiência. Você pode aceitar ou recusar a qualquer momento. Veja sobre o iMasters.
Estou estudando algoritmos e lógica de programação, logo, sempre tento comparar meu código com o do professor, para aprimorar minha aprendizagem. Analisando quantidade de linhas, lógica usada, rotinas, entre outros... Para definir onde posso melhorar ou não.
Vocês experientes (ou não) podem me falar quais critérios devo levar em conta, ao comparar dois pseudocódigos e se isso é uma ação válida, isto é, vai acrescentar na minha vida?
Abaixo segue o código do professor e o meu.
Meu código:
algoritmo "Dissecando Matrizes"
var
opcao, L, C:inteiro
M: vetor [1..4, 1..4] de inteiro
Procedimento Menu()
inicio
EscrevaL ("")
EscrevaL ("======================")
EscrevaL ("MENU DE OPÇÕES")
EscrevaL ("======================")
EscrevaL ("[1] Mostrar a Matriz")
EscrevaL ("[2] Diagonal Principal")
EscrevaL ("[3] Triângulo Superior")
EscrevaL ("[4] Triângulo Inferior")
EscrevaL ("[5] Sair")
Escreva ("===== OPÇAO: ")
Leia (opcao)
FimProcedimento
inicio
Para L <- 1 ate 4 faca
Para C <- 1 ate 4 faca
Escreva ("Digite o valor para posição [ ",L,", ",C,"]: ")
Leia (M[L,C])
FimPara
FimPara
LimpaTela
Repita
Menu()
Repita
Escolha opcao
Caso 1
LimpaTela
Para L <- 1 ate 4 faca
Para C <- 1 ate 4 faca
Escreva (M[L,C]:2)
Fimpara
EscrevaL ()
FimPara
Menu()
Caso 2
LimpaTela
Para L <- 1 ate 4 faca
Para C <- 1 ate 4 faca
Se (L = C) entao
Escreva (M[L,C]:2)
Senao
Escreva (" ":2)
FimSe
Fimpara
EscrevaL()
FimPara
Menu()
Caso 3
LimpaTela
Para L <- 1 ate 4 faca
Para C <- 1 ate 4 faca
Se(L = C - 1) ou (L = c - 2) ou (L = C - 3) entao
Escreva (M[L,C]:2)
Senao
Escreva (" ":2)
FimSe
FimPara
EscrevaL ()
FimPara
Menu()
Caso 4
LimpaTela
Para L <- 1 ate 4 faca
Para C <- 1 ate 4 faca
Se (L = C + 1) ou (L = c + 2) ou (L = C + 3) entao
Escreva (M[L,C]:2)
Senao
Escreva (" ":4)
FimSe
FimPara
EscrevaL ()
FimPara
Menu()
Caso 5
LimpaTela
Escreva ("SAINDO...")
FimEscolha
Ate (opcao = 5)
Ate (opcao = 5)
LimpaTela
Escreva ("SAINDO...")
fimalgoritmo
Código do professor:
var
m: vetor[1..4, 1..4] de Inteiro
l, c, op: Inteiro
Procedimento MostraMatriz()
inicio
Para l <- 1 ate 4 faca
Para c <- 1 ate 4 faca
Escreva(m[l,c]:4)
FimPara
EscrevaL()
FimPara
FimProcedimento
Procedimento DiagonalPrincipal()
var t: inteiro
inicio
Para l <- 1 ate 4 faca
EscrevaL(m[l,l]:4)
Para t <- 1 ate l faca
Escreva(" ")
FimPara
FimPara
FimProcedimento
Procedimento TrianguloSuperior()
var t: Inteiro
inicio
Para l <- 1 ate 3 faca
Escreva(" ")
Para c <- l+1 ate 4 faca
Escreva(m[l,c]:4)
FimPara
EscrevaL()
Para t <- 1 ate l faca
Escreva(" ")
FimPara
FimPara
EscrevaL()
FimProcedimento
Procedimento TrianguloInferior()
inicio
Para l <- 2 ate 4 faca
EscrevaL()
Para c <- 1 ate l-1 faca
Escreva(m[l,c]:4)
FimPara
FimPara
EscrevaL()
FimProcedimento
inicio
Para l <- 1 ate 4 faca
Para c <- 1 ate 4 faca
Escreva("Digite valor para a posicao [", l, ",", c, "]: ")
Leia(m[l,c])
FimPara
FimPara
LimpaTela
Repita
EscrevaL()
EscrevaL("MENU DE OPCOES")
EscrevaL("====================")
EscrevaL("[1] Mostrar a Matriz")
EscrevaL("[2] Diagonal Principal")
EscrevaL("[3] Triangulo Superior")
EscrevaL("[4] Triangulo Inferior")
EscrevaL("[5] Sair")
Repita
EscrevaL("===== OPCAO: ")
Leia(op)
Ate (op >=1) e (op <=5)
LimpaTela
Escolha op
Caso 1
MostraMatriz()
Caso 2
DiagonalPrincipal()
Caso 3
TrianguloSuperior()
Caso 4
TrianguloInferior()
Caso 5
EscrevaL("ENCERRANDO...")
FimEscolha
Ate (op = 5)
fimalgoritmo
Em minha análise amadora, entendo que o meu foi melhor construído que o do professor, o que acham?
@KhaosDoctor Obrigado por responder!
Eu já sei o básico da lógica de programação, mas tenho vontade de aprender mais sobre. Para saber o tipo de código (procedural ou contínuo) eu devo utilizar em determinada situação, por exemplo.
Você pode me recomendar alguma obra didática para estudar sobre?
Uma dica importante, nunca use código continuo, a não ser que a linguagem que você está usando só possua este modo de programação, por exemplo, o MSDOS ou outras linguagens mais antigas que não tinham declarações de funções nem rotinas.
Hoje em dia 99% das linguagens possuem essa característica de criação de funções e separação do código em rotinas e procedimentos. Este modelo de programação é bem mais eficiente, em programas pequenos isso não vai fazer diferença, mas em programas maiores a diferença notável.
Em uma analise detalhada você vai perceber que o seu código e o do seu professor ambos foram bem construidos, a diferença é que o seu está apenas organizado, enquanto o dele está funcional e otimizado.
Veja, o que você construiu ali encima é o que chamamos de programação continua, ela segue o programa linha a linha, ou seja, ela vai começar na linha 1 e você pode acompanhar todos os passos que ela faz porque ela pula uma linha por vez, mas preste atenção no nível de identação de código que você chegou, muitos de seus condicionais estão quase no meio da página. Este nível de nesting é ruim para leitura, porque você se perde o que está dentro do que, por exemplo:
se (a > b) então
se (b>c) entao
se (c>d) então
faz algo
fimse
fimse
fimse
Veja como a leitura fica complicada.
O código do seu professor utiliza rotinas, ou seja, pedaços reutilizáveis de código que podem ser chamados apenas pelo nome, dessa forma você omite a lógica toda do programa principal e mantem o seu código enxuto, lembre-se de que o melhor código é aquele que é o mais simples de ler para qualquer pessoa, aquele que mais se assemelha a linguagem natural.
Vamos comparar aquele mesmo exemplo que eu dei acima:
Procedimento verificaAB()
inicio
se (a>b) então
verificaBC()
fimse
fimprocedimento
Procedimento verificaBC()
inicio
se (b>c) então
verificaCD()
fimse
fimprocedimento
Procedimento verificaCD()
inicio
se (c>d) então
faça algo
fimse
fimprocedimento
inicio
verificaAB()
fimalgoritmo
O seu programa fica mais extenso? Sim, ele fica, porém mais modulado. Desta forma se você alterar uma rotina todo o código alterado vai estar encapsulado em uma unica parte do programa, e portanto você não vai ter que alterar a estrutura inteira do mesmo. Fora que seu código inicial fica mais legível e de melhor entendimento porque você não precisa assimilar um trecho grande de lógica de uma unica vez, mas sim diversos trechos menores que, juntos, compõem a lógica final.
Os impactos na execução são vários, uma vez que o uso de memória é reduzido já que as rotinas são criadas na memória na hora de sua execução e destruidas ao final dela (não é sempre uma regra), o que poupa bastante memória utilizando apenas a porcentagem de recurso que é essencial ao funcionamento do programa. Desta forma o programa de seu professor provavelmente rodará mais rápido do que o seu (em um programa pequeno como este vai ser dificil de medir isso que eu acabei de falar, mas ao se criar dois programas grandes identicos, um totalmente contínuo e outro procedural, é fácil notar a diferença).