semana 5 - algoritmo

Prévia do material em texto

Lógica de Programação 
Aracele Garcia de Oliveira Fassbinder 
 
Curso Técnico em Informática 
 
 
 
 
 
 
 
 
 
 
Instituto Federal de Educação, Ciência e Tecnologia do Sul de Minas Gerais 
Muzambinho - MG 
2012 
 1 
Indicação de ícones 
Os ícones são elementos gráficos utilizados para ampliar as formas de linguagem e 
facilitar a organização e a leitura hipertextual. 
 
Atenção: indica pontos de maior relevância no texto. 
 
Saiba mais: oferece novas informações que enriquecem o 
assunto ou “curiosidades” e notícias recentes relacionadas ao 
tema estudado. 
 
Glossário: indica a definição de um termo, palavra ou 
expressão utilizada no texto. 
 
Mídias Integradas: sempre que se desejar que os estudantes 
desenvolvam atividades empregando diferentes mídias: 
vídeos, filmes, jornais, ambiente virtual de ensino e 
aprendizagem e outras. 
 
Atividades de aprendizagem: apresenta atividades em 
diferentes níveis de aprendizagem para que o estudante possa 
realizá-las e conferir o seu domínio do tema estudado. 
 
 
 2 
Sumário 
 
Palavra da professora-autora ........................................................................................ 4 
Apresentação da disciplina ............................................................................................ 5 
Projeto instrucional ........................................................................................................ 7 
Aula 1 - Introdução à Lógica de Programação ......................................................................... 9 
1.1 História da Computação ................................................................................................... 9 
1.2 Lógica de Programação, Algoritmos e Programas ......................................................... 12 
1.3 Desenvolvimento de Algoritmos .................................................................................... 16 
1.4 Editor e Interpretador de Pseudocódigos: VisuALG ...................................................... 19 
1.4.1Como obter o VisuALG?........................................................................................ 19 
1.4.2Executando o VisuALG ......................................................................................... 20 
1.4.3A linguagem do VisuALG...................................................................................... 21 
1.4.4Comando de Saída de Dados .................................................................................. 23 
1.4.5Seu primeiro algoritmo no VisuALG: Olá Mundo ................................................. 24 
1.4.6Comando de Entrada de Dados .............................................................................. 26 
1.5 Atividades propostas para a aula 1 ................................................................................. 28 
Aula 2 – Variáveis, Constantes, Tipos de Dados e Operadores ............................................ 29 
2.1 Variáveis e Constantes .......................................................................................................... 29 
2.2 Identificadores ....................................................................................................................... 30 
2.3 Tipos de Dados ...................................................................................................................... 31 
2.4 Declarações de Variáveis ...................................................................................................... 32 
2.5 Atribuição de Valores para Variáveis ................................................................................... 33 
2.6 Operadores ............................................................................................................................ 36 
2.7 Definição do Problema Base: ................................................................................................ 41 
2.8 Atividades propostas para a aula 2 ........................................................................................ 43 
Aula 3 – Estruturas Condicionais ou de Seleção .................................................................... 42 
3.1 Desvio e Seleção do Fluxo de Instruções .............................................................................. 42 
3.2 Se...entao...senao ................................................................................................................... 44 
3.2.1 Resolvendo o “problema base” no VisuALG ........................................................ 46 
3.2.2 Condição Composta e os operadores booleanos.................................................... 46 
3.2.2 Aninhamento da estrutura se ................................................................................. 48 
3.3 Caso...escolha ........................................................................................................................ 48 
3.3.1 Resolvendo o “problema base” no VisuALG ........................................................ 49 
 3 
3.4 Atividades propostas para a aula 3 ........................................................................................ 51 
Aula 4 – Estruturas de Repetição ............................................................................................ 52 
4.1 Contexto ................................................................................................................................ 52 
4.2 Para...faça .............................................................................................................................. 53 
4.3 Enquanto ............................................................................................................................... 54 
4.4 Repita .................................................................................................................................... 55 
4.5 Resolvendo o “problema base” ............................................................................................. 56 
4.6 Atividades propostas para a aula 4 ........................................................................................ 60 
Aula 5 - Variáveis Indexadas Homogêneas ............................................................................. 61 
5.1 Vetores e Matrizes ................................................................................................................. 61 
5.2 Variáveis Indexadas Unidimensionais (vetor) ...................................................................... 63 
5.2.1 Trabalhando com Vetores no VisuALG ................................................................ 64 
5.2.2 Resolvendo o problema base ................................................................................. 67 
5.3 Variáveis Indexadas Bidimensionais (matriz) ....................................................................... 70 
5.3.1 Trabalhando com Matrizes no VisuALG .............................................................. 72 
5.4 Atividades propostas para a aula 5 ........................................................................................ 74 
Aula 6 - Subalgoritmos ............................................................................................................. 75 
6.1 Modularização do Código ..................................................................................................... 75 
6.1.1 Funções .................................................................................................................. 76 
6.1.2 Procedimentos ....................................................................................................... 81 
6.2 Atividades propostas para a aula 6 ........................................................................................ 84 
Referências .................................................................................................................................. 85 
Currículo da professora-autora.................................................................................. 87 
 
 
 4 
Palavra da professora-autora 
Caro estudante, 
Após o estudo de vários assuntos relacionados ao mundo da Informática, chegou a hora 
de dar um passo essencial na sua formação: o estudo da Lógica de Programação. A 
Lógica de Programação é muito importante para todos aqueles que buscam 
compreender a melhor forma de se comunicar com os computadores! 
 
Este caderno sobre Lógica de Programação possui um papel fundamental na sua 
formação como "Técnico em Informática", pois ele traz o conteúdo necessário para que 
você consiga expressar a resolução de problemas de uma forma que o computador 
entenda, ou seja, através dos algoritmos implementados em uma determinada linguagem 
de programação. Aproveite ao máximo todo material contido aqui, dedique-se muito, 
pois estamos falando da introdução ao desenvolvimento de sistemas. Após todo este 
estudo, você terá condições de passar de um simples usuário de computador para um 
programador de sistemas, seja web, desktop ou para dispositivos móveis. 
 
A aprendizagem de programação de computadores existe muito esforço e prática. 
Para terminar, deixo a você algumas dicas úteis de como estudar algoritmos: 
 Faça a leitura deste caderno e procure ler materiais adicionais. 
 Pergunte sempre que estiver com dúvida. 
 Resolva os exercícios propostos e os complementares. 
 Comece a resolver os algoritmos pelos mais simples e avance quando estiver 
confiante de que aprendeu o conteúdo que lhe foi proposto. 
 Crie rotinas de estudo. 
 Um assunto é sequência do outro. Concentre-se em manter o mesmo ritmo de 
aprendizagem ao longo de toda a disciplina, a fim de obter melhores resultados. 
 A única maneira de aprender algoritmos é praticando, resolvendo todos eles. 
Não basta apenas ler o conteúdo e assistir as aulas. Fique atento sobre isso! 
 
Bons estudos! 
Um grande abraço! 
 
Professora Aracele Garcia de Oliveira Fassbinder 
 5 
Apresentação da disciplina 
Olá, car@ estudante! 
Através desta disciplina você descobrirá a importância de conhecer os fundamentos do 
desenvolvimento de sistemas. A Lógica de Programação é a base para as demais 
disciplinas do seu curso e é através dela que você conseguirá o embasamento necessário 
para conseguir escrever algoritmos em Linguagens de Programação importantes para o 
desenvolvimento de sistemas. 
 
O objetivo deste material é auxiliá-lo no conhecimento de conteúdos dos fundamentos 
da Lógica de Programação e desenvolvimento de algoritmos. Com ele, você perceberá a 
importância de conhecer esses conceitos para aplicá-los de maneira coerente na 
construção de algoritmos que automatizem tarefas feitas manualmente ou resolvem 
algum tipo de problema específico. 
 
Programar exige muito raciocínio, paciência e treino, muito treino. 
É importante lembrar que a aprendizagem é um processo contínuo. Além disso, cada 
pessoa aprende de uma maneira, ou seja, possui o seu próprio estilo de aprendizagem. 
Sendo assim, esta disciplina possui diversas atividades que contribuem para o 
desenvolvimento do seu raciocínio lógico e comunicação interpessoal. 
 
Para que você obtenha sucesso, será necessário que se envolva com as atividades 
propostas, buscando cumprir as tarefas, seguir as instruções, agir com organização e 
controle sobre o tempo previsto. Será preciso, também, participar de forma ética e ativa 
nos fóruns e encontros presenciais, com os colegas da turma e com o tutor presencial. 
O seu sucesso depende exclusivamente de você! Mas isso não significa que você está 
sozinho, conte sempre com os colegas, tutores e com a professora. Entre em contato 
através do ambiente virtual de aprendizagem, através de fóruns de dúvidas e chats. 
 
O estudo da da Aula 1 deste caderno é importantíssima ! 
Procure perceber os conceitos relacionados com a lógica de programação: a história do 
computador, instruções, algoritmos e a ferramenta que vamos utilizar para implementar 
os nossos algoritmos. O objetivo desta aula é que você perceba e identifique o que é a 
 6 
Lógica e a importância desse conceito para aprender algoritmos, ou seja, aprender a 
base da programação ! 
 
A segunda aula traz os tipos de dados possíveis de uso em nossos pseudocódigos, 
conceitos e regras para uso de variáveis, além de expressões e operações. Estes novos 
conceitos são importantes e precisamos conhecê-los antes de efetivamente começar a 
trabalhar com programação! 
 
Na terceira aula você continuará aprendendo sobre os pseudocódigos, mas trabalhará de 
forma específica com as Estruturas Condicionais. 
 
Na quarta aula você aprenderá a trabalhar com as Estruturas de Repetição, a fim de 
repetir blocos de comandos para resolver problemas que envolvem tarefas repetitivas. 
 
Na quinta aula você trabalhará com formas de armazenamento um pouco mais 
complexas que as variáveis aprendidas nas primeiras aulas. 
 
E, por fim, você aprenderá uma técnica muito útil para modularizar o seu código e 
deixá-lo mais legível. 
 
Esta é a base da Lógica de Programação, independente da Linguagem de Programação 
que será utilizada para desenvolver algoritmos. 
 
Fica aqui o desafio de concluirmos este estudo com SUCESSO! 
Profª. Aracele Garcia de Oliveira Fassbinder 
 
 7 
Projeto instrucional 
Disciplina: Lógica de Programação (carga horária: 60h). 
Ementa: Introdução à Computação, Lógica de Programação, Instruções, Algoritmos, 
comandos de entrada e saída de dados, dados, tipos de ados, estruturas sequenciais, 
estruturas condicionais, estruturas de repetição, variáveis indexadas homogêneas e 
subprogramação. 
AULA OBJETIVOS DE APRENDIZAGEM MATERIAIS 
CARGA 
HORÁRIA 
(horas) 
1. Introdução à 
Lógica de 
Programação 
Conhecer a história da 
Computação e compreender a 
sua evolução. 
 
Compreender a importância 
da Lógica e das Linguagens 
de Programação para o 
desenvolvimento de sistemas. 
 
 
 
 
 
 
 
 
Caderno e 
Ambiente Virtual 
de Ensino- 
Aprendizagem. 
 
http://eadinfo.muz.i
fsuldeminas.edu.br/ 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
10 
2. Variáveis e 
Operadores 
Definir e compreender o uso 
de variáveis e constantes. 
 
Compreender o que são e 
quais são os tipos de dados 
básicos. 
 
Conhecer a definição e o 
correto uso de expressões e 
operadores. 
10 
3. Estruturas de 
Decisão 
Compreender o uso das 
estruturas condicionais ou de 
seleção no processo de 
criação de algoritmos. 
 
Resolver algoritmos que 
incluem o uso de estruturas 
condicionais. 
10 
4. Estruturas de 
Repetição 
Compreender o uso das 
estruturas de repetição no 
processo de criação de 
algoritmos. 
 
Resolver algoritmos que 
incluem o uso de estruturas 
de repetição e as estruturas já 
estudadas. 
 
 
 
10 
http://eadinfo.muz.ifsuldeminas.edu.br/
http://eadinfo.muz.ifsuldeminas.edu.br/
 8 
5. Variáveis 
Compostas 
Homogêneas: Vetores 
e Matrizes 
Compreender o uso das 
variáveis compostas 
homogêneas. 
 
Resolver algoritmos que 
incluem o uso de variáveis 
indexadas homogêneas. 
 
 
 
Caderno e 
Ambiente Virtual 
de Ensino- 
Aprendizagem. 
 
http://eadinfo.muz.i
fsuldeminas.edu.br 
 
10 
6. Subalgoritmos 
Compreender a aplicação da 
modularização do código 
para resolver problemas mais 
complexos. 
 
Resolver problemas que 
envolvam a modularização 
do código. 
10 
 
 
http://eadinfo.muz.ifsuldeminas.edu.br/
http://eadinfo.muz.ifsuldeminas.edu.br/
 9 
Aula 1 - Introdução à Lógica de Programação 
Objetivos 
Conhecer a história da Computação e compreender a sua evolução. 
Compreender a importância da Lógica e das Linguagens de Programação para o 
desenvolvimento de sistemas. 
1.1 História da Computação 
Por volta de 4000-1200 anos a.C., habitantes da primeira civilização conhecida na 
Suméria mantém um registro de transações comerciais emtábuas de argila. 
A necessidade de contar e quantificar coisas mais complexas que os cálculos que 
utilizavam somente os dedos e recursos primários foram apoiados pelo desenvolvimento 
do Ábaco, inventado na Babilônia, por volta de 3000-2400 a.C. 
 
Figura 1.1 - Ábaco Russo 
Fonte: Wikipedia (Ábaco), 2012 
A evolução constante da matemática e das ciências exatas fez com que Blaise Pascal 
criasse, por volta de 1640 d.C., um somador baseado no mecanismo de engrenagem, o 
qual é chamado de “Pascalene” ou “Pascalina”, a primeira máquina somadora mecânica. 
Pascal, que aos 18 anos trabalhava com seu pai em um escritório de coleta de impostos 
na cidade de Rouen, desenvolveu a máquina para auxiliar o seu trabalho de 
contabilidade. Entretanto, apenas em 1672, o alemão Gottfried Leibniz conseguiu o que 
Pascal não tinha conseguido: criar uma calculadora mais completa, que efetuava a soma 
e a divisão, além da raiz quadrada. 
 10 
 
Leia mais sobre a história dos computadores e da computação. Acesse: 
http://www.tecmundo.com.br/mac-os-x/1697-a-historia-dos-computadores-e-da-
computacao.htm#ixzz2FIrZSpgE 
 
