Apostila de Lógica de Programação

Prévia do material em texto

QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 1 
APOSTILA DE LÓGICA DE PROGRAMAÇÃO
Direitos autorais reservados à: 
Professor Eduardo Reus Souza. 
Escola QI – Porto Alegre 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 2 
Sumário 
Aula 1 ............................................................................................................................... 6 
Apresentação da Disciplina .......................................................................................... 6 
1. Considerações iniciais ...................................................................................... 6 
1.1. Lógica e Lógica de Programação ................................................................. 6 
1.2. Problema ....................................................................................................... 6 
1.3. Algoritmo ..................................................................................................... 6 
1.4. Programa ....................................................................................................... 6 
1.5. Formas de se representar um Algoritmo ...................................................... 6 
1.6. Regras para a Criação de Algoritmos ........................................................... 7 
1.7. Como proceder na construção de algoritmos? .............................................. 7 
1.7.1. Leia com atenção o enunciado do problema ............................................ 7 
1.7.2. Obtenha os dados de entrada .................................................................... 7 
1.7.3. Obtenha os dados de saída ........................................................................ 8 
1.7.4. Determinar o que deve ser feito para transformar as entradas 
determinadas nas saídas especificadas ..................................................................... 8 
1.7.5. Testar o algoritmo ..................................................................................... 8 
1.8. Exercícios propostos ..................................................................................... 8 
2. Variáveis e Constantes de memória (RAM) ..................................................... 9 
2.1. Memória ....................................................................................................... 9 
2.2. Como um programa é tratado na memória? ................................................. 9 
2.3. Variáveis ....................................................................................................... 9 
2.4. Constantes ..................................................................................................... 9 
2.5. Regras para formação de Identificadores ..................................................... 9 
2.6. Tipos de Dados ........................................................................................... 10 
2.7. Principais tipos de dados utilizados na disciplina ...................................... 10 
2.8. Exercícios Propostos .................................................................................. 10 
Aula 2 ............................................................................................................................. 11 
Começando a programar na Linguagem C ................................................................. 11 
3. Linguagens de programação ........................................................................... 11 
3.1. Linguagens de Baixo Nível ........................................................................ 11 
3.2. Linguagens de Alto Nível ........................................................................... 11 
3.3. Compilador ................................................................................................. 11 
3.4. Estrutura padrão de um algoritmo (C) ........................................................ 11 
3.5. Indentação ..................................................... Erro! Indicador não definido. 
3.6. Operadores aritméticos ............................................................................... 13 
3.7. Regras de precedência de operadores ......................................................... 13 
3.8. Exercícios Propostos .................................................................................. 13 
Aula 3 ............................................................................................................................. 14 
3.9. Utilizando instruções de I/O ....................................................................... 14 
3.10. Exercícios Propostos .............................................................................. 15 
Aula 4 ............................................................................................................................. 17 
Introdução ao DEV-C++ ............................................................................................ 17 
4. Sobre o software ............................................................................................. 17 
4.1. O que é DEV-C++? .................................................................................... 17 
4.2. Versão do DEV-C++ .................................................................................. 17 
4.3. Interface do Software.................................................................................. 17 
4.4. Compilando um Projeto .............................................................................. 19 
4.5. Tipos de Erros ............................................................................................. 21 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 3 
4.6. Exercício Proposto ...................................................................................... 21 
Aula 5 ............................................................................................................................. 22 
Algoritmos Condicionais ............................................................................................ 22 
5. Introdução ....................................................................................................... 22 
5.1. Instrução IF (SE) ........................................................................................ 22 
5.2. Operadores Relacionais .............................................................................. 23 
5.3. Exercícios Propostos .................................................................................. 24 
Aula 6 ............................................................................................................................. 25 
Exercícios ................................................................................................................... 25 
Aula 7 ............................................................................................................................. 26 
Seleção encadeada ...................................................................................................... 26 
5.4. Instrução SWITCH ..................................................................................... 27 
5.5. Exercícios Propostos .................................................................................. 27 
5.6. Operadores (Conectores) Lógicos .............................................................. 29 
5.6.1. Operador && (E) .................................................................................... 29 
5.6.2. Operador || (OU) ..................................................................................... 29 
5.6.3. Operador ! (Não) ....................................................................................29 
5.7. Exercícios Propostos .................................................................................. 31 
Aula 8 ............................................................................................................................. 32 
Aula 9 ............................................................................................................................. 33 
Avaliação I .................................................................................................................. 33 
6. Introdução ....................................................................................................... 33 
6.1. Tipo de avaliação ........................................................................................ 33 
6.2. Continuação dos exercícios ........................................................................ 33 
Aula 10 ........................................................................................................................... 34 
Algoritmos de Repetição (Laços – Loops) ................................................................. 34 
7. Introdução ....................................................................................................... 34 
7.1. WHILE (ENQUANTO) ............................................................................. 34 
7.2. DO – WHILE (FAÇA ENQUANTO) ........................................................ 35 
7.3. FOR (PARA) .............................................................................................. 36 
7.4. Tipos de Variáveis ...................................................................................... 36 
7.4.1. Variáveis Contadoras .............................................................................. 36 
7.4.2. Variáveis Acumuladoras ........................................................................ 36 
7.4.3. Lixo de Memória .................................................................................... 37 
7.5. Modificações do Sinal de Atribuição ......................................................... 37 
7.6. Loops Infinitos ............................................................................................ 37 
7.7. Exercícios Propostos .................................................................................. 37 
Aula 11 ........................................................................................................................... 38 
Aula 12 ........................................................................................................................... 39 
Aula 13 ........................................................................................................................... 40 
Aula 14 ........................................................................................................................... 41 
Aula 15 ........................................................................................................................... 42 
Revisão Geral Para a Prova I ...................................................................................... 42 
Aula 16 ........................................................................................................................... 43 
Prova I ........................................................................................................................ 43 
Aula 17 ........................................................................................................................... 44 
Considerações sobre a prova ...................................................................................... 44 
Aula 18 ........................................................................................................................... 45 
Variáveis Homogêneas Unidimensionais (Vetores) ................................................... 45 
8. Introdução ....................................................................................................... 45 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 4 
8.1. O que são vetores? ...................................................................................... 45 
8.2. Representação Gráfica ................................................................................ 45 
8.3. Utilidade para Vetores ................................................................................ 45 
8.4. Declarando Vetores .................................................................................... 45 
8.5. Exemplo Prático ......................................................................................... 46 
8.6. Exercícios Propostos .................................................................................. 47 
Aula 19 ........................................................................................................................... 48 
Aula 20 ........................................................................................................................... 49 
Aula 21 ........................................................................................................................... 50 
Variáveis Homogêneas Multidimensionais (Matrizes) .............................................. 50 
9. Introdução ....................................................................................................... 50 
9.1. O que são Matrizes? ................................................................................... 50 
9.2. Representação Gráfica ................................................................................ 50 
9.3. Declarando Matrizes. .................................................................................. 50 
9.4. Exemplo Prático ......................................................................................... 51 
9.5. Exercícios Propostos .................................................................................. 52 
Aula 22 ........................................................................................................................... 53 
Aula 23 ........................................................................................................................... 54 
Aula 24 ........................................................................................................................... 55 
Introdução a Programação Modular ........................................................................... 55 
10. Introdução ................................................................................................... 55 
10.1. Por que Utilizar Programação Modular? ................................................ 55 
10.2. Como Implementar Programação Modular? .......................................... 55 
10.2.1. Funções ................................................................................................... 55 
10.2.2. Assinatura ............................................................................................... 55 
10.2.3. Argumento .............................................................................................. 55 
10.2.4. Parâmetro ................................................................................................ 55 
10.3. Exemplo Prático ..................................................................................... 55 
10.4. Escopo das Variáveis – Instanciamento de Variáveis ............................ 57 
10.5. Exercícios Propostos .............................................................................. 58 
Aula 25 ........................................................................................................................... 59 
10.6. Passagem de Parâmetros por Valor e Referência ................................... 59QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 5 
Introdução 
A disciplina introduz o estudo da programação, destacando a construção de algoritmos. 
Abrange os conceitos fundamentais da programação até o uso de estruturas básicas de 
dados (vetores, matrizes e registros). 
 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 6 
