Apostila Algoritmos parte 6

Prévia do material em texto

1 
 
 
Instituto Federal do Triângulo Mineiro Curso de Licenciatura em Computação – EaD 
Disciplina de Algoritmos Prof. Ernani Cláudio Borges 
Estudos para as atividade da DÉCIMA semana - PARTE 6 
 
Observações importantes: 
a) Esta atividade irá fazer a introdução aos conceitos: 
• Estrutura REPETIÇÃO PARA. 
 
b) Em caso de dúvidas, entre em contato com seu TUTOR A DISTÂNCIA. 
 
Tranquilidade, firmeza, objetividade e BONS ESTUDOS! 
 
 
Nome do aluno(a): __________________________________________________________ Data: ____/_____/_____ 
Matrícula (RA): __________________________ ____________________________________ 
Nome do POLO: _____________________________________________________________ 
 
 
 
 
1 ESTRUTURA DE REPETIÇÃO – “Para” 
 
Antes e lhe apresentar a nova estrutura, vamos recordar os conceitos da 
estrutura de repetição “enquanto”. Você lembra? 
Vejamos ... 
 
Fique de olho! 
A estrutura de repetição “ENQUANTO”, irá executar os comandos existentes 
dentro do “laço” pelo tempo que satisfazer à condição da pergunta que abriu o bloco 
“enquanto”, ou seja, “enquanto a condição for verdadeira” irá entrar no bloco e 
executar seus comandos internos. 
Analise o exemplo abaixo: 
 
 cont � 1 
 equanto cont <= 5 faça 
 mostre (cont, ‘ ‘) 
 cont � cont + 1 
 fimenquanto 
 
Veja que o valor inicial (ou conteúdo) de cont é igual a 1. 
Quando chegamos na próxima linha: “enquanto cont <= 5”, lemos a pergunta 
e analisamos qual o conteúdo da variável cont ... e temos uma resposta 
“verdadeira”, e assim, entramos no laço e executamos os comandos “mostre” e a 
2 
 
atribuição “cont ���� cont + 1”, o qual irá receber o valor 2, o fimenquato retorna a 
pergunta com o valor atual de cont igual a 2 ... entramos no laço novamente e 
executamos os comandos mostre e cont mais 1 ... esses passos irão se repetir até 
que o conteúdo de cont seja maior que 5 e sair para a primeira linha abaixo do 
fimenquanto. 
 
Relembrou?? 
 
 
Bom, após Você ter “ficado de Olho!”, vamos apresentar-lhe a estrutura de 
repetição “REPITA”. 
 
Vamos lá! 
 
1.1 A Estrutura PARA 
 
A diferença entre as duas estruturas: “enquanto” e “para”, é que a primeira 
(enquanto) verifica se é possível entrar no laço, ou seja, caso a condição seja 
verdadeira, poderá a entrada no laço (ou também chamado de bloco de repetição) e 
executar os comandos internos. Além disso, esta estrutura possibilita, na abertura do 
bloco (laço) formular “condições” com tratamento por: números, caracteres e ou 
valor lógico (verdadeiro ou falso). Por exemplo, podemos ter as seguintes 
possibilidades: 
 
Exemplos de abertura bloco “enquanto” - revisão 
 
a) Para mostrar os números de 1 a 5 podemos ter abertura (condição) do 
enquanto da forma abaixo: 
 cont � 1 
 equanto cont <= 5 faça 
 mostre (cont, ‘ ‘) 
 cont � cont + 1 //incremento de +1 até atender a condição 
 fimenquanto 
 
b) Mostrar os números maiores que zero, e para “parar” a sequencia, 
receber uma resposta “sim” para continuar mostrando os números ou 
“não” para sair: 
 cont � 1 
3 
 
 resp � ‘sim’ 
 equanto resp = ‘sim’ faça 
 mostre (cont, ‘ ‘) 
 cont � cont + 1 
 mostre (‘deseja ver o próximo número (sim ou não): ‘) 
 leia (resp) 
 fimenquanto 
 
 
 
Já a condição de entrada da estrutura “PARA”, só pode trabalhar com número 
e contem três parâmetros para formar sua estrutura de abertura do bloco: 
a) o valor inicial; 
b) a condição de parada; e, 
c) qual a variação (incremento ou decremento) para atender a condição de 
parada. 
 
Vamos conhecer a estrutura “PARA”: 
 
