




















Estude fácil! Tem muito documento disponível na Docsity
Ganhe pontos ajudando outros esrudantes ou compre um plano Premium
Prepare-se para as provas
Estude fácil! Tem muito documento disponível na Docsity
Prepare-se para as provas com trabalhos de outros alunos como você, aqui na Docsity
Os melhores documentos à venda: Trabalhos de alunos formados
Prepare-se com as videoaulas e exercícios resolvidos criados a partir da grade da sua Universidade
Responda perguntas de provas passadas e avalie sua preparação.
Ganhe pontos para baixar
Ganhe pontos ajudando outros esrudantes ou compre um plano Premium
Comunidade
Peça ajuda à comunidade e tire suas dúvidas relacionadas ao estudo
Descubra as melhores universidades em seu país de acordo com os usuários da Docsity
Guias grátis
Baixe gratuitamente nossos guias de estudo, métodos para diminuir a ansiedade, dicas de TCC preparadas pelos professores da Docsity
Uma introdução abrangente à programação em algoritmos, explorando conceitos essenciais como variáveis, tipos de dados, vetores, matrizes, registros, procedimentos e funções. Através de exemplos práticos e bem explicados, o documento demonstra como implementar algoritmos para resolver problemas computacionais, desde a declaração de variáveis até a utilização de estruturas de dados e procedimentos. O conteúdo é ideal para estudantes que desejam iniciar sua jornada na programação, fornecendo uma base sólida para o desenvolvimento de habilidades de programação.
Tipologia: Manuais, Projetos, Pesquisas
1 / 28
Esta página não é visível na pré-visualização
Não perca as partes importantes!
1 - Introdução e estruturas básicas 2 - Comandos básicos 3 - Estruturas Condicionais e de Repetição 4 - Vetores e Matrizes Antes de relembrarmos como escrevemos algoritmos, vamos relembrar o que é um algoritmo. Na disciplina anterior, vimos que Guimarães e Lages definem algoritmo como: “[...] descrição de um padrão de comportamento, expressão em termos de um repertório bem definido e finito de ações primitivas, das quais damos por certo que elas podem ser executadas” (GUIMARÃES; LAGES, 1994, p. 4). Farrer et. al. (1999, p. 14) descreve Algoritmo como: “um conjunto de comandos que, obedecidos, resultam numa sucessão finita de ações.” Assim, Algoritmo é uma série de passos que são executados para chegarmos a uma solução. Uma receita de bolo é um grande exemplo disso. Na computação, escrevemos algoritmos para ordenarmos ao computador o que deve ser feito. Para isso, usamos uma sintaxe bem definida para que a máquina entenda o que queremos. Nesta aula, vamos relembrar a sintaxe do PORTUGOL (adaptado ao programa Visualg) que é usada para construção de algoritmos.
Um algoritmo processa dados. Um algoritmo escrito em Portugol reconhece os seguintes tipos de dados.
Podemos considerar um algoritmo como uma sequência de instruções. Em cada instrução, podemos ter expressões. Por sua vez, as expressões são formadas por operadores. São avaliadas da esquerda para a direita, da mesma forma que lemos um texto. Porém, existe uma ordem de precedência, que indica quais expressões serão avaliadas primeiro. Vejamos:
São palavras que a linguagem utiliza para compor um algoritmo, assim, já tem um sentido definido. O usuário não pode usar essas palavras para nomear variáveis ou para estabelecer outro sentido. Quadro 4 - Palavras reservadas.
Um algoritmo possui a seguinte estrutura básica: algoritmo “Nome do Programa” //Entre aspas você nomeia o algoritmo // isto é um comentário // abaixo você faz a declaração das variáveis do algoritmo var var01 : inteiro var02 : logico
var03 : real // (...) inicio // comeca a declaração das instruções do algoritmo
O conceito de variável é um dos conceitos mais importantes em algoritmos, pois por meio dele armazenamos dados a serem salvos para serem processados em um algoritmo. Cada variável tem um nome para sua identificação. E esse nome deve obedecer às seguintes regras:
Um algoritmo possui comandos básicos. Vamos relembrar?
Para colocarmos dados em uma variável, usamos o comando de atribuição. O identificador fica no lado esquerdo da expressão. O valor ou a expressão que computará o valor a ser atribuído fica no lado direito da expressão. Eles são separados pelo sinal de atribuição (<-). X <- 9
Para calcular valores, usamos expressões. Essas expressões usam valores, variáveis e operadores. Seu resultado pode ser salvo em uma variável. SOMA <- x + 9 POTENCIA <- I ** 2
Vocês podem deixar mais claro seu código explicando o que esse programa faz. Para isso, existem os comentários. Durante a execução, o computador vai descartar tudo o que você escrever em um comentário. Para escrevermos comentários, usamos as chaves para delimitar o início e o fim de um comentário ou usamos as duas barras para declarar que o restante da linha é um comentário. X <- 9 // atribui o valor 9 a variável X
Outra forma de definir valores em uma variável é usar o comando leia. Esse comando permite que o programa espere o usuário informar os valores para uma variável. Sua sintaxe é definida da seguinte forma: leia(
As estruturas condicionais permitem ao programador definir comandos que serão executados em determinadas condições. As condições são expressas por meio de valores, variáveis, operadores relacionais e operadores lógicos. As estruturas condicionais são expressas da seguinte forma: se <condição> entao //comandos caso resultado da condição seja verdadeira senao //opcional //comandos caso o resultado da condição seja falsa fimse Vamos a um exemplo: se media >= 7.0 entao escreva(“Aprovado!”) senao escreva(“Reprovado!”) fimse
As estruturas de repetição permitem que o programador indique comandos que serão repetidos várias vezes. Em algoritmos, temos três tipos de estruturas de repetição, a saber:
1 - Introdução aos Registros 2 - Como criar e usar Registros 3 - Usando conjuntos dentro de um Registro 4 - Usando conjunto de registros Você viu, na aula anterior, que podemos criar variáveis compostas por um tipo só, denominadas de variáveis compostas homogêneas. Porém, na vida real, várias situações envolvem dados de diversos tipos, por exemplo:
Como falamos, um registro é um tipo de dados em que você define quais campos serão compostos de uma variável desse tipo. Assim, na linguagem PORTUGOL, devemos declarar primeiro a estrutura do registro. Para isso, usamos a sintaxe: tipo
Você pode usar além dos tipos primitivos, um conjunto (vetor ou matriz) de um tipo primitivo para ser um campo de um registro. Para isso, podemos usar a mesma notação que usamos para declarar um registro, só que aplicado a um campo de um registro. Supomos que queremos registrar as notas de um aluno durante quatro bimestres, além de seu nome. Para isso, podemos usar essa sintaxe: tipo Registro_Aluno = registro nome : caractere notas : vetor[1..4] de real fimregistro Para ler ou escrever dados em um campo composto de um vetor, usamos a mesma sintaxe para um campo comum, acrescentado pelo índice do elemento que devemos usar, assim como acessamos índices de um vetor ou matriz, que vimos em Algoritmos I. leia(aluno.notas[1]) escreva(aluno.notas[1]) Vamos ver um exemplo para contextualizar essa situação. Exemplo 3: Escreva um algoritmo que leia e escreva os dados de um aluno. Um aluno é identificado pelo seu nome, além das notas dos seus quatro bimestres. algoritmo “Exemplo Alunos” //declara aqui o tipo para o aluno tipo Registro_Aluno = registro nome : caractere notas : vetor[1..4] de real fimregistro var aluno : Registro_Aluno //Aqui declaramos uma variável do tipo Registro_Aluno i : inteiro inicio //leia os dados desse aluno leia(aluno.nome) para i de 1 ate 4 passo 1 faca leia(aluno.notas[i]) fimpara //escreva os dados desse aluno escreva(aluno.nome) para i de 1 ate 4 passo 1 faca escreva(aluno.notas[i]) fimpara fimalgoritmo
Normalmente, quando escrevemos algoritmos envolvendo registros, usamos um conjunto de registros para armazenar uma quantidade de dados. Um conjunto funciona da mesma forma que um vetor ou uma matriz, mas ao invés de cada posição armazenar um dado, ela armazena uma série de campos que foram definidos previamente. Figura 1 - Estrutura de um vetor de registros. Fonte: Acervo Pessoal. Para criarmos um vetor ou uma matriz de registros, devemos primeiro declarar a estrutura do registro, da mesma forma que você aprendeu na seção II. Depois, você deve declarar uma variável como um vetor ou uma matriz, da mesma forma que você aprendeu na disciplina anterior. A diferença fica no fato de que, ao invés de declarar como um dos tipos primitivos, você declara essa variável como sendo do tipo que você definiu previamente. Por exemplo, um registro para registrar alunos da seguinte estrutura: //declara aqui o tipo para o aluno tipo Registro_Aluno = registro nome : caractere notas : vetor[1..4] de real fimregistro Podemos declarar um vetor para armazenar 8 alunos da seguinte forma: var alunos : vetor[1..8] de Registro_Aluno Para declarar uma matriz de 8 linhas e 8 colunas para os alunos, podemos usar a seguinte instrução: alunosM :vetor[1..8,1..8] de Registro_Aluno Depois, para usar os dados do conjunto de registros, devemos primeiramente indicar o nome do conjunto, depois indicamos o(s) índice(s) do conjunto a ser acessado. Em seguida, colocamos um ponto e indicamos o nome do campo a ser acessado. //lê o campo nome da primeira posição do vetor de alunos leia(alunosV[1].nome) //escreve na tela a segunda posição do campo notas da posição 2, 2 da matriz de alunos. escreva(alunosM[2,2].notas[2]) Para ilustrar melhor, vamos ver mais um exemplo: Exemplo 4: Escreva um algoritmo que registre os dados de 10 praças de pedágio. Para cada praça, registre o nome da rodovia, o quilômetro da rodovia onde fica esse pedágio, a cidade onde fica esse pedágio e o seu valor. No final calcule o valor total dos pedágios neste trajeto. algoritmo “Calcula Pedágios” tipo Registro_Pedagios = registro nome : caractere quilometro : inteiro cidade : caractere valor : real fimregistro var pedagios : vetor[1..10] de Registro_Pedagios i : inteiro valorTotal : real
1 - Para que modularizar? 2 - Introdução aos Procedimentos 3 - Usando Parâmetros Durante a sua jornada de estudo, você desenvolveu vários algoritmos, de diversos tamanhos. Muitos desses algoritmos que você escreveu nesse tempo são pequenos, para ajudar na fixação do conteúdo estudado. Porém, é comum na Informática a criação de algoritmos mais complexos, com várias situações de execução. Nessas situações, podem ser criados algoritmos com centenas ou milhares (talvez milhões) de linhas, acarretando os seguintes problemas:
momento em que o procedimento é chamado, sublinhamos o nome desse procedimento. A seguir, mostramos um exemplo de uso de procedimentos em um algoritmo. Exemplo 5: crie um algoritmo que chame um procedimento que leia dois números e depois informe ao usuário a soma desses números. Esse procedimento deve ser chamado n vezes, sendo que o valor de n deve ser informado pelo usuário no início da execução. algoritmo “soma” procedimento SOMA var N1, N2, RESP : inteiro inicio leia(N1) leia(N2) RESP <- N1 + N escreva(RESP) fim var n: inteiro inicio escreva(“Informe o número de vezes que o procedimento deve ser executado”) leia(n) para i de 1 até n passo 1 faca SOMA() fimpara fimalgoritmo Lembrem-se de que nesse algoritmo que toda vez que chamamos o procedimento SOMA, o fluxo de execução é desviado para o procedimento SOMA, fazendo que o bloco principal do programa pare o loop que está executando e espere o fim desse procedimento. Você pode entender isso dessa maneira: toda vez que chamamos um procedimento, “incluímos” o código desse procedimento no lugar da chamada desse módulo. Figura 1 - Exemplo de analogia de como o computador interpreta as funções. Fonte: Acervo Pessoal. Vimos, de uma forma básica, como podemos declarar um procedimento. Mas não é só isso. Podemos declarar variáveis, cujos valores são passados ao procedimento no ato de sua chamada. A eles damos o nome de parâmetros, que veremos a seguir.
Parâmetros são variáveis que declaramos em um procedimento, cujos valores serão definidos pelo bloco de código chamador no ato de sua chamada. É uma maneira de comunicação entre o bloco de código chamador e o procedimento chamado, onde é realizada uma transmissão de dados. Normalmente, os parâmetros são utilizados para passar valores ou definir qual comportamento que um procedimento irá fazer. Para o nosso exemplo do procedimento SOMA anterior, poderíamos, ao invés do procedimento ser encarregado de ler os valores do teclado, pedir ao chamador quais serão os valores a serem somados, onde o bloco chamador pode obter de diversas formas (de um vetor, do teclado, de um arquivo etc.). Para usarmos os parâmetros, devemos seguir as seguintes regras: ● Após o nome do procedimento, definimos entre parênteses uma lista de variáveis da seguinte forma:
3 - Usando Parâmetros Parâmetros são variáveis que declaramos em um procedimento, cujos valores serão definidos pelo bloco de código chamador no ato de sua chamada, sendo uma maneira de comunicação entre o bloco chamador e o procedimento invocado. Os parâmetros são especificados entre parênteses, após o seu nome, na declaração do procedimento. Existem duas formas de transmissão de parâmetros. A passagem de parâmetros por valor, em que o bloco chamador transmite uma cópia do conteúdo a ser passado. Já na passagem por referência, a posição de memória em que a variável se encontra é passada ao procedimento, possibilitando ao procedimento alterar o valor da variável do bloco chamador diretamente. MANZANO, José Augusto N. G.; OLIVEIRA, Jayr Figueiredo de Oliveira. Algoritmos - lógica para desenvolvimento de programação. 2. ed. São Paulo: Érica, 2014. VENANCIO, Claudio Ferreira. Desenvolvimento de Algoritmos : Uma Nova Abordagem. São Paulo: Érica, 2000. FARRER, Harry; et. al. Algoritmos Estruturados. 3. ed. São Paulo: LTC, 1999.
MELO, Pedro O. S. Vaz de. Passagem de Parâmetros. Belo Horizonte: UFMG. Disponível em: <http:// homepages.dcc.ufmg.br/~olmo/aula8-parametros.pdf>. Acesso em 26 out. 2017. GUIMARÃES, Rafael Silva. Funções e Procedimentos. IFES. Disponível em: <ftp://ftp.ci.ifes.edu.br/informatica/ rafael/Tecnico/Tecnicas_Programacao/Apresentacao/ IFES-TP-Aula04-Funcoes&Procedimentos.pdf >. Acesso em 26 out. 2017. VARELA, Marcelo. Os Procedimentos (Procedures) e Funções (Functions). Imasters, 2002. Disponível em: <https://imasters.com.br/artigo/345/linguagens/os- procedimentos-procedures-e-funcoes-functions?trace= 9021197&source=single>. Acesso em 20 out. 2007. SILVA, Elaine Quintino. Aprendendo a programar: procedimentos e funções. GlobalCoders, 2010. Disponível em: <http://blog.globalcode.com.br/2010/06/aprendendo- programar-procedimentos-e.html>. Acesso em 20 out. 2017. BARANAUSKAS, José Augusto. Sub-algoritmos: Funções e Procedimentos. Disponível em: <http:// dcm.ffclrp.usp.br/~augusto/teaching/ici/Funcoes-e- Procedimentos.pdf>. Acesso em 26 out. 2017.
1 - Conhecendo Funções Você estudou na aula anterior os procedimentos, que é uma forma de implementar módulos em um algoritmo. Também aprendeu sobre como funciona os parâmetros, que é uma forma de comunicação entre o bloco chamador e o procedimento, consistindo em uma passagem de valores no início da execução do procedimento. Mas vocês, estimados(as) alunos(as), devem estar se perguntando: Existe uma forma de comunicação em que o procedimento entrega um valor ao bloco chamador? A resposta para esta pergunta é SIM. Mas o nome para estes módulos que devolvem valores no fim da execução muda. Eles se chamam funções. Funções são módulos que, quando avaliados dentro de uma expressão, retornam obrigatoriamente um valor à expressão. (VENANCIO, 2000, p. 46). Por esse motivo, quando uma função é encerrada, o bloco chamador é retomado na mesma linha da declaração da função (não na próxima, como ocorre em um procedimento) para que seja recebido o valor devolvido pela função. Em termos de funcionamento, essa é a única coisa que muda. Um procedimento não retorna um valor no fim da sua execução, enquanto que uma função sempre vai retornar um valor. O restante que vimos sobre o funcionamento de procedimentos se aplica as funções da mesma forma. Em termos de declaração, as funções têm mais diferenças do que os procedimentos. Vejamos a seguir como é declarada uma função em algoritmo: funcao
VARELA, Marcelo. Os Procedimentos (Procedures) e Funções (Functions). Imasters, 2002. Disponível em: <https://imasters.com.br/artigo/345/linguagens/os- procedimentos-procedures-e-funcoes-functions?trace= 9021197&source=single>. Acesso em: 20 out. 2007. SILVA, Elaine Quintino. Aprendendo a programar: procedimentos e funções. GlobalCoders, 2010. Disponível em: <http://blog.globalcode.com.br/2010/06/aprendendo- programar-procedimentos-e.html>. Acesso em: 20 out. 2017.
1 - Introdução ao escopo de variáveis 2 - Escopo Local 3 - Escopo Global 4 - Cuidados com o escopo de variáveis Até meados dos anos 2000, os computadores pessoais não tinham uma fartura de memória disponível que existem nos computadores hoje. Enquanto que os computadores de hoje possuem de 2 a 8 Gigabytes (equivalente a 2000 a 8000 Megabytes) de memória, os computadores do final da década de 1990 possuíam até 64 Megabytes de memória. Já na década de 1980 existiam computadores de apenas 1 Megabyte de memória, enquanto que os computadores da décadas de 1960 e 1970 possuíam valores de memória ainda menores. Figura 1 - Anúncio de um computador em 1995, nos Estados Unidos. Perceba que a quantidade de memória disponível é de apenas 4 Megabytes. Fonte: Disponível em: http://i.imgur.com/sf2dD.jpg. Acesso em: 23 out. 2017. Devido a essa escassez de memória, os programadores daquela época tinham uma preocupação sobre o uso eficiente de memória. Assim, a programação estruturada, que havia surgido na década de 1960, propõe uma técnica para facilitar o gerenciamento de variáveis, para que o programador use o mínimo possível de memória. Ela se chama escopo de variáveis. Manzano e Figueiredo oferecem uma definição sobre isso: “O escopo de uma variável, ou sua abrangência operacional, está vinculado à forma de sua visibilidade no programa (...) em relação às sub-rotinas que compõem um programa (...)” (MANZANO, FIGUEIREDO; 2014; p. 216). Diante dessa definição, podemos entender que o escopo de uma variável se refere a que locais uma variável vai existir durante o tempo de vida de um programa. Em programas, uma variável pode ser de dois escopos. Ou pode ser de escopo local ou pode ser de escopo global. Detalharemos sobre eles nas próximas seções. Uma variável é de escopo local quando existir somente no local onde foi declarado. Ou seja, se foi declarado no corpo principal de um programa, só existirá no corpo principal. Se for declarado em um procedimento, essa variável só existirá durante a execução do procedimento. Uma variável de escopo local (pode ser chamada também de variável local) pode ser declarada de duas formas: ● declarada dentro de uma função ou de um procedimento. Neste caso, essa variável só será visível durante a execução do módulo onde foi criado; ● declarada após todas as funções e procedimentos do programa. Nessa situação, a variável só existirá apenas no bloco principal do programa, não sendo visível para todos os módulos do programa. Podemos fazer uma analogia a esta situação. Digamos que o bloco principal e cada módulo ou procedimento do programa seja uma caixa. Em variáveis de escopo local, cada variável ficaria em uma caixa, dentro do seu mundo que ele conhece. Ele não existe nos outros blocos do programa. Figura 2 - Analogia com as variáveis locais. Fonte: Acervo Pessoal. Vamos a um exemplo para mostrar o funcionamento das variáveis locais: Exemplo 11: crie um programa que leia duas variáveis no teclado, e inverta esses valores das duas variáveis após a leitura. Por exemplo, se foram lidos os valores 7 e 2, o programa deve invertê-los e essas variáveis deverão estar com os valores 2 e 7, respectivamente. O código para troca de valores deverá ser implementado em um procedimento. algoritmo “Inverte_Valores” procedimento TROCA(num1:inteiro, num2:inteiro) var X : inteiro inicio X <- num num1 <- num num2 <- X fim var //neste bloco, temos apenas variáveis locais //visíveis apenas no bloco principais num1, num2 : inteiro
comprovarmos, veja o teste de mesa que foi feito para esse programa, apresentado a seguir: Variáveis globais Comentário num1 num 2 7 Antes da chamada do procedimento 2 7 Foi chamado o procedimento 2 7 X = 2 (num1) 7 7 num1 recebe o valor de num 7 2 num2 recebe o valor de X 7 2 Procedimento encerrado Porém, nem tudo são flores nas variáveis globais. Por sua natureza, essas variáveis podem causar vários tipos de problemas. Vamos discutir sobre elas a seguir.
Devido ao fato que as variáveis globais são visíveis por todo o código e também qualquer alteração que seja feita por um trecho de código em uma variável global impacta diretamente em todos os demais, o uso de variáveis globais deve ser feito com cuidado, pois uma alteração mal planejada em alguma das variáveis globais pode causar um erro difícil de ser detectado no código. Vamos a um exemplo. Exemplo 13: escreva um algoritmo que somente conte quantas vezes um procedimento foi chamado. algoritmo “TesteErro” var //Aqui temos uma variável global contador : inteiro procedimento CONTA inicio contador <- contador + 1 fim procedimento EXIBE inicio contador <- 5 escreva(“contador = ”, contador) fim inicio contador <- 0 CONTA() CONTA() CONTA() EXIBE() fimalgoritmo Nesse exemplo, se você não olhasse o que tem dentro do procedimento EXIBE, você falaria que o programa vai exibir o valor 4, pois o procedimento CONTA foi chamado 4 vezes. Está errado. Nesse exemplo, o programador colocou uma atribuição equivocada no procedimento EXIBE, colocando o valor 5 na variável contador. Assim, por mais que o procedimento CONTA fosse chamado várias e várias vezes, o programa sempre vai exibir o valor 5 no final da execução, devido a essa atribuição. Nesse exemplo, pode ser fácil encontrar o erro relacionado às variáveis globais. Mas em programas complexos, com dezenas de procedimentos e funções, pode ser uma tarefa árdua achar um erro semelhante a que tratamos aqui. Assim, outro problema que é associado ao uso de globais é o aumento da complexidade da manutenção do código , visto que como uma variável pode ser usada em vários locais ao mesmo tempo, o tempo que é gasto para a manutenção, devido ao trabalho de alterar em vários locais. Isso também acarreta na perda de flexibilidade do código, pois os módulos dependerão de variáveis dentro do programa. Lembre-se de que a flexibilidade é a grande vantagem de usar a modularização. Por isso, somente use variáveis globais em casos estritos, como, por exemplo, em variáveis que indicam o status do sistema, por exemplo. Sempre que possível, use variáveis locais para o programa principal e seus módulos e use a passagem de parâmetros para passar valores para um módulo. Com isso, finalizamos aqui o nosso estudo sobre o escopo de variáveis. Na próxima aula, veremos sobre a recursividade, para finalizar nossos estudos sobre a modularização.
Chegamos ao final da nossa aula 05, que abordamos sobre escopo de variáveis. Vamos recordar? 1 - Introdução ao escopo de variáveis O escopo de variáveis é o nome dado a forma de visibilidade de uma variável em um programa. Foi uma técnica criada para aperfeiçoar o gerenciamento de memória dos programas nos primórdios da informática, quando as máquinas possuíam pouca memória, em relação aos computadores dos tempos atuais. 2 - Escopo Local Chamamos de variáveis de escopo local aquelas que foram declaradas após todas as funções e procedimentos ou dentro de uma função ou procedimento. Essas variáveis existem somente no bloco onde foi declarado, não sendo possível usar em outros locais do código. 3 - Escopo Global As variáveis de escopo global são aquelas que foram declaradas antes da declaração de funções e procedimentos. São chamadas assim porque podem ser usadas em qualquer lugar do programa, possuindo um valor para todos os locais durante a sua execução.
4 - Cuidados com o escopo de variáveis As variáveis globais, devido a sua natureza, podem causar vários problemas ao programa, como erros ocasionados por atribuições inesperadas, dificuldade na manutenção e perda de flexibilidade no programa. Por isso, é recomendado sempre usar variáveis locais e passagem de parâmetros no programa. MANZANO, José Augusto N. G.; OLIVEIRA, Jayr Figueiredo de Oliveira. Algoritmos - lógica para desenvolvimento de programação. 2. ed. São Paulo: Érica, 2014. VENANCIO, Claudio Ferreira. Desenvolvimento de Algoritmos : Uma Nova Abordagem. São Paulo: Érica, 2000. FARRER, Harry; et. al. Algoritmos Estruturados. 3. ed. São Paulo: LTC, 1999.
fimenquanto retorne(resp) fim var numero, fat : inteiro inicio escreva(“Entre com um número:”) leia(numero) fat <- FATORIAL(numero) escreva(“Resultado: ”, fat) fimalgoritmo Nesse algoritmo, perceba o uso das variáveis auxiliares para controlar a repetição do cálculo do fatorial. Vamos ver o teste de mesa dessa função, para o fatorial do número 5. resp i 1 5 5 4 20 3 60 2 120 1 120 0 Agora, vamos ver um algoritmo recursivo para o cálculo do fatorial. Exemplo 15: Implemente um algoritmo que contenha uma função recursiva para o cálculo do fatorial. algoritmo “Fatorial_Recursivo” funcao FATORIAL(N : inteiro) : inteiro var resp : inteiro inicio se (n > 0) entao resp <- n * FATORIAL(N - 1) senao resp <- 1 fimse retorne(resp) fim var numero, fat : inteiro inicio escreva(“Entre com um número:”) leia(numero) fat <- FATORIAL(numero) escreva(“Resultado: ”, fat) fimalgoritmo Aqui nesse algoritmo, eliminamos a estrutura de repetição e trocamos por uma estrutura recursiva. Aproveitamos o fato que podemos usar os resultados de funções em expressões de cálculo de resultados e colocamos o resultado da chamada recursiva para ser multiplicado por n. Para entendermos uma função recursiva, devemos entender que neste caso, há uma pilha de funções, onde a cada nova chamada recursiva, é empilhada uma nova função da memória. Para compreendermos esse conceito, vamos explicar o mesmo exemplo do fatorial do número 5:
nosso último tópico sobre modularização de programas. Caso você tenha dúvidas, use os recursos que você tem a sua disposição em sua área do aluno. Na próxima aula, veremos outro tópico importante em algoritmo, o uso de arquivos.
Chegamos ao final da nossa aula sobre recursividade. Vamos recordar? 1 - Conceito de Recursividade Em computação, o nome recursividade é dado a capacidade de uma função poder chamar a si mesma. Essa possibilidade pode transformar algoritmos complexos em algoritmos mais simples e elegantes. 2 - Criando algoritmos recursivos Qualquer situação que envolva uma estrutura de repetição pode ser programada de maneira recursiva. Porém, devemos ter em mente duas observações: sempre colocar uma situação onde a recursividade para (caso contrário, a recursão pode repetir-se indefinidamente) e usar em determinadas situações (pois a recursão consome mais recursos de memória do que uma estrutura de repetição simples). MANZANO, José Augusto N. G.; OLIVEIRA, Jayr Figueiredo de Oliveira. Algoritmos - lógica para desenvolvimento de programação. 2. ed. São Paulo: Érica, 2014. VENANCIO, Claudio Ferreira. Desenvolvimento de Algoritmos : Uma Nova Abordagem. São Paulo: Érica, 2000. FARRER, Harry; et. al. Algoritmos Estruturados. 3. ed. São Paulo: LTC, 1999.
FEOFILOFF, Paulo. Recursão e algoritmos recursivos. São Paulo: USP, 2017. Disponível em: <https://www.ime. usp.br/~pf/algoritmos/aulas/recu.html>. Acesso em: 30 out. 2017.