Sumário

Sumário
Capítulo 1. Introdução a Lógica de Programação.......................................................................................... 4
1.1. Noções de Lógica.......................................................................................................................................... 4
1.2. O que é lógica................................................................................................................................................ 4
1.3. A real lógica do dia a dia.......................................................................................................................... 5
1.4. Lógica de programação............................................................................................................................. 5
1.5. O que é um algoritmo.............................................................................................................................. 11
1.6. Porque é importante construir um algoritmo..............................................................................11
1.7. As maneiras de representarmos um algoritmo............................................................................12
1.7.2. Fluxograma Convencional........................................................................................................... 12
Capítulo 2. Tópicos Preliminares........................................................................................................................ 16
2.1. Tipos primitivos......................................................................................................................................... 16
2.2. Constantes................................................................................................................................................... 16
2.3. Variável.......................................................................................................................................................... 18
2.4. Formação de identificadores................................................................................................................ 18
2.5. Declaração de variáveis.......................................................................................................................... 18
2.6. Comandos de entrada e saída.............................................................................................................. 20
2.7. Expressões aritméticas............................................................................................................................ 20
2.8. Operadores aritméticos........................................................................................................................... 21
2.9. Expressões lógicas..................................................................................................................................... 23
2.10. Operadores relacionais........................................................................................................................... 23
2.11. Operadores lógicos.................................................................................................................................... 24
2.12. Comando de atribuição......................................................................................................................... 26
2.13. EXERCÍCIOS PROPOSTOS.................................................................................................................. 28
Capítulo 3. Estruturas de Controle..................................................................................................................... 29
3.1. Estrutura sequencial................................................................................................................................ 29
3.2. Estrutura de seleção................................................................................................................................. 30
3.3. Seleção de múltipla escolha................................................................................................................. 32
3.4. Estruturas de repetição.......................................................................................................................... 34
3.5. Repetição com teste no início e no final......................................................................................... 35
3.6. Repetição com variável de controle.................................................................................................. 39
3.7. Comparação entre estruturas de repetição................................................................................... 41
Capítulo 4. Estruturas de Dados.......................................................................................................................... 42
4.1. O que é estruturas de dados.................................................................................................................. 42
4.2. Variáveis compostas homogêneas...................................................................................................... 42
4.3. Variáveis compostas unidimensionais.............................................................................................. 43
4.4. Declaração e manipulação(unidimensional)................................................................................ 44
4.5. Variáveis compostas multidimensionais......................................................................................... 45
4.6. Declaração e manipulação(multidimensionais )......................................................................... 46
4.7. Variáveis compostas heterogêneas..................................................................................................... 47
4.8. Registros (declaração e manipulação)............................................................................................. 47
Logica de Programação 3

Capítulo 1. Introdução a Lógica de Programação

Objetivos
Apresentar os conceitos elementares de lógica e sua aplicação no cotidiano; Definir o que é um
algoritmo; Estabelecer uma relação entre a lógica e o algoritmo; Mostrar exemplos de como utilizar a
lógica em situações do dia a dia, apresentando de forma simples e coerente.

1.1. Noções de Lógica

Lógica é algo muito comum na nossa vida, a prova disso é o que fazemos durante o dia,
pois mesmo sem perceber usamos a lógica todo momento, por exemplo:
Ao acordamos: Ao acordar, tenho um algoritmo para Fazer o
• Tomamos um banho. café?
• Escovamos os dentes.
• Tomamos o café da manhã.
Para irmos ao trabalho:
• Colocamos uma roupa apropriada.
• Pegamos um ônibus.
• Chegamos no trabalho.

Perceba que podemos detalhar mais coisas a respeito do exemplo anterior, nessa sequência
foi definida alguns fatos comuns.
Quando queremos chegar a um objetivo final, temos que traçar uma lógica coerente que
tenha sentido, onde em uma sequência lógica temos definido todos os passos que devemos
seguir até o final.

1.2. O que é lógica.

Lógica vem do grego clássico logos(λογική), que
significa palavra, pensamento, ideia, argumento, relato,
razão lógica ou princípio lógico. É uma parte da filosofia
que estuda o fundamento, a estrutura e as expressões
humanas do conhecimento. A lógica foi criada por
Aristóteles no século IV a.C. Para estudar o pensamento
humano e distinguir interferências e argumentos certos e
errados.
Já que o pensamento é a manifestação do
conhecimento, e que o conhecimento busca a verdade, é
preciso estabelecer algumas regras para que essa meta
possa ser atingida.
Logica de Programação 4

1.3. A real lógica do dia a dia.

Sempre que estamos pensando em algo, a lógica nos acompanha. Usamos a lógica quando
falamos ou quando escrevemos para por em ordem o nosso pensamento que está sendo
expressado.
A automação é o processo em que uma tarefa deixa de ser desempenhada pelo homem e
passa a ser realizada por máquinas, sejam estes dispositivos mecânicos, eletrônicos (como
os computadores) ou de natureza mista. Para que a automação de uma tarefa seja bem
sucedida é necessário que a máquina que irá realizá-la seja capaz de desempenhar cada uma
das etapas constituintes do processo a ser automatizado com eficiência, de modo a garantir a
repetição do mesmo. Assim, é necessário que seja especificado com clareza e exatidão o
que deve ser realizado em cada uma das fases do processo a ser automatizado, bem como a
sequência em que estas fases devem ser realizadas.
A essa especificação da sequência ordenada de passos que deve ser seguida para a
realização de uma tarefa, garantindo a sua repetibilidade, dáse o nome de ALGORITMO.
Ao contrário do que se pode pensar, o conceito de
algoritmo não foi criado para satisfazer as necessidades
da computação. Pelo contrário, a programação de
computadores é apenas um dos campos de aplicação dos
algoritmos. Na verdade, há inúmeros casos que podem
exemplificar o uso (involuntário ou não) de algoritmos
para a padronização do exercício de tarefas rotineiras.
No entanto, daqui por diante a nossa atenção se volta
para automação de tarefas utilizando computadores e
para isto definiremos o que lógica de programação. Os
algoritmos são descritos em uma linguagem chamada
PSEUDOCÓDIGO.
Este nome é uma alusão à posterior implementação em uma linguagem de programação, ou
seja, quando formos programar em uma linguagem, por exemplo PHP, C, C++, java, etc,
estaremos gerando nossos código usando a ferramenta VISUALG.
Exemplo:
Preciso pagar um conta de luz.
O valor da conta e de R$ 45,25 reais.
Portanto preciso de R$ 45,25 reais para pagar a conta.
Pagarei a conta as 3:00h da tarde.
Voltei para casa.

1.4. Lógica de programação.

A lógica de programação é necessária para pessoas que desejam trabalhar com
desenvolvimento de sistemas e programas, assim, ela permite definir a sequência lógica para a
criação de aplicativos. Significa o uso correto das leis do pensamento, da “ordem da raz ão”, do
processo de raciocínio e simbolização formais na programação de computadores. Com isso
criase técnicas que cooperam para a produção de soluções logicamente válidas e coerentes,
que resolvam com qualidade os problemas que se deseja programar.
Logica de Programação 5

Então o que é lógica?

Lógica de programação é a técnica de encadear pensamentos para atingir determinado objetivo.

Usar o raciocínio é algo abstrato, intangível. Os seres humanos tem a capacidade de