Figura1.2 - Máquina de Pascal 
Fonte: A era da Tecnologia, 2012 
A Máquina de Pascal e todas as outras que apareceram antes ou depois dela estavam 
longe de serem consideradas um computador, pois não podiam ser programadas, isto 
quer dizer que a entrada era feita apenas de números, mas não de instruções a respeito 
do que fazer com estes números. 
Até que, por volta de 1833, Charles Babbage, hoje conhecido como o "Pai do 
Computador", iniciou o projeto Máquina Analítica com Cartões Perfurados, que é 
considerado um dos primeiros modelos teóricos de um computador, pois era possível 
passar instruções para que a máquina as reproduzisse automaticamente, com pouca 
intervenção humana. 
 
Figura 1.3 - Máquina Analítica de Charles Babbage 
Fonte: DMA Departamento de Matemática Aplicada, 2012 
http://www.tecmundo.com.br/mac-os-x/1697-a-historia-dos-computadores-e-da-computacao.htm#ixzz2FIrZSpgE
http://www.tecmundo.com.br/mac-os-x/1697-a-historia-dos-computadores-e-da-computacao.htm#ixzz2FIrZSpgE
 11 
Os primeiros programas para computador foram baseados nos estudos publicados pela 
matemática Ada Augusta Byron King (1815-1852), mais conhecida como Condessa de 
Lovelace ou Ada Lovelace. Ela foi pioneira na área de Lógica de Programação e é 
principalmente conhecida por ter escrito um programa que poderia utilizar a máquina 
analítica de Charles Babbage. Este programa utilizava os conceitos de subprogramação 
e repetições. Ela também iniciou o desenvolvimento do que hoje conhecemos como 
desvios condicionais. Os trabalhos iniciados por Ada inspiraram o trabalho de Alan 
Turing que, em 1940, construiu o primeiro computador moderno. 
 
Figura 1.4 - Primeira efetiva programadora de computadores 
Fonte: American University in Bulgaria, 2012 
Os acontecimentos seguintes envolveram diversos matemáticos, lógicos, físicos e 
engenheiros. Os trabalhos consistiam, em sua maioria, em continuar uma linha de 
trabalho já iniciada por outra pessoa ou na criação de um novo trabalho que viesse a 
refutar algum outro. 
Refutar significa encontrar um raciocínio ou um argumento que contradiz o 
que outra pessoa está dizendo. 
Citaremos alguns nomes influentes para a história dos computadores e da lógica de 
programação, mas deixaremos para você a busca por novas informações. Tente 
pesquisar sobre George Boole (Lógica Simbólica), Cantor (Teoria dos Conjuntos), 
Gottlob Fregue (Lógica, Teoria da Linguagem) e outros lógicos e matemáticos, tais 
como G. Peano, Bertrand Russel, Whitehead, Godel, Alonso Church, Alan Turing 
(Teoria da Computabilidade e Máquina de Turing), Isaac Asimov (Robot). 
 12 
Além disso, procure conhecer mais sobre a história dos computadores modernos, 
pesquise por Bell Labs, Colossus, Mark I, IBM, ENIAC, Grace Murray (programadora 
do Mark I) e Edsger Dijkstra (construiu um algoritmo eficiente para caminhos curtos), 
dentre outros. 
Saiba mais sobre a História da Computação através do livro digital “História da 
Computação – o caminho do pensamento e da tecnologia”, escrito por Cléuzio Fonseca 
Filho e disponibilizado aqui: 
http://www.pucrs.br/edipucrs/online/historiadacomputacao.pdf 
Biografia de Alan Turing em http://informatica.hsw.uol.com.br/alan-turing.htm 
 
1.2 Lógica de Programação, Algoritmos e Programas 
A Lógica é a Ciência que estuda o raciocínio. Raciocínio pode ser definido como uma 
forma de processar informações simbólicas a fim de atingir um determinado objetivo ou 
conhecimento. A Lógica relaciona-se intimamente com três grandes áreas de 
conhecimento, tais como a Matemática, a Informática, a Filosofia e a Linguística. 
Vários dos fundadores da moderna Ciência da Computação foram lógicos. A 
Inteligência Artificial Simbólica tem na Lógica um de seus principais pilares. Toda a 
Matemática utiliza-se, em sua expressão linguística, de conceitos puramente lógicos; 
não é possível daí entender Matemática seriamente sem entender em detalhes a Lógica, 
pelo menos em suas bases elementares.(FASSBINDER, 2010) 
A Lógica, quando aplicada na Matemática, para estudar o raciocínio matemático, pode 
ser chamada de Lógica Matemática. No caso da área de Informática, temos a Lógica de 
Programação, a qual é uma aplicação da lógica para escrevermos Algoritmos, 
representados em uma determinada Linguagem de Programação que o computador 
entenda e, assim, fazer com que o computador resolva algum problema ou automatize 
alguma tarefa. 
http://www.pucrs.br/edipucrs/online/historiadacomputacao.pdf
http://www.pucrs.br/edipucrs/online/historiadacomputacao.pdf
http://informatica.hsw.uol.com.br/alan-turing.htm
 13 
A Lógica de Programação permite que criemos uma sequência de instruções ou passos a 
serem seguidos pelo computador a fim de obtermos uma solução para um problema. 
Desta forma, 
LÓGICA DE PROGRAMAÇÃO é a técnica de encadear os pensamentos para se atingir 
um objetivo. Estes pensamentos podem ser descritos como uma sequência de instruções. 
INSTRUÇÕES são conjuntos de regras ou normas definidas para a realização de uma 
tarefa. Em informática, instrução é a informação que indica a um computador uma ação 
elementar a ser executada. 
Antes de falarmos o que é um algoritmo, pense na seguinte situação “Comer uma 
maça”. Esta tarefa bem simples exige uma sequência de instruções logicamente 
ordenadas para que, ao final, o objetivo seja alcançado, ou seja, que você consiga comer 
a maça! 
 
Figura 1.5 - Sequência de instruções para comer uma maça 
Fonte: Comidas e Bebidas, 2012 
Uma sugestão de instruções válidas e ordenadas para que você consiga comer uma 
maça: 
1. Pegar a maça 
2. Lavar a maça 
3. Pegar uma faca 
4. Descascar a maça com a faca 
5. Comer a maça 
6. Jogar o caroço e as sementes no lixo 
 
Não tem como você jogar o caroço e as 
sementes no lixo sem antes ter 
descascado e comido a maça! 
Você percebe a importância de raciocinar 
sobre as instruções e como elas devem 
ser ordenadas para que o resultado final 
seja alcançado com sucesso? 
 14 
Agora podemos definir um dos conceitos mais importantes da área de desenvolvimento 
de programas para quaisquer tipos de dispositivos, sejam eles computadores, tabletes, 
celulares, televisão digital, carros, equipamentos domésticos, dentre outros: o 
ALGORITMO! 
Um ALGORITMO é um conjunto de instruções, logicamente ordenadas, para a 
obtenção de um objetivo específico. 
Leia mais sobre a definição de algoritmo através do artigo “O que é um 
algoritmo de computador”, disponível no portal HowStuffWorks. Acesse: 
http://informatica.hsw.uol.com.br/questao717.htm 
A noção de algoritmo é muito simples e não é específica da área de informática. Os 
algoritmos fazem parte da sua vida, mesmo que você não tenha consciência disso! 
Todas as situações descritas abaixo fazem parte da vida das pessoas e elas, 
mentalmente, criamum algoritmo para resolvê-las. 
 Explicar para uma pessoa como ela faz para chegar a um determinado lugar. 
o Você precisa saber a origem da pessoa. A partir disso, você verifica todos 
os passos lógicos para que ela consiga chegar ao seu destino. 
 Fazer um bolo seguindo uma receita. 
o Você precisa identificar os ingredientes (a entrada do seu algoritmo) e 
seguir alguns passos básicos, tais como pegar uma vasilha, colocar os 
ingredientes, batê-los com uma batedeira, pegar uma forma, untar a 
forma, colocar a massa, ligar o forno, colocar a forma e esperar um 
tempo até que o bolo fique pronto. 
 Sair para trabalhar. 
o Você espera o despertador tocar. Se ele tocar você o desliga. Aí você vai 
até o banheiro, escova os dentes, troca de roupa, toma café. Se estiver 
chovendo, então você pega um guarda-chuva, sai de casa e pensa um 
caminho para chegar ao trabalho. 
http://informatica.hsw.uol.com.br/questao717.htm
 15 
 A ordem das instruções é importante para se atingir o resultado desejado. 
Além disso, o algoritmo sempre deve ter um fim, para que o objetivo esperado seja 
alcançado. Agora, o mais importante de tudo: cada pessoa raciocina de uma forma, ou 
seja, cada pessoa desenvolve algoritmos de acordo com os seus pensamentos, suas 
experiências de vida e sua compreensão sobre o problema. Desta forma, teremos 
algoritmos diferentes, mas que conseguem resolver o mesmo problema proposto! 
Os algoritmos serão utilizados para desenvolvermos programas que resolvem problemas 
específicos ou automatizam tarefas até então realizadas de forma manual. 
Automação é um processo em que uma tarefa deixa de ser desempenhada pelo 
homem e passa a ser realizada por máquinas, não importando se estas máquinas são 
mecânicas ou eletrônicas. (SALIBA, 1993) 
Para que uma tarefa seja automatizada devem-se conhecer todas as etapas necessárias 
para promover essa automatização e, além disso, o dispositivo que desempenhará este 
processo deve estar apto a garantir a repetição da tarefa, conforme programação 
definida. Para que isso aconteça, você deve ter em mente o seguinte: 
 Programas são escritos em determinadas Linguagens de Programação. 
 Existem diversas Linguagens de Programação. Então você deve escolher aquela 
que pode ser entendida pelo dispositivo que desempenhará a tarefa que está 
sendo automatizada. 
 Você pode escrever programas para computadores, dispositivos móveis, carros, 
microondas, geladeiras, televisões digitais, dentre outros. 
Artigo “Os 10 tipos de computadores”, disponível no portal HowStuffWorks 
http://informatica.hsw.uol.com.br/10-tipos-de-computador.htm 
http://informatica.hsw.uol.com.br/10-tipos-de-computador.htm
 16 
De forma bastante geral, neste caderno, trataremos algoritmo, programa, 
software e sistemas como termos parecidos e que possuem a mesma essência: são 
escritos em uma linguagem de programação que o computador ou outro equipamento 
entenda, são constituídos de instruções lógicas ordenadas, possuem um fim e, 
principalmente, realizam uma determinada tarefa ou resolvem um determinado 
problema. 
Leia mais sobre as definições de algoritmo, programa, software e sistema em: 
 http://pt.wikipedia.org/wiki/Programa%C3%A7%C3%A3o_de_computadores 
 http://pt.wikipedia.org/wiki/Programa_de_computador 
 http://pt.wikipedia.org/wiki/Software 
 http://pt.wikipedia.org/wiki/Sistema 
1.3 Desenvolvimento de Algoritmos 
A primeira preocupação no momento de desenvolver um algoritmo é dividir o problema 
apresentado nas três fases fundamentais de qualquer resolução lógica: 
ENTRADA PROCESSAMENTO SAÍDA 
Imagine o seguinte problema: 
Você precisa calcular a média final dos alunos da disciplina de Lógica de Programação, 
sendo que eles realizarão três provas parciais (P1, P2, P3), onde a média aritmética 
simples é obtida através da fórmula (P1 + P2 + P3)/3. 
Problema 
Calcular a média aritmética simples dos alunos da disciplina de 
Lógica de Programação. 
Solução Esperada A média final dos alunos. 
Dados de Entrada P1, P2, P3 
Processamento O cálculo desta fórmula: Média= (P1 + P2 + P3)/3 
Dados de Saída A média final dos alunos. 
http://pt.wikipedia.org/wiki/Programa%C3%A7%C3%A3o_de_computadores
http://pt.wikipedia.org/wiki/Programa_de_computador
http://pt.wikipedia.org/wiki/Software
http://pt.wikipedia.org/wiki/Sistema
 17 
A próxima etapa consiste em programar este algoritmo em uma Linguagem de 
Programação que o computador entenda. 
Ou seja, uma Linguagem de Programação é uma forma de codificar o seu algoritmo 
para que seja possível manter uma comunicação com o computador. Desta forma, ele 
poderia executar todo aquele algoritmo que foi desenvolvido por um programador. 
Programador é o nome que recebe uma pessoa que programa ou desenvolve 
sistemas, escreve algoritmos, etc... 
Imagine a seguinte situação: uma conversa entre duas pessoas: 
 
Figura 1.6 - Ilustrando a ideia de Linguagens de Programação 
Fonte: Zun, 2012 
 Imagine que a menina seja o seu programa e o menino seja o computador, mas 
vocês estão tentando se comunicar! 
 Quando a menina diz “Olá, tudo bem?!”, este é o algoritmo que ela criou. Ele 
tem um fim, segue uma ordem (a ordem das palavras e da gramática da 
linguagem utilizada) e possui um objetivo: cumprimentar você. 
 O Português é a linguagem de Programação que a menina utilizou para se 
comunicar com você, pois você também entende esta língua! 
Então, da mesma forma que usamos linguagens para nos comunicarmos com outras 
pessoas e estas linguagens possuem regras que devemos seguir para conseguirmos nos 
comunicar, isso também acontece com os algoritmos (programas, sistemas, softwares, 
etc...) e os computadores (dispositivos móveis, etc...). 
 18 
A Linguagem de Programação que utilizaremos para criar os nossos algoritmos neste 
caderno é conhecida como “Portugol”. É uma linguagem simples, fácil de ser 
compreendida, muito utilizada no ensino de programação e é baseada na língua 
portuguesa. 
Alguns autores da área de Lógica de Programação não consideram Portugol 
como uma linguagem de programação completa. Muitas a chamam de pseudo-
linguagem. Ela é realmente muito utilizada no ensino introdutório de algoritmos e 
programação, mas para desenvolver programas mais robustos você vai ter que optar por 
outras linguagens, tais como Java, C, C++, dentre outras. 
Mas os computadores não entendem o Português, certo? A linguagem que os 
computadores entendem é a binária. Desta forma, existe um programa de fins 
específicos, conhecido por “Compilador”, que traduz o seu algoritmo escrito em uma 
linguagem de programação para a linguagem de máquina entendida pelos 
computadores! 
Leia mais sobre o que são compiladores. Acesse: 
http://pt.wikipedia.org/wiki/Compiladores 
É comum, quando se trabalha com programação, fazermos uso de um ambiente 
específico para a escrita e testes de algoritmos. Ambientes mais complexos e robustos 
são chamados de IDE (Integrated Development Environment) ou Ambiente de 
Desenvolvimento Integrado. Este tipo de ambiente possui diversos recursos acoplados e 
disponíveis para os programadores, tais como editor, compilador, linker, depurador, 
modelagem, testes, dentre outros. 
Saiba mais sobre Ambientes de Desenvolvimento Integrado. Acesse: 
http://pt.wikipedia.org/wiki/Ambiente_de_Desenvolvimento_Integrado 
http://pt.wikipedia.org/wiki/Compiladores
http://pt.wikipedia.org/wiki/Ambiente_de_Desenvolvimento_Integrado
 19 