1.2 Em foco: Vamos analisar a estrutura PARA? 
 
 
 Para var de x até valor final passo y faça 
 ação 1 
 ação 2 
 . 
 . 
 . 
 fim-para 
 
 
Observe que as palavras: 
• “para” �abre o bloco de repetição, 
• “var” � representa a variável que tem um valor inicial; 
• “valor final” � verifica se o valor inicial é menor ou igual ao valor final; e, 
• “passo” � representa qual a variação do valor, ou seja, de 1 em 1, ou 2 
em 2, ou 5 em 5 ... enfim ... vai depender do problema. 
 
4 
 
Fique de olho! 
Atenção para a característica do “passo”, pois, algumas linguagens de 
programação é permitida. 
 
 
 
1.3 Exemplo 1 – sequencia de números de 1 até 15. 
Para começarmos os primeiros testes, vamos criar um algoritmo que 
possibilite mostrar os número de 1 até 15, variando de 1 em 1. 
 
 
 
1.3.1 Visão central do problema 
 
 
Analisando o problema vamos precisar de quantas variáveis? 
Como você deve ter percebido, precisamos SOMENTE de uma 
variável para mostrar os números, começando por 1 e variar de 1 em1. 
 
Assim, vamos executar os seguintes passos: 
1) criar a variável x do tipo inteiro; 
2) criar a estrutura de repetição e mostrar o valor de x a cada 
execução e variando o conteúdo de x com mais 1. 
4) finalizar o algoritmo 
 
 
 
1.3.2 Visão panorâmica da resolução do problema 
 
/* 
 Cabeçalho: Algoritmo para mostrar a seqüência de 1 a 15 variando de 1 em 1. 
 Nome do Programador: Ernani Cláudio Borges 
 Data: 10/11/2013 
 */ 
5 
 
 
/* nome do algoritmo */ 
algoritmo sequencia1a 15 
 
/* bloco para criar e determinar os tipos de variáveis */ 
var 
 x : inteiro 
 
/* bloco do código principal */ 
inicio 
 
 // inicializar variáveis 
 x � 1 
 
 // corpo do algoritmo 
 
 
 
 
 Para x de 1 ate 15 passo 1 faça 
 mostre (x) 
 x � x + 1 
 fim-para 
 mostre (“acabou !”) 
 pausa 
fim. 
 
 
Vamos analisar! 
 
Fique de olho! 
Em análise do bloco de repetição “PARA” da “visão panorâmica 1.3.2”, vale 
uma reflexão de como sua execução ocorrerá: 
 
para x de 1 ate 15 passo 1 faça 
 mostre (x) 
fim-para 
 
A simulação (teste de mesa) deste bloco terá o seguinte raciocínio: 
• a variável x tem valor inicial igual a 1, entramos no bloco “para”, mostramos 
seu conteúdo na tela; 
• logo em seguida, no “fim-para”, automaticamente irá fazer o “INCREMENTO” 
a variável x de forma que irá receber o valor que ela tem mais 1, ou seja, 
recebe o valor 2; 
• retornamos, assim, ao início do “para”, o compilador irá verificar se o valor de x 
ainda é menor ou igual ao valor final, que em nosso exemplo é igual a 15; 
• E ASSIM POR DIANTE. 
 
6 
 
Você compreendeu? 
 
Só vamos finalizar e sair de dentro do laço “para” quando o valor de x for 
maior que 15, pois, desta forma irá satisfazer à condição. 
 
 
 
1.4 Exemplo 2 – seqüência de números de 1 até n variando de 1 em 1. 
Vamos a mais exemplos ... Vamos lá! 
 
Exemplo: 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 , 11 , ... , n 
 
1.4.1 Visão central do problema 
 
 
Para resolver o problema de mostrar todos os números inteiro de 1 
até “n” vamos precisar um uma variável para contar de 1 até n variando 
de 1 em 1, e uma outra variável que irá representar o valor final “n” da 
seqüência, a qual será fornecida pelo usuário. 
 
Deste modo, executaremos os seguintes passos: 
1) criar as variáveis x e n do tipo inteiro; 
2) inicializar a variável x com 1 e n com 0; 
3) receber o valor de n via teclado; 
4) validar de forma corretiva para que o valor de n seja maior que 
zero; 
4) criar a estrutura de repetição e mostrar o valor de x e a cada 
execução variar o conteúdo de x com mais 1 até que o x seja 
maior que n. 
5) finalizar o algoritmo 
 
 
 