expressá-lo através de palavras ou escrita, que por sua vez se baseia em um determinado
idioma, que segue uma série de padrões (gramática). Um mesmo raciocínio pode ser
expresso em qualquer um dos inúmeros modos, mas continuará representando o mesmo
raciocínio, usando apenas outra convenção.
Em programação temos várias linguagens como, java, C, php,
Python, delphi dentre muitas outras que existem, porém cada
uma delas tem um padrão próprio.
Essas por sua vez, são muito atreladas a uma grade
diversidade de detalhes computacionais, mas com o mesmo
raciocínio, seguindo as regras da linguagem, pode ser obtido o
mesmo resultado.
Logica de Programação 6

1.5. O que é um algoritmo

Um algoritmo é formalmente uma sequência finita de passos que levam a execução de
uma tarefa. Podemos pensar em algoritmo como uma receita, uma sequência de instruções
que busca uma meta específica. Estas tarefas não podem ser redundantes nem subjetivas na
sua definição, logo, devem ser claras e precisas.
Os algoritmos servem como modelo para programas, pois sua linguagem é intermediária a
linguagem humana e as linguagens de programação, sendo então, uma boa ferramenta na
validação da lógica de tarefas a serem automatizadas. Os algoritmos servem para representar
a solução de qualquer problema, mas no caso do processamento de dados, eles devem seguir
as regras básicas de programação para que sejam compatíveis com as linguagens de
programação.
Por esse motivo os algoritmos são independentes das linguagens. Ao contrário de uma
linguagem de programação, não existe um formalismo rígido de como deve ser escrito o
algoritmo. O algoritmo deve ser fácil de se interpretar e fácil de codificar, ou seja, ele deve ser
o intermediário entre a linguagem falada e a linguagem de programação a qual for definir.
Como exemplos de algoritmos podemos citar os algoritmos das operações básicas (adição,
multiplicação, divisão e subtração) de números reais decimais. Outros exemplos seriam os
manuais de aparelhos eletrônicos, como um DVD player, aparelhos celulares, televisores, que
explicam passo a passo como operar, programar, gravar um evento, listar suas fotos, etc.
Até mesmo as coisas mais simples, podem ser descritas por sequências lógicas. Por
exemplo:
“Trocar uma lâmpada”.
• Pegar uma escada
• Colocar a escada no local certo.
• Pegar a lâmpada nova
• Subir na escada.
• Retirar a lâmpada velha.
• Colocar a lâmpada nova.
• Descer da escada.
• Guardar a escada.
• Colocar a lâmpada velha no lixo.
• Ligar o interruptor para testar.

“Somar dois números quaisquer”.

• Escreva o primeiro número no retângulo A
• Escreva o segundo número no retângulo B
• Some o número do retângulo A com número do retângulo B e coloque o
resultado no retângulo C

1.6. Porque é importante construir um algoritmo.

Saber construir algoritmos é fundamental na formação de profissionais de informática ou
computação e como tal, proporcionar condições para essa aprendizagem é um constante
desafio aos professores e profissionais da área.
Um algoritmo tem um papel importante, pois ele determina de que formas podemos
resolver um determinado problema, um programa de computador por exemplo, é
desenvolvido com muita lógica e principalmente um conjunto de algoritmos.
Outra importância da construção dos algoritmos é que um vez concebida uma solução
algorítmica para um problema, esta pode ser traduzida para qualquer linguagem de
programação e ser agregada das funcionalidades disponíveis nos diversos ambientes;
costumamos denominar esse processo de codificação.
1.7. As maneiras de representarmos um algoritmo.
Existem diversas formas de representação de algoritmos, mas não há um consenso com
relação a melhor delas para ser aplicada na resolução do problema proposto. Algumas
formas de representação de algoritmos tratam os problemas apenas em nível lógico,
abstraindose de detalhes de implementação muitas vezes relacionados com alguma
linguagem de programação específica.
Por outro lado existem formas de representação de algoritmos que possuem uma maior
riqueza de detalhes e muitas vezes acabam por obscurecer as ideias principais do algoritmo,
dificultando seu entendimento. Sendo assim temos as seguintes formas:
• Descrição Narrativa;
• Fluxograma Convencional;
• Pseudocódigo,também conhecido como Português Estruturado ou Portugol.

1.7.1. Descrição Narrativa.

Nesta forma de representação os algoritmos são expressos diretamente em
linguagem natural. Como exemplo, observe os algoritmos seguintes:

Esta representação é pouco usada na prática porque o uso da linguagem natural muitas
vezes da oportunidade a interpretações que podem resultar em erros, ambiguidades e
imprecisões.
Por exemplo, a instrução afrouxar ligeiramente as “porcas” no algoritmo da troca de pneus
esta sujeita a interpretações diferentes por pessoas distintas. Uma instrução mais precisa
seria: “afrouxar a porca, girando-a 30 grau no sentido anti-horário”.
Por mais simples que seja um algoritmo narrativo, pode haver uma grande quantidade de
detalhes, que por sua vez segue um conjunto de regras dentro da sequencia a qual
pertencem.

1.7.2. Fluxograma Convencional.

É uma representação gráfica de algoritmos onde formas geométricas diferentes implicam
ações (instruções, comandos) distintos. Tal propriedade facilita o entendimento das ideias
contidas nos algoritmos e justifica sua popularidade.
Esta forma é aproximadamente intermediária a descrição narrativa e ao pseudocódigo
(subitem seguinte), pois é menos imprecisa que a primeira e, no entanto, não se preocupa com
detalhes de implementação do programa, como o tipo das variáveis usadas. Notase que os
fluxogramas convencionais preocupamse com detalhes de nível físico da implementação do
algoritmo. Por exemplo, figuras geométricas diferentes são adotadas para representar
operações de saída de dados realizadas em dispositivos distintos.
 Existem diversas ferramentas para criação de fluxograma como Jude (agora chamado
Astah), Microsoft Visio, Dia(usado no linux), dentre outras, cada uma delas tem uma
vantagem em particular.

Trabalharemos com o editor de diagrama chamado Jude (astah), onde podemos

facilmente instalar no Windows e sua licença é de livre acesso.

Dica: Pesquise o uso dessas ferramentas por meios da internet, amigos ou professores.

Observe as principais formas geométrica usadas para representação de Fluxogramas de

algoritmos:
Início ou fim do fluxograma Operação de entrada de dados

Operação de atribuição Decisão

Operação de saída de dados

Um fluxograma se resume a um único símbolo inicial por

onde a execução do algoritmo começa, e um ou mais
símbolos finais, que são pontos onde a execução do
algoritmo se encerra. Partindo do símbolo inicial, há
sempre um único caminho orientado a ser seguido,
representando a existência de uma única sequência de
execução das instruções. Isto pode ser melhor visualizado
pelo fato de que, apesar de vários caminhos poderem
convergir para uma mesma figura do diagrama, há sempre
um único caminho saindo desta. Exceções a esta regra são
os símbolos finais, dos quais não há nenhum fluxo saindo,
e os símbolos de decisão, de onde pode haver mais de um
caminho de saída (usualmente dois caminhos),
representando uma bifurcação no fluxo.
O exemplo ao lado representa um fluxograma
convencional, mostrando a representação do algoritmo
de cálculo da média de um aluno sob a forma de um
fluxograma.
 A imagem abaixo é uma representação no diagrama de Chapin. (não abordaremos esse
diagrama, nessa apostila).

1.7.3. Português Estruturado ou Pseudocódigo.

Esta forma de representação de algoritmos é rica em detalhes, como a definição dos tipos
das variáveis usadas no algoritmo. Por assemelhar-se bastante a forma em que os programas
são escritos, encontra muita aceitação. Na verdade, esta representação é suficientemente
geral para permitir a tradução de um algoritmo nela representado para uma linguagem de
programação específica seja praticamente direta. A forma geral da representação de um
algoritmo na forma de pseudocódigo é a seguinte:

Algoritmo é uma palavra que indica o início da definição de um algoritmo em forma de