Neste caderno, faremos uso do VisuALG, que não pode ser classificado como um IDE, 
pois é um ambiente simples para programação de algoritmos em Portugol. O VisuALG 
é um editor e interpretador de Pseudocódigos, desenvolvido pela empresa Apoio 
Informática sob domínio público, em uma versão freeware. 
Você poder ler mais informações sobre o VisuALG acessando o site da 
empresa Apoio Informática: http://www.apoioinformatica.inf.br/o-visualg 
A partir de agora começaremos a parte práticado conteúdo deste caderno. Vamos 
perceber a forma correta de fazer uso do VisuALG e também vamos compreender a 
linguagem que usaremos para construir nossos algoritmos. 
O conteúdo desta aula não tem a pretensão de ser totalmente original. Algumas 
figuras e explicações fazem parte do material disponibilizado pela empresa Apoio 
Informática. Acesse: http://www.apoioinformatica.inf.br/a-tela-principal. 
1.4 Editor e Interpretador de Pseudocódigos: VisuALG 
É um programa criado pela empresa Apoio Informática e é muito útil para quem está 
iniciando seus aprendizados em Lógica de Programação ou na construção de 
Algoritmos Computacionais. 
Nele você pode digitar os comandos em Portugol e ver seu programa funcionando! 
1.4.1 Como obter o VisuALG? 
A versão 2.5, disponível neste endereço abaixo, é uma versão stand-alone, que não 
precisa ser instalada e funciona até dentro de pendrives ! 
Segundo a Wikipédia, são chamados stand alone, ou stand-alone (literalmente 
"ficam em pé por si só") os programas completamente auto-suficientes: para seu 
funcionamento não necessitam bibliotecas ou outros arquivos auxiliares. 
http://www.apoioinformatica.inf.br/o-visualg
http://www.apoioinformatica.inf.br/a-tela-principal
http://www.apoioinformatica.inf.br/
 20 
Você pode obter a versão stand-alone aqui: http://www.guanabara.info/2007/09/visualg-v25/ 
A versão do VisuALG que será utilizada também estará disponível para você através do 
ambiente virtual de ensino e aprendizagem. 
Basta fazer o download do arquivo, salvá-lo no seu computador e clicar duas vezes 
sobre o mesmo para que a tela inicial apareça. 
1.4.2 Executando o VisuALG 
Basta dar dois cliques no arquivo VisuAlg25.exe. 
Imediatamente aparecerá a tela principal do VisuALG: 
 
Figura 1.7 - Tela Principal do VisuALG 
Fonte: Elaborado pela Autora 
A tela do VisuALG compõe-se da barra de tarefas, do editor de textos (que toma toda a 
sua metade superior), do quadro de variáveis (no lado esquerdo da metade inferior), do 
simulador de saída (no correspondente lado direito) e da barra de status. 
Quando o programa é carregado, já apresenta no editor um "esqueleto" de 
pseudocódigo, com a intenção de poupar trabalho ao usuário e de mostrar o formato 
básico que deve ser seguido. Explicaremos a seguir cada componente da interface do 
VisuALG. 
http://www.guanabara.info/2007/09/visualg-v25/
 21 
A Barra de Tarefas contém os comandos mais utilizados no VisuALG (estes comandos 
também podem ser acessados pelo menu ou por atalhos no teclado). 
 
Figura 1.8 - Barra de Tarefas do VisuALG 
Fonte: Apoio Informática: a Tela do VisuALG, 2012 
Veja mais explicações sobre a barra de tarefas do VisuALG. Acesse: 
http://www.apoioinformatica.inf.br/a-tela-principal 
1.4.3 A linguagem do VisuALG 
A linguagem que o VisuAlg interpreta é bem simples: é uma versão portuguesa dos 
pseudocódigos largamente utilizados nos livros de introdução à programação, conhecida 
como "Portugol". 
A linguagem do VisuAlg permite apenas um comando por linha. 
Para facilitar a digitação e evitar confusões, todas as palavras-chave do 
VisuALG foram implementadas sem acentos, cedilha, etc. Portanto, o tipo de dados 
lógico é definido como logico, o comando se..então..senão é definido como 
se..entao..senao, e assim por diante. O VisuALG também não distingue maiúsculas e 
minúsculas no reconhecimento de palavras reservadas e nomes identificadores de 
variáveis. 
Em qualquer linguagem de programação, se uma palavra é reservada, ou seja, se ela é 
própria da linguagem de programação, então você não pode utilizá-la fora daquele 
http://www.apoioinformatica.inf.br/a-tela-principal
 22 
contexto para o qual ela foi criada Veja a lista de palavras reservadas da linguagem do 
VisuALG: 
Figura 1.9 - Palavras Reservadas da Linguagem do VisuALG 
Fonte: TONET, 2012, p. 49 
O formato básico do pseudocódigo, ou seja, dos algoritmos que podem ser criados no 
VisuALG é o seguinte: 
 
Onde: 
 A primeira linha é composta pela palavra-chave algoritmo seguida do seu nome 
delimitado por aspas duplas. Este nome será usado como título nas janelas de 
leitura de dados. 
 A seção seguinte é a de declaração de variáveis, que termina com a linha que 
contém a palavra-chave inicio. 
 23 
 Deste ponto em diante está a seção de comandos, que continua até a linha em 