7 
 
1.4.2 Visão panorâmica da resolução do problema 
 
/* 
 Cabeçalho: Algoritmo para mostrar a seqüência de 1 a n. 
 Nome do Programador: Ernani Cláudio Borges 
 Data: 10/11/2013 
 */ 
/* nome do algoritmo */ 
algoritmo sequencia_de_1_a_n 
 
/* bloco para criar e determinar os tipos de variáveis */ 
var 
 x, n : inteiro 
 
/* bloco do código principal */ 
inicio 
 
 // inicializar variáveis 
 x � 1 
 n � 0 
 /* corpo do algoritmo */ 
 mostre (“digite o valor limite para n: ”) 
 leia (n) 
 enquanto n <= 0 faça 
 mostre (‘número inválido ...digite um número positivo: ’) 
 leia(n) 
 fim-enquanto 
 para xde 1 até n passo 1 faça 
 mostre (x) 
 fim-para 
 mostre (“acabou !”) 
 pausa 
fim. 
 
 
1.5 Exemplo 3 – números de 1 a 100 variando de 5 em 5 
Vamos criar um algoritmo processe e mostre os número de 1 a 100, variando 
de 5 em 5 
Acompanhe a visão central e vamos criar o algoritmo. 
 
1.5.1 Visão central do problema 
 
 
Bom, vamos interpretar o problema: 
8 
 
 
Precisamos de uma variável, a qual irá receber 1 inicialmente, 
vamos mostrá-la no vídeo, e logo a seguir variar seu conteúdo em mais 
cinco, ou seja, vamos mostrar: 1, 6, 11, 16, 21, ..., 96. 
 
Analise os passos do algoritmo: 
1) criar a variável x do tipo inteiro; 
2) inicializar a variável x com 1; 
3) abrir o laço: para x de 1 ate 100 passo 5 faça 
 3.1) mostrar o conteúdo de x; 
5) pausar e finalizar o algoritmo. 
 
 
 
1.5.2 Visão panorâmica da resolução do problema 
 
/* 
 Cabeçalho: Algoritmo para mostrar os número de 1 a 100 variando de 5 em 5. 
 Nome do Programador: Ernani Cláudio Borges 
 Data: 10/11/2013 
 */ 
/* nome do algoritmo */ 
algoritmo números_1_a_100 
 
/* bloco para criar e determinar os tipos de variáveis */ 
var 
 x : inteiro 
 
/* bloco do código principal */ 
inicio 
 
 // inicializar variáveis 
 x � 1 
 
 // corpo do algoritmo 
 
 para x de 1 ate 100 passo 5 faça 
 mostre (x) 
 fim-para 
 mostre (“acabou !”) 
 pausa 
fim. 
 
 
9 
 
 
1.6 Exemplo 4 – fatorial de um número. 
Vamos criar um algoritmo que receba, processe e mostre o valor do fatorial 
deste número. 
 
Fique de olho! 
Sabemos que o fatorial de um número na matemática é a soma de todos os 
números inteiro de seu intervalo, começando pelo número até 
Veja, o fatorial de 5 é igual a 120, ou seja, 1 * 2 * 3 * 4 * 5 = 120 
 
 
1.6.1 Visão central do problema 
 
 
Bom, vamos interpretar o problema: 
 
Receber um número positivo via teclado, vamos validar 
corretivamente para que esse número seja positivo, e vamos criar um 
laço para efetuar o cálculo do fatorial deste número. 
 
Analise os passos do algoritmo: 
1) criar as variáveis cont, n, fat do tipo inteiro; 
2) inicializar a variável cont, fat com 1 e n com 0; 
3) receber o número positivo via teclado; 
 3.1) receber o número (leia (n)); 
 3.2) validar o número para seja positivo (maior que zero); 
5) calcular o fatorial; 
5) mostrar o resultado do cálculo; 
5) pausar e finalizar o algoritmo. 
 
 
 
10 
 
1.6.2 Visão panorâmica da resolução do problema 
 
/* 
 Cabeçalho: Algoritmo para mostrar o número fatorial de um número 
 Nome do Programador: Ernani Cláudio Borges 
 Data: 10/11/2013 
 */ 
/* nome do algoritmo */ 
algoritmo fatorial 
 