pseudocódigo.
I Nome do programa: é um nome simbólico dado ao algoritmo com a finalidade de
distinguilos dos demais.
II – Var: consiste em uma porção opcional onde são declaradas as variáveis globais
usadas no algoritmo principal;
III Início e Fim: são respectivamente as palavras que delimitam o início e o término do
conjunto de instruções do corpo do algoritmo.
O algoritmo do cálculo da média de um aluno, na forma de um pseudocódigo, fica da
seguinte forma no visualg:
 Dica: O Visual versão 3.0 será a ferramenta que utilizaremos no decorrer do
aprendizado, lembrando que não usaremos todos os recursos disponíveis diretamente na
ferramenta, uma parte é pratica com programação lógica dentro do Visualg, a outra mostra
conceitos que são logicamente utilizados nas maiorias das linguagens de programação,
uma vez que, até então, a versão do Visual não abrange praticar todo conteúdo contido
nessa apostila como registos, manipulação de arquivo, dentre outros.

DICA: Existe uma tecla de atalho CTRL + H qu abre um HELP no caso de você precisar
relembrar alguma sintaxe de comandos do visualg.
Logica de Programação 21

Capítulo 2. Tópicos Preliminares

Objetivos
Apresentar basicamente alguns tipos de dados a ser implementados e adotados; Falar qual sua
importância; Diferenciar variável e constante; Apresentar comados e processo de entrada.

2.1. Tipos primitivos.

Todo o trabalho realizado por um computador é baseado na manipulação das
informações contidas em sua memória. A grosso modo de expressarse, estas informações
podem ser classificadas em dois tipos:
As instruções, que comandam o funcionamento da máquina e determinam a maneira
como devem ser tratados os dados. As instruções são específicas para cada modelo de
computador, pois são funções do tipo particular de processador utilizado em sua
implementação.
Os dados propriamente ditos, que correspondem a porção das informações a serem
processadas pelo computador.

2.1.1. Tipos de Primitivos de Dados

Quaisquer dados a ser tratado na construção de um algoritmo deve pertencer a algum tipo,
que irá determinar o domínio de seu conteúdo. Os tipos mais comuns de dados são
conhecidos como tipos primitivos de dados, são eles: inteiro, real, caractere e lógico. A
classificação que será apresentada não se aplica a nenhuma linguagem de programação
específica, pelo contrário, ela sintetiza os padrões utilizados na maioria das linguagens.
Inteiro: todo e qualquer dado numérico que pertença ao conjunto de números
inteiros relativos (negativo, nulo ou positivo). Exemplos: {...4,3,2,1,0,1,2,3,4,...}.
Real: todo e qualquer dado numérico que pertença ao conjunto de números reais
(negativo, nulo ou positivo). Exemplos: {15,34; 123,08 ; 0,005 12,0 ; 510,20}.
Numérico: tratase de todo e qualquer número que pertença ao conjunto dos inteiros
ou reais, também abrange números binários, octal e hexadecimal.
Dados literais: todo e qualquer dado composto por um conjunto de caracteres
alfanuméricos (números, letras e caracteres especiais). Exemplos: {“Aluno Aprovado”,
“10% de
multa”, “Confirma a exclusão ??”, “S”, “9930002”, “email”,”123nm”,”fd54fd”}.
Lógico: A existência deste tipo de dado é, de certo modo, um reflexo da maneira como
os computadores funcionam. Muitas vezes,estes tipos de dados são chamados de booleanos,
devido à significativa contribuição de Boole a área da lógica matemática. A todo e qualquer
dado que só pode assumir duas situações dados biestáveis,algo como por exemplo {0/ 1,
verdadeiro/falso, sim/não, true/false }.

2.2. Constantes.
Uma constante é um determinado valor fixo que não se modifica ao longo do tempo,
durante a execução de um programa. Conforme o seu tipo, a constante é classificada como
sendo numérica, lógica e literal.
Logica de Programação 22

Nesse exemplo temos o número 4 como constante, ou seja, ele nunca se altera.

2.3. Variável.
Uma variável é um espaço reservado na memória do computador para armazenar um tipo
de dado determinado. As variáveis devem receber nomes para poderem ser referenciadas e
modificadas quando necessário. Um programa deve conter declarações que especificam de
que tipo são as variáveis que ele utilizará e as vezes um valor inicial. Tipos podem ser por
exemplo: inteiros, reais,caracteres,etc. As expressões combinam variáveis e constantes para
calcular novos valores.
Veja um exemplo de variáveis do tipo carácter e outra do tipo inteiro,ele serão
armazenados na memória :

Veja um exemplo onde atribuímos valores as variáveis nome e idade:

2.4. Formação de identificadores.

Toda variável deve possuir um nome para sua identificação dentro de um algoritmo, mas
vale ressaltar que não podemos atribuir qualquer nome a ela,e uma vez atribuindo, verificar
se ele é um identificador válido ou não. Na figura abaixo observamos um resumo através de
um gráfico que segue resumidamente as regras.

Representamos nomes escolhidos para rotular as variáveis,procedimentos e funções,

normalmente, obedecem as seguintes regras:
1. O primeiro carácter deve ser uma letra.
2. Os nomes devem ser formados por caracteres pertencentes ao seguinte
conjunto :
{a,b,c,..z,A,B,C,...Z,0,1,2,...,9,_}.
3. Os nomes escolhidos devem explicitar seu conteúdo. EX: A, B1, BC3D,SOMA,
CONTADOR. obs.: Um exemplo de identificador inválido seria 2AB ou qualquer outro
iniciado por um dígito.

2.5. Declaração de variáveis

Toda variável possui algum conteúdo, que será armazenado por ela e manipulado pelo
algoritmo. As variáveis que serão utilizadas nos algoritmos devem ser declaradas
inicialmente. A declaração de uma variável indica o tipo de dado que ela pode “guardar” no
decorrer da execução do algoritmo (ou no decorrer da execução do programa que
futuramente será construído).
Para declararmos uma variável, temos que criar um identificador para ela, que será o nome
Logica de Programação 23
da variável no algoritmo, e também temos que definir o tipo de dado que a variável pode
armazenar. Faremos a declaração de variáveis obedecendo ao seguinte padrão:

Portugol: [nome:do[ nome

tipo deda variável] ;
variável]
Padrão Visualg: [nome da variável]: [ nome do tipo de variável]

Percebemos que existe duas diferença na declaração das variáveis do portugol em relação a
do Visual,que é justamente a troca de posições e a ausência de pontoevirgula.

Exemplo:

Visualg: Portugol:
alunos : caracter : alunos ;
caracter
valor : inteiro inteiro : valor ;
b : real real : b ;

2.6. Comandos de entrada e saída.

Em um algoritmo é preciso representar a troca de informações que ocorrerá entre o
mundo da máquina e o nosso mundo, para isso, devemos utilizar comandos de entrada e
saída, sendo que,a nível de algoritmo esses comandos representam apenas a entrada e a
saída da informação,independe do dispositivo utilizado (teclado, discos, impressora,
monitor,...), mas, sabemos que nas linguagens de programação essa independência não
existe, ou seja, nas linguagens de programação temos comandos específicos para cada
tipo de unidade de Entrada/Saída.

2.6.1. COMANDO DE ENTRADAS DE DADOS

Para que possamos obter dados do meio exterior para uso do computador (memória
principal),estes têm de vir através dos dispositivos de entrada. Da mesma forma, as
informações que são produzidas, tem de ser levadas ao meio externo (um arquivo, um a
impressora, uma tela etc.) através de um dispositivo de saída. Para isso, utilizamos dois
comandos assim definidos:
Comando “leia” tem a finalidade de lê, do meio externo, a próxima informação disponível
para leitura e armazena na(s) variável(eis) discriminada(s) após o comando, entre
parênteses. Mais tarde aprenderemos como especificar a leitura de um dado que est á
armazenado em um arquivo e de que arquivo está sendo lido o dado.