Aula 1 
Apresentação da Disciplina 
1. Considerações iniciais 
1.1. Lógica e Lógica de Programação 
Lógica de programação é a técnica de encadear pensamentos para atingir 
determinado objetivo. Estes pensamentos podem ser descritos como uma seqüência de 
instruções que devem ser seguidas para se cumprir uma determinada tarefa. Gerando ao 
final o que chamamos de programa. 
1.2. Problema 
A definição mais simples para problema é uma situação que precisa ser resolvida 
1.3. Algoritmo 
Algoritmo é uma seqüência ordenada e finita de passos lógicos, bem definas e 
eficazes para a solução de um problema em um tempo finito. 
Reparem que algoritmo não está diretamente relacionado à informática. Uma receita de 
bolo, por exemplo, seria um algoritmo que iria solucionar um problema específico do 
cotidiano humano. 
Reparem também que para um problema podemos ter diversos algoritmos, e que 
muitas vezes, estes só funcionariam dependendo de fatores externos. Como fazer um 
bolo de chocolate visto que faltou luz? A solução provavelmente será diferente da 
solução convencional. 
1.4. Programa 
Um programa não mais é do que um algoritmo computacionalmente aplicável. Isto 
é, serve para resolvermos problemas exclusivos do ambiente computacional. 
Todo programa é um algoritmo, porém nem todo algoritmo é um programa. 
1.5. Formas de se representar um Algoritmo 
Existem várias formas de se representar um algoritmo. Uma delas é escrevê-lo 
através da linguagem natural que usamos no dia-a-dia. Esta maneira, porém, podem 
levar a muitas ambigüidades, passíveis de interpretações errôneas. 
Outra forma de se representar os algoritmos são os fluxogramas convencionais, que 
usam formas geométricas diferentes para as diversas ações. Este método é bastante 
popular pela sua facilidade de compreensão, mas é um pouco limitado, preocupando-se 
muito com detalhes de nível físico da implementação do algoritmo. Outros tipos de 
fluxogramas mais modernos foram criados, mas não obtiveram a mesma popularidade. 
Na medida que os algoritmos tornaram-se muito grandes e complexos, os fluxogramas 
deixaram de ser utilizados para a representação da implementação, sendo direcionados 
para a fase de projeto do software. 
A terceira forma chama-se de pseudocódigo ou metalinguagem. Esta forma de 
representação de um algoritmo assemelha-se muito à forma com que os programas são 
escritos e consiste na descrição dos passos do algoritmo através de frases construídas 
sob uma sintaxe rigorosamente definida. Assim, consegue-se uma descrição do 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 7 
algoritmo livre de ambigüidades e com uma estrutura bastante flexível e completa, onde 
todos os elementos estão representados. 
No estudo da lógica de programação da nossa disciplina, será utilizada a terceira 
forma de representação, utilizando a sintaxe da linguagem de programação C. Não 
utilizaremos o padrão de português estruturado para evitar que nossos algoritmos 
precisem ser reescritos (faça em português, e depois refaça na sintaxe correta da 
linguagem). 
1.6. Regras para a Criação de Algoritmos 
A criação de algoritmos computacionais obedece ao princípio da informática. 
Sendo assim, sempre devemos pensar que nossas soluções devem passar por três 
fases distintas: 
 
 
 
 
Onde: 
Entrada: São os dados que devem ser informados (pelo usuário, ou não) para que o 
programa possa ser executado. 
Processamento: São os procedimentos que devem ser empregados para solucionar o 
problema. Neste podemos incluir operações matemáticas, comparações, repetições, etc. 
Saída: É o resultado final do algoritmo que deve ser entregue a algum lugar ou alguém. 
 
É importante ressaltar que: 
 A ordem das instruções devem ser levadas em consideração. 
 Não existe processamento sem a entrada de dados. 
 A saída de dados deve ser apresentada. 
 O número de instruções deve ser sempre finito. 
 
Exemplo 
Imagine o seguinte problema: calcular a média final dos alunos da 3ª Série. Os 
alunos realizarão quatro provas: P1, P2, P3 e P4. 
Onde: 
 
 Média Final = 
 
A entrada de dados serão as quatro notas. 
O processamento será o cálculo da média propriamente dita. 
A saída de dados será a exibição dessa média. 
1.7. Como proceder na construção de algoritmos? 
1.7.1. Leia com atenção o enunciado do problema 
Nessa primeira etapa devemos compreender perfeitamente o que precisamos 
fazer. A grande maioria dos problemas encontrados nos programas atuais ocorre 
por falhas na interpretação inicial do problema. 
1.7.2. Obtenha os dados de entrada 
Durante a leitura do problema, podemos descobrir quais são os dados que 
precisamos solicitar para a execução do algoritmo. 
Entrada Saída Processamento 
 P1 + P2 + P3 + P4 
 4 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 8 
1.7.3. Obtenha os dados de saída 
Da mesma forma que na entrada de dados, os dados de saída (qual a resposta que 
preciso informar) também pode ser descoberta lendo atentamente a definição do 
problema. 
1.7.4. Determinar o que deve ser feito para transformar as 
entradas determinadas nas saídas especificadas 
Nesta fase é que teremos a construção do algoritmo propriamente dito, pois, a 
partir de alguns requisitos especificados, devemos determinar qual seqüência de 
ações é capaz de transformar um conjunto definido de dados nas informações de 
resultado. 
1.7.5. Testar o algoritmo 
Nesta fase devemos verificar se o algoritmo realmente resolve o problema 
proposto, mesmo com variações nos dados de entrada. Essa é uma das principais 
fases do projeto, afinal, a premissa que devemos ter em relação a um software 
lançado no mercado é a de que este funciona. Chamamos esta etapa de teste de 
mesa. 
Vale ressaltar, que por mais exaustiva que seja a bateria de testes. Um programa 
nunca estará 100% imune a erros. Nessa etapa tentamos chegar o mais próximo 
possível deste índice. 
1.8. Exercícios propostos 
 
1. Especifique as ações necessárias para mover três disco de uma Torre de Hanói, que 
consiste de três hastes (a - b - c), uma das quais serve de suporte para três discos de 
tamanhos diferentes (1 - 2 - 3 ), os menores sobre os maiores. Pode-se mover um 
disco de cada vez para qualquer haste, contanto que nunca seja colocado um disco 
maior sobre um menor. O objetivo é transferir os três disco para outra haste. 
 
 
 
 
 
 
 
 
 
 
 
2. Construa um algoritmo que informe os passos necessários para a trocar o pneu de 
um carro. Tendo como situação inicial que o carro estava em movimento numa 
estrada, que há acostamento e espaço suficiente para a troca. 
c b 
2 
a 
3 
1 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 9 
2. Variáveis e Constantes de memória (RAM) 
2.1. Memória 
Memória é um dispositivo utilizado para guardar de forma temporária ou não algum 
tipo de informação. 
Quando um programa é executado (tornando-se o que chamamos de processo), todo o 
seu conteúdo é posto na memória RAM (Random AccessMemory) do computador. 
Sendo que é somente nela que o mesmo é executado. 
2.2. Como um programa é tratado na memória? 
Todo o programa que é posto da memória RAM do computador é dividido em três áreas 
 
Área de Dados 
Área de Código 
Pilha 
Onde: 
Área de Dados: É o local destinado para o armazenamento dos dados vindos do 
usuário, cálculos, saídas. Enfim, é o espaço que o algoritmo tem para trabalhar. 
Área de Código: É o local onde está o algoritmo propriamente dito. 
Pilha: É quem garante a continuidade do programa. Se o programam efetua “saltos” 
dentro do código, é a pilha que mantém a informação de onde o código estava antes do 
salto consequentemente garantindo um retorno correto ao final do salto. Pilhas utilizam 
uma estrutura de dados manipulada pelo que chamamos de FIFO (First Input First 
Output). 
2.3. Variáveis 
Variáveis são espaços reservados (alocados) na memória RAM do computador, que 
devem possuir um nome e um tipo de dado, sendo que seu conteúdo pode sofrer 
alteração durante a execução do programa. 
Em outras palavras, variáveis são as informações que podemos utilizar na área de dados 
de um programa. Por exemplo, o Nome de um cliente, as Notas de um aluno, a 
Temperatura atual. Mas note que todos estes dados podem mudar a qualquer momento. 
2.4. Constantes 
Variáveis são espaços reservados (alocados) na memória RAM do computador, que 
devem possuir um nome e um tipo de dado, sendo que seu conteúdo NÃO pode sofrer 
alteração durante a execução do programa. 
Repare que a diferença entre uma variável e uma constante na sua definição é sutil, 
porém na prática essa diferença é muito relevante. O valor que for definido na criação 
(declaração) de uma constante a acompanha durante todo o ciclo de vida do processo. 
2.5. Regras para formação de Identificadores 
Para a criação de um identificador (nome de uma variável ou constante, por exemplo) 
devemos tomar cuidado com uma série de fatores. São eles: 
 O nome de um identificador não pode ser iniciado por número. 
 O nome de um identificador não pode conter espaços ou qualquer caracter 