que se encontra a palavra-chave fimalgoritmo. Esta última linha marca o final do 
pseudocódigo: todo texto existente a partir dela é ignorado pelo interpretador. 
O VisuALG permite a inclusão de comentários: qualquer texto precedido de "//" é 
ignorado, até se atingir o final da sua linha. Por este motivo, os comentários não se 
estendem por mais de uma linha: quando se deseja escrever comentários mais longos, 
que ocupem várias linhas, cada uma delas deverá começar por "//". 
1.4.4 Comando de Saída de Dados 
escreva (<lista-de-expressões>) 
O comando acima escreve no dispositivo de saída padrão o conteúdo de cada uma das 
expressões que compõem <lista-de-expressões>. As expressões dentro desta lista 
devem estar separadas por vírgulas; depois de serem avaliadas, seus resultados são 
impressos na ordem em que aparecem. 
É possível especificar o número de espaços no qual se deseja escrever um determinado 
valor. Por exemplo, o comando escreva(x:5) escreve o valor da variável x em 5 espaços, 
alinhado-o à direita. Para variáveis reais, pode-se também especificar o número de casas 
fracionárias que serão exibidas. Por exemplo, considerando y como uma variável real, o 
comando escreva(y:6:2)escreve seu valor em 6 espaços colocando 2 casas decimais. 
escreval (<lista-de-expressões>) 
Idem ao anterior, com a única diferença que pula uma linha em seguida. 
Releia este item sempre que estiver com dúvidas sobre o comando de escrita 
do VisuALG. Inicialmente, você pode ficar um pouco confuso sobre esta ideia de lista 
de expressões, mas após a aula 2 você compreenderá que é possível escrever valores 
armazenados em variáveis, valores diretos, textos que aparecem entre as duplas e a 
concatenação entre textos que aparecem entre aspas duplas, valores diretos e valores 
armazenados em variáveis. Exemplos: escreval (2), escreval(2+2), escreval(“Olá”), 
escreval(nome), escreval(“Olá ", nome). 
 24 
1.4.5 Seu primeiro algoritmo no VisuALG: Olá Mundo 
Vamos criar o primeiro algoritmo no VisuALG? 
Popularmente, quando se está aprendendo uma nova linguagem de programação o 
primeiro algoritmo criado é chamado de Hello, World! Em português, Olá Mundo. 
Saiba mais sobre o primeiro programa Hello, World e a implementação do 
mesmo em diversas linguagens de programação. Acesse: 
http://pt.wikipedia.org/wiki/Programa_Ol%C3%A1_Mundo 
Para criar um novo algoritmo, clique no menu Arquivo e escolha a opção novo ou 
clique no ícone novo. Entretanto, toda vez que você inicia o VisuALG, ele já abre com 
um novo arquivo de algoritmo para ser digitado. 
 
Para exibir as linhas no VisuALG, clique no menu Exibir e escolha a opção 
Número de Linhas. 
 
 
Barra de menus 
Neste espaço você digita os seus 
algoritmos. O esqueleto do 
algoritmo já vem definido ao 
abrir o VisuALG ou ao criar um 
novo arquivo. 
Para salvá-lo: clique no menu 
Arquivo e escolha a opção 
Salvar. 
Para executá-lo: clique no 
menu Algoritmo e escolha a 
opção Executar. 
http://pt.wikipedia.org/wiki/Programa_Ol%C3%A1_Mundo
 25 
Digite o código abaixo: 
Digite apenas o nome do algoritmo, complete a função, o autor e acrescente o 
comando da linha 10. Os demais textos aparecem automaticamente quando você abre o 
VisuALG ou clica no menu Arquivo e escolhe a opção novo. Os textos que aparecem na 
cor verde, iniciados por //, são os comentários da linguagem, servem para deixar o 
código mais legível, mas são desconsiderados no momento de execução do algoritmo. 
 
Para executar qualquer algoritmo no VisuALG, basta acessar o menu Algoritmo e clicar 
na opção Executar. Um atalhopara a execução de algoritmos é o F9. 
O resultado aparece neste prompt com a cor preta: 
 
 26 
1.4.6 Comando de Entrada de Dados 
Através de comandos de entrada é possível que o usuário digite valores que serão salvos 
em variáveis. A explicação sobre variáveis será feita na próxima aula! 
Utilize o comando abaixo quando você precisar que o usuário digite algum valor: 
leia (<lista-de-variáveis>) 
O comando leia recebe valores digitados pelo usuário, atribuindo-os às variáveis cujos 
nomes estão em <lista-de-variáveis> (é respeitada a ordem especificada nesta lista). 
Observe o exemplo abaixo: 
 
Abra o VisuALG e digite: 
 o nome do algoritmo: “Exemplo com comando de entrada – leia”; 
 declare a variável numero. Observe que não existe acentuação nas palavras 
reservadas e nos identificadores da linguagem do VisuALG. A única 
acentuação que pode existir é aquela que aparece em palavras que estão entre 
aspas duplas, assim como em “Exemplo de código”, “Média”, “O número 
digitado é”, etc... 
 digite os comandos que estão nas linhas 10, 11 e 12. 
o O comando da linha 10 faz com que apareça no prompt a frase “Digite 
um número”. 
 27 
o O comando da linha 11 faz com que o cursor do mouse fique piscando no 
prompt, aguando o usuário digitar um valor. Quando o usuário digita o 
valor e tecla <enter>, este valor é armazenado na variável numero. 
o O comando da linha 12 exibe no prompt a frase “O número digitado é” 
concatenado com o valor armazenado na variável numero. A 
concatenação é feita através da vírgula. Desta forma, se o número 
digitado é 8, a frase que aparece no prompt é O número digitado é 8. 
Tecle F9 para executar o algoritmo. O resultado aparece a seguir: 
 
 
Se você estiver no prompt e teclar Esc, o programa será imediatamente interrompido. 
Daí, basta clicar no ícone fechar (um x no canto superior direito do prompt) e você 
consegue voltar para a tela principal do VisuALG. 
Todas as aulas possuem atividades complementares. Elas estão localizadas no 
anexo deste caderno. 
 
 
 
 28 
1.5 Atividades propostas para a aula 1 
 
1. Escreva, a seguir, o que você entende por lógica. 
________________________________________________________________
_____________________________________________________________ 
2. Escreva no espaço abaixo pelo menos mais dois exemplos de algoritmos que 
você encontrou em seu dia a dia: 
________________________________________________________________
________________________________________________________________ 
3. Descrever as tarefas a seguir de tal maneira que qualquer pessoa que leia as suas 
instruções, saiba exatamente como agir. 
a. Tomar banho 
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________ 
b. Trocar uma lâmpada 
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________
_____________________________________________________________ 
 29 
 
Aula 2 – Variáveis, Constantes, Tipos de Dados e Operadores 
Objetivos 
Definir e compreender o uso de variáveis e constantes. 
Compreender o que são e quais são os tipos de dados básicos. 
Conhecer a definição e o correto uso de expressões e operadores. 
Antes de começarmos a programar algoritmos, devemos conhecer os conceitos que 
serão apresentados a seguir. 
2.1 Variáveis e Constantes 
Através das variáveis e das constantes podemos guardar as informações que são 
utilizadas enquanto o programa está sendo executado. Elas são regiões da memória 
RAM (Random Access Memory) do computador às quais associamos um nome 
(identificador) e guardamos um determinado conteúdo. Além disso, cada variável ou 
constante possui o tipo de conteúdo que ela pode armazenar. 
A diferença entre as constantes e as variáveis é que as constantes mantêm seu valor 
inalterado durante todo o desenvolvimento da programação, enquanto que as variáveis 
podem ter seu valor alterado a qualquer momento. 
 Para saber mais sobre o funcionamento da Memória RAM, acesse o site 
http://informatica.hsw.uol.com.br/memoria-ram.htm 
Fazendo uma comparação com a sua vida pessoal, imagine o seu guarda-roupas. Ele 
possui diversas divisões, não é mesmo? 
Imagine, também, que ele possua várias gavetas e que elas estejam organizadas da 
seguinte forma: uma gaveta para as camisetas, outra gaveta para as roupas íntimas e, por 
fim, uma gaveta para as meias. 
http://informatica.hsw.uol.com.br/memoria-ram.htm
 30 
Fazendo uma comparação desta situação pessoal com as variáveis, temos que: 
 O seu guarda-roupas é como se fosse a memória RAM do computador. 
 Cada gaveta é como se fosse uma pequena área dentro da memória RAM que 
guarda um determinado conteúdo, ou seja, as variáveis ou as constantes. 
 Os tipos de roupas guardadas é como se fossem os tipos das variáveis e das 
constantes, ou seja, o valor que elas podem armazenar. 
 E, cada roupa guardada em cada gaveta, é como se fosse o conteúdo ou valor 
armazenado em cada variável ou constante. 
As variáveis são úteis para guardar valores enquanto o algoritmo está sendo executado. 
Quando você fecha o VisuALG ou cancela a execução, todos os valores armazenados 
nas variáveis se perdem. Para que isso não aconteça, você precisa guardar os dados em 
um arquivo texto ou em um banco de dados, mas isso é conteúdo para outras 
disciplinas. 
Leia mais sobre memória principal e memória secundária. Acesse: 
http://pt.wikipedia.org/wiki/Mem%C3%B3ria_%28computador%29 
2.2 Identificadores 
São os nomes das variáveis e constantes utilizadas na construção de algoritmos. O 
acesso a estas variáveis ou constantes é feito através de seus respectivos identificadores. 
Normalmente, as regras de criação de um identificador para variáveis e constantes são: 
 O primeiro caractere deve ser uma letra (maiúscula ou minúscula). 
o Exemplos: total, idade, Nome, dataNascimento, etc... 
 Não utilize espaços nos nomes. Substitua-os com o caractere “_”. 
o Exemplos: data_nascimento, dias_uteis, ano_nascimento, etc... 
 Não utilize caracteres de acentuação e nem cedilha. 
o Exemplos: media, acoesParaProximoAno, acoes_para_proximo_ano, 
total_funcionarios, etc... 
http://pt.wikipedia.org/wiki/Mem%C3%B3ria_%28computador%29
 31 
Várias Linguagens de Programação fazem diferenciação entre letras 
maiúsculas e minúsculas. Quando isso acontece, dizemos que a linguagem é Case 
Sensitive. Desta forma, nome e Nome serão consideradas duas variáveis diferentes, da 
mesma forma que dataNascimento e datanascimento. No VisuALG isso não acontece, 
mas é muito importante que você mantenha um padrão para a escrita de identificadores 
e variáveis e constantes. 
Identificadores válidos: nome, telefone, idade_filho, idadeFilho, nota1, n1, Est_Civil 
Identificadores inválidos: 3Endereco, Estado Civil, PARA, algoritmo, 
numero/complemento 
O identificador PARA é inválido, pois é uma palavra reservada. Em qualquer 
linguagem de programação, se uma palavra é reservada, ou seja, se ela é própria da 
linguagem de programação, então você não pode utilizá-la fora daquele contexto para o 
qual ela foi criada. Neste caso, PARA servirá pra definir uma estrutura de repetição, 
sendo assim, você não pode utilizá-la pra nomear uma variável. 
2.3 Tipos de Dados 
Salvetti & Barbosa (1998) ressaltam que um programa de computador é descrito em 
uma linguagem de programação. Geralmente, cada linguagem de programação tem seus 
próprios tipos de dados, isto é, conjunto de valores, operações e relações já 
implementadas (disponíveis para uso). Na implementação surge o conceito de domínio,isto é, da limitação do conjunto de valores dos elementos representados. 
Neste caderno, as explicações sobre os tipos de dados do VisuALG não têm a 
pretensão de serem inéditas, pois elas estão baseadas nas explicações sobre a linguagem 
do VisuALG, disponível no site da empresa Apoio Informática. 
O VisuALG prevê quatro tipos de dados: inteiro, real, caracter, literal (conjunto de 
caracteres) e lógico (ou booleano). 
 32 
As palavras-chave ou palavras reservadas que os definem são as seguintes (observe que 
elas não têm acentuação): 
 inteiro: define variáveis numéricas do tipo inteiro, ou seja, sem casas decimais. 
o 3, 6, 10, 1000, 35 
 real: define variáveis numéricas do tipo real, ou seja, com casas decimais. 
o 3.5, 7, 8.90, 56.78 
 Literal: define variáveis do tipo string, ou seja, cadeia de caracteres. 
o “Maria”, “José”, “Escreva o seu nome:”, “Idade:” 
 logico: define variáveis do tipo booleano, ou seja, com valor VERDADEIRO ou 
FALSO. 
O VisuALG permite também a declaração de variáveis estruturadas através da palavra-
chave vetor, como será explicado na aula 06. 
2.4 Declarações de Variáveis 
Os nomes das variáveis devem começar por uma letra e depois conter letras, números 
ou underline, até um limite de 30 caracteres. As variáveis podem ser simples ou 
estruturadas (na versão atual, os vetores podem ser de uma ou duas dimensões). 
Não podem existir duas variáveis com o mesmo nome. 
Toda variável deve ser declarada na seção var antes de ser utilizada. 
A seção de declaração de variáveis começa com a palavra-chave var, e continua com a 
seguinte sintaxe: 
 
 
 
 
 33 
Exemplos: 
var 
a: inteiro 
valor1, valor2: real 
nome_do_aluno: literal 
sinalizador: logico 
Note que não há a necessidade de ponto e vírgula após cada declaração: basta pular 
linha. 
Veja as declarações de variáveis exemplificadas acima, mas dentro de um contexto real, 
ou seja, dentro de um algoritmo no ambiente do VisuALG. 
 
Pronto! Com as variáveis declaradas, agora precisamos armazenar valores nelas e 
começar a desenvolver algoritmos mais completos. 
2.5 Atribuição de Valores para Variáveis 
Basicamente, existem duas formas de se armazenar valores em variáveis: 
1. O usuário digita um valor através do prompt, tecla enter e o valor digitado é 
armazenado na variável através do comando de leitura leia. 
 
 34 
Exemplos: 
 Leia(nome) 
 Leia(idade) 
Vamos relembrar o código criado na última aula, quando exemplificamos o uso do 
comando leia para entrada de dados. 
Crie um novo algoritmo no VisuALG, digite o código abaixo e tecle F9 para ver o 
resultado. 
 
Observando o prompt de execução deste algoritmo, você deve perceber o seguinte: o 
cursor pisca, esperando que o usuário digite algo. Quando o usuário digitar um número 
e teclar <enter>, o valor digitado será armazenado na variável numero. Desta forma, o 
programador pode fazer o que precisar com esta variável, pois ela já possui um valor 
associado. 
Que tal observarmos alguns exemplos para tornar ainda mais clara essa ideia? 
Vamos lá... 
Atividade: Sendo dada uma lista de alunos com o código de matrícula e nome do aluno, 
faça um algoritmo que peça ao usuário para entrar com os valores de matrícula e nome 
do aluno e, ao final, exiba estas informações. Veja uma proposta de algoritmo já com o 
prompt de execução do mesmo: 
 35 
 
2. Outra forma de armazenar um valor em uma variável é utilizar o comando de 
atribuição. 
A atribuição de valores para variáveis é feita com o operador <-. 
Do seu lado esquerdo fica o identificador da variável à qual está sendo atribuído o valor, 
e à sua direita pode-se colocar qualquer expressão (constantes, variáveis, expressões 
numéricas), desde que seu resultado tenha tipo igual ao da variável. 
Exemplos: 
 a <- 3 
 Valor1 <- 1.5 
 Valor2 <- Valor1 + a 
 Valor3 <- (a * 3) 
 nome_do_aluno <- "José da Silva" 
 sinalizador <- FALSO 
Atividade: Crie um novo algoritmo no Visualg, declare a variável inteira idade, atribua 
o valor 30 para esta variável e exiba a seguinte frase: “A sua idade é 30”. Salve o 
algoritmo como “algoritmo_exemplo_comando_atribuicao” e tecle F9 para executá-lo. 
 36 
 
Observe: Novamente utilizamos a vírgula para concatenar valores. Neste caso, 
concatenamos a frase literal “A sua idade é” e o valor armazenado na variável idade. 
Observe que existe um espaço após o “é”. Se você esquecer-se de colocar este espaço, o 
resultado final será “A sua idade é30”. Percebe? Com a concatenação de valores 
conseguimos criar frases mais elaboradas. 
2.6 Operadores 
Os operadores são fundamentais para a resolução de problemas através de algoritmos, 
bem como já acontece com a matemática. Através deles conseguimos criar expressões 
mais completas e realizar cálculos mais reais. 
Existem alguns que são fundamentais para o desenvolvimento de programas, como os 
aritméticos, os relacionais e os lógicos. 
Operadores Aritméticos da linguagem do VisuALG: 
São aqueles cujo resultado da avaliação é do tipo numérico, seja ele inteiro seja real. 
Somente o uso de operadores aritméticos e de variáveis numéricas é permitido em 
expressões deste tipo. 
 
 37 
Operadores de Caracteres da linguagem do VisuALG: 
 
Operadores Relacionais da linguagem do VisuALG: 
Os operadores relacionais realizam a comparação entre dois operandos ou duas 
expressões e resultam em valores lógicos (VERDADEIRO ou 
FALSO).
 
Operadores Lógicos da linguagem do VisuALG: 
Os operadores lógicos atuam sobre expressões e também resultam em valores lógicos 
verdadeiro ou falso. 
 
A tabela abaixo, conhecida por tabela-verdade, mostra os resultados das aplicações dos 
operadores lógicos conforme os valores dos operadores envolvidos. 
 O operador lógico “e” só é verdadeiro se ambos os operandos também são 
verdadeiros. 
 O operador lógico “ou” só é falso se ambos os operandos também são falsos. 
 O operador lógico “não” inverte os valores, ou seja, se uma variável lógica é 
verdadeira, o operador lógico “não”, aplicado a esta variável, retornará o valor 
falso. 
 38 
 
Observe os valores da primeira linha. Suponha que A seja uma variável lógica que 
armazena um valor ou uma expressão que retorne verdadeiro. Suponha que B também 
seja verdadeiro. Neste caso, o resultado de A e B (terceira coluna) será verdadeiro, pois 
o operador lógico “e” só é verdadeiro quando ambos os operandos também são 
verdadeiros, caso contrário ele é falso. O resultado de A ou B(quarta coluna) será 
verdadeiro, pois o operador lógico “ou” só é falso quando ambos os operandos também 
são faltos, em qualquer outro caso, o resultado será sempre verdadeiro. 
De acordo com a necessidade, as expressões podem ser unidas pelos operadores lógicos. 
Exemplo: (1+4>3) e (2<>2) resulta FALSO, pois VERDADEIRO e FALSO resulta 
FALSO. 
Ordem na Avaliação de Expressões 
A execução das expressões acontece da esquerda para direita, mas além dos parênteses, 
que possuem uma prioridade maior, existem prioridades entre os operadores envolvidos 
na expressão. 
Atenção nesta ordem. Ela pode influenciar no resultado de um algoritmo, assim como já 
acontece na matemática: 
 39 
Figura 2.1 - Prioridade de resolução das expressões 
Fonte: TONET, 2012, p. 07 
Exemplos: 
 (3 + 3)/3 resulta o valor 2 
 3 + 3/3 resulta o valor 4 
 (2>3) ou (3<2) e (2<3) resulta Falso 
 (2>3) e (3<2) ou (2<3) resulta Verdadeiro 
Vamos praticar? 
Atividade: Faça um algoritmo que leia dois valores inteiros, calcule e exiba a sua média 
aritmética. 
Problema 
Faça um algoritmo que leia dois valores inteiros, calcule e exiba a 
sua média aritmética. 
Solução Esperada A média aritmética dos dois valores lidos. 
Dados de Entrada valor1, valor2 
Processamento media <- (valor1 + valor2)/ 
Dados de Saída O valor armazenado na variável media 
Uma proposta de algoritmo para resolver este problema: 
 40 
 
Crie um novo algoritmo, digite o códigoacima (exceto as partes que já aparecem no 
editor do VisuALG), salve o algoritmo como algoritmo_calcula_media e tecle F9 para 
executá-lo. 
Atividade: Faça um algoritmo que lê o valor do raio e calcule a área do círculo 
correspondente. 
Problema 
Faça um algoritmo que lê o valor do raio e calcule a área do 
círculo correspondente. 
Solução Esperada O cálculo da área do círculo correspondente 
Dados de Entrada Valor do raio 
Processamento area <- Pi*R2 
Dados de Saída O valor armazenado na variável area 
Uma proposta de algoritmo para resolver este problema: 
 
Crie um novo algoritmo, digite o código acima (exceto as partes que já aparecem no 
editor do VisuALG), salve o algoritmo como algoritmo_calcula_area e tecle F9 para 
executá-lo. 
 41 
2.7 Definição do Problema Base: 
De forma bem geral, você precisa compreender que os programadores possuem alguns 
tipos de estruturas que podem ser utilizadas e combinadas entre si pra que seja possível 
organizar o raciocínio e escolher as instruções que formarão o algoritmo que resolverá 
algum problema. São elas: 
 Estruturas Sequenciais 
 Estruturas Condicionais 
 Estruturas de Repetição 
 
 
Figura 2.2 - Comparando as ferramentas que o programador precisa para poder desenvolver algoritmos 
Fonte: Simone Abrero, 2012 e Atualização Farmacêutica, 2012 
Da mesma forma que o pedreiro possui a caixa de ferramentas pra trabalhar e 
o médico usa a maleta com os instrumentos que ele também necessita pra exercer a sua 
função, imagine que essas estruturas (sequencial, condicional e repetição) ajudam a 
preencher a caixa de ferramentas do programador. Você precisa aprender como 
funcionam estas estruturas, como elas podem ser utilizadas e quais são os comandos ou 
instruções relacionadas com cada uma. 
A estrutura sequencial será apresentada a seguir. As duas últimas estruturas, condicional 
e repetição, serão explicadas nas aulas seguintes. 
Para que você consiga perceber a evolução do conhecimento relacionado ao 
desenvolvimento de algoritmos, as principais explicações sobre cada estrutura serão 
baseadas no que chamaremos de “Problema Base”. Este problema base será construído 
a seguir e sofrerá modificações nas próximas aulas. Ou seja, começaremos a resolução 
do nosso problema base com os recursos que temos atualmente, ou seja, a estrutura 
 42 
sequencial, que é a mais simples de todas. O algoritmo será melhorado a partir do 
momento em que aprendemos as demais estruturas. 
Problema Base: imagine um cenário relacionado com alunos, notas e disciplinas. 
Alguns pontos podem ser definidos a partir deste cenários: 
 Alunos possuem nomes, matrículas, notas e disciplinas. 
 Existem critérios de aprovação para cada disciplina. Desta forma, um aluno é 
aprovado na disciplina se consegue atingir estes critérios. 
A Estrutura Sequencial admite uma instrução após a outra. 
Desta forma, para começarmos a resolver o nosso problema base utilizando uma 
estrutura sequencial, devemos apenas utilizar uma instrução após a outra. 
Veja este exemplo: 
Problema 
Faça um algoritmo que lê o nome e a nota de um aluno e exiba 
essas informações neste formato: Aluno(a): YYY – Nota: XX 
Solução Esperada Nome e nota do aluno exibidas no prompt. 
Dados de Entrada Nome e Nota 
Processamento 
Leitura do nome e da nota. Escrita do nome e da nota em um 
formato específico. 
Dados de Saída Dados do aluno exibidos em um formato específico. 
Segue uma proposta de algoritmo para resolver este problema através de Estrutura 
Sequencial, ou seja, um comando após o outro: 
 
 43 
Crie um novo algoritmo, digite o código acima (exceto as partes que aparecem 
automaticamente quando você cria um novo arquivo ou abre o VisuALG) e tecle F9 
para executá-lo. 
Digite um nome. Tecle <enter>. Digite uma nota. Tecle <enter>. Veja o resultado que 
aparece no prompt (tela preta). 
2.8 Atividades propostas para a aula 2 
 
1. Resolva as expressões lógicas, determinando se o resultado é verdadeiro ou 
falso: 
a. (6<8)ou(3>7)= 
b. não (2<3)= 
c. (5>=6 ou 6<7 ou não(a+5-6=8) {onde a = 5} 
d. (34>9 e 5+u = 34) ou (5=15/3 e 8>12) = ((u = 29) e 8>12) {onde u = 29} 
e. 2>3= 
2. Classifique os conteúdo das variáveis abaixo de acordo com seu tipo, 
assinalando com N os dados numéricos, com L os lógicos, com C os literais. 
( ) VERDADEIRO ( ) -545 ( ) " 444 " 
( ) "Joaquim" ( ) "VERDADEIRO" ( ) 0.000078 
( ) -49 ( ) +342 ( ) 569 
( ) 5.3 ( ) 2045 ( ) FALSO 
( ) 0 ( ) "abc" ( ) "João" 
3. Assinale com um X os nomes de identificadores de variáveis válidos: 
( ) leia ( ) enquanto ( ) escreva 
( ) ABC DE ( ) etc. ( ) b316 
( ) A123 ( ) Aa ( ) guarda_chuva 
( ) -_ad ( ) A&a ( ) guarda-chuva 
( ) 123a ( ) –a ( ) 3cd1 
 
 
 
 44 
 
4. Considere as declarações de variáveis apresentadas abaixo: 
var 
NOME, COR, TESTE, DIA: literal 
SOMA, NUM: inteiro 
Salario: real 
X:lógico 
 
a. ( ) Salario <- “insuficiente” 
b. ( ) Salario <- 150 
c. ( ) Salario <- 5.000 
d. ( ) X <- (NOME = COR) 
e. ( ) SOMA + 2 <- NUM 
f. ( ) DIA <- "seGUNDA" 
g. ( ) NUM <- "*ABC*" 
h. ( ) X <- X + 1 
i. ( ) COR <- "PRETO" 
j. ( ) TESTE <- SOMA 
k. ( ) NUM <- SOMA 
l. ( ) SOMA <- NUM + 2 * X 
m. ( ) NOME <- “5”
5. Analise o seguinte algoritmo e descreva o que ele faz. 
 
 42 
Aula 3 – Estruturas Condicionais ou de Seleção 
Objetivos 
Compreender o uso das estruturas condicionais ou de seleção no processo de criação de 
algoritmos. 
Resolver algoritmos que incluem o uso de estruturas condicionais. 
3.1 Desvio e Seleção do Fluxo de Instruções 
A nossa vida não é uma sequencia perfeita, sem desvios e sem obstáculos, você 
concorda? 
Ao acordarmos, podemos olhar para o céu e pensar: “parece que vai chover. Caso 
chova, seria bom ter um guarda-chuva na bolsa”. Outro exemplo: ao sair de casa e ir 
para o trabalho, você pode pensar “se o trânsito estiver bom, então vou fazer o caminho 
que sempre faço para chegar ao trabalho. Senão, vou optar por outro caminho, para 
evitar o congestionamento”. E como estas, existem inúmeras outras situações nas quais 
trabalhamos com condições e devemos tomar decisões. Estas decisões nos fazem 
seguir caminhos ou fluxos diferentes, mas que contribuem para alcançarmos o 
objetivo final. 
Desta forma, se desenvolvermos algoritmos em uma linguagem em que o computador 
entenda, para automatizar alguma tarefa do dia a dia ou resolver algum problema para 
nós humanos, não podemos esperar que estes algoritmos também sejam perfeitamente 
lineares, sem desvios, sem obstáculos e sem tomadas de decisão e seleção ! 
As Estruturas Condicionais ou de Seleção são fundamentais para que seja possível 
construirmos programas que consigam tratar situações mais complexas do nosso dia a 
dia. 
Voltemos ao nosso problema base. Na estrutura sequencial, foi possível ler o nome e a 
nota de um aluno. Isso é muito trivial, considerando que existem critérios de aprovação 
que são estabelecidos pela escola onde o aluno está. Desta forma, se assumirmos que 
um aluno será aprovado em uma determinada disciplina, caso a sua nota seja maior ou 
igual a 6,0 (seis), temos uma condição ou critério de aprovação do mesmo. Caso 
 43 
contrário, o aluno estará reprovado. Assim, devemos verificar o valor atual da nota do 
aluno e realizar um teste, ou seja: 
 Devemos ter o valor da sua nota armazenado em uma variável, por exemplo, na 
variável nota. 
 Com este valor armazenado, podemos testar ou verificar se ele está aprovado ou 
não, mediante a implementação de uma condição. 
 Se o valor armazenado na variável nota for maior ou igual a 6,0 (seis), então o 
aluno está aprovado. Caso contrário, o aluno está reprovado. 
Observe que a resposta do teste ou da condição deve sempre ser um valor verdadeiro 
(True) ou Falso (False). Veja o fluxograma abaixo. 
 
Figura 3.1 - Fluxo do algoritmo quando existe uma estrutura condicional 
Fonte: Elaborado pela autora 
Existem, basicamente, 2(dois) tipos de instruções condicionais ou de seleção. São elas: 
 Se...entao...senao 
 Caso..escolha 
 44 
3.2 Se...entao...senao 
Sintaxe para o se...entao...senao: 
 
ou 
 
Nas linguagens de programação existentes, conforme as suas sintaxes, as 
estruturas condicionais, assim como as outras estruturas, podem ser escritas de uma 
outra forma. Você tem que verificar o manual de cada linguagem de programação e 
descobrir como fazer para usar ou escrever estas instruções. 
A cláusula se executa um bloco de instruções caso uma determinada condição seja 
verdadeira. A cláusula senao executa um bloco de instruções caso a condição seja falsa. 
Não é necessário que todo se seja acompanhado de um senao, mas todo senao só pode 
existir após um se. 
Na criação de algoritmos, a acentuação é ignorada. Ou seja, o senão não deve 
receber o acento. Desta forma, no conteúdo deste caderno, utilizaremos as acentuações 
corretas para fazer as devidas explicações, mas no momento de codificar os algoritmos, 
você deve ficar atento para não utilizar a acentuação destas palavras reservadas. 
 
 45 
Palavra Reservada: palavras que não podem ser utilizadas como nomes de 
variáveis ou constantes por serem reservadas para uso da gramática da linguagem de 
programação utilizada. Exemplos de palavras reservadas na linguagem do VisuALG: 
algoritmo, var, literal, real, inteiro, inicio, escreva, escreval, leia, se, entao, senao, fimse, 
fimalgoritmo, dentre outras. 
A sintaxe abaixo trata apenas o valor verdadeiro da condição. Ou seja, nada acontece se 
o resultado da condição é falso. 
 
Já neste sintaxe de instrução condicional o tratamento é mais completo, pois existem 
instruções que devem ser executadas caso a condição seja verdadeira (bloco abaixo do 
então) e existem outras instruções que serão executadas caso a condição seja falsa 
(bloco após o senão). 
 
Observe que podem existir uma ou mais instruções caso a condição seja 
verdadeira ou falsa. Ou seja, um bloco de instruções é composto por uma ou mais 
instruções. Além disso, estas instruções podem ser estruturas sequenciais, estruturas 
condicionais ou estruturas de repetição. As estruturas de repetição serão vistas na 
próxima aula. 
 
 46 
3.2.1 Resolvendo o “problema base” no VisuALG 
Voltemos ao nosso problema base: “aprovação de um aluno”. Se tomarmos que um 
aluno será aprovado em uma determinada disciplina caso a sua nota seja maior ou igual 
a 6,0 (seis), temos uma condição de aprovação. Caso contrário, temos uma situação de 
reprovação. 
Os valores de entrada são: o nome e a nota do aluno. A nota do aluno assume o tipo 
“real”, pois valores do tipo 7.5 ou 3.4 podem ser aceitos. 
Abra o VisuALG e digite o código abaixo. Salve-o como 
algoritmo_problema_base_condicional, execute e analise o resultado. 
 
3.2.2 Condição Composta e os operadores booleanos 
Agora pense na seguinte situação: um aluno será aprovado caso a nota final seja maior 
ou igual a 6,0 (seis) e a sua frequência seja maior que 75 da carga horária da disciplina 
(por cento). 
Neste caso, os dados de entrada são: o nome do aluno, a sua nota e a sua frequência. 
A condição é composta, pois dependerá do valor da nota e do valor da frequência. Neste 
momento, uma expressão booleana ou lógica é muito útil. 
 47 
Uma expressão booleana é qualquer expressão que retorne true ou false e pode 
ser criada com os operadores de comparação e/ou lógicos. Saiba mais sobre operadores 
lógicos lendo este material http://pt.wikipedia.org/wiki/Operador_l%C3%B3gico 
Você consegue perceber o uso do operador lógico e na condição proposta para o nosso 
problema base? 
Observe as seguintes possibilidades para a condição apresentada. O aluno será aprovado 
apenas se o resultado da condição nota>=6 for verdadeira e o resultado da condição 
frequência>=75 também for verdadeira, pois e foi o operador lógico utilizado. 
Quadro 3.1 - Possibilidades para a condição de aprovação do exemplo proposto 
Nota>=6 Frequência>=75 Resultado da condição Nota>=6 e Frequência>=75 
V V V 
V F F 
F V F 
F F F 
Fazendo uma modificação no algoritmo criado anteriormente, temos o seguinte código. 
 
http://pt.wikipedia.org/wiki/Operador_l%C3%B3gico
 48 
3.2.2 Aninhamento da estrutura se 
A estrutura de decisão se pode ser apresentada de forma aninhada, ou seja, com um se 
dentro de outro. 
Considere o seguinte exemplo: leia um número inteiro e verifique se ele é um número 
positivo, negativo ou é o zero. Uma possível solução algorítmica para este problema 
encontra-se a seguir: 
 
No VisuALG, se existe um aninhamento da estrutura se, aquele se que vier 
após o senao deve ser colocado na linha seguinte. Por exemplo, observe o código 
colocado na linha 10. 
Teoricamente, não existe um limite para uma estrutura aninhada, mas quanto maior o 
aninhamento, mais difícil fica para entendermos o código desenvolvido. 
Para resolver este problema, podemos utilizar a estrutura condicional caso...escolha. 
Esta estrutura será descrita a seguir. 
3.3 Caso...escolha 
A estrutura caso...escolha trabalha com múltiplas opções de valores para a expressão 
que está sendo avaliada. 
 
 49 
Sintaxe para o caso...escolha: 
 
Esta estrutura é muito usada em: 
 algoritmos com chamadas de funções ou menus, o que torna o código mais fácil de 
ser entendido, se compararmos com o uso de estruturas se aninhadas. 
 a opção senao é opcional. 
 o rótulo é definido através de literais ou constantes numéricas inteiras, embora este 
item varie entre as linguagens de programação. 
3.3.1 Resolvendo o “problema base” no VisuALG 
Suponha que o professor de educação física do nosso problema base pretenda classificar 
seus alunos atletas em categorias e ele quer automatizar esta tarefa construindo um 
algoritmo. Para isso, ele criou uma tabela que contém a faixa etária do aluno atleta e a 
sua categoria. A tabela está demonstrada abaixo: 
IDADE DO ALUNO CATEGORIA 
05 A 10 Infantil 
11 a 15 Juvenil 
16 a 20 Júnior 
21 a 25 Profissional 
A função do algoritmo é solicitar para o usuário, que neste caso é o professor de 
educação física, que entre com o nome e a idade (inteira) de um aluno. O algoritmo 
deve verificar qual é a categoria relacionada com a idade do aluno e exibi-la na tela. 
 
 
 50 
Vamos implementar uma solução para este problema no VisuALG? 
 
Observe que no código acima nós estamos armazenando o resultado dentro da 
variável categoria. Uma outra possibilidade seria escrever diretamente o nome da 
categoria associada à idade do aluno atleta. 
 
 
 
 
 
 
 
 51 
3.4 Atividades propostas para a aula 3 
 
1. Escreva um programa que leia um número inteiro. Se o número lido for positivo, 
escreva uma mensagem indicando se ele é par ou ímpar. Se o número for 
negativo, escreva a seguinte mensagem “Este número não é positivo”. 
2. Faça um algoritmo que receba o valor do salário de uma pessoa e o valor de um 
financiamento pretendido. Caso o financiamento seja menor ou igual a 5 vezes o 
salário da pessoa, o algoritmo deverá escrever "Financiamento Concedido"; 
senão, ele deverá escrever "Financiamento Negado". Independente de conceder 
ou não o financiamento, o algoritmo escreverá depois a frase "Obrigado por nos 
consultar." 
3. Faça um programa que gere o balanço de um edifício segundo as especificações: 
Dados de entrada: total de apartamentos, total de moradores e valor do 
condomínio por apartamento. 
Cálculos: média de moradores por apartamento e total arrecadado. 
Resultado do programa: deve ser impresso na tela com o seguinte formato: 
 
 *********************************************************** 
 * EDIFíCIO BOA VISTA * 
 *********************************************************** 
 * TOTAL DE APARTAMENTOS : ....... * 
 * TOTAL DE MORADORES : ....... * 
 * VALOR DO CONDOMINIO : ....... ************************************************************ 
 * BALANCO FINAL * 
 *********************************************************** 
 * MEDIA DE MORADORES/APTO : ....... * 
 * TOTAL ARRECADADO : ....... * 
 *********************************************************** 
 
 
 52 
Aula 4 – Estruturas de Repetição 
Objetivos 
Compreender o uso das estruturas de repetição no processo de criação de algoritmos. 
Resolver algoritmos que incluem o uso de estruturas de repetição e as estruturas já 
estudadas. 
4.1 Contexto 
Imagine as seguintes situações: 
a) Uma professora precisa corrigir as avaliações de uma turma e verificar se eles 
foram aprovados em sua disciplina. Ela precisa repetir esta ação n vezes. Ou 
seja, se existirem 30 alunos nesta turma, ela repetirá 30 vezes a ação de corrigir 
as atividades. 
b) Para cada dia de trabalho você olha para o céu, antes de sair de casa, e verifica 
se vai chover. Se for chover, você coloca o guarda-chuva na bolsa. Observe que, 
se você trabalhar 20 dias por mês, você repetirá 20 vezes a ação de verificar se 
vai chover, não é verdade? Pode ser que não chova todas as vezes que você 
verificar, ou seja, não será todo dia que você colocará o guarda-chuva na bolsa, 
mas todos os dias você verificará se irá chover. 
Onde queremos chegar? 
Novamente, se desenvolvemos algoritmos em uma linguagem em que o computador 
entenda, para automatizar alguma tarefa do dia a dia ou resolver algum problema para 
nós humanos, não podemos esperar que estes algoritmos realizem apenas uma atividade 
em cada vez que ele for executado, não é mesmo?! 
Em todos algoritmos implementados até agora, sempre foi possível resolvê-los com 
uma sequência única de instruções e todos eram executados apenas uma única vez. 
No momento de verificar se um aluno foi aprovado, o nosso código estava 
implementado para fazer a verificação de apenas um aluno, certo? E se quiséssemos 
verificar para 30 alunos? E se quiséssemos verificar enquanto existissem alunos para 
serem verificados? Teríamos que fechar e executar o algoritmo novamente? Teríamos 
 53 