Exemplo: leia (v) O valor da variável (v) é dado por um dispositivo de entrada.
Logica de Programação 24
2.6.2. COMANDO DE SAIDAS DE DADOS
Comando escreva ou escreval: Imprime (na tela ou na impressora) o conteúdo da(s)
variável(eis) especificada(s) após o comando, entre parênteses. Não será preocupação nossa a
formatação de relatórios, mas o comando permite a impressão de texto (entre “ ”), se for
necessária para clareza ou especificação do que está sendo impresso.

Exemplo: escreva(x) O valor atual da variável (x) é informado para um dispositivo de

saída.

Vale ressaltar que em linguagens de programação geralmente termina um comando com

ponto e virgula( ; ), mas para o uso no Visualg, não precisamos usar ; para fechar o
comando,uma vez que isso ocorre de forma automática.

Exemplo: escreva(x) O valor atual da variável (x) é informado para um dispositivo de

em visualg:numero : inteiro
portugol: inteiro numero;
saída.

Também podemos concatenar valores no comando de saída. Isso varia muito de uma
linguagem para outra, por exemplo:

ao executar(tecla de atalho F9) isso imprime na tela resultado seguinte:

Esse exemplo ao lado utilizamos os a

subtração de dois números e logo após
imprimimos o resultado na tela.

O resultado da saída desse programa é a seguinte:

Logica de Programação 25
Exemplo com o comando leia e escreva:

códigofonte. saída da execução:

utilizamos o “escreval” quando queremos uma quebra de linha, troque por “escreva” e perceba
o que acontece:

2.7. Expressões aritméticas.

Quando construímos algoritmos é comum trabalharmos com expressões matemáticas para
a resolução de alguns problemas. As expressões matemáticas podem fazer uso de operadores
aritméticos e relacionais. As variáveis (ou constantes) manipuladas pelos operadores são
chamadas de operandos. Observe o diagrama:
Logica de Programação 26

Exemplos:

A+B(A e B são os operados, e + é o operador da expressão). ((2 * A) +

5)
(B/A)
((A//2)*B) – 15

2.8. Operadores aritméticos

Chamamos de operadores aritméticos o conjunto de símbolos que representa as
operações básicas da matemática.

Para representa potencia e radiciação utilizamos:

Opera Função Significado Exemplos

dor
^ Potenciação x elevado a y 2^8
raizQ(x Radiciação Raiz quadrada de x raizQ(9)
)
Exemplo:
códigofonte. Saída da execução.

Usaremos outras operações matemáticas não convencional, porém muito úteis nas
construção de algoritmo, que são o resto e o quociente da divisão inteira, conforme abaixo:

Opera Funç Exem

dor
mod ão
Resto da divisão plo 1
9 mod 4 resolta em
div Quociente da divisão 9 div 4 resulta em 2
Exemplo:
Logica de Programação 27

Algoritmo que possui as quatros operações:

códigofonte. Saída da execução.

Algoritmo que calcula o quociente e resto de uma divisão:

 2.9.
2.9.
2.9.
2.9.
2.9.
2.9.
2.9.
2.9.
2.9.
Expressões lógicas
As expressões lógicas sempre retornaram True (Verdadeiro) e False (Falso). Para se montar
expressões lógicas utilizamos de operadores relacionais e operadores lógicos.
Exemplo:
Visualg: Portugol:
a <- a <-
verdadeiro
b <- falso verdadeiro;
b <- falso;

2.10. Operadores relacionais.

São utilizados para relacionar variáveis ou expressões, resultando num valor lógico
(Verdadeiro ou Falso), sendo eles mostrados na tabela abaixo:

Obs.: utilizamos somente o “=” no lugar de “==”, e “<>” no lugar de “!=”, mas isso somente
no Visualg.

Exemplos:
comparações:
num != 3 {compara se num é diferente de 3,se for igual retorna falso}
nome = ‘DENISE’ {compara se nome é igual a ‘DENISE’ ,se for retorna verdadeiro}
num > 5 é falso (0) {3 não é maior que 5}

Algoritmo abaixo mostra o uso desse operadores relacionais.

código-fonte. Saída da execução.

2.11. Operadores lógicos.
São utilizados para avaliar expressões lógicas. Estes operadores servem para avaliar
expressões que resultam em valores lógico sendo verdadeiro ou falso:

Esses operadores tem a finalidade de novas proposições lógicas composta a partir de outra
proposições lógicas simples. Observe:

Operador Função
não negação
e conjunção
ou disjunção

Com isso podemos podemos construir a Tabela verdade onde trabalhamos com todas as
possibilidades combinatória entre os valores de diversas variáveis envolvidas, as quais se
encontram em apenas duas situações (V e F), e um conjunto de operadores lógicos. Veja o
comportamento dessas variáveis:
Operação de Negação:
A (not)
F não
VA
V F

Operação de conjunção:
A B Ae
F F B
F
F V F
V F F
V V V

Operação de disjunção nãoexclusiva:

A B A ou
F F B
F
F V V
V F V
V V V
 Exemplos:

ACHOU = falso , ACHOU = true;

NUM = 9
( 4 > 5 ) e ( 5 > 3) => falso e verdadeiro (1) = falso (0)
não ACHOU => verdadeiro

Exemplo:
código-fonte. Saída da execução.

2.12. Comando de atribuição.

O operador de atribuição é utilizado para atribuir valores aos identificadores(variáveis e
constantes) e na montagem de expressões(aritméticas,lógicas e literal).
Com isso podemos definir sempre que um tipo de dado deve ser compatível com o tipo
da variável.
A figura abaixo mostra em diagrama a sua sintaxe:

O valor da expressão é atribuído ao identificador (variável).

X <- 2 y <- 5-x Z <- (3*(y- 9)) w <- (4*((w+2y)/2)*x)

 Este comando permite que se forneça ou altere o valor de uma determinada variável, onde o
tipo desse valor seja compatível ao tipo de variável na qual está sendo armazenado, de acordo
com o especificado na declaração.
Exemplo:
NUM <­8 {A variável NUM recebe o valor 8}
NOME <­“Guilherme” {A variável NOME recebe o valor ‘Guilherme’}

2.12.1. PRIORIDADE DE OPERADORES:

Durante a execução de uma expressão que envolve vários operadores, é necessário a
existência de prioridades, caso contrário poderemos obter valores que não representam o
resultado esperado. A maioria das linguagens de programação utiliza as seguintes prioridades
de operadores:
1. Efetuar operações embutidas em parênteses "mais internos".
2. Efetuar Funções.
3. Efetuar multiplicação e/ou divisão.
4. Efetuar adição e/ou subtração.
5. Operadores Relacionais.
6. Operadores Lógicos

2.13. EXERCÍCIOS PROPOSTOS

1º)Como podemos definir o conceito de tipos primitivos de dados.

2°)Cite alguns tipos primitivos e der exemplos.

3°)Qual a diferença entre constantes e variáveis.
4°)Como podemos definir a formação de um identificador válido? crie cinco identificadores
no Visualg (o nome devera ser uma única letra e após isso os tipos).
5°)Crie o seguinte código no Visualg e diga qual o resultado final.
 6°)Crie um programa no onde podemos receber dois números digitados pelo usuário no
final ele some os números e imprima o resultado.
7°)Dado a formula:

8º)crie um programa para calcular a formula de Bhaskara. Onde no final mostre ao