/* bloco para criar e determinar os tipos de variáveis */ 
var 
 cont, n, fat : inteiro 
 
/* bloco do código principal */ 
inicio 
 
 // inicializar variáveis 
 cont � 1 
 n � 0 
 fat � 1 
 
 // corpo do algoritmo 
 
 repita 
 mostre (“digite o um número: ”) 
 leia (n) 
 // Validação para o número ser positivo 
 se (n <= 0) faca 
 mostre (“número invalido ... digite outro número positivo: ”) 
 leia (n) 
 fimse 
 ate-que n > 0 
 // Laço para o cálculo do fatorial 
 para cont de 1 ate n passo 1 faça 
 Fat � fat * cont 
 fim-para 
 mostre (‘o valor do fatorial = ‘, fat) 
 mostre (“acabou !”) 
 pausa 
fim. 
 
 
 
Fique de olho! 
Observe na resolução do algoritmo acima fizemos a validação corretiva 
utilizando a estrutura de repetição “REPITA”. Desta forma, estou demonstrando que 
é você quem decide qual estrutura de repetição utilizar e quando utilizar. 
 
11 
 
 
 
1.6.3 Visão central do problema – outra forma de executar o mesmo algoritmo 
do fatorial 
 
 
Vamos refazer o algoritmo do fatorial utilizando estruturas de 
repetição diferentes das que forma utilizadas na resolução anterior. 
Vejamos: 
 
 
1.6.4 Visão panorâmica da resolução do problema – parte 2 
 
/* Cabeçalho: Algoritmo para mostrar o número fatorial de um número – parte 2 
 Nome do Programador: Ernani Cláudio Borges 
 Data: 10/11/2013 
nome do algoritmo */ 
algoritmo fatorial 
 
/* bloco para criar e determinar os tipos de variáveis */ 
var 
 cont, n, fat : inteiro 
 
/* bloco do código principal */ 
inicio 
 
 // inicializar variáveis 
 cont � 1 
 n � 0 
 fat � 1 
 
 // corpo do algoritmo 
 
 mostre (“digite o um número: ”) 
 leia (n) 
 // Validação para o número ser positivo 
 enquanto (n <= 0) faca 
 mostre (“número invalido ... digite outro número positivo: ”) 
 leia (n) 
 fim-enquanto 
 // Laço para o cálculo do fatorial 
 enquanto cont <= n faça 
 fat � fat * cont 
 cont � cont +1 
 fim-enquanto 
 mostre (‘o valor do fatorial = ‘, fat) 
12 
 
 mostre (“acabou !”) 
 pausa 
fim. 
 
 
 
1.7 Exemplo 5 – Somatória da sequencia 1 
Elabore um algoritmo que processe e apresente o valor de S correspondente 
a série abaixo : 
50
99
...
6
11
5
9
4
7
3
5
2
3
1
1
+++++++=S 
 
 
Vamos a visão central! 
 
1.7.1 Visão central do problema 
 
 
Observando a sequência, podemos verificar que temo um 
numerador 1 sendo divido por um denominador 1, o resultado da 
divisão é guardado em S, logo a seguir temo outro numerador 3 sendo 
divido por outro denominador 2 o resultado é acumulado com o 
conteúdo de S ... e assim por diante. 
Observa-se ainda que no numerador está variando de 2 4em 2 (1, 
3, 5, ..., 99 ) e o denominador variando de 1 em 1 (1, 2, 3, 4, ... 50). 
Criaremos, então vamos criar três variáveis: S, num, den ... pois já 
temos a condição de parada para o laço de repetição ... Sabe qual é? 
Escolhi colocar o “para” den de 1 até 50 passo 1. O que acha? 
 
Analise os passos do algoritmo: 
1) criar a variável S do tipo real; 
2) criar num, den do tipo inteiro; 
3) inicializar a variável s com 0, num e den com 1; 
5) calcular a sequencia; 
13 
 
5) mostrar o resultado do cálculo; 
5) pausar e finalizar o algoritmo. 
 
 
1.7.2 Visão panorâmica da resolução do problema 
 
/* Cabeçalho: Algoritmo para mostrar a somatória 
 Nome do Programador: Ernani Cláudio Borges 
 Data:10/11/2013 
nome do algoritmo */ 
algoritmo somatorio1 
 
/* bloco para criar e determinar os tipos de variáveis */ 
var 
 num, den : inteiro 
 s : real 
 