especial, exceto o underline “_”. 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 10 
 O nome de um identificador não pode ser igual ao de qualquer palavra reservada 
da linguagem de programação. 
 Procure utilizar nomes curtos, e que possuam algum significado associado ao 
identificador. 
2.6. Tipos de Dados 
Dados, são as informações em sua forma mais bruta. Sendo que estas informações 
podem ser classificadas em alguns grupos distintos 
 Numéricos: Conjunto formado pelos números (inteiros, reais, etc). 
 Alfanuméricos: Conjunto formado por letras e números (palavras). 
 Lógicos: Representam apenas dois valores/estados. Verdadeiro ou Falso. 
Vale ressaltar que a linguagem C (não C++) não possui um tipo de dado que represente 
valores lógicos. 
2.7. Principais tipos de dados utilizados na disciplina 
 Int (inteiro): Números inteiros entre -32768 e 32767 
 Float (ponto flutuante): Números reais entre 3,4E-38 e 3,4E+38 
 Char (caracter): Tipo alfanumérico que pode variar entre 1 e 255 caracteres, 
este tipo pode também ser referido por string. 
 Void: Representa a não existência de um tipo. 
Vale ressaltar que estes não são os únicos tipos de dados existentes na linguagem C, 
mas sim os que utilizaremos durante o curso de lógica de programação. 
2.8. Exercícios Propostos 
1. Quais dos identificadores abaixo são considerados INVÁLIDOS? Justifique sua 
resposta. 
a) Contas_a_pagar 
b) Salário_Familia 
c) 1Bimestre 
d) Nota1 
e) Endereço 
f) #DDD 
g) Telefone Residencial 
 
2. Defina o melhor tipo de dado para cada expressão abaixo. Considerando apenas int, 
float e char. 
a) 23.56 
b) “minha casa é azul” 
c) 45 
d) “123B56” 
e) -345 
f) 40456 
g) -34.6 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 11 
Aula 2 
Começando a programar na Linguagem C 
3. Linguagens de programação 
Linguagem de programação é uma classe de software (do mesmo jeito que editores de 
texto, planilhas eletrônicas, etc.) onde todos os seus representantes têm por 
característica principal a capacidade de desenvolver novos softwares. Sendo que essa 
classe de software é dividida em dois grandes grupos. Linguagens de alto e baixo nível. 
3.1. Linguagens de Baixo Nível 
São as linguagens que mais se aproximam do idioma da máquina. Possuem uma maior 
complexidade de compreensão, porém seu desempenho é significativamente melhor do 
que as linguagens de alto nível. 
Exemplos de linguagens de baixo nível: Assembly, Fortran, Algol e C. 
3.2. Linguagens de Alto Nível 
São as linguagens que mais se aproximam do idioma humano. Possuem uma 
complexidade de aprendizado inferior as linguagens de baixo nível, porém possuem 
desempenho também inferior a estas. 
Como o “idioma humano” é vasto, vale ressaltar que a grande maioria das linguagens de 
programação encontram-se no idioma Inglês. 
Exemplos de linguagens de alto nível: Cobol, Clipper, Basic, Visual Basic, Pascal e 
Delphi. 
3.3. Compilador 
Compilador é o nome do software responsável pela tradução de um código alto nível 
para baixo nível (para que o processador possa executar suas instruções) gerando ao 
final o que chamamos de arquivo executável. Sendo que a velocidade de processamento 
de um programa está diretamente relacionado a qualidade deste compilador. 
3.4. Estrutura padrão de um algoritmo (C) 
Para programarmos na linguagem C, devemos nos preocupar primeiro com a sua sintaxe 
básica. Abaixo estão explicitadas algumas das principais características da linguagem. 
 Case Sensitive: O nome de um identificador, bem como de instruções devem 
ser escritos da mesmo forma que foram criados, de modo que letras maiúsculas e 
minúsculas fazem diferença. 
 Utilização de bibliotecas: Para utilizarmos alguma instrução já existente na 
linguagem, devemos identificar em qual biblioteca essa instrução se encontra 
logo no inicio do código através da instrução “include”. 
 Utilização de um bloco principal: Todo o programa desenvolvido em C, deve 
possuir uma função principal definida com o nome “main”. 
 Definição de inicio e fim de bloco: Sempre que precisarmos definir inicio e fim 
de um bloco de instruções, utilizaremos os caracteres {}. 
Obs: Como utilizaremos o compilador DEV-C++ durante as aulas, algumas 
includes podem ter nomes diferentes das tradicionais includes do C. 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 12 
Exemplo de um programa 
 
#include <stdio.h> 
 
void main() 
{ 
 int valor1, valor2; 
 float soma; 
 
 valor1 = 23000; 
 valor2 = 15500; 
 soma = valor1 + valor2; 
} 
 
Explicando o código acima 
#include <stdio.h> Esta linha define que poderemos utilizar no nosso código 
fonte instruções de I/O (Entrada e Saída de dados). 
void main() Define onde que o nosso programava vai começar a 
execução 
{ Inicio do bloco de instruções 
int valor1, valor2 Cria na área de dados (declara) duas variáveis de tipo 
inteiro com nomes valor1 e valor2. 
float soma; Cria na área de dados (declara) uma variável de tipo 
ponto flutuante com nome soma 
valor1 = 23000; Atribui o valor 23000 para a variável valor1 
valor2 = 15500; Atribui o valor 15500 para a variável valor2 
soma = valor1 + valor2; Soma o conteúdo das duas variáveis e joga a resposta do 
cálculo na variável soma. 
} Encerra o bloco de intruções 
 
3.5. Endentação 
Repare que o código acima possui alguns espaços entre os caracteres { e } que servempara facilitar a visualização do código na busca de possíveis erros. Esta técnica chama-
se endentação de código. Sendo vital no desenvolvimento de um programa. 
Na grande maioria das linguagens a endentação tem uma importância meramente 
estética, porém existem linguagens que definem inicio e fim de bloco por ela. Python 
seria um bom exemplo disso. 
 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 13 
3.6. Operadores aritméticos 
Dentro da linguagem C, utilizaremos os seguintes operadores aritméticos: 
Operador Nome Exemplo Resposta 
+ Adição X = 5 + 2 7 
- Subtração X = 5 – 2 3 
* Multiplicação X = 5 * 2 10 
/ Divisão inteira X = 5/2 2 
/ Divisão real X = 5.0/2.0 2.5 
% Resto de uma divisão inteira X = 5 % 2 1 
pow Potenciação* X = pow(5,2) 25 
sqrt Raiz quadrada* X = sqrt(25) 5 
 
* Para que as funções “pow” e “sqrt” possam funcionar corretamente, devemos 
adicionar a biblioteca “math.h” nas includes de seu código. 
3.7. Regras de precedência de operadores 
As regras de precedência matemática entre os operadores aritméticos é respeitada pelo 
compilador C. Sendo assim, a multiplicação e divisão são efetuadas antes da adição e 
subtração, por exemplo. Se você quiser que a regra de precedência seja modificada, é 
permitida a utilização de parênteses. De modo que tudo o que estiver dentro destes 
parênteses serão calculados primeiro. 
3.8. Exercícios Propostos 
1. Faça um algoritmo que calcule a média entre dois valores inteiros (5 e 25). 
 
2. Faça um algoritmo que calcule a área de um quadrado de lado L= 10. 
 
3. Faça um algoritmo que calcule a hipotenusa de um triângulo retângulo de catetos 
b=3 e c = 4. (
22 cbh
) 
 
4. Faça um algoritmo que efetue as seguintes operações: 
a) A vale 10 
b) B vale o dobro de A 
c) C vale a raiz quadrada do dobro de A 
d) D vale a metade da raiz quadrada do dobro de A 
e) E vale o cubo da metade da raiz quadrada do dobro de A 
f) F vale a terça parte do cubo da metade da raiz quadrada do dobro de A. 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 14 
Aula 3 
3.9. Utilizando instruções de I/O 
Até o momento, nossos algoritmos apesar de funcionarem, não estão respeitando 
corretamente o principio da informática (aula 1) que é o da Entrada, Processamento e 
Saída de dados. Já que: 
 Nossa entrada de dados é sempre fixa 
 Não estamos exibindo o resultado de nossos cálculos para o usuário do 
programa. 
Para solucionar este problema, a linguagem C possui três instruções para a 
leitura/escrita de dados, scanf, gets e printf. Onde: 
 scanf: Utilizado para a leitura de valores numéricos, sendo que sempre devemos 