usuário x1 e x2 separadamente.

Dica:o usuário digita três valores, a,b e c,o programa terá duas variáveis para receber o
calculo, x1 e x2.Para calcular raiz quadrada use o comando raizQ(x) onde x é o numero que
tem valor inteiro,atribua o resultado da raiz a soma e depois a subtração.
ex: b ← raizQ(25) , b recebe 5,pois é raiz de 25, e b deve ser do tipo real.

9°)Crie um diagrama onde podemos representar o programa da questão 7.

10°)Crie um programa que receba pelo usuário o nome,ano de nascimento, ano atual, e
calcule a idade, mostrando a seguinte saída ex: meu nome é Juan e tenho 23 anos de idade.
11°) Crie um diagrama para representação da questão 9.
12º) Usando o comando o tipo de dado logico do Visualg, teste os operadores
relacionais. ex: a : logico , a ← 12 <=5, escreva(a).
Capítulo 3. Estruturas de Controle
Objetivos
Mostrar conceitos e estrutura sequencial de fluxo, em etapas lógicas, onde podese assimilar
suas variações, combinações e equivalências; Apresentar estruturas de repetição e sua aplicação.

As estrutura de controle de dado são responsáveis pela manipulação dos dados conforme
seja necessário na realização de um processamento. Cada instrução programável possui uma
lógica de operação e estabelece uma sequencia de ações a serem efetuadas ou verificadas.
Quando estivermos criando os algoritmos serão necessárias as manipulações de dados
respeitando a sequencia lógica de cada comando, buscando sempre alcançar os objetivos
almejados pelos algoritmos. Basicamente as estruturas de controle de dados são de três tipos
principais:
Sequencial: conjunto de comandos separados por ponto e vírgula (;) que são executados
em uma sequência linear de cima para baixo.
Seleção:a partir de um teste condicional, uma instrução, ou um conjunto de instruções,
podem ser executados ou não, dependendo exatamente do resultado do teste efetuado.
Repetição:uma instrução ou o conjunto de instruções que será executado repetidamente,
de acordo com o resultado de um teste condicional.

3.1. Estrutura sequencial.

A estrutura sequencial é a mais convencional entre todas as possíveis, pois ela consiste na
execução de uma instrução de cada vez, onde o encerramento da primeira instrução permite o
acionamento da instrução seguinte, respeitando a ordem de cima para baixo.
Observe o exemplo a seguir:
Declarações
real NOTA;
Inicio

escreva("Informa a nota da prova: ");

leia(NOTA);
escreva("Nota =", NOTA);
Fim
O mesmo exemplo no Visualg fica:
 O algoritmo proposto no exemplo anterior é descritivo e respeita as regras de organização
e sintaxe do português estruturado. Porém, qual é a primeira instrução a ser executada neste
algoritmo?
Ele será executado de maneira sequencial, onde a partir da palavra reservada Declarações
as instruções vão sendo executadas de cima para baixo e a próxima instrução só é executada
após a anterior ser encerrada. O ponto e vírgula marca exatamente o final da instrução a ser
executada, no caso dos comando do Visualg vale lembrar que suas instruções não finalizam
com ponto e virgula, pois ao passar pra próxima linha o programa reconhece como
finalização da instrução anterior.
1. Primeira execução será a criação da variável NOTA.
2. Segunda será a escrita da mensagem que orienta o usuário.
3. Na terceira será armazenado o valor informado pelo usuário.
4. A quarta e última mostrará uma mensagem e o valor lido
É importante observar que sempre será executado primeiro o bloco de declarações e na
sequencia o bloco de instruções. A execução da palavra reservada Fim encerra a execução do
algoritmo.

3.2. Estrutura de seleção.

Este tipo de estrutura permitir a escolha de um caminho sequencial a ser executado.
Primeiramente, ela efetua um teste condicional que definirá o caminho de execução do
algoritmo baseado no resultado deste teste.
Os testes condicionais são baseados na lógica convencional, podem obter o resultado de
verdadeiro ou falso. Estes testes podem ser efetuados sobre operações relacionais simples ou
com expressões lógicas complexas que resultem em um valor lógico (verdadeiro ou falso).
As estruturas de seleção podem ser classificadas de 4 formas diferentes, sendo esta
classificação baseada na organização lógica existente em cada situação. Esta classificação se
resume em:

> Seleção simples.

> Seleção composta.
> Seleção encadeada.
> Seleção de múltipla escolha.

1. Seleção Simples
Neste tipo de seleção é proposto um teste condicional, que sendo verdadeiro possibilitará a
execução de uma instrução ou um conjunto de instruções (bloco condicional) específica.
Português estruturado:
Acompanhe a seguir as regras de representação em algoritmo para a técnica descritiva do
português estruturado.
 Sintaxe:

:
se (<condição>) então
comando 1;
comando 2;
:
:
comando n;
fim se;

Exemplo: No Visualg:

Declarações
inteiro IDADE;
Inicio
escreva("Informe sua idade: ");
leia(IDADE);
se (IDADE < 15) então
escreva ("Você é uma criança");
fim se;

Fim

Este algoritmo será executado sequencialmente até chegar ao comando SE (comando

condicional SE) que realizará o teste condicional para verificar a veracidade do valor
informado pelo usuário e armazenado na variável IDADE.
Se ela for verdadeira, ou seja, for menor que 15 a mensagem "Você é uma criança" será
mostrada na tela. Se o valor informado pelo usuário não atender ao teste condicional, a
mensagem não será exibida e o bloco condicional não será executado.
Fluxograma:
Abaixa temos no fluxograma o simbolo que representa
uma decisão ou seleção e a seguinte:
As suas vértices indica qual
a saída caso ela for verdadeira
ou falsa.

Acompanhe a seguir a representação em

algoritmo na técnica gráfica do fluxograma:
 Exercício rápido:
1°) Crie um algoritmo que leia um número e diga se ele é maior ou menor que 10.
2°) Crie um algoritmo que leia dois números e determine qual é o maior entre eles,
imprimindo na tela (“o primeiro número é o maior”, “o segundo número e o maior” ) de acordo
com o valor digitado.

2. Seleção Composta
A seleção composta sempre executará um bloco condicional, pois se o resultado do
teste condicional for verdadeiro um conjunto de instruções ou somente uma será executada e
se o resultado não for verdadeiro um outro conjunto de instruções, ou somente uma, será
executada também.
Este tipo de seleção sempre identificará um único caminho de instruções a ser
percorrido, dependendo sempre do resultado da veracidade do testes condicional
executado.
Sintaxe:
:
se (<condição>) então
comando 1;
:
comando n;
senão
comando 5;
:
comando m;
fim se;

Exemplo: no Visualg

Declaraçõe
s
inteiro idade;

Inicio
escreva("Informe sua idade: ");
leia(idade);

se (idade < 15) então

escreva ("Você é uma criança");
senão
escreva("Você é adulto");

fim se;
Fim

Se a idade informada for menor que 15 então a mensagem a classificará como uma
criança, senão a mensagem apresentada será que Você é adulto.
Logica de Programação 39

Veja como é o fluxograma que representa o código anterior abaixo:

Exercício rápido:
1°) Crie um algoritmo que leia sua
idade e diga se você é de “maior idade”
ou de “menor idade”.
2°) Crie um algoritmo que um
número, caso ele seja menor que 0,
transforme ele em positivo, se não,
imprima seu valor na tela.