que repetir o bloco de instruções inúmeras vezes? Esta não é a opção mais viável. 
Queremos que na mesma execução de algoritmo seja possível verificar a aprovação de 
quantos alunos existirem ou quantos alunos quisermos verificar! 
As Estruturas de Repetição são fundamentais para que seja possível construirmos 
programas que consigam tratar situações que envolvem repetição. 
Existem, basicamente, 3 (três) tipos de instruções de repetição. 
São elas : 
 Para...faça 
 Enquanto...faça 
 Repita...até 
Nas linguagens de programação existentes, conforme as suas sintaxes, as 
estruturas de repetição, assim como as outras estruturas, podem ser escritas de uma 
outra forma. Você tem que verificar no manual de cada linguagem de programação, pra 
saber como usar ou escrever estas instruções. Além disso, no momento de implementar 
estas instruções no seu algoritmo, os acentos devem ser ignorados! Você deve usar: 
para...faca, enquanto...faca, repita...ate. 
4.2 Para...faça 
Sintaxe para o para...faca: 
 
Na estrutura para..faca, a <variável de controle> é inicializada com <valor inicial> e no 
início de cada iteração, seu valor é comparado com <valor final>. Se o valor da 
<variável de controle> for menor ou igual ao <valor final>, a <lista de comandos> é 
executada e após ser executado o último comando da lista, a <variável de controle> é 
 54 