utilizar o operador “&” antes da variável de leitura. 
 gets: Utilizado para leitura de valores alfanuméricos 
 printf: Utilizado para a escrita de valores tanto numéricos quanto 
alfanuméricos. 
Exemplo de utilização 
 
#include <stdio.h> 
void main() 
{ 
 int v1, v2; 
 float media; 
 char nome[30]; 
 
 gets(nome); 
 scanf("%d", &v1); 
 scanf("%d", &v2); 
 
 media = (v1 + v2)/2.0; 
 
 printf ("A sua media é: %f", media); 
} 
 
Repare a maneira como foi feita a leitura das variáveis nome, v1 e v2: 
 Nome como é um char, foi lida utilizando a função gets. 
 v1 e v2 por serem numéricas, precisaram ser lidas utilizando o scanf, sendo que 
“%d” é um atributo da função que avisa o compilador que será lido (no caso da 
printf, escrito) um valor de tipo de dado inteiro. 
 A leitura da linha onde encontra-se o printf seria da seguinte forma: Escreva na 
tela a frase “A sua média é: juntamente com um valor de ponto flutuante”, sendo 
que esse valor foi passado para a função logo em seguida separado por uma 
vírgula. 
Alguns atributos importantes que podem ser utilizado nas funções scanf e printf: 
Atributo Utilização Exemplo 
%d Leitura/escrita de dados numéricos inteiros scanf(“%d”, &idade); 
%f Leitura/escrita de dados numéricos reais printf(“%f”,salario); 
%s Escrita de dados do tipo char (strings) printf(“%s”, nome); 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 15 
Dentro de uma instrução printf, podemos fazer a escrita de mais valores, compondo uma 
sentença completa. 
Exemplo: 
 
printf (“%s, Os valores %d e %d formam a média: %f”, nome, v1, v2, media); 
 
Podemos também utilizar a função printf para exibir mensagens para o usuário. Por 
exemplo, no caso anterior, seria interessante exibir uma mensagem ao usuário pedindo 
para que ele informe o seu nome e dois valores inteiros. 
O código ficaria da seguinte maneira: 
 
#include <stdio.h> 
void main() 
{ 
 int v1, v2; 
 float media; 
 char nome[30]; 
 
 printf ("Digite o seu nome: "); 
 gets(nome); 
 printf ("Digite o primeiro valor inteiro: "); 
 scanf("%d", &v1); 
 printf ("Digite o segundo valor inteiro: "); 
 scanf("%d", &v2); 
 
 media = (v1 + v2)/2.0; 
 
 printf ("%s, Os valores %d e %d formam a media: %f", nome, v1, v2, media); 
} 
3.10. Exercícios Propostos 
1. Refaça as questões 1, 2 e 3 da lista anterior, utilizando agora os comandos para 
entrada e saída de dados. 
 
2. Faça um algoritmo que leia três valores reais (ponto flutuante) e calcule a sua média 
ponderada, com os respectivos pesos 2, 3 e 4 para os valores. 
 
3. Faça um algoritmo que leia um valor inteiro e um valor real. Multiplique estes 
valores e exiba o resultado. 
 
4. Faça um algoritmo que leia 4 valores reais (x1, y1, x2, y2) equivalentes a dois pares 
ordenados. Calcule e exiba a distância entre estes dois pontos de acordo com a 
fórmula abaixo: 
2
12
2
12 )()( yyxxd
 
 
5. Faça um algoritmo que leia três valores reais e calcule x’ e x” de acordo com a 
fórmula abaixo 
a
cabb
xx
*2
**4
",'
2 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 16 
6. Faça um algoritmo que leia um valor inteiro equivalente a um determinado valor em 
segundos. Retorne quantas horas, minutos e segundos são compostos por este valor. 
Por exemplo o valor 3670 (segundos) formaria 1 hora, 1 minuto e 10 segundos. 
 
7. Faça um algoritmo que leia dois valores inteiros. Logo após troque os valores entre 
estas variáveis. Ou seja, o conteúdo da variável 1 passará para a variável 2 e vice e 
versa. 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 17 
Aula 4 
Introdução ao DEV-C++ 
4. Sobre o software 
4.1. O que é DEV-C++? 
DEV-C++ é o nome de um dos mais famosos compiladores C para a plataforma 
Windows, sendo que este é um freeware que pode ser baixado dos mais diversos 
lugares. Alguns links serão escritos no apêndice deste manual. 
4.2. Versão do DEV-C++ 
Utilizaremos durante as aulas a versão 4.9.9.2 do DEV-C++ 
4.3. Interface do Software 
Após uma instalação simples do programa o ambiente de desenvolvimento deve ser 
como o mostrado abaixo: 
 
 
Onde: 
 No canto esquerdo temos o navegador de classes/projetos que será utilizado para 
podermos alternar entre arquivos. 
 Na área superior encontram-se os principais atalhos do compilador 
 Na parte inferior temos uma caixa de mensagens que o compilador irá exibir 
conforme a necessidade. 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 18 
Criando um novo projeto 
Para criarmos um novo projeto devemos acessar o menu Arquivo/Novo/Projeto...Escolha a opção Console Application, certificando-se que a opção “Projeto C” esteja 
marcada. 
Você pode definir um nome para seu projeto nesta mesma janela. 
 
 
 
Ao clicar em OK, o compilador irá solicitar que você salve seu projeto. Procure salvar 
um projeto por pasta para evitar um acumulo de arquivos, de modo que seja fácil a 
seleção do documento certo. 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 19 
Logo após a criação do projeto. Você estará apto para começar a programar. 
Repare que a interface do código é muito similar ao que já estamos trabalhando, de 
modo que apenas precisamos modificar (apagar) algumas instruções e nossa aplicação 
estará igual ao de nosso caderno. 
 
 
Repare que existe uma linha obrigatória no final do código fonte: 
system (“pause”); 
 
Onde: 
system(“pause”): Fará com que o programa após sua conclusão seja fechado somente 
após o pressionamento de alguma tecla. A não existência desta linha de instrução 
fecharia o programa sem que o usuário tenha tempo de visualizar as respostas. Podemos 
utilizar qualquer instrução DOS na função system. 
4.4. Compilando um Projeto 
Após a escrita do algoritmo, finalmente é a hora de testar o funcionamento do mesmo. 
Para isso, devemos compilar nosso projeto. 
Existem três atalhos importantes que devemos saber nesse momento. 
 Pressionar as teclas CTRL + F9: Compila o código, porém não o executa. 
 Pressionar as teclas CTRL + F10: Executa um código compilado. 
 Pressionar a tecla F9: Compila e executa o código. 
É importante ressaltar que quando um projeto for compilado, ele deverá ser salvo 
novamente.
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 20 
Abaixo temos uma imagem que representa o resumo do compilador: 
 
 
 
Repare que neste caso o compilador não encontrou nenhum erro durante a tradução do 
código fonte. 
Vejamos abaixo uma situação onde existam erros de sintaxe. 
 
 
No lugar do resumo de compilação, o código teve uma linha destacada e na parte 
inferior do programa estão sendo exibidos alertas do compilador. Neste caso a 
informação é de que o programa não conseguiu compilar a linha 10, devido a falta de 
um “;” na linha 9. 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 21 
4.5. Tipos de Erros 
Durante toda o processo de desenvolvimento de software, encontraremos apenas dois 
tipos de erros em nossos programas. São eles: 
 Erros de Sintaxe: Ocorrem durante a fase de projeto do código, caracterizados 
por falhas na digitação (eu escrevo errado). São facilmente identificados, pois 
são acusados pelo compilador. Como por exemplo escrever “mai” no lugar de 
“main”. 
 Erros de Lógica: Ocorrem em tempo de execução, caracterizados por falhas na 
concepção do código (eu penso errado). São muito mais complexos de serem 
encontrados, já que o programa é executado normalmente, sendo que este apenas 
devolve um valor errado de resposta. Este tipo de erro só pode ser encontrado 
com testes de mesa. 
4.6. Exercício Proposto 
1. Passe todos os algoritmos feitos na listagem anterior para o DEV-C++, anotando 
possíveis erros de sintaxe e perguntando para seu professor o que estes significam. 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 22 
Aula 5 
Algoritmos Condicionais 
5. Introdução 
Até o momento, todos os algoritmos que estamos fazendo podem ser considerados 
Algoritmos Seqüenciais, isto é, executam todas as suas linhas de instrução sem que 
hajam desvios nem repetições no código fonte. Em um ambiente prático, este tipo de 
situação não ocorre, já que durante um programa diversas situações devem ser testadas 
para que seu resultado final seja satisfatório. 
Por exemplo, se formos fazer um programa para cálculo de peso ideal para um 
indivíduo, a fórmula para homens e mulheres é diferente. Sendo assim, em algum 
momento do programa deve-se descobrir o sexo da pessoa e caso seja alguém do sexo 
masculino, faça a fórmula X, caso contrário, a fórmula Y será executada. 
Para podermos trabalhar com algoritmos condicionais podemos utilizar dois tipos de 
instruções IF (SE) e SWITCH (CASO, não é tradução literal): 
5.1. Instrução IF (SE) 
Esta instrução avalia uma determinada condição lógica, e dependendo da resposta que 
esta condição retornar, será feito um bloco de algoritmo ou não. 
Sintaxe: 
if (condição lógica) 
 { 
 <Bloco de algoritmo que será executado caso a condição lógica seja verdadeira>; 
 } 
<Bloco de algoritmo que será executado independentemente da resposta da condição 
lógica>; 
 
Dentro da instrução if, ainda podemos utilizar uma segunda instrução (else - senão) que 
também avalia a condição lógica testada, porém somente sendo executado se esta 
condição for falsa. 
Sintaxe: 
if (condição lógica) 
 { 
 <Bloco de algoritmo que será executado caso a condição lógica seja verdadeira>; 
 } 
else 
 { 
 <Bloco de algoritmo que será executado caso a condição lógica seja falsa>; 
 } 
 
Para melhor compreensão, faremos agora um exemplo prático da utilização deste tipo 
de instrução. Façamos um algoritmo que leia o nome e as duas notas de um aluno, 
retornando a sua média e uma mensagem “Aprovado” ou “Reprovado” dependendo da 
sua média. A média mínima para aprovação será 6. 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 23 
#include <stdio.h> 
void main() 
{ 
 float n1, n2, media; 
 char nome[25]; 
 
 printf("Digite o seu nome: "); 
 gets(nome); 
 printf("Digite sua primeira nota: "); 
 scanf("%f", &n1); 
 printf("Digite sua segunda nota: "); 
 scanf("%f", &n2); 
 
 media = (n1 + n2)/ 2.0; 
 printf ("%f \n", media); 
 if (media >= 6) 
 { 
 printf ("Parabens! Voce esta APROVADO \n"); 
 } 
 else 
 { 
 printf ("Infelizmente voce esta REPROVADO \n"); 
 } 
 
 system("pause"); 
} 
 
O trecho em destaque no código é o que diferencia um algoritmo condicional de um 
puramente seqüencial. Repare que apenas uma das duas mensagens será exibida na tela, 
sendo que tudo depende do retorno do teste “media >= 6”(média ser maior ou igual a 6). 
5.2. Operadores Relacionais 
Para que possamos fazer perguntas lógicas para o processador, devemos sempre utilizar 
um dos operadores abaixo demonstrados. 
 
Operador Significado 
> Maior do que 
< Menor do que 
>= Maior ou igual a 
<= Menor ou igual a 
== Igual a 
!= Diferente de 
 
 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 24 
5.3. Exercícios Propostos 
1. Faça um algoritmo que leia um valor real qualquer e o classifique como POSITIVO 
ou NEGATIVO. Obs: Trate o número ZERO como positivo. 
 
2. Faça um algoritmo que leia um valor inteiro e informe se este valor é maior do que 
10 ou não. 
 
3. Faça um algoritmo que leia dois valores reais e informe se estes valores são iguais 
ou diferentes. 
 
4. Faça um algoritmo que leia um valor inteiro e retorne se este valor é PAR ou 
ÍMPAR. 
 
5. Faça um algoritmo que leia dois valores reais e exiba ao final qual dos dois é o 
maior. 
 
6. Faça um programa que leia o Nome, Valor Hora e Total de Horas Trabalhadas de 
um funcionário. Calcule e exiba: 
a) O salário bruto 
b) O valor de Vale Transporte (6% do Salário Bruto) 
c) O desconto deImposto de Renda (11% do Salário Bruto para salários superiores 
a R$ 1440,00) 
d) O salário líquido. 
 