3. Seleção encadeada
A instrução de seleção (SE) pode ser encadeada uma dentro da outra, seja no bloco
verdadeiro (então) ou falso (senão). Todas as instruções programáveis podem estar dentro de
qualquer um dos blocos da instrução de seleção.
O encadeamento destas instruções também é chamada de aninhamento de instruções de
seleção ou condicional várias, não existindo um limite de quantos testes condicionais podem
estar dentro de outro. Quem estabelece este tipo de limite é a solução lógica proposta no
algoritmo para alcançar uma solução eficiente.

Sintaxe:

:
se (<condição_1>) então
<bloco de comandos 1>;
senão
se (<condição_2>) então
<bloco de comandos 2>;
senão
se (<condição_3>) então
:
fim se; fim se;
fim se;
 Exemplo: no Visualg:

Declarações inteiro idade;

Início
escreva("Informe sua idade: "); leia(idade);
se (idade < 20) então se(idade < 15) então
escreva ("Você é criança"); senão
escreva ("Você é adolescente"); fim se;
senão
se(idade < 50) então escreva("Você é
adulto");
senão
escreva("Você é velho"); fim se;
fim se; Fim

Fluxograma:

Exercício rápido:
1°) Crie um Algoritmo que receba os três lados(A,B,C) de um triângulo e diga de ele é
triângulo escaleno(todos os lados diferente), isósceles(somente dois lados iguais) ou
equilátero(todos os lados iguais).
2°) Dadas três variáveis, crie um algoritmo que determine quem é a maior, a
intermediaria e a menor.

3.3. Seleção de múltipla escolha.

Uma outra instrução condicional, muito utilizada nas avaliações de igualdade, é a
seleção de múltipla escolha. Ela verifica somente a igualdade do valor avaliado, onde sua
veracidade resultará na execução de um bloco, ou de uma única instrução específica.

escolha (X) caso <v1>:

comandos; caso <v2>:
comandos; caso <v3>:
comandos; caso contrario:
comandos;
fim escolha;

Sintaxe:

<v1>, <v2>, <v3> são supostos valores a serem relacionados por meio da operação de
igualdade.
Exemplo:
Declarações inteiro estação;
Inicio

escreva("Digite o período trimestral do ano em que estamos: "); leia(estação);

escolha (estação){ instrução de múltipla escolha sobre estação }

caso 1: escreva ("verão");{ testes de igualdades sobre estação } caso 2: escreva

("outono");
caso 3: escreva ("inverno"); caso 4: escreva ("primavera");

caso contrario: escreva ("período inválido"); fim escolha;

Fim
 No Visualg

Temos algumas diferenças de sintaxe, onde uma delas é a ausência de dois pontos após
caso, a outra é o comando “outrocaso” que no portugol é representado por “casocontrario”.

3.4. Estruturas de repetição.

O processamento de valores pode ocorrer diversas vezes sobre uma mesma lógica, porém
os dados a serem manipulados podem ser diferentes, como no calculo da tabuada de um
número. Este calculo realiza a mesma operação de multiplicação sobre os valores numéricos
inteiros sequencias, normalmente iniciados em um (1) e seguindo até o número dez (10)
quando estamos aprendendo a calcular e memorizar o resultado obtido nesta operação.
Sendo assim, Vamos criar um algoritmo que leia um número positivo e apresente o
resultado de sua tabuada de um a dez (1 à 10). Observe o exemplo proposto:
Exemplo:
 Supondo que o valor desejado seja 2 então: Solução (algoritmo descritivo):
2x1=2
2x2=4
2x3=6
2x4=8
2 x 5 = 10
2 x 6 = 12
2 x 7 = 14
2 x 8 = 16
2 x 9 = 18
2 x 10 = 20

Para o exemplo acima foi desenvolvido um algoritmo que atende ao problema apresentado,
mas se os valores tivessem que ser gerados até 1000? .Assim o algoritmo não ficaria mais
complexo, pois a operação a ser realizada seria a mesma, e ele ficaria bem maior. Adiante
veremos a solução para esse problema.
Dica: os laços de repetição são conhecidos em inglês como loops ou looping.

3.5. Repetição com teste no início e no final.

1. TESTE INÍCIO
Com o intuito de controlarmos as manipulações necessários sobre os dados armazenados,
também podemos utilizar as instruções de repetição, que permitem a repetição de uma
operação quantas vezes forem necessárias, baseando esta repetição no resultado de um teste
condicional.
Para isso temos a estrutura enquanto <condição> faça.
A instrução de repetição ENQUANTO ... FAÇA permite a execução do conjunto de
comandos pertencentes ao seu bloco de repetição, sendo eles executados a partir de um
teste condicional verdadeiro. Enquanto este teste permanecer verdadeiro a repeti ção é
executada continuamente, sendo encerrada somente quando a condição for falsa.
Sintaxe:
:
enquanto (< condição >) faça

<bloco de repetição>; { com um ou vários comandos } fim

enquanto;
 Exemplo (descritivo): No Visualg:

Declarações

real nota, media; inteiro aux;

Início aux ← 1;
media ← 0;

enquanto aux < 50 faca escreva("Informe sua

nota: "); leia(nota);
media ← media + nota; aux ← aux + 1;
fim enquanto

escreva("Média da turma = ",media /50); Fim

Fluxograma:
Observe a representação genérica em um
algoritmo gráfico usando o ENQUANTO...FAÇA.

Exercício rápido:
1°) Crie um algoritmo que conte de 1 até 100.
2°) Crie um algoritmo que receba 10
números e imprima na tela após cada
digitação.
3°) Crie um programa que conte de 1 a 52.
2. TESTE FINAL
Para o teste final temos a instrução REPITA ... ATÉ, onde possui características
relevantes na sua lógica de execução.
As principais características dessa instrução são:
• O teste condicional para realizar a repetição sobre o bloco de instruções
existente entre a palavra reservada REPITA e ATÉ é executado somente no final do
bloco, conforme organização sequencial do algoritmo
• O bloco entre as duas palavras reservadas desta instrução será executado no
mínimo uma vez
• A repetição é executada somente se o teste condicional for falso, pois
sendo ele
verdadeiro a repetição é encerrada.

Sintaxe:
:
repita

<bloco de repetição>;{ com um ou vários comandos } até

(<condição>);
:
Exemplo (descritivo): No Visualg:

Declarações
real nota, media;
inteiro aux;
Início
aux ← 1;
media ← 0;
repita
escreva("Informe sua nota: ");
leia(nota);
media ← media + nota;
aux ← aux + 1;
até (aux > 50);
escreva("Média da turma = ",media /50);
Fim

Usando a representação gráfica, vamos

observar o mesmo exemplo usando a
instrução REPITA ...ATÉ.
O bloco de repetição vai ser executado até a
condição for maior que 50. Observe
Fluxograma ao lado:

Exercício rápido:
1°) Crie um Algoritmo que leia um
número e mostre vários “*” na tela de
acordo com esse número. Ex: 10 vai
imprimir **********.
2°) Crie um algoritmo que leia dois números
e mostre o intervalo entre eles. Ex: 5 e 12 vai
mostra: 6,7,8,9,10,11.
3.6. Repetição com variável de controle.
Na estrutura de repetição vista até agora, ocorrem casos que fica difícil determinar o
números de vezes que um bloco vai executar. Ou seja,será executado enquanto a condição for
satisfatória.
A instrução de repetição PARA ... FAÇA executa um conjunto de instruções por uma
quantidade de vezes bem definidas (conhecidas).

Sintaxe:
:
para X de i até f passo p faça

<comandos>; fim para; onde:

X é uma variável inteira que auxiliará na contagem da repetição iniciada com o valor i até o
valor final de f ,p é o valor do incremento dado a variável X.
O problema da tabuada, apresentado anteriormente, pode ser solucionado com o
algoritmo que usa eficientemente a instrução de repetição para ... faça.