/* bloco do código principal */ 
inicio 
 
 // inicializar variáveis 
 s � 0 
 num � 1 
 den � 1 
 
 // cálculo da sequencia somatoria 
 para den de 1 ate 50 passo 1 faça 
 s � s + (num / den) 
 num � num + 2 
 den � den + 1 
 fim-para 
 mostre (‘valor da soma = ‘, s) 
 pausa 
fim. 
 
 
 
1.8 Exemplo 6 – Somatória da sequencia 2 
Elabore um algoritmo que processe e apresente o valor de S correspondente 
aos 20 primeiro “termos” da série abaixo : 
...
30
985
25
988
20
991
15
994
10
997
5
1000
++++++=S 
 
Vamos a visão central! 
14 
 
 
1.8.1 Visão central do problema 
 
 
Observando a sequência, podemos verificar que temo um 
numerador 1000 sendo divido por um denominador 5, o resultado da 
divisão é guardado em S, o qual, inicialmente tem conteúdo 0 (zero), 
logo a seguir temo outro numerador 997 sendo divido por outro 
denominador 10 o resultado é acumulado com o conteúdo de S ... e 
assim por diante. 
Observa-se ainda que no numerador está variando de 3 em 3 
(1000, 997, 994, 991, ...) e o denominador variando de 5 em 5 (5, 10, 
15, 20, ...). 
Criaremos, então vamos criar três variáveis: S, num, den ... pois já 
temos a condição de parada para o laço de repetição ... Sabe qual é? 
Podemos escolher a estrutura “para” cont de 1 até 20 passo 1. O que 
acha? Pois, o problema pediu o somatórios dos 20 primeiros termos. 
 
Analise os passos do algoritmo: 
1) criar a variável S do tipo real; 
2) criar num, den, cont do tipo inteiro; 
3) inicializar a variável s com 0, cont com 1, num com 1000 e den com 
5; 
5) calcular a sequencia; 
5) mostrar o resultado do cálculo; 
5) pausar e finalizar o algoritmo.1.8.2 Visão panorâmica da resolução do problema 
 
/* Cabeçalho: Algoritmo para mostrar a somatória 
 Nome do Programador: Ernani Cláudio Borges 
 Data:10/11/2013 
nome do algoritmo */ 
algoritmo somatória2 
15 
 
 
/* bloco para criar e determinar os tipos de variáveis */ 
var 
 num, den : inteiro 
 s : real 
 
/* bloco do código principal */ 
inicio 
 
 // inicializar variáveis 
 s � 0 
 num � 1000 
 den � 5 
 cont � 1 
 
 // cálculo da sequencia somatoria 
 para cont de 1 ate 20 passo 1 faça 
 s � s + (num / den) 
 num � num -3 
 den � den + 5 
 fim-para 
 mostre (‘valor da soma = ‘, s) 
 pausa 
fim. 
 
 
 
1.9 Exemplo 7 – Somatória da sequencia 3 
Elabore um algoritmo que processe e apresente o valor de S correspondente 
aos 20 primeiro “termos” da série abaixo : 
50654321
2...222222 +++++++=S 
 
Vamos a visão central! 
 
1.9.1 Visão central do problema 
 
 
Veja bem ... 
Observamos o expoente está variando de 1 em 1 até chegar em 
cinquenta. 
Analisando como fazer o cálculo da exponenciação teremos, como 
por exemplo 25 ... ou seja, 2 * 2 * 2 * 2 * 2 = 32 ... desta forma podemos 
16 
 
criar uma estrutura de repetição para o cálculo da exponenciação. 
Criaremos, então vamos criar três variáveis: S, cont, res, expo. 
 
Analise os passos do algoritmo: 
1) criar a variável S do tipo real; 
2) criar cont, res, expo do tipo inteiro; 
3) inicializar a variável s com 0, cont, res e expo com 1; 
5) calcular a sequencia; 
5) mostrar o resultado do cálculo; 
5) pausar e finalizar o algoritmo. 
 
 
1.9.2 Visão panorâmica da resolução do problema 
 
/* Cabeçalho: Algoritmo para mostrar a somatória 
 Nome do Programador: Ernani Cláudio Borges 
 Data:10/11/2013 
nome do algoritmo */ 
algoritmo somatória3 
 
/* bloco para criar e determinar os tipos de variáveis */ 
var 
 cont, expo, res : inteiro 
 s : real 
 