7. Faça um algoritmo que leia dois valores inteiros equivalentes a hora inicial e final de 
um jogo. Retorne o tempo de duração deste jogo sabendo que o jogo pode começar 
em um dia e terminar em outro, e que o tempo máximo de jogo é 24 horas. 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 25 
Aula 6 
Exercícios 
Aula destinada a continuação e implementação dos exercícios sobre algoritmos 
condicionais. 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 26 
Aula 7 
Seleção encadeada 
É muito comum que dentro de um algoritmo tenhamos vários testes que tenham que ser 
feitos a uma mesma variável ou situação. Para este tipo de situação podemos utilizar o 
encadeamento (aninhamento) de instruções if. Por exemplo, vamos modificar o 
exercício número um da lista anterior para que agora ele considere o valor 0 (zero) 
como nulo. 
 
#include <stdio.h> 
void main() 
{ 
 float valor; 
 
 printf("Digite um valor: "); 
 scanf("%f", &valor); 
 
 if (valor > 0) 
 { 
 printf("O valor é positivo! \n"); 
 } 
 else 
 { 
 if (valor < 0) 
 { 
 printf("O valor é Negativo! \n"); 
 } 
 else 
 { 
 printf("O valor é nulo! \n"); 
 } 
 } 
 system("pause"); 
} 
 
Repare que o segundo teste só será feito caso o primeiro falhe. Este tipo de abordagem é 
interessante para evitar que uma grande quantidade de testes similares sejam feitas 
quando apenas um deles pode ser executado. 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 27 
5.4. Instrução SWITCH 
Utilizar uma seqüência encadeada de testes lógicos apesar de interessante, em algumas 
situações pode tornar o código relativamente complexo. Quando possuímos uma lista de 
valores para avaliar-mos, por exemplo. 
Quando nos deparamos com este tipo de situação existe uma instrução que se mostra 
mais otimizada e organizada para a manipulação dos dados. Essa instrução chama-se 
switch. 
Exemplo: 
 
#include <stdio.h> 
 
void main() 
{ 
 int valor; 
 
 printf("Digite um valor: "); 
 scanf("%d", &valor); 
 
 switch (valor) 
 { 
 case 1: 
 printf ("Foi digitado o valor 1 \n"); 
 break; 
 
 case 2: 
 printf ("Foi digitado o valor 2 \n"); 
 break; 
 
 case 3: 
 printf ("Foi digitado o valor 3 \n"); 
 break; 
 
 default: 
 printf("Foi digitado um valor diferente de 1, 2 ou 3 \n"); 
 } 
 system("pause"); 
} 
 
A instrução switch através de instruções case avalia o conteúdo da variável “valor”, de 
modo que a instrução “default” é executada se todos os testes falharem. 
Percebam que dentro de cada case foi utilizado uma instrução “break” que fará com que 
o switch seja interrompido no momento que encontrar a associação correta para a 
variável “valor”. 
Dentro de cada case não é necessário definir o bloco entre chaves. 
 
5.5. Exercícios Propostos 
1. Faça um algoritmo que recebe um número inteiro, escreva o mês correspondente a 
este número ou a mensagem “mês inválido” 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 28 
 
2. Faça um algoritmo que recebe dois valores reais juntamente com uma variável 
controladora de tipo inteiro. 
a) Caso a variável controladora seja 1, some os valores digitados. 
b) Caso a variável controladora seja 2, multiplique os valores digitados. 
c) Caso a variável controladora seja 3, encontre o maior valor. 
d) Caso a variável controladora seja qualquer outro valor, calcule a média entre os 
valores. 
 
3. Faça um algoritmo que simule o caixa de um Fast-Food. Serão digitados o código de 
um produto, juntamente com a quantidade desejada deste produto. Seu programa 
deve retornar o nome do produto juntamente com o valor final a ser pago. 
 
Código Produto Valor Unitário 
1 Sanduíche de Presunto R$ 2,30 
2 Suco de Tamarindo R$ 1,50 
3 Pastel de Vento R$ 1,30 
4 Pão com margarina R$ 0,70 
 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 29 
5.6. Operadores (Conectores) Lógicos 
Além do que já foi trabalhado durante o curso, existe a possibilidade de que uma 
expressão lógica faça mais de uma pergunta ao mesmo tempo. De modo que essas 
perguntas tem de estar relacionadas de alguma forma. Imagine que exista a necessidade 
de se fazer um filtro em um programa de modo que sejam tratados de forma diferente 
pessoas do sexo feminino menores de idade, maiores de idade, pessoas do sexo 
masculino maiores de idade e menores de idade. 
Se formos fazer um teste para cada possibilidade, o código seria gigantesco. Utilizando 
os operadores lógicos, poderíamos fazer perguntas agrupadas (se for mulher E menor de 
idade, se for homem E maior de idade, etc.). 
Durante o curso iremos trabalhar com três operadores lógicos. São eles: 
5.6.1. Operador && (E) 
 Também conhecido como multiplicação lógica 
 Retorna como resposta “Verdadeiro” se e somente se as duas expressões lógicas 