Solução da tabuada (descritiva):

Declarações
inteiro valor, contador;
Início
escreva ("Informe o valor desejado: "); leia(valor);
para contador de 1 até 10 passo 1 faça
escreval(valor, " x ",contador," = ", ( valor * contador) ); fim para;
Fim

No Visualg:
 Vamos acompanhar outro exemplo na aplicação desta instrução de repetição.
Exemplo (descritivo): No Visualg:
Declarações

real nota, soma, media; inteiro aux;

Início soma <- 0;
para aux de 1 até 50 passo 1 faça
escreva("Informe sua nota: "); leia(nota);
soma<- soma + nota; fim para;
media <- soma / 50;

escreva ("Média da turma = ", MEDIA);

Fim

Neste exemplo, a repetição, ou looping, realizado pela instrução para ... faça efetua a
leitura e a soma de 50 notas de alunos de uma turma, apresentando no seu final a média
desta turma.

Fluxograma:
Acompanhe a seguir o algoritmo gráfico da
solução descrita anteriormente em português
estruturado.

Exercício rápido:
1°) Faça um algoritmo que receba 10 números e
imprima somente os 5 primeiros. 2°) Faça um
algoritmo que imprima somente números pares
de 2 até 20.
3.7. Comparação entre estruturas de repetição.

As estruturas de repetição possuem uma forma diferenciada para controlar a quantidade de

repetições a serem executadas. Estes controles podem ser genericamente classificados em
automático ou controlado pelo usuário do programa.
AUTOMÁTICO: Uma variável auxiliar contará de quantas vezes será executado o conjunto
de comandos (bloco de repetição), sem interferência direta do usuário. O bloco será
repetido sempre a quantidade de vez prevista pelo desenvolvedor do programa.
CONTROLADO PELO USUÁRIO: O programa sempre respeitará a solicitação do
usuário, executando um bloco de repetição quantas vezes forem solicitadas pelo usuário,
respeitando a lógica existente no programa desenvolvido.
Na tabela a seguir podemos ver um comparativo de estruturas de repetição;

Estrutura Condição Quantidade de Condição de existência

Enquanto Início execuções
0 ou muitas Condição verdadeira
Repita Final Minimo 1 Condição falsa
Para Não tem ((vf-vi) div p)+1 v<=vf

Onde:
v →
variável de controle;
vi →
é a variável de controle;
vf →
é o valor final da variável v;
p →
é o valor o incremento dado à variável;

Diagrama:

enquanto:

repita:

para:
Logica de Programação 51

Repare que a estrutura para é a mais complexa, uma vez que acontece vários processos no
mesmo, as estruturas repita e enquanto são muito semelhantes. A diferença está na ordem da
expressão e ação, pois em repita a expressão lógica é testada no final, ou seja, a ação executa
pelo menos uma vez.
Comparação da sintaxe:
enquanto:

enquanto aux < 50 faca

….......
fim enquanto

repita

repita
…......

até (aux > 50); para

para aux de 1 até 50 passo 1 faça
….....
fim para;

veja um exemplo de um programa feito com as três estruturas:

Repare que a variável aux é iniciada varias vezes pois a cada laço de repetição é
Logica de Programação 52
incrementado um novo valor, no cado de 1 até o numero 10.
3.8. EXERCÍCIOS PROPOSTOS
1°)Quais os três tipos de estruturas de dados, e diga qual a principal diferença entre
elas.

2°) Quais as estruturas de seleção, defina cada uma delas.

3°) Usando estrutura de seleção crie um algoritmo no Visualg onde o usuário digite 4 notas
de um aluno e mostre no final a média dizendo ao usuário se ele foi aprovado ou reprovado.
4°) Usando escolha crie um algoritmo onde o usuário digite um numero de 1 a 7,após isso
imprima a seguinte frase, ex : “a opção escolhida foi a de número 5”.
5°) Crie um fluxograma para a questão 4 de acordo com a forma
resolvida.

6°) Defina qual a principal finalidade de uma estrutura de

repetição.
7º) Crie um algoritmo no visual que receba dois números, o primeiro devera ser digitado
por uma pessoa, o outro por outra pessoa ,o intuito do Algoritmo e verificar se o segundo
usuário chutou o numero próximo do primeiro ou não, caso ele acerte o chute imprima na
tela(use a estrutura se para comparar).
8°) usando estrutura de repetição enquanto, crie um Algoritmo no Visualg que conte de 1
até 20.
9°) Agora com os mesmos códigos da questão 9, faça um Algoritmo que, ao chegar em 20
comece a contar de novo(acrescente a estrutura se para reinicializar a variável) .
10°)Crie um Algoritmo onde o usuário entre com o tempo em minutos, após isso ele
imprima na tela uma contagem regressiva(use qualquer estrutura de repetição).
11°)Faça um Algoritmo onde o usuário entre com numero e imprima a tabuada daquele
numero(use qualquer estrutura de repetição).
12°) Dada a expressão H= 1/1+3/2+5/3+7/4+.....+99/50,crie um algoritmo que
mostre o valor final de H.
13°) Crie um algoritmo que o usuário entre com um numero e ele diga se é “par” ou
“impar”(use qualquer estrutura de comparação)..
14º) Crie um programa que mostre toda a tabuada de 1 até 9 (use qualquer estrutura de
repetição).
Capítulo 4. Estruturas de Dados
Objetivos
Mostrar a manipulação de vetores e matrizes em sua aplicação; Mostrar aplicabilidade dessas
estruturas visando somente o conceito de registros (uma vez que não existe registos nas versões
Atuais do Visualg).

4.1. O que é estruturas de dados.

São organizações de dados construídas a partir da composição dos tipos primitivos já

existentes (caractere, inteiro, real, lógico). Esses novos tipos de dados podem armazenar um
conjunto de dados conhecidos como variáveis compostas. As variáveis que armazenam esses
tipos de dados podem ser classificadas em: variáveis compostas homogêneas e variáveis
compostas heterogêneas.
As variáveis compostas são estruturas de dados (armazenam um conjunto de dados)
homogêneos ou heterogêneas. Esses dados podem ser armazenados em dois tipos de
variáveis: as variáveis unidimensionais (conhecidas como vetores) e as variáveis
multidimensionais (conhecidas como matriz).
O diagrama abaixo mostra as regras sintáticas, supondo que o valor a ser atribuído é um
conjunto de informações:

Lembrando que estas regras podem mudar de acordo com a linguagem. Veja a forma
estruturada utilizada no Visualg.
Declaração:

Inicialização:

4.2. Variáveis compostas homogêneas.

As estruturas de dados homogêneas permitem agrupar diversas informações dentro de
uma mesma variável. Este agrupamento ocorrerá obedecendo sempre ao mesmo tipo de
dado, e é por esta razão que estas estruturas são chamadas homogêneas. A
utilização deste tipo de estrutura de dados recebe diversos nomes, como: variáveis
indexadas, variáveis compostas, variáveis subscritas, arranjos, vetores, matrizes,
tabelas em memória ou arrays. Os nomes mais usados para essas estruturas homogêneas
são: matrizes (genérico) e vetores (matriz de uma linha e várias colunas).
 Exemplos:
Alcateia (vários lobos), conjunto de números inteiros, lista de contatos, time de
futebol, o vetor notas, que armazena o conjunto de notas da primeira e outros.

4.3. Variáveis compostas unidimensionais.

São variáveis que necessitam de apenas um índice para individualizar um elemento do
conjunto que são chamado de vetores. Os vetores são usados nos casos em que um conjunto
de dados do mesmo tipo precisa ser armazenado em uma mesma estrutura.