/* bloco do código principal */ 
inicio 
 // inicializar variáveis 
 s � 0 
 cont � 1 
 expo � 1 
 cont � 1 
 res � 1 
 // cálculo da sequencia somatoria 
 para expo de 1 ate 50 passo 1 faça 
 cont � 1 
 enquanto cont <= expo faç 
 res � 2 * res 
 cont � cont + 1 
 fim-enquanto 
 s � s + res 
 expo � expo + 1 
 res � 1 
 fim-para 
 mostre (‘valor da soma = ‘, s) 
17 
 
 pausa 
fim. 
 
 
 
1.10 Exemplo 8 – Somatória da sequencia 4 
Elabore um algoritmo que processe e apresente o valor de S correspondente 
aos 20 primeiro “termos” da série abaixo : 
...
5
!5
4
!4
3
!3
2
!2
++++=S 
 
Vamos a visão central! 
 
1.10.1 Visão central do problema 
 
 
Veja bem ... 
Observamos o numerador começa em 2 e está variando de 1 em 1 
até chegar em vinte e um. 
Já sabemos como calcular o fatorial ... Você lembra? Só 
recordando ... é a multiplicação de todos o termos do número, 
começando por 1, variando de 1 em 1 até ele. Desta forma, após 
calcular o fatorial do primeiro numerador, vamos dividi-lo pelo 
denominador e o resultado irá somar ao conteúdo de S (que inicialmente 
é zero). Após, vamos incrementar as variáveis do numerador e 
denominador com mais um. Lembrando que vamos precisar de um 
contador para contar até 20 (os vinte primeiros termos da sequencia). 
 
Analise os passos do algoritmo: 
1) criar a variável S do tipo real; 
2) criar cont, num, den, fat do tipo inteiro; 
3) inicializar a variável s com 0, cont, fat com 1, num e den com 2; 
5) calcular a sequencia; 
5) mostrar o resultado do cálculo; 
18 
 
5) pausar e finalizar o algoritmo. 
 
 
1.10.2 Visão panorâmica da resolução do problema 
 
/* Cabeçalho: Algoritmo para mostrar a somatória 
 Nome do Programador: Ernani Cláudio Borges 
 Data:10/11/2013 
nome do algoritmo */ 
algoritmo somatória4 
 
/* bloco para criar e determinar os tipos de variáveis */ 
var 
 cont, fat, num, den : inteiro 
 s : real 
 
/* bloco do código principal */ 
inicio 
 // inicializar variáveis 
 s � 0 
 cont1 � 1 
 cont2 � 1 
 fat � 1 
 num � 2 
 den � 2 
 
 // cálculo da sequencia somatoria 
 para cont1 de 1 ate 20 passo 1 faça 
 enquanto cont2 <= num faça 
 fat � fat * cont2 
 cont2 � cont2 + 1 
 fim-enquanto 
 s � s + fat 
 fat � 1 
 num � num + 1 
 den � den + 1 
 cont2 � 1 
 fim-para 
 mostre (‘valor da soma = ‘, s) 
 pausa 
fim. 
 
 
 
 
 
 
19 
 
2 REFERÊNCIAS 
 
ASCENCIO, Ana Fernanda Gomes. Fundamentos da programação de 
Computadores: Algoritmos, Pascal, C/C++ e Java. 2ed. São Paulo: Pearson 
Prentice Hall, 2007. 
 
ASCENCIO, Ana Fernanda Gomes. Fundamentos da programação de 
computadores. Prentice Hall. São Paulo, 1999. 
 
ASCENCIO, Ana Fernanda Gomes. Fundamentos da programação de 
computadores. Prentice Hall. São Paulo, 2002. 
 
 
GUIMARÃES, Ângelo de Moura; LAGES, Newton Alberto de Castilho. Algoritmos e 
Estruturas de Dados. 23ed. Rio de Janeiro: LTC – Livros Técnicos e Científicos 
Editora S.A., 1994. 
 
FARRER, Harry, Algoritmos Estruturados. LTC. Rio de Janeiro, 1999 
 
FORBELLONE, André Luiz Villar. A lógica de Programação: A construção de 
Algoritmos e Estruturas de Dados. São Paulo: Makron Books, 1993. 
 
MANZANO, José Augusto. Algoritmos: Lógica para Desenvolvimento de 
programação. Érica. São Paulo, 1996.