por ele conectadas forem verdadeiras. 
 
Tabela verdade 
&& V F 
V V F 
F F F 
 
5.6.2. Operador || (OU) 
 Também conhecido como adição lógica 
 Retorna como resposta “Falso” se e somente se as duas expressões lógicas por 
ele conectadas forem falsas. 
Tabela verdade 
|| V F 
V V V 
F V F 
 
5.6.3. Operador ! (Não) 
 Também conhecido como inversor lógico 
 Retorna o valor oposto a uma expressão lógica 
Tabela verdade 
! V F 
 F V 
 
Exemplos 
a) (25 > 10 && 23 % 2 == 1)? Resposta: VERDADEIRO 
b) (25 != 50/2 || 12 > 20)? Resposta: FALSO 
c) (!(2 + 2 = 4)) ? Resposta: FALSO 
d) (40 > 30 && 25 < 12 || 12 % 2 ==0)? Resposta: 
e) (!((25 > 10 && 23 % 2 == 1)))? Resposta: 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 30 
Exemplo Prático 
Fazer um programa que leia as duas notas de um aluno juntamente com sua 
freqüência. Informe se o aluno está aprovado ou reprovado sabendo que a média 
mínima de aprovação é 6 e que a freqüência mínima de aprovação é 75. 
 
#include <stdio.h> 
void main() 
{ 
 float n1, n2, freq, media; 
 
 printf("Digite sua primeira nota: "); 
 scanf("%f", &n1); 
 printf("Digite sua segunda nota: "); 
 scanf("%f", &n2); 
 printf("Digite sua freqüência: "); 
 scanf("%f", &freq); 
 
 media = (n1 + n2)/ 2.0; 
 if (media >= 6 && freq >= 75) 
 { 
 printf ("Parabens! Voce esta APROVADO \n"); 
 } 
 else 
 { 
 printf ("Infelizmente voce esta REPROVADO \n"); 
 } 
 
 system("pause"); 
} 
 
Tente fazer o código acima utilizando operador lógico OU agora. 
 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 31 
5.7. Exercícios Propostos 
1. Faça um algoritmo que lê um valor inteiro e retorna se este é um valor Par Positivo, 
Par Negativo, Ímpar Positivo, Ímpar Negativo ou Nulo. 
 
2. Faça um algoritmo que leia três valoresreais e os exiba de forma crescente. 
 
3. Faça um algoritmo que leia três valores reais e exiba ao final o maior valor 
 
4. Faça um algoritmo que leia três valores reais e calcule x’ e x” de acordo com a 
fórmula abaixo. Obs.: Seu programa deve prever os erros de raiz negativa e divisão 
por zero. 
a
cabb
xx
*2
**4
",'
2 
 
5. Faça um programa que dada a idade de um nadador classifica-o em uma das 
seguintes categorias: 
 Infantil = 8-10 anos 
 Juvenil = 11-17 anos 
 Adulto = maiores de 18 anos 
 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 32 
Aula 8 
Aula destinada a continuação e implementação dos exercícios propostos na lista 
anterior, bem como novos exercícios disponibilizados pelo professor. 
 
Continuação dos exercícios: 
 
6. A Secretaria de Meio Ambiente, que controla o índice de poluição, mantém 3 grupos 
de indústrias que são altamente poluentes do meio ambiente. O índice de poluição 
aceitável varia de 0,05 até 0,29. Se o índice sobe para 0,3 as indústrias do 1º grupo 
são intimadas a suspenderem suas atividades, se o índice crescer para 0,4 as 
industrias do 1º e 2º grupo são intimadas a suspenderem suas atividades, se o índice 
atingir 0,5 todos os grupos devem ser notificados a paralisarem suas atividades. Faça 
um programa que leia o índice de poluição medido e emita a notificação adequada 
aos diferentes grupos de empresas. 
 
7. Desenvolva um algoritmo que efetue a leitura de três valores para os lados de um 
triângulo, considerando lados como: A, B e C. O algoritmo deverá verificar se os 
lados fornecidos forma realmente um triângulo (cada lado é menor que a soma dos 
outros dois lados). Se for esta condição verdadeira, deverá ser indicado qual tipo de 
triângulo foi formado: isósceles (dois lados iguais e um diferente), escaleno (todos 
os lados diferentes) ou eqüilátero (todos os lados são iguais). 
 
Faça um algoritmo que leia o dia e o mês de nascimento de uma pessoa. Ao final do 
algoritmo retorne o seu signo de acordo com a tabela abaixo: 
 
Nascidos entre: Signo: 
20/03 a 20/04 Áries 
21/04 a 20/05 Touro 
21/05 a 20/06 Gêmeos 
21/06 a 21/07 Câncer 
22/07 a 22/08 Leão 
23/08 a 22/09 Virgem 
23/09 a 22/10 Libra 
23/10 a 21/11 Escorpião 
22/11 a 21/12 Sagitário 
22/12 a 20/01 Capricórnio 
21/01 a 18/02 Aquário 
19/02 a 19/03 Peixes 
 
 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 33 
Aula 9 
Avaliação I 
6. Introdução 
Aula destinada a apresentação do primeiro trabalho a ser desenvolvido na disciplina de 
lógica de programação. 
6.1. Tipo de avaliação 
Cabe ao professor decidir que tipo de avaliação será proposta, podendo esta ser um 
teste, trabalho para se entregar no mesmo dia ou um trabalho para ser entregue 
posteriormente. 
6.2. Continuação dos exercícios 
No caso da avaliação ser um trabalho a ser entregue posteriormente, utilize essa aula 
para dar continuidade nos exercícios. 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 34 
Aula 10 
Algoritmos de Repetição (Laços – Loops) 
7. Introdução 
Como visto anteriormente, dentro de um algoritmo existem vários tipos de estruturas 
que podem ser utilizadas. Até o momento estudamos estruturas seqüenciais e 
condicionais. 
Dentro de nossos algoritmos vai ser comum encontrarmos trechos de código que 
precisam ser executados várias vezes em seqüência (para validações, por exemplo). Para 
este tipo de problema, ao invés de repetirmos seguidamente o código fonte, podemos 
utilizar instruções de repetição que fazem justamente o papel de re-executar um 
determinado bloco de algoritmo. 
As instruções que permitem repetição de código são três: 
7.1. WHILE (ENQUANTO) 
 Laço de repetição que executa um determinado bloco de instruções enquanto sua 
condição lógica for verdadeira. 
 Sempre testa sua condição lógica antes de executar. 
 Após a execução do código, retorna para a condição e repete o teste. 
Sintaxe: 
while (condição lógica) 
 { 
 <instruções que serão executadas enquanto a condição for verdadeira>; 
 } 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 35 
Exemplo: 
#include <stdio.h> 
void main() 
{ 
 int valor, soma; 
 valor = 5; 
 soma = 0; 
 while (valor <= 8) 
 { 
 soma = soma + valor; 
 valor = valor + 1; 
 } 
 printf("%d\n", soma); 
 system("PAUSE"); 
} 
 
Este algoritmo irá executar as instruções “soma = soma + valor;” e “valor = valor + 1;” 
enquanto o conteúdo da variável valor for menor ou igual a 8. Sendo que quando esta 
condição for falsa o programa irá exibir essa soma na tela e encerrar. 
7.2. DO – WHILE (FAÇA ENQUANTO) 
 Possui comportamento similar ao while. 
 Laço de repetição que executa um determinado bloco de instruções enquanto sua 
condição lógica for verdadeira. 
 Sempre testa sua condição lógica depois de executar o bloco de instruções. 
 Executa pelo menos uma vez as instruções de seu bloco. 
Sintaxe: 
do 
 { 
 <instruções que serão executadas> 
 } while (condição lógica); 
 
Exemplo: 
#include <stdio.h> 
void main() 
{ 
 int valor, soma; 
 valor = 5; 
 soma = 0; 
 do 
 { 
 soma = soma + valor; 
 valor = valor + 1; 
 } while (valor<=8); 
 printf("%d\n", soma); 
 system("PAUSE"); 
} 
 
Repare que este código retorna o mesmo valor que o exemplo anterior, porém o teste é 
feito apenas no final da execução da primeira volta do laço. Este tipo de abordagem é 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 36 
muito comum quando utilizamos menus, onde as opções devem ser exibidas na tela 
enquanto não for feita uma escolha válida. 
7.3. FOR (PARA) 
 Laço de repetição contado. 
 Executa enquanto sua condição for verdadeira. 
 O controle de voltas do laço é feito pelo próprio laço. 