Exemplo:
1. Guardar 20 números diferentes em um mesmo tipo de variável.
2. Lista de palavras em uma mesmo tipo de variável.
3. 50 Médias de alunos em um mesmo tipo de variável.

Diagrama:

Diagrama da estrutura no Visualg:

onde:
Li = representa o limite inicial do
vetor. Lf = representa o limite final
do vetor.
Tipo primitivo: representa qualquer uns dos tipos básicos de dados.
4.4. Declaração e manipulação(unidimensional).
Ao imaginar o elevador de um prédio sabemos que este é capaz de acessar qualquer
um de seus andares. Entretanto, não basta saber que andar desejamos atingir se não
soubermos o nome do edifício, pois qualquer um possui andares. O que precisamos de
antemão é saber o nome do edifício e só então nos preocuparmos para qual daqueles
andares queremos ir. O mesmo acontece com os vetores, visto que são compostos por diversas
variáveis e, como podem existir muitos vetores, torna se necessário determinar qual vetor
contém o dado desejado e depois especificar em qual posição este se encontra. O nome do
vetor é determinado por meio do identificador que foi utilizado na definição de variáveis, e a
posição, por meio da constante, expressão aritmética ou variável que estiver dentro dos
colchetes, também denominada índice. Após isolar um único elemento do vetor, poderemos
manipulálo através de qualquer operação de entrada, saída ou atribuição.
A sintaxe do comando de definição de vetores é a seguinte:

Portugol:<nome do tipo de variável> : [ nome da variável] <expressão>;

Padrão Visualg: [nome da variável] : vetor[<valor do índice>] de [ tipo de variável]

Observe:

Declaração convencional : tipo: nome[n];

Declaração no Visualg: nome : identificador[n]de tipo

n – é o tamanho do vetor.
Exemplo:
real: media[40];
inteiro: valor[100];
alunos : vetor[0..50] de caracter
dias : vetor[0..31] de inteiros

4.4.1. Leitura de Dados de Uma Matriz do Tipo Vetor

A leitura de um vetor é feita passo a passo, ou seja, um de seus componentes por vez usando
a mesma sintaxe da instrução primitiva da entrada de dados, onde além do nome da
variável, deve ser explicitada a posição do componente lido.
Sintaxe:

leia(<nome_da_variável> [ <índice> ]);

Veja uma figura onde representamos um vetor de 10 posições onde cada uma guarda uma
nota diferente. Para recuperarmos o valor guardado, devemos fazer uma chamada do nome do
vetor passando pra ele qual a posição queremos. Vale lembrar que se passarmos um índice
inválido ocorrerá um erro no algoritmo.
notas : vetor[1..10] de real
escreva(notas[6])
 Uma observação importante a ser feita é a utilização da construção para a fim
de efetuar a operação de leitura repetidas vezes em cada uma delas, lendo um
determinado componente do vetor. De fato esta construção é muito comum
quando se opera com vetores, devido à necessidade de se realizar uma mesma
operação com os diversos componentes dos mesmos. Na verdade, são raras as
situações que se deseja operar isoladamente com um único componente do
vetor.
Um vetor é uma estrutura de dados indexada, ou seja, cada valor pode ser
acessado através de um índice, o qual corresponde a uma posição no vetor os
índices são valores inteiros e positivos (0, 1, 2, 3,...); em outras palavras, uma
posição específica do vetor pode ser acessada diretamente através do seu
índice.
Abaixo temos o exemplo de uma operação com para, onde temos um vetor
notas de 5 posições e cada uma será atribuída o valor de 1*10 até 5*10 logo
após a leitura :

atribuição: leitura:

4.5. Variáveis compostas multidimensionais.

São as variáveis que necessitam mais de um índice para a
individualização de seus elementos. As variáveis multidimensionais podem ser
bidimensionais, onde o primeiro elemento representa a linha e o segundo a
coluna. Podem ainda ser tridimensionais, onde o elemento representa a página
(face).
Diagrama:
 Diagrama da estrutura no Visualg:

onde:
Li = representa o limite inicial do vetor.
Lf = representa o limite final do vetor. V = vetor.
Vn = números de vetores.
Tipo primitivo: representa qualquer uns dos tipos básicos de dados.

Dica: Cada vetor é separado por virgula, com isso formamos uma matriz.

4.6. Declaração e manipulação(multidimensionais ).

Para declarar uma matriz multidimensional temos que definir quantas
dimensões a mesma vai possuir. Cada matriz vai ser composta por dois ou
mais vetores.
Sintaxe da declaração:

tipo IDENTIFICADOR = matriz [LI1..LF1, LI2..LF2, ..., LIn..LFn] de <tipo>;

Onde:
LI1..LF1, LI2..LF2, ..., LIn..LFn : São os limites dos intervalos de variação dos
índices da variável, onde cada par de limites está associado a um índice;
<tipo> : representa qualquer um dos tipos básicos ou tipo anteriormente
definido; lista de variáveis : lista de variáveis (separadas por vírgula) que
terão o mesmo tipo denotado por IDENTIFICADOR.

Exemplo:
tipo SALA = matriz [1..4,
1..4] de inteiro; tipo M =
matriz [1..3, 1..5, 1..4] de
inteiro;

No Visualg:
notas : vetor [1..2,1..5] de inteiro
alunos : vetor[1..3,1..20] de caracter
 Veja um Exemplo onde temos o seguinte código:

Observe que no código temos uma matriz com duas dimensões onde cada
dimensão é um vetor. Além disso, essa matriz é guardada em uma variável
chamada dados, onde ela representa tanto o nome como a rua de uma
determinada pessoa.

4.7. Variáveis compostas heterogêneas.

Já sabemos que um conjunto homogêneo de dados é composto de variáveis do
mesmo tipo primitivo, porém se tivéssemos um conjunto em que os elementos
não são do mesmo tipo, teríamos então um conjunto heterogêneo de dados.
Considerando que os andares de um prédio são divididos em apartamentos
temos uma estrutura multidimensional. Para localizarmos um indivíduo 4 neste
prédio precisaremos de seu nome, o andar e o número do apartamento.
Considerando uma estrutura bidimensional (dois índices: andar e
apartamento),o primeiro índice indica a linha e o segundo, a coluna.

O elemento Selecionado é referenciado por MSALA [2, 3].

4.8. Registros (declaração e manipulação).

Uma das principais estruturas de dados é o registro. Para exemplificar, imagine
 uma passagem de ônibus, que é formada por um conjunto de dados logicamente
relacionados, porém de tipos diferentes, tais como número da passagem
(inteiro), origem e destino (caractere), data (caractere), horário (caractere),
poltrona (inteiro), distância (real), que são subdivisões do registro (elementos
do conjunto), também chamadas de campos. Logo, um registro é composto por
campos que são partes que especificam cada um dos dados.
Observe o seguinte formulário abaixo:

Uma das principais estruturas de dados é o registro. Para exemplificar

imagine uma identificação de passageiro, ou seja, aquele formulário de
informações que o passageiro entrega ao motorista antes de embarcar no
ônibus junto com a passagem. Ela é formada por um conjunto de informações
logicamente relacionadas, porém de tipos diferentes tais como números de
passageiros(inteiro), idade(inteiro) e o nome do passageiro(caracteres) que são
subdivisões do registro (elementos do conjunto), também chamadas de campo.
Um registro é composto por campos que são partes que especificam cada uma
das informações que o compõe. Uma variável do tipo registro é uma variável
composta, pois engloba um conjunto de dados e é heterogênea (cada campo
pode ser de um tipo primitivo diferente).

Diagrama:

Dica: Não existe registro no Visualg, portanto para programação do mesmo usase outras
linguagens que serão visto nos módulos mais adiante.