incrementada. Isto se repete até que o valor da <variável de controle> seja maior que o 
<valor final>, quando então é executado o comando imediatamente após a palavra 
<fimpara>. A instrução <passo> é opcional e será útil quando o <incremento> do laço 
de repetição for diferente de 1. 
A estrutura para...faca deve ser utilizada quando você sabe o número exato de 
vezes que o bloco de comandos deve ser repetido. O número de repetições pode estar 
armazenado em uma constante ou em uma variável. 
4.3 Enquanto 
Sintaxe para o enquanto...faca: 
 
Na estrutura enquanto...faca, a <expressão lógica ou relacional> é avaliada e, se ela for 
verdadeira, a <lista de comandos> é executada. Ou seja, a <lista de comandos> será 
repetida enquanto a <expressão lógica ou relacionado> for verdadeira (true), pois 
quando ela for falsa, a execução do algoritmo vai para a próxima instrução que esteja 
após a palavra <fimenquanto> 
Exemplos de expressões relacionais: 
 Enquanto (idade<18) faca 
 Enquanto (opção= “continuar”) faca 
 Enquanto (i >=6) faca 
Exemplos de expressões lógicas 
 Enquanto ((nota>=6) e (frequência>=75)) faca 
 Enquanto ((opcao="c") ou (opção=”C”)) faca 
 Enquanto nao(opcao="s") faca 
 55 
Em todos os casos acima, as variáveis de controle devem ser alteradas em 
algum momento e em alguma instrução que esteja dentro do enquanto...fimenquanto. 
Caso contrário, o algoritmo entra em um loop infinito e nunca termina! 
4.4 Repita 
Sintaxe para o repita...ate: 
 
Na estrutura de repetição repita...ate, a <lista de comandos> é executada até que a 
<expressão lógica ou relacional> seja verdadeira. Ou seja, enquanto a <expressão lógica 
ou relacional> não for alcançada, enquanto ela for falsa, a <lista de comandos> será 
repetida. Quando a <expressão lógica ou relacional> for verdadeira, então a execução 
do algoritmo sai da estrutura de repetição e executa a próxima instrução que estiver após 
a palavra ate. 
Normalmente, existem uma ou mais variáveis que compõem a <expressão lógica ou 
relacional> que será testada ao final de cada iteração. Essas variáveis podem ser 
inicializadas antes do início do laço e terão seus valores modificados dentro do mesmo. 
Esta modificação acontece após um cálculo ou após a digitação de um valor pelo 
usuário. Desta forma, quando essas variáveis assumirem os valores que tornam a 
<expressão lógica ou relacional> verdadeira, o laço é terminado e o algoritmo segue a 
sua execução com as instruções que aparecerem após o mesmo. 
Observe que o teste de saída do enquanto...faca é feito no início. Já o teste de 
saída do repita...ate é feito no fim de suas respectivas estruturas. Isso significa que a 
<lista de comandos> na estrutura repita...ate será executada pelo menos uma vez. O que 
pode não acontecer na estrutura enquanto...faca se, logo no primeiro teste, a <expressão 
lógica ou relacional> for atendida. 
 56 
4.5 Resolvendo o “problema base” 
Voltemos ao nosso problema base: “aprovação de um aluno”. Utilizando apenas a 
estrutura sequencial foi possível ler o nome e a nota de um aluno. Com o uso da 
estrutura condicional foi possível verificar/testar se o aluno seria aprovado ou não, 
mediante um critério. Agora, queremos verificar se n alunos serão aprovados ou 
reprovados. 
Primeiro, vamos pensar sobre qual estrutura de repetição deve ser utilizada. 
a) Suponha que desejamos verificar a aprovação dos 5 alunos de uma turma. Desta 
forma, sabemos, a priori, que o número de vezes que a lista de comandos 
deve ser repetida será 5. Podemos, neste caso, usar a estrutura para...faca, 
conforme pode ser observado no código abaixo. 
O código abaixo é o mesmo utilizado para demonstrar a resolução do 
problema base com o uso da estrutura condicional se...entao...senao. Ele foi modificado 
para ser repetido através da estrutura para...faca. 
Alterações feitas no código original, que só calculava a aprovação de um aluno: 
 Alteração nos comentários que explicam o que o algoritmo faz. 
 Declaração da variável de controle i. 
 Inclusão da estrutura para...faca. 
 Todo o código que precisa ser repetido deve ficar entre o para...faca e o fimpara. 
 57 
 
b) Suponha que desejamos verificar a aprovação dos n alunos de uma turma, mas 
pelo menos um aluno deve ser verificado. Desta forma, não sabemos, a priori, 
quantas vezes as instruções serão repetidas. Podemos, neste caso,usar a 
estrutura repita..até, conforme pode ser observado no código abaixo. 
O código abaixo é o mesmo utilizado para demonstrar a resolução do 
problema base com o uso da estrutura condicional se...entao...senao. Ele foi modificado 
para ser repetido através da estrutura repita...ate. 
 58 
 
Alterações feitas no código original, que só calculava a aprovação de um aluno: 
 Alteração nos comentários que explicam o que o algoritmo faz. 
 Inclusão da variável de opcao. 
 Inclusão da estrutura repita...ate. 
 Todo o código que precisa ser repetido deve ficar entre o repita e o ate. 
c) Finalmente, suponha que desejamos verificar a aprovação dos n alunos de uma 
turma, mas não existe um critério de que ao menos um aluno seja verificado. 
Desta forma, não sabemos, a priori, quantas vezes as instruções serão repetidas. 
Podemos, neste caso, usar a estrutura enquanto..faca, conforme pode ser 
observado no código abaixo. 
 59 
 
Observe algo muito importante: a expressão de condição do enquanto pode 
envolver uma ou mais variáveis (no caso acima envolve apenas a variável opção). O 
valor anterior destas variáveis decidirá se o laço será iniciado ou não. Uma vez 
dentro do laço, estas variáveis que formam a condição do enquanto devem sofrer 
alterações em seus valores. Caso contrário, o algoritmo entrará em um loop infinito 
e ficará executando até que você feche o VisuALG. 
 60 
 
4.6 Atividades propostas para a aula 4 
 
1. Elabore um programa para achar todos os números ímpares entre 10 e 1000. 
2. Faça um programa que leia as variáveis C e N, respectivamente código e número 
de horas trabalhadas de um operário. Calcule o salário sabendo-se que ele ganha 
R$ 10,00 por hora. Quando o número de horas exceder a 50, calcule o excesso 
de pagamento armazenando-o na variável E, caso contrário zerar tal variável. A 
hora excedente de trabalho vale R$ 20,00. No final do processamento imprimir o 
salário total e o salário excedente. O programa só deve parar de rodar quando o 
usuário responder "S" na seguinte pergunta, "Deseja encerrar o programa?". 
3. Escreva um programa que calcule e exiba a média da nota dos alunos de uma 
turma em uma prova. O número de alunos é desconhecido. Os dados de um 
aluno são: número de matrícula e a sua nota na prova em questão. 
4. Este programa deve apresentar um menu em tela com a relação dos candidatos e 
opção para sair. A cada voto, conta-se um ponto para o candidato. Cada vez que 
o eleitor digitar uma opção errada, deve anular o voto e contar um para votos 
nulos. Após todos terem votado, o programa deve apresentar em tela qual dos 
candidatos foi o vencedor e o total de votos nulos. 
5. Leia para N pessoas quaisquer as seguintes informações: 
a. Idade, Peso, Sexo. 
b. Este programa deve fornecer como saída: 
i. A média dos pesos dos homens 
ii. A média da idade das mulheres 
iii. Quantas mulheres acima de 25 anos 
iv. Total de pessoas. 
 61 
Aula 5 - Variáveis Indexadas Homogêneas 
Objetivos 
Compreender o uso das variáveis compostas homogêneas. 
Resolver algoritmos que incluem o uso de variáveis indexadas homogêneas. 
5.1 Vetores e Matrizes 
Para todos os algoritmos que nós programamos até agora, incluindo o “problema base”, 
foi necessário declarar as variáveis antes de utilizá-las. Ao trabalharmos com estruturas 
de repetição, estas variáveis foram utilizadas para guardar dados específicos, mas a cada 
nova iteração, os dados guardados anteriormente eram substituídos por novos dados. 
Observe o código abaixo, que recebe o nome, a nota e a frequência de um aluno, mas 
também verifica se ele foi aprovado, segundo um critério de aprovação. Este código foi 
utilizado anteriormene para explicar o uso de estruturas de repetição no problema base. 
 
Suponha que, na primeira iteração, os valores sejam: 
i nome nota Frequência resultado 
1 Maria 6 78 Aprovado(a) 
Agora observe que, na segunda iteração, as variáveis são as mesmas, mas os valores 
armazenados nelas são diferentes. Desta forma, como nós guardamos os valores dentro 
das mesmas variáveis e para cada iteração, aqueles inseridos anteriormente serão 
perdidos assim que você digitar os novos valores para nome, nota e frequência: 
 62 
i nome nota Frequência resultado 
1 Maria 6 78 Aprovado(a) 
2 José 5 56 Reprovado(a) 
Segundo Tonet (2012) a declaração de variáveis, uma a uma, é suficiente para a 
codificação algorítmica da solução de uma ampla gama de problemas, mas é 
insuficiente para resolver um grande número de problemas computacionais. Imagine, 
por exemplo, como faríamos para construir um algoritmo que lesse os nome de 500 
pessoas e imprimisse um relatório destes mesmos nomes, mas ordenados 
alfabeticamente. Não seria uma tarefa simples, pois teríamos que definir 500 variáveis 
do tipo literal, como é mostrado abaixo: 
 
Uma alternativa para contornar este problema é usar as variáveis indexadas 
homogêneas, também conhecidas por variáveis indexadas unidimensionais (vetor) e 
variáveis indexadas bidimensionais (matriz). 
São homogêneas, pois continuam guardando o mesmo tipo de dado. Por exemplo, se um 
vetor do tipo inteiro é declarado, então ele só consegue guardar valores inteiros. O 
mesmo vale para a matriz. 
São indexadas, pois as posições são referenciadas ou acessadas através de índices. Na 
linguagem do VisuALG, o índice inicial do vetor é o 1(um). O mesmo vale para a 
matriz, mas a posição é referenciada pelo índice da linha e da coluna na qual ela se 
encontra. De qualquer forma, os índices da matriz também iniciam-se em 1 (um). 
 63 
5.2 Variáveis Indexadas Unidimensionais (vetor) 
Ascencio & Campos (2002) definem vetor como uma variável composta homogênea 
unidimensional formada por uma sequência de variáveis, todas do mesmo tipo, com o 
mesmo identificador (mesmo nome) e alocadas sequencialmente na memória. 
Quando definimos uma variável indexada unidimensional(vetor) devemos 
definir a capacidade máxima de armazenamento que ela aceita, ou seja, a quantidade de 
elementos (valores) que ela suportará. Pode acontecer que você implemente um 
algoritmo que não faça uso de todas as posições do vetor, desta forma, as posições 
inutilizadas ficarão vazias. Caso você tente acessar uma posição que não existe, ou seja, 
uma posição que vai além do tamanho máximo do vetor, aparecerá uma mensagem 
dizendo que a posição X não foi encontrada. 
Graficamente, pode-se pensar que um vetor possui as seguintes formas visuais: 
a) Uma linha e várias colunas (esta é a visualização mais comum para um vetor): 
 
b) Uma coluna e várias linhas: 
 
 
 
