Escolar Documentos
Profissional Documentos
Cultura Documentos
Sumário
Capítulo 1. Introdução a Lógica de Programação .........................................................................................3
1.1. Noções de Lógica .........................................................................................................................................3
1.2. O que é lógica. ..............................................................................................................................................3
1.3. A real lógica do dia a dia. ........................................................................................................................4
1.4. Lógica de programação. ...........................................................................................................................4
1.5. O que é um algoritmo ...............................................................................................................................6
1.6. Porque é importante construir um algoritmo. ...............................................................................6
1.7. As maneiras de representarmos um algoritmo. .............................................................................7
1.7.2. Fluxograma Convencional. ............................................................................................................7
Capítulo 2. Tópicos Preliminares ....................................................................................................................... 21
2.1. Tipos primitivos........................................................................................................................................ 21
2.2. Constantes. ................................................................................................................................................. 21
2.3. Variável......................................................................................................................................................... 22
2.4. Formação de identificadores. .............................................................................................................. 22
2.5. Declaração de variáveis ......................................................................................................................... 22
2.6. Comandos de entrada e saída. ........................................................................................................... 23
2.7. Expressões aritméticas. .......................................................................................................................... 25
2.8. Operadores aritméticos.......................................................................................................................... 26
2.9. Expressões lógicas .................................................................................................................................... 28
2.10. Operadores relacionais. ......................................................................................................................... 28
2.11. Operadores lógicos. ................................................................................................................................. 29
2.12. Comando de atribuição. ........................................................................................................................ 30
2.13. EXERCÍCIOSPROPOSTOS .................................................................................................................. 31
Capítulo 3. Estruturas de Controle .................................................................................................................... 33
3.1. Estrutura sequencial. .............................................................................................................................. 33
3.2. Estrutura de seleção. .............................................................................................................................. 34
3.3. Seleção de múltipla escolha. ............................................................................................................... 39
3.4. Estruturas de repetição. ........................................................................................................................ 40
3.5. Repetição com teste no início e no final. ....................................................................................... 41
3.6. Repetição com variável de controle. ................................................................................................ 45
3.7. Comparação entre estruturas de repetição. ................................................................................. 47
Capítulo 4. Estruturas de Dados ......................................................................................................................... 50
4.1. O que é estruturas de dados. ................................................................................................................ 50
4.2. Variáveis compostas homogêneas. .................................................................................................... 50
4.3. Variáveis compostas unidimensionais. ............................................................................................ 51
4.4. Declaração e manipulação(unidimensional). .............................................................................. 52
4.5. Variáveis compostas multidimensionais......................................................................................... 53
4.6. Declaração e manipulação(multidimensionais )........................................................................ 54
4.7. Variáveis compostas heterogêneas. ................................................................................................... 55
4.8. Registros (declaração e manipulação). ........................................................................................... 55
Logica de Programação 3
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.
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.
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.
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.
Dica: Pesquise o uso dessas ferramentas por meios da internet, amigos ou professores.
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
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: trata-se 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 :
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 ponto-e-virgula.
Exemplo:
Visualg: Portugol:
alunos : caracter caracter : alunos ;
valor : inteiro inteiro : valor ;
b : real real : b ;
Exemplo: leia (v) O valor da variável (v) é dado por um dispositivo de entrada.
Logica de Programação 24
Também podemos concatenar valores no comando de saída. Isso varia muito de uma
linguagem para outra, por exemplo:
utilizamos o “escreval” quando queremos uma quebra de linha, troque por “escreva” e perceba
o que acontece:
Exemplos:
Exemplo:
código-fonte. 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:
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}
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) não
F A
V
V F
Operação de conjunção:
A B Ae B
F F F
F V F
V F F
V V V
Exemplos:
Exemplo:
código-fonte. Saída da execução.
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:
2.13. EXERCÍCIOSPROPOSTOS
1º)Como podemos definir o conceito de tipos primitivos de dados.
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:
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.
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.
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.
Logica de Programação 35
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
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ções
inteiro idade;
Inicio
escreva("Informe sua idade: ");
leia(idade);
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 37
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;
Logica de Programação 38
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).
Logica de Programação 39
2°) Dadas três variáveis, crie um algoritmo que determine quem é a maior, a
intermediaria e a menor.
<v1>, <v2>, <v3> são supostos valores a serem relacionados por meio da operação de
igualdade.
Exemplo:
Declarações
inteiro estação;
Inicio
leia(estação);
fim escolha;
Fim
Logica de Programação 40
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”.
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.
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;
Logica de Programação 42
Declarações
Início
aux ← 1;
media ← 0;
fim enquanto
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.
Logica de Programação 43
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>);
:
Logica de Programação 44
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
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.
Logica de Programação 45
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.
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:
Logica de Programação 46
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.
Logica de Programação 47
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 48
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:
repita
repita
…......
até (aux > 50);
para
Repare que a variável aux é iniciada varias vezes pois a cada laço de repetição é
incrementado um novo valor, no cado de 1 até o numero 10.
Logica de Programação 49
Lembrando que estas regras podem mudar de acordo com a linguagem. Veja a forma
estruturada utilizada no Visualg.
Declaração:
Inicialização:
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.
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:
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.
Logica de Programação 52
Observe:
n – é o tamanho do vetor.
Exemplo:
real: media[40];
inteiro: valor[100];
alunos : vetor[0..50] de caracter
dias : vetor[0..31] de inteiros
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])
Logica de Programação 53
atribuição: leitura:
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.
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
Logica de Programação 55
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.
Diagrama:
Dica: Não existe registro no Visualg, portanto para programação do mesmo usa-se outras
linguagens que serão visto nos módulos mais adiante.