Esta instrução de repetição é muito comum de ser utilizada quando sabemos exatamente 
o número de voltas que nosso bloco de instruções irá fazer. 
Sintaxe: 
for (variável = valor inicia; condição de execução; valor de incremento para a variável) 
 { 
 <instruções que serão repetidas>; 
 } 
 
Exemplo: 
#include <stdio.h> 
void main() 
{ 
 int valor, soma; 
 valor = 5; 
 soma = 0; 
 for (valor = 5; valor<=8; valor = valor +1) 
 { 
 soma = soma + valor; 
 } 
 printf("%d\n", soma); 
 system("PAUSE"); 
} 
 
Utilizando este tipo de abordagem, reparem que não foi necessário incrementar a 
variável valor dentro do bloco do for. 
7.4. Tipos de Variáveis 
Implementado laços de repetição em nossos códigos, devemos reparar que algumas 
variáveis possuem um comportamento diferente do que estamos acostumados, onde elas 
mesmas servem de base para o seu próximo valor. 
7.4.1. Variáveis Contadoras 
Tipo de variável que tem por comportamento principal sofrer alteração nos seus dados 
de maneira constante. Nos exemplos anteriores a variável “valor” possui um 
comportamento de contadora. 
7.4.2. Variáveis Acumuladoras 
Tipo de variável que tem por comportamento principal sofrer alteração nos seus dados 
de maneira variável. Nos exemplos anteriores a variável “soma” possui um 
comportamento de acumuladora. 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 37 
7.4.3. Lixo de Memória 
Na grande maioria das linguagensde programação, quando declaramos uma variável 
esta possui um valor aleatório inicial chamado lixo de memória, de modo que se 
mantermos este valor na variável, teremos um programa que retornará valores 
incorretos. Para eliminar o problema do lixo de memória, devemos explicitamente dar 
um valor inicial para as variáveis. 
Todas as variáveis consideradas contadoras ou acumuladoras devem ser 
inicializadas pelo programador. 
7.5. Modificações do Sinal de Atribuição 
O símbolo de atribuição “=” dentro da linguagem C pode sofrer algumas 
transformações que visam diminuir o número de caracteres digitados dentro do código. 
Sendo amplamente utilizados na manipulação de contadores e acumuladores. 
 
Símbolo Exemplo Similar 
+= A += 3; A = A + 3; 
-= A -= 3; A = A – 3; 
*= A *= 3; A = A * 3; 
/= A /= 3; A = A / 3; 
%= A %= 3; A = A % 3; 
++ A ++ A = A + 1; 
-- A -- A = A -1; 
 
A partir de agora, utilizaremos estes operadores sempre que possível. 
7.6. Loops Infinitos 
Um algoritmo entra em Loop, quando ocorre uma situação tal que o mesmo entra em 
um laço e não consegue sair deste. Este erro deve ser evitado a todo o custo dentro de 
nossos programas. Para uma visualização prática sobre um programa em loop, remova a 
linha “valor = valor + 1;” de qualquer um dos exemplos acima citados e veja o 
resultado. 
7.7. Exercícios Propostos 
1. Faça um algoritmo que calcule a soma de todos os valores inteiros existentes entre 1 
e 100. Faça esse algoritmo três vezes, uma para cada laço de repetição. 
 
2. Faça um algoritmo que leia um valor inteiro e calcule a soma de todos os valores 
inteiros entre 1 e o valor informado. Faça esse algoritmo três vezes, uma para cada 
laço de repetição. 
 
3. Faça um algoritmo que leia um valor inteiro e calcule o seu fatorial. O fatorial de 
um número é o resultado da multiplicação deste próprio número pelos seus valores 
menores parando no 1. Exemplo: 5! = 5x4x3x2x1 = 120. Faça esse algoritmo três 
vezes, uma para cada laço de repetição. 
 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 38 
Aula 11 
Continuação dos exercícios 
 
4. Faça um programa que leia um número qualquer e calcule a tabuada desse número. 
A tabuada deve ser exibida ao usuário no seguinte formato (considerando a leitura 
do número 2): 
2 X 1 = 2 
2 X 2 = 4 
2 X 3 = 6 
... 
2 X 10 = 20 
 
5. Faça um algoritmo que leia dois valores (X e Y) e calcule XY. Obs.: Não utilize a 
função “pow”. 
 
6. Faça um algoritmo que leia dois valores positivos (A e B) e calcule a multiplicação 
de A por B. Obs.: Não utilize o operador aritmético “*”. 
 
7. Faça um algoritmo que resolva a seguinte situação. 
“A empresa de João tem um quadro de 36 funcionários, sendo que a cada ano são 
contratados 5 novos colaboradores. Enquanto que a empresa de Joaquim possui um 
quadro de 50 funcionários e a cada ano são contratados 3 novos funcionários. 
Quantos anos serão necessários para que João ultrapasse Joaquim?” 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 39 
Aula 12 
Continuação dos exercícios (leitura de dados dentro dos laços) 
 
8. Faça um algoritmo que leia um número indeterminado de valores reais e quando for 
digitado um valor negativo, exiba a soma destes valores. 
 
9. Faça um algoritmo que leia 25 valores inteiros. Logo após a leitura dos valores, 
exiba a média entre os valores. 
 
10. Faça um algoritmo que leia um número indeterminado de valores. E quando for 
digitado 0 (zero) exiba a quantidade de números pares e ímpares digitados. 
 
11. Faça um algoritmo que leia 15 valores reais e ao final da leitura exiba o maior valor 
informado. 
 
12. Faça um algoritmo que leia 10 nomes e idades. Ao final da leitura exiba o nome da 
pessoa mais velha. 
 
13. Faça um algoritmo que leia 50 valores inteiros e logo após a leitura exiba o 
percentual de valores múltiplos de 5 digitados. 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 40 
Aula 13 
Continuação dos exercícios 
 
14. Faça um algoritmo que leia um valor inteiro e retorne se este valor é perfeito ou não. 
Obs.: Números perfeitos são aqueles cujo a soma de seus divisores (excluindo o 
próprio número) formam exatamente o valor original. Exemplo: 6 (1+2+3 = 6) 
 
15. Faça um algoritmo que leia um usuário e senha digitados pelo usuário. O programa 
deve exibir a mensagem “Bem Vindo” caso o usuário digitado seja “aluno” e a 
senha digitada seja “segredo”. O programa deve avisar quando o login não for 
efetuado e emitir um aviso de bloqueio caso o usuário erre seu login três vezes. 
 
16. Faça um programa que leia o Nome, Valor Hora, Total de Horas Trabalhadas e a 
idade de 50 funcionários. Após a leitura dos dados exiba: 
a) A média salarial bruta da empresa 
b) O nome e a idade do funcionário mais velho 
c) O nome e o salário do funcionário que tiver a maior renda. 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 41 
Aula 14 
Continuação dos exercícios (desafios) 
 
17. Faça um algoritmo que leia um número inteiro qualquer e retorne se este número é 
primo ou não. Obs.: Números primos são aqueles divisíveis apenas por 1 (um) e por 
eles mesmos. 
 
18. Faça um algoritmo que leia 3 valores inteiros e exiba o MMC (Mínimo Múltiplo 
Comum) entre estes valores. 
 
19. Faça um algoritmo que leia o Nome, Idade e Sexo de 50 pessoas. Retorne ao final o 
nome da mulher mais velha e do homem mais jovem. 
 
20. Faça um algoritmo que imprima na tela os 10 primeiros valores da seqüência de 
Fibonacci. (1, 1, 2, 3, 5, 8, 13, 21, 34 e 55). Obs.: Utilizar laços para gerar a 
seqüência. 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 42 
Aula 15 
Revisão Geral Para a Prova I 
Aula destinada a revisão de todo o conteúdo desenvolvido até o momento, bem como 
conclusão de exercícios. 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 43 
Aula 16 
Prova I 
Boa prova a todos. 
 Lembrem-se sempre de ler com atenção todas as questões da prova. 
 Faça primeiro as questões que você considerar mais fáceis. 
 Não fique com dúvidas em relação à interpretação da prova. 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 44 
Aula 17 
Considerações sobre a prova 
Aula destinada a correção da prova e tirar dúvidas em relação a avaliação. 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 45 
Aula 18 
Variáveis Homogêneas Unidimensionais (Vetores) 
8. Introdução 
A partir deste ponto do curso iremos quebrar o paradigma de que uma variável só pode 
armazenar um valor por vez. 
8.1. O que são vetores? 
Vetores são variáveis como quaisquer outras. Devem possuir nome, tipo de dado e seu 
conteúdo pode sofrer alteração durante a execução do programa. Porém, diferente de 
uma variável convencional, vetores podem armazenar mais de um valor ao mesmo 
tempo. Desde que estejam em posições diferentes. 
8.2. Representação Gráfica 
Um vetor pode ser representado como uma tabela de apenas uma linha ou coluna. 
 
 
 
Na linguagem C, a primeira posição de um vetor é sempre a posição 0 (zero), sendo 
crescente a partir deste ponto. 
Sendo assim, um vetor de 6 posições possui índice variando entre 0 e 5. 
8.3. Utilidade para Vetores 
Vetores são de grande utilidadequando precisamos armazenar dados de forma a não 
perdermos os dados anteriormente digitados. 
8.4. Declarando Vetores 
Declarar vetores na linguagem C é relativamente simples. 
Sintaxe: 
<Tipo de dado> <Nome do vetor> [número de posições]; 
Exemplos: 
int vetor1[10]; 
float vetor2[15]; 
 
Quando o vetor a ser declarado for de tipo char, devemos informar primeiro o número 
de caracteres que cada posição irá armazenar e logo após o número de posições. 
Exemplo: 
char vetor3[20] [12]; 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 46 
8.5. Exemplo Prático 
Desenvolver um programa que leia um vetor inteiro de 5 posições e exibir a soma deste 
vetor. 
#include <stdio.h> 
 
int main() 
{ 
 int vetor[5]; 
 int i; 
 float soma; 
 
 for (i = 0; i<5; i++) 
 { 
 printf ("Digite um valor: "); 
 scanf ("%d", &vetor[i]); 
 } 
 soma = 0; 
 for (i = 0; i<5; i++) 
 { 
 soma = soma + vetor[i]; 
 //ou soma += vetor[i]; 
 } 
 
 printf ("A soma do vetor é: %f \n", soma); 
 system("PAUSE"); 
 return 0; 
} 
 
Explicando o código: 
 O primeiro laço faz a leitura de dados do vetor de forma seqüencial (posição por 
posição) onde a variável “i” serve de índice para o vetor. 
 O segundo laço faz o que chamamos de varredura no vetor (passar por todas as 
posições) de modo que na variável soma seja acumulado o valor de cada posição 
do vetor. 
 O programa poderia ser desenvolvido em apenas um laço, mas está disposto 
desta maneira justamente para demonstrar que os dados continuam armazenados 
no vetor, mesmo quando a leitura de informações já está posicionada em outra 
linha. 
 Se em algum momento for necessário recuperar alguma informação digitada, 
será possível. 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 47 
8.6. Exercícios Propostos 
1. Faça um algoritmo que leia um vetor de 11 posições de tipo real. Logo após a leitura 
dos dados, exiba a média do vetor. 
 
2. Faça um algoritmo que leia um vetor inteiro de 10 posições. Ao final da leitura, 
exiba a quantidade de valores pares existentes no vetor. 
 
3. Faça um algoritmo que leia um vetor real de 6 posições e retorne a média dos 
valores positivos do vetor. 
 
4. Faça um algoritmo que leia dois vetores reais de 5 posições. Gere um terceiro vetor 
de mesmo tamanho e tipo que obedeça a seguinte regra de formação: 
a) Na primeira posição do vetor 3 será armazenada a multiplicação entre a primeira 
posição do vetor 1 e a primeira posição do vetor 2. 
b) Na segunda posição do vetor 3 será armazenada a multiplicação entre a segunda 
posição do vetor 1 e a segunda posição do vetor 2. 
c) ... 
 
5. Faça um algoritmo que leia um vetor string de 10 posições. Após a leitura de todo o 
vetor o usuário deve informar mais uma palavra. Seu programa deve exibir quantas 
vezes esta palavra existe no vetor. 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 48 
Aula 19 
Continuação dos Exercícios 
 
6. Faça um algoritmo que leia dois vetores string de 10 posições equivalentes a grade 
de respostas de um aluno e o gabarito da mesma prova feita pelo professor. Seu 
programa deve informar a nota do aluno sabendo que cada acerto equivale a 1 ponto. 
Seu programa também deve retornar uma mensagem para o usuário de acordo com o 
seu número de acertos 
a) Até 3 acertos: PRECISA MELHORAR 
b) Até 5 acertos: REGULAR 
c) Até 7 acertos: BOM 
d) Acima de 8 acertos: CONTINUE ASSIM. 
 
7. Faça um algoritmo que leia um vetor inteiro de 10 posições. Logo após a leitura de 
todo o vetor, inverta os valores de todo o vetor. 
 
8. Faça um algoritmo que leia um vetor real de 8 posições. Logo após a leitura exiba o 
maior valor digitado no vetor. 
 
9. Faça um algoritmo que gere um vetor de 10 posições contendo os primeiros 10 
valores da seqüência Fibonacci. 
 
10. Faça um algoritmo que leia um vetor de 6 posições inteiro e reorganize os dados 
deste vetor de modo que seus dados sejam exibidos de maneira crescente. 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 49 
Aula 20 
Aula destinada à correção dos exercícios e remoção de dúvidas. 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 50 
Aula 21 
Variáveis Homogêneas Multidimensionais (Matrizes) 
9. Introdução 
Dentro da programação, vetores não são a única forma de se armazenar múltiplos 
valores dentro de uma variável. 
9.1. O que são Matrizes? 
Matrizes possuem rigorosamente a mesma definição de vetores. Porém os seus dados 
podem ser armazenados em uma estrutura de dados que possua mais de uma dimensão. 
9.2. Representação Gráfica 
A representação gráfica de uma matriz depende do número de dimensões que ela 
possuir. A forma mais comum de encontrarmos uma matriz é no formato de duas 
dimensões. 
 
 
 
 
É indiferente pensarmos que cada posição da matriz é indexada pelo número de sua 
coluna seguido por sua linha ou o seu inverso. Para uma maior facilidade de 
compreensão, iremos trabalhar com o sistema de linha x coluna. 
9.3. Declarando Matrizes. 
A declaração de matrizes é similar a declaração de vetores. 
Sintaxe: 
<Tipo de dado> <Nome da matriz> [número de linhas] [número de colunas]; 
Exemplos: 
int matriz1[10][5]; 
float matriz2[6][6]; 
 
Quando a matriz a ser declarada for de tipo char, devemos informar primeiro o número 
de caracteres que cada posição irá armazenar e logo após o número de linhas e colunas. 
Exemplo: 
char matriz3[20][8][5]; 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 51 
9.4. Exemplo Prático 
#include <stdio.h> 
 
int main() 
{ 
 int matriz[3][3]; 
 int linha,coluna; 
 float soma; 
 
//Leitura dos dados 
 for (linha = 0; linha<3; linha++) 
 { 
 for (coluna = 0; coluna<3; coluna++) 
 { 
 printf ("Digite um valor: "); 
 scanf ("%d", &matriz[linha][coluna]); 
 } 
 } 
//Soma e exibição da matriz 
 soma = 0; 
 for (linha = 0; linha<3; linha++) 
 { 
 for (coluna = 0; coluna<3; coluna++) 
 { 
 printf ("%d ", matriz[linha][coluna]); 
 soma = soma + matriz[linha][coluna];//ou soma +=matriz[linha][coluna]; 
 } 
 printf("\n"); 
 } 
 printf("\n A soma da matriz é: %f",soma); 
 
 system("PAUSE"); 
 return 0; 
} 
 
Explicando o código 
 Agora a entrada de dados é feita utilizando dois laços e não apenas um. 
 Repare que para cada volta do laço de linha, o laço de coluna faz três voltas. 
 Para a varredura da matriz o processo se repete 
 Para visualizarmos a matriz é interessante que a cada linha seja feita uma quebra 
de linha (“\n”) entre os laços. 
QI - Escola de Educação Profissional 
Apostila de Lógica de Programação 
 
Professor: Eduardo Reus Souza 52 
9.5. Exercícios Propostos 
1. Faça um algoritmo que leia uma matriz 4x4 de tipo real e exiba ao final a sua média. 
 
2. Faça um algoritmo que leia uma matriz 3x5 de tipo inteiro e exiba quantos valores 
pares existem na matriz. 
 
3. Faça um algoritmo que leia uma matriz 5x5 de tipo real e exiba a soma das linhas 
pares e a média das linhas ímpares. 
 
4. Faça um algoritmo que leia uma matriz 2x8 e coloque seus valores em uma matriz