A forma visual de vetor apresentada na letra “a” possui 07 (sete) posições, ou seja, ele 
pode armazenar até 07 (sete) valores de mesmo tipo. Se este é um vetor que guarda 
informações sobre nomes, então ele pode guardar até 07 nomes diferentes, um em cada 
célula ou posição. Cada nome será referenciado através de um índice. 
Suponha que o vetor seja populado da seguinte forma: 
1 2 3 4 5 6 7 
Maria José Isabel Marcelo João Ana Joaquim 
 64 
A posição (ou índice) 01 guarda o valor “Maria”. 
A posição (ou índice) 02 do vetor guarda o valor “José”, e assim por diante. 
Sabendo que as variáveis possuem a mesma identificação, ou seja, o nome do vetor é o 
mesmo, então só é possível referenciar cada posição do vetor através de um índice. 
Em grande parte das Linguagens de Programação utilizadas para o 
desenvolvimento de sistemas computacionais, os índices de um vetor começam com 
zero. Desta, forma, o vetor apresentado anteriormente seria referenciado da seguinte 
forma: 
0 1 2 3 4 5 6 
Maria José Isabel Marcelo João Ana Joaquim 
A posição (ou índice) 0 guarda o valor “Maria”. 
O vetor continua com 07 posições, ou seja, guardando 07 valores, mas os índices vão de 
0 até 6. 
5.2.1 Trabalhando com Vetores no VisuALG 
Para trabalhar com vetores você deve declará-los, assim como fizemos com as outras 
variáveis dosnossos algoritmos. 
A sintaxe para declaração de um vetor dependerá da linguagem de 
programação que você estiver usando para construir os seus algoritmos. 
Neste caderno, utilizamos a seguinte sintaxe para declarar ou definir um vetor: 
 
 
 65 
 
onde: 
 <identificador> é o nome do vetor 
 vetor é uma palavra reservada que só pode ser utilizada para o contexto de 
declaração e acesso de vetores 
 <tamanho> é valor numérico inteiro que define a quantidade de posições do 
vetor 
 <tipo> é o tipo de valores que serão armazenados no vetor, tais como inteiro, 
literal, real, caractere, lógico. 
 Exemplos: 
o Declare um vetor de 5 posições para guardar nomes: 
 nomes:vetor[1..5] de literal 
o Declare um vetor de 10 posições para guardar idades: 
 idades:vetor[1..10] de inteiro 
o Declare um vetor de 20 posições para guardar o resultado do critério de 
aprovação de 20 alunos, sendo que os possíveis valores serão apenas 
verdadeiro ou falso. 
 aprovacoes:vetor[1..20] de logico 
Com o vetor declarado, podemos realizar as seguintes ações básicas: 
 Inserir dados em uma posição do vetor. 
 Exibir informações de uma posição do vetor. 
 Percorrer o vetor, inserindo valores em cada uma das posições. 
 Percorrer o vetor, exibindo os valores armazenados em suas posições. 
Para armazenar um valor dentro de uma posição do vetor você deve utilizar o 
comando com a sintaxe abaixo: 
 
 
 66 
 
onde: 
 <identificador> é o nome do vetor, utilizado durante a sua declaração. 
 <posição> é o índice do vetor e serve para referenciar a posição ou célula do 
vetor que receberá um valor. 
 <- é o sinal de atribuição de valor, ou seja, neste caso ele coloca o <valor> que 
está do lado direito do operador <- para dentro da posição do vetor que está 
sendo definida no lado esquerdo do mesmo. 
 <valor> é o valor que deve ser armazenado em uma posição do vetor. Observe 
que este valor deve respeitar o tipo utilizado na declaração do vetor. Se o vetor 
só aceita valores do tipo literal, então você deve apenas atribuir este tipo de 
valor para o seu vetor. 
o Exemplos: 
 nomes[3]<- “Maria” 
 O literal “Maria” será armazenado na posição 3 do vetor. 
o Pensando na visualização de vetor apresentada anteriormente, o resultado 
final será este: 
 Maria 
Outros exemplos de atribuição de valores em vetores: 
o idades[1]<-24 
o aprovacoes[1]<-falso 
o idades[1] <- outras_idades[3] 
 este último exemplo demonstra que é possível pegar o valor 
armazenado em um vetor e guardar este valor dentro de uma 
posição de outro vetor, desde que ambos os vetores sejam de 
mesmo tipo e estejam declarados. 
Para exibir um valor armazenado em uma posição do vetor você pode utilizar o 
comando que possui a seguinte sintaxe: 
 67 
 
Observe que é a mesma sintaxe utilizada anteriormente, para guardar um valor 
em uma posição do vetor, mas sem o uso do sinal de atribuição ( <- ). 
Desta forma, para imprimir o valor armazenado na posição 3, observe o 
comando abaixo: 
escreval(“Nome:”, nomes[3]) 
O resultado será Nome: Maria, pois concatenamos o literal “Nome:” e o valor 
literal armazenado na posição 3 do vetor nomes, ou seja, “Maria”. 
Agora, pense na seguinte situação: precisamos resolver um problema que 
envolve muitos valores. Para cada valor deve acontecer um cálculo ou um bloco de 
comandos específicos. Neste caso, precisaríamos utilizar estruturas de repetição para 
tratar o bloco de comandos que será repetido e devemos utilizar vetores para guardar 
todos os valores. As estruturas de repetição serão utilizadas para percorrer o vetor 
guardando os valores necessários. Além disso, elas podem ser utilizadas para percorrer 
o vetor exibindo ou testando os valores armazenados no mesmo. 
Exemplificaremos esta situação, de forma prática, através da resolução do 
problema base. Acompanhe a seguir: 
5.2.2 Resolvendo o problema base 
Voltemos ao nosso problema base. Utilizando apenas a estrutura sequencial foi possível 
ler o nome e a nota de um aluno. Com o uso da estrutura condicional foi possível 
verificar/testar se o aluno seria aprovado ou não, mediante um critério. E, com o uso de 
laços de repetição, foi possível verificar a aprovação de n alunos. Entretanto, toda vez 
que digitamos um nome, uma nota ou uma frequência, os valores anteriores eram 
perdidos, ou seja, substituídos pelos novos valores (nome, nota e frequência) digitados 
pelo usuário. 
Vamos utilizar um vetor para resolver este problema. 
 68 
Na verdade, precisaremos de 4(quatro) vetores: 
 Um para guardar os nomes 
 Um para guardar as notas 
 Um para guardar as frequências 
 E, por fim, outro vetor para guardar a situação dos alunos (aprovado ou 
reprovado) 
Este é o código original apresentando (sem o uso de vetor) 
 
Alterando o código acima para fazer uso de vetores: 
 69 
 
Algumas explicações sobre o código acima: 
 As linhas 6-10 possuem as declarações de variáveis. Temos uma variável 
simples (i), que é a variável de controle utilizada nas duas estruturas de repetição 
“para”. 
 A primeira estrutura de repetição está percorrendo os vetores e guardar os 
respectivos valores (nomes, notas, frequências e situações). 
 A segunda estrutura de repetição serve para percorrer o vetor situações exibindo 
as informações ali armazenadas. 
 Observe que os nomes (identificadores) dos vetores estão no plural. Isso não é 
um padrão, mas serve para exemplificar que este tipo de variável guarda muitos 
nomes, notas, frequências e assim por diante. 
 
 70 
5.3 Variáveis Indexadas Bidimensionais (matriz) 
Graficamente, pode-se pensar que uma matriz bidimensional possui a seguinte forma 
visual: 
a) Várias linhas e várias colunas 
 
 
 
A forma visual de matriz apresentada anteriormente possui 21 (vinte e uma) posições, 
ou seja, ela pode armazenar até 21 (vinte e um) valores de mesmo tipo. Se esta é uma 
matriz que guarda informações sobre nomes, então ela pode guardar até 21 nomes 
diferentes, um em cada célula ou posição. Cada nome será referenciado através de um 
índice composto de informações sobre a linha e sobre a coluna da posição que deve ser 
acessada. Dizemos que esta matriz é 3x7, ou seja, ela possui 3 linhas e 7 colunas. 
Suponha que a matriz seja populada da seguinte forma: 
 1 2 3 4 5 6 7 
1 Maria José Isabel Marcelo João Ana Joaquim 
2 Carol Pedro Ana C. Rosa Marília Bruna Rafael 
3 Isabela Luana João José Cristina Rose Júlia 
A posição (ou índice) linha 1 e coluna 3 guarda o valor “Isabel”. 
A posição (ou índice) linha 2 e coluna 4 guarda o valor “Rosa”, e assim por diante. 
Sabendo que as variáveis possuem a mesma identificação, ou seja, o nome da matriz é o 
mesmo, então só é possível referenciar cada posição da matriz através de um índice que 
contenha informações sobre a linha e a coluna. 
Neste caderno, utilizamos a seguinte sintaxe para declarar ou definir uma matriz: 
 71 
 
onde: 
 <identificador> é o nome do vetor 
 vetor é uma palavra reservada que só pode ser utilizada para o contexto de 
declaração e acesso de vetores. Neste caso, vetores bidimensionais (matrizes). 
 <tamanho1> é a quantidade de linhas 
 <tamanho2> é a quantidade de colunas 
o Os tamanho1 e tamanho2 seguem o padrão [vi..vf], ondo vi é o valor do 
tamanho inicial e vf é o valor do tamanho final. 
 <tipo> é o tipo de valores que serão armazenados no vetor, tais como inteiro, literal, 
real, caractere, lógico. 
 Para armazenar um valor dentro da matriz você deve utilizar o comando com a sintaxe 
abaixo: 
 
onde: 
 <identificador> é o nome do vetor, utilizado durante a sua declaração. 
 <posição 1> e <posição 2> são os valores da linha e da coluna, respectivamente, 
e servem para referenciar a posição ou célula da matriz que receberá um valor. 
o Exemplo: nomes[1,3]<- “Maria” 
o O literal “Maria” será armazenado na posição 1,3 da matriz, ou seja, posição 
cuja linha é 1 e cujacoluna é 3. 
o Pensando na visualização de matriz apresentada anteriormente, o resultado final 
será este: 
 1 2 3 4 5 6 7 
1 Maria José Maria Marcelo João Ana Joaquim 
2 Carol Pedro Ana C. Rosa Marília Bruna Rafael 
3 Isabela Luana João José Cristina Rose Júlia 
 72 
Para exibir um valor armazenado em uma posição da matriz você pode utilizar o 
comando que possui a seguinte sintaxe: 
 
Observe que é a mesma sintaxe utilizada anteriormente, para guardar um valor 
em uma posição da matriz, mas sem o uso do sinal de atribuição ( <- ). 
Desta forma, para imprimir o valor armazenado na posição cuja linha é 1 e cuja 
coluna é 3, observe o comando abaixo: 
escreval(“Nome:”, nomes[1,3]) 
Desta forma, o resultado será Nome:Maria, pois concatenamos o literal 
“Nome:” e o valor armazenado na posição cuja linha é 1 e coluna é 3 ou seja, “Maria”. 
5.3.1 Trabalhando com Matrizes no VisuALG 
Observe a seguinte situação: 
Atividade: Implemente um algoritmo que solicite as notas de um aluno e os respectivos 
pesos para cada um dos 4 bimestres. Estes valores deverão estar armazenados em uma 
única matriz. Ao final, exiba a média aritmética ponderada dessas notas. As notas 
podem variar de 0 até 10. 
A média aritmética ponderada de n números é a soma dos produtos de cada 
número multiplicados por seus respectivos pesos, dividida pela soma de seus pesos. 
Exemplo: Suponha os 3 números e seus respectivos pesos: 3(peso 2), 5(peso 3), 
2(peso5). A média aritmética ponderada é (3x2 + 5x3 + 2x5)/ (2 + 3 + 5). O resultado 
será (6 + 15 + 10)/10 = 31/10 = 3,1 
Uma solução seria criar uma matriz 4x2, ou seja, com 4 linhas e 2 colunas. Cada linha 
receberá a nota do aluno e o peso da nota para o respectivo bimestre, conforme ilustrado 
abaixo: 
 73 
 notas pesos 
1º Bimestre 
2º Bimestre 
3º Bimestre 
4º Bimestre 
Desta forma, precisamos declarar uma matriz que guarde as notas e os pesos de um 
aluno. Como vimos, a matriz é uma variável bidimensional indexada e homogênea, 
então ela deve receber valores de mesmo tipo. Para este caso, estamos trabalhando com 
valores inteiros, mas que também poderiam ser do tipo real. 
Observe no algoritmo proposto que fixamos que as notas de cada bimestre serão 
armazenadas na coluna 1 e as pesos de cada bimestre serão armazenados na coluna 2. 
As variáveis numerador e denominador têm seus valores acumulados a cada nova 
iteração, pois ao final do laço de repetição, elas servirão para calcularmos o valor da 
média aritmética ponderada de notas de um aluno. 
Veja uma proposta de algoritmo para resolver este 
problema:
 
 74 
5.4 Atividades propostas para a aula 5 
 
1. Uma agência de publicidade pediu à agência de modelos Luz & Beleza para 
encontrar uma modelo que tenha idade entre 18 e 20 anos para participar de uma 
campanha publicitária milionária de produtos de beleza. Foram inscritas 5 
candidatas e, ao se inscreverem, forneceram nome e idade. Tais informações 
foram armazenadas em 2 vetores distintos. Faça um programa para imprimir o 
vetor que contém os nomes das candidatas aptas a concorrer a uma vaga para a 
campanha milionária. 
2. Dada uma sequência de n números armazenados em um vetor de inteiros, 
imprima os valores deste vetor na ordem inversa que foi realizada a leitura. 
3. Dados dois vetores x e y, ambos com n elementos, determinar o produto escalar 
desses vetores. Ou seja, realizar a soma de todos os resultados da multiplicação 
de x[i] por y[i]. (Multiplicação de vetores). 
 75 
Aula 6 - Subalgoritmos 
Objetivos 
Compreender a aplicação da modularização do código para resolver problemas mais 
complexos. 
Resolver problemas que envolvam a modularização do código. 
6.1 Modularização do Código 
Em geral, problemas complicados exigem algoritmos maiores e com mais linhas de 
código. Além disso, se estes problemas possuem diversos trechos de códigos que serão 
repetidos em alguns momentos do código, a repetição destes blocos de comandos ao 
longo do desenvolvimento do algoritmo pode prejudicar o seu entendimento. 
Existe uma técnica conhecida como “Dividir para Conquistar”. Esta técnica pode ser 
aplicada em diversas áreas de estudo e possui este fundamento: dividir um problema 
maior em problemas menores, até que este problema maior possa ser resolvido. 
No caso da área de desenvolvimento de algoritmos, esta técnica pode ajudar nas 
seguintes situações: 
 Contribui para o reuso do código, uma vez que existirão chamadas para os 
subalgoritmos e a repetição de códigos será praticamente nula. 
 Ajuda a deixar o código mais organizado e legível, ou seja, mais fácil de ser 
compreendido por qualquer pessoa. 
 Facilita no momento de fazer alguma manutenção no código ou descobrir erros. 
 Serve para que vários membros de uma equipe de desenvolvimento consigam 
atuar no mesmo projeto, cada um trabalhando em um módulo diferente, dentre 
outras situações. 
Desta forma, subalgoritmos, sub-rotinas, subprogramas ou módulos são blocos de 
instruções que realizam tarefas específicas e podem ser chamados a partir do programa 
principal ou a partir de outros subalgoritmos, quantas vezes forem necessárias. 
Com a modularização do código original, surgem dois conceitos importantes: 
 76 
 O programa principal 
 Os tipos de subprogramas: 
o Funções 
o Procedimentos 
A diferença entre procedimentos e funções está unicamente no tipo de retorno: funções 
retornam valores após a execução da sua lista de instruções, mas os procedimentos não 
retornam. 
As “funções” e os “procedimentos” aparecem, principalmente, em linguagens 
baseadas na programação estruturada. Em outros paradigmas de programação, tal como 
o paradigma orientado a objetos, este conceito não existe da forma como explicamos 
anteriormente. Sendo assim, quando você for estudar o desenvolvimento de algoritmos 
em uma linguagem baseada em outro paradigma de programação, você deve verificar 
todos os conceitos associados e perceber de que forma a subprogramação acontece. 
Além disso, a sintaxe e a forma de funções de determinadas linguagens de programação 
também devem ser verificadas. 
6.1.1 Funções 
Uma função, em matemática, significa associar para cada valor x um elemento y 
correspondente, também denotado por ƒ(x)=y. 
Uma função, em Lógica de Programação, é um subalgoritmo que pode ou não receber 
uma informação, mas sempre retorna um valor ou uma informação. A chamada de uma 
função é feita através da citação do seu nome seguido, opcionalmente, de seus 
argumentos iniciais entre parênteses. As funções podem ser predefinidas, ou seja, 
próprias da linguagem ou criadas pelo programador de acordo com o seu interesse. 
A criação de uma Função deve ser declarada, com os demais objetos, no início do 
programa. Este tipo de subalgoritmo sempre retorna um e apenas um valor ao algoritmo 
que lhe chamou. Cada função tem associada ao seu valor de retorno um tipo explícito. 
 77 
 
Onde: 
 <identificador> é o nome da função 
 Passagem de parâmetros por referência: utiliza-se a construção VAR antes dos 
identificadores para indicar a passagem por referência. Os identificadores são 
separados por vírgula. 
 <parâmetros>: Entre um mesmo tipo de dados são separados por vírgula. Entre 
tipos de dados diferentes a separação é feita com ponto-e-vírgulas ';'. 
 <tipo de retorno da função>: Real, Inteiro, Lógico ou Literal. 
 <declaração de variáveis locais> idêntica à declaração de variáveis globais. As 
variáveis declaradas localmente tem validade dentro do escopo da função. 
 <retorne> local onde é colocado a variável de retorno. 
Sempre declare as variáveis globais antes da função. A função sempre fica 
dentro do escopo Algoritmo e Fim Algoritmo. Procure não Declarar variáveis globais 
com o mesmo nome das variáveis locais da função. 
Veja este algoritmo criado para realizar a soma entre dois números. Criou-se uma 
função que recebe dois valores reais e devolve a soma destesnúmeros para o programa 
principal, onde o resultado da soma é exibido para o usuário: 
 78 
 
Digite o algoritmo acima, salve-o como exemplo_funcao e tecle F9 para executá-lo. 
O VisuALG possui diversas funções predefinidas e você pode usá-las em seus 
algoritmos. 
Dica: Para acessar as funções do VisuALG, basta teclar Ctrl + j. 
A seguinte tela será exibida: 
 
 
Figura 6.1 - Funções predefinidas do VisuALG, obtidas quando tecla-se Ctrl + j 
Fonte: Elaborado pela autora 
 79 
Observe que as funções predefinidas são aquelas que possuem abre e fecha parênteses 
após a definição da função, tal como em Abs(valor:real): real. 
Isso significa que a função predefinida Abs é uma função, recebe um valor real e 
devolve outro valor real. Já a função Asc (s: caracter): inteiro recebe um caracter e 
devolve um valor inteiro. 
Segue abaixo uma lista de funções predefinidas e as respectivas funcionalidades. 
Funções predefinidas do VisuALG Explicação 
Abs (valor : real) : real 
Devolve o valor absoluto de um número, 
que é o valor desse mesmo número 
independentemente do seu sinal. 
Exemplo: o valor absoluto de -3 é 3 
Asc (s : caracter) : inteiro Retorna o código ASCII 
Compr (c : caracter) : inteiro 
Retorna a dimensão do caractere. 
Compr("abc") devolve 3 
Compr("e") devolve 1 
Copia (c : caracter , posini, posfin : 
inteiro) : caracter 
Copia um determinado trecho do 
caractere. 
Copia ("teste", 4 , 2) devolve te 
Int (valor : real) : inteiro Converte o valor em inteiro 
Maiusc (c : caracter) : caracter 
Converte em Maiúscula 
Maiusc(“teste”) devolve TESTE 
Maiusc(“a”) devolve A 
Minusc (c : caracter) : caracter Converte em Minúscula 
Pos (subc, c : caracter) : inteiro 
Retorna a posição do Caractere subc 
dentro do texto c. 
Pos(e, “teste”) devolve 
Quad (valor : real) : real 
Devolve um valor elevado quadrado. 
Quad(4) devolve 16 
Raizq (valor : real) : real 
Devolve a raiz quadrada de um valor. 
Raizq(16) devolve 4 
 80 
Saiba mais sobre o código ASCII (American Standard Code for Information 
Interchange) em http://pt.wikipedia.org/wiki/ASCII 
O algoritmo abaixo faz uso de algumas funções predefinidas no VisuALG: 
 
Linha Explicação 
6 O valor literal “José Silva” é armazenado na variável nome. 
7 
A função Compr recebe a variável nome e devolve o seu tamanho. Este valor 
para tamanho é armazenado na variável quant_caracteres. 
8 
A função Pos recebe o caractere espaço em branco e a variável onde a 
primeira ocorrência do mesmo será procurada. O resultado será armazenado 
na variável local_espaco. 
9 
A função Copia recebe uma variável nome, o valor inicial (local_espaco + 1) 
e a quantidade de caracteres após o valor inicial que deve ser devolvido. O 
resultado será armazenado na variável sobrenome. 
 
Modifique o algoritmo acima para que o nome seja digitado pelo usuário e 
armazenado na variável nome através do comando de leitura, o leia(). 
 
http://pt.wikipedia.org/wiki/ASCII
 81 
6.1.2 Procedimentos 
Na linguagem de programação do VisuALG, procedimento é um subprograma que não 
retorna nenhum valor. Sua declaração, que deve estar entre o final da declaração de 
variáveis e a linha início do programa principal, segue a sintaxe abaixo: 
 
onde: 
 <identificador> é o nome do procedimento. 
 [var] significa que a passagem de parâmetros é opcional, mas se existir, as 
variáveis devem ser declaradas com o uso da palavra reservada var. Os 
parâmetros são separados por vírgulas. 
 <parâmetros> são os valores que o procedimento deve receber ao ser chamado. 
Entre um mesmo tipo de dados são separados por vírgula. Entre tipos de dados a 
separação é feita com ponto e vírgula ';'. 
Exemplificaremos o uso de procedimentos através do problema abaixo: 
Atividade: Implemente um algoritmo, de forma modular, que receba 4 valores inteiros e 
os ordene em ordem crescente. 
Entrada: 4 números inteiros. 
Processo: ordenar estes 4 números em ordem crescente. 
Saída: exibir os 4 números ordenados. 
Este tipo de problema exige o uso de variáveis auxiliares, veja a imagem abaixo. 
 82 
Número1 Número2 Número3 Número4 
7 6 8 9 
Como fazer para trocar o valor armazenado na variável Número2 com o valor 
armazenado na variável Número1? 
Você deverá criar uma variável auxiliar para guardar um dos dois valores, caso 
contrário, um valor será perdido. 
No exemplo abaixo, a variável auxiliar está recebendo o valor armazenado na variável 
Número2. 
Variável Auxiliar 
6 
Desta forma, a variável Número2 pode receber o valor armazenado na variável 
Número1: 
Número1 Número2 Número3 Número4 
 7 8 9 
Para completar o processo de ordenação, o valor armazenado na variável auxiliar já 
pode ser armazenado na variável Número1: 
Número1 Número2 Número3 Número4 
6 7 8 9 
 
Uma proposta de algoritmo para resolver este problema será apresentada a seguir: 
 83 
 
Linha Explicação 
4-11 Definição e implementação do procedimento. 
6 
A variável local aux foi declarada. Ela pode ser utilizada apenas dentro do 
procedimento. Ela servirá como uma variável auxiliar e temporária, enquanto 
a troca de valores está sendo realizada nas linhas 8, 9 e 10 
14 
O usuário deve digitar 4 valores inteiros, os quais serão armazenados nas 
respectivas variáveis A, B, C e D. 
15 
Enquanto os valores armazenados em A, B, C e D não estiverem ordenados, o 
bloco de comandos especificados entre o enquanto e fimenquanto serão 
executados. 
29 Os valores ordenados serão exibidos para o usuário 
 
 84 
Observe o resultado através do console: 
 
 
6.2 Atividades propostas para a aula 6 
 
1. Escreva um programa que verifique se um número é par ou ímpar através de 
uma função chamada VERIFICA. A função deve receber um número inteiro (n), 
verificar se o número é par ou ímpar e deve retornar se o número (n) é par (1) ou 
ímpar (0). No programa principal, teste este retorno. Se o retorno for 1, exiba 
“Par”, mas se for 0, exiba “Ímpar”. 
2. Escreva um programa que calcule e retorne o valor da hipotenusa através da 
função HIPOTENUSA. A função recebe o valor da base e da altura de um 
triângulo. Fórmulas: hipotenusa
2
 = base
2 
+ altura
2
 
area=(base * altura)/2 
3. Escreva um programa que calcule e retorne o salário atualizado através da 
função REAJUSTE. A função deve receber o valor do salário e o índice de 
reajuste. 
 85 
Referências 
ASCENSIO, Ana Fernanda Gomes e CAMPOS, Edilene Aparecida Veneruchi. 
Fundamentos da Programação de Computadores – Algoritmos, Pascal e C/C++. 
Porto Alegre, Prentice Hall, 2002. 
FASSBINDER, Aracele Garcia de Oliveira. Uma Apresentação dos Principais 
Sistemas relacionados à Lógica Clássica. Florianópolis, 2010. 307 f. Dissertação 
(Mestrado em Ciência da Computação) – Centro Tecnológico, Universidade Federal de 
Santa Catarina, Florianópolis, 2010. 
LOPES, Anita; GARCIA, Guto. Introdução à Programação: 500 Algoritmos 
resolvidos. Rio de Janeiro, Campus, 2002. 
SALIBA, Walter Luiz Caram. Técnicas de Programação: Uma abordagem 
estruturada. São Paulo, Makron Books, 1993. 
SALVETTI, Dirceu Douglas; BARBOSA, Lisbete Madsen. Algoritmos. São Paulo, 
Makron Books, 1998. 
TONET, Bruno. Introdução aos algoritmos. Caxias do Sul: Núcleo de apoio à 
aprendizagem de programação. 2012. 
Páginas de Internet: 
APOIO INFORMÁTICA. VisuALG. Disponível em 
<http://www.apoioinformatica.inf.br/o-visualg>. Acesso em 16 dez. 2012. 
Apoio Informática: A tela do VisuALG. http://www.apoioinformatica.inf.br/a-tela-
principal Acesso em 18 dez. 2012 
Atualização Farmacêutica, 2012. http://atualizacaofarmaceutica.com Acesso em 18 dez. 
2012. 
A era da Tecnologia. 
http://aeradatecnologia.files.wordpress.com/2011/06/pascalina2.jpg Acesso em 18 dez. 
2012. 
American University in Bulgaria. http://cssu-bg.org/WomenInCS/ada_lovelace.php 
Acesso em 18 dez. 2012. 
Comidase Bebidas. 
http://comidasebebidas.uol.com.br/album/maca_do_amor_album.htm Acesso em 18 
dez. 2012. 
DMA Departamento de Matemática Aplicada. 
http://www.dma.eui.upm.es/historia_informatica/Doc/Maquinas/MaqAnaliticaBabbage.
htm Acesso em 18 dez. 2012. 
http://aeradatecnologia.files.wordpress.com/2011/06/pascalina2.jpg
http://www.dma.eui.upm.es/historia_informatica/Doc/Maquinas/MaqAnaliticaBabbage.htm
http://www.dma.eui.upm.es/historia_informatica/Doc/Maquinas/MaqAnaliticaBabbage.htm
 86 
Simone Abrero. http://simoneabrero.blogspot.com/2010/09/reforma-me-deixando-
louca.html Acesso em 18 dez. 2012 
Wikipedia http://pt.wikipedia.org/wiki/%C3%81baco Acesso em 18 dez. 2012 
Zun. http://www.zun.com.br/emprego-de-pronomes-relativos/ Acesso em 18 dez. 2012. 
 
 
 
 
http://www.zun.com.br/emprego-de-pronomes-relativos/
 87 
Currículo da professora-autora 
 
 
 
 
 
 
 
Aracele Garcia de Oliveira Fassbinder é graduada em 
Ciência da Computação pelo Centro Universitário de 
Formiga – UNIFOR-MG(2001-2004). Especialista em 
Administração de Sistemas de Informação pela 
Universidade Federal de Lavras – UFLA (2006-2007). 
Mestre em Ciência da Computação pela Universidade 
Federal de Santa Catarina – UFSC (2008-2010). 
Especialista em Design Instrucional para EaD Virtual pela 
Universidade Federal de Itajubá – Unifei (2011-2012). 
É professora efetiva do IFSULDEMINAS – Câmpus 
Muzambinho, atua nos cursos técnicos em informática e 
no curso de Ciência da Computação. Atualmente é 
coordenadora do Curso Técnico em Informática Integrado 
ao Ensino Médio. 
Acesse o Currículo Lattes completo em: 
http://lattes.cnpq.br/4653358157110108: 
 
 
 
http://lattes.cnpq.br/4653358157110108