Algoritmos(2)

Prévia do material em texto

1 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Algoritmos Aplicados a Engenharia 
Material de apoio 
Professores de Algoritmos da Universidade Nove de Julho - UNINOVE 
 
 
 
2 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3 
 
Sumário 
Aula 1: Conceitos de Algoritmos ................................................................................................... 7 
1. Algoritmos ................................................................................................................................ 7 
1.1. Descrição Narrativa ....................................................................................................... 8 
1.2. Diagrama em Blocos ..................................................................................................... 9 
1.3. Pseudocódigo ............................................................................................................... 10 
1.4. Linguagem de Programação ..................................................................................... 11 
Aula 2: Exercícios sobre o conceito básico de algoritmos .................................................. 12 
1. Exercícios ............................................................................................................................... 12 
Aula 3: Conceitos de Variáveis ..................................................................................................... 14 
1. Tipos de Informações (Variáveis) .................................................................................... 14 
1.1. Regras para nomear Variáveis .................................................................................. 15 
2. Exercícios de fixação .......................................................................................................... 15 
Aula 4: Operadores Aritméticos, Lógicos e Relacionais ....................................................... 17 
1. Operadores Aritméticos ..................................................................................................... 17 
1.1. Operadores Relacionais ............................................................................................. 18 
1.2. Operadores Lógicos .................................................................................................... 18 
2. Exercícios ............................................................................................................................... 19 
Aula 5: Estrutura Sequencial ........................................................................................................ 21 
1. Estrutura Sequencial ........................................................................................................... 21 
2. Exercícios ............................................................................................................................... 23 
Aula 6: Estrutura condicional ....................................................................................................... 25 
1. Estrutura condicional simples .......................................................................................... 25 
2. Estrutura condicional composta ou encadeada .......................................................... 26 
Aula 7: Exercícios sobre estrutura condicional ....................................................................... 29 
1. Exercícios ............................................................................................................................... 29 
Aula 8: Estrutura de repetição ...................................................................................................... 33 
1. Estrutura de repetição ........................................................................................................ 33 
1.1. Estrutura de repetição com quantidade de repetições definidas (Para) ....... 34 
1.3. Uso de estrutura de repetição com teste lógico no início (Enquanto) .......... 35 
1.4. Estrutura de repetição com teste lógico no fim (Faça-Enquanto) .................. 36 
Aula 9: Exercícios sobre estrutura de repetição ..................................................................... 37 
1. Exercícios ............................................................................................................................... 37 
Aula 10: Breve visão da linguagem C ......................................................................................... 39 
 
 
4 
 
1. Introdução .............................................................................................................................. 39 
1.1. O compilador Dev-C++ ................................................................................................ 41 
Aula 11: Introdução a linguagem C ............................................................................................. 43 
1. Introdução .............................................................................................................................. 43 
2. Variáveis e Tipos de Dados ............................................................................................... 43 
2.1. Palavras reservadas em C ......................................................................................... 44 
2.2. Identificadores .............................................................................................................. 44 
2.3. Tipos de dados .............................................................................................................. 44 
2.4. Variáveis de ponto flutuante ..................................................................................... 45 
2.5. Declaração de variáveis .............................................................................................. 45 
2.6. Inicialização de variáveis ........................................................................................... 45 
3. Operadores ............................................................................................................................ 46 
3.1. Operador de Atribuição .............................................................................................. 46 
3.2. Operadores Aritméticos ............................................................................................. 47 
Aula 12: Introdução a linguagem C (Continuação) ................................................................. 48 
3.3. Operadores de Atribuição Aritmética ..................................................................... 48 
3.4. Operadores Incrementais ........................................................................................... 48 
3.5. Operadores Relacionais e Lógicos ......................................................................... 49 
3.6. Operador Condicional ................................................................................................. 50 
4. A estrutura básica de um programa em C/ C++ ........................................................... 51 
5. Montando o primeiro programa ........................................................................................ 51 
5.1. Análises sobre o 1º programa ................................................................................... 51 
Aula 13: Comandos de entrada e saída de dados ................................................................... 53 
1. Função printf() ....................................................................................................................... 53 
2. Função scanf() ......................................................................................................................55 
3. Função sprintf() .................................................................................................................... 55 
4. Exemplo de uso das funções scanf e printf .................................................................. 56 
4.1. Análises sobre o programa ....................................................................................... 56 
5. Exercícios ............................................................................................................................... 57 
Aula 14: Comandos de decisão (Linguagem C) ....................................................................... 58 
1. O comando if ......................................................................................................................... 58 
1.1. Sintaxe do comando if ................................................................................................ 59 
1.2. Comandos if encadeado ............................................................................................. 59 
1.3. O comando if-else ........................................................................................................ 59 
 
 
5 
 
2. O comando switch ............................................................................................................... 60 
3. Exercícios ............................................................................................................................... 62 
Aula 15: Laços de Repetição (Linguagem C) ............................................................................ 63 
1. O laço for ................................................................................................................................ 63 
1.1. Sintaxe do laço for ....................................................................................................... 64 
1.2. Múltiplas instruções dentro do corpo de um laço for ........................................ 65 
1.3. Laço for encadeado ..................................................................................................... 65 
2. Exercícios ............................................................................................................................... 66 
Aula 16: Laços de Repetição ......................................................................................................... 67 
1. O Laço while .......................................................................................................................... 67 
1.1. Sintaxe do laço while .................................................................................................. 67 
1.2. O laço while encadeado .............................................................................................. 68 
2. O Laço do-while .................................................................................................................... 69 
3. Exercícios ............................................................................................................................... 70 
Aula 17: Funções .............................................................................................................................. 71 
1. Chamando uma função ....................................................................................................... 71 
1.1. Funções simples .......................................................................................................... 72 
1.2. O protótipo da função ................................................................................................. 73 
1.3. A definição de uma função ........................................................................................ 73 
1.4. Passando vários argumentos para uma função .................................................. 73 
1.5. Chamadas a funções usadas como argumentos de outras funções ............. 74 
2. Macros ..................................................................................................................................... 75 
2.1. A diretiva #define .......................................................................................................... 75 
2.2. Criação de macros ....................................................................................................... 76 
Aula 18: O uso de Caracteres gráficos ....................................................................................... 78 
1. O uso de Caracteres gráficos ........................................................................................... 78 
1.1. Imprimindo caracteres gráficos ............................................................................... 78 
1.2. Como obter os caracteres do código ASCII .......................................................... 79 
Aula 19: Vetores ............................................................................................................................... 82 
1. O uso dos vetores ................................................................................................................ 82 
1.1. Declaração de um vetor .............................................................................................. 83 
1.2. Acessando os elementos de um vetor ................................................................... 83 
1.3. Inicializando um vetor ................................................................................................. 84 
2. Exercícios ............................................................................................................................... 85 
 
 
6 
 
Aula 20: Matrizes .............................................................................................................................. 86 
1. Definindo uma matriz .......................................................................................................... 86 
1.1. Inicialização de matrizes de duas dimensões ...................................................... 87 
1.2. Matrizes como argumentos de funções ................................................................. 87 
 
 
 
 
7 
 
Aula 1: Conceitos de Algoritmos 
Objetivo: Dominar os conceitos de um algoritmo, sabendo representá-lo das três 
formas básicas: descritiva (ou narrativa), fluxograma (ou diagrama de blocos) e 
pseudocódigo (ou português estruturado ou portugol). 
 
1. Algoritmos 
Um algoritmo é uma sequência finita de instruções bem definidas que levam a 
solução de uma tarefa, ou um conjunto de regras para a solução de um problema 
(MANZANO, 2009; DASGUPTA; PAPADIMITRIOU; VAZIRANI, 2009; MANZANO; 
MANZANO, 2008). Todo algoritmo é feito utilizando-se da lógica. 
A importância da disciplina de computação básica na formação de 
engenheiros está relacionada à necessidade de capacitação dos alunos de 
engenharia na resolução de problemas diversos com o auxílio computacional, 
combinando o melhor da informática aos avanços tecnológicos. 
Para resolver um problema de forma automática (com o auxílio do 
computador), primeiramente é necessário encontrar uma maneira de descrevê-lo 
com clareza e precisão. Em outras palavras, é preciso encontrar uma sequência 
finita de passos não ambíguos que levam à sua solução, ou seja, o seu algoritmo. 
Um exemplo simples de algoritmo é uma receita para preparar um bolo. De 
acordo com o dicionário Aurélio, um algoritmo é definido como: "Processo de 
cálculo, ou de resolução de um grupo de problemas semelhantes, em que se 
estipulam, com generalidade e sem restrições, regras formais para a obtenção de 
resultado ou de solução de problema. Conjunto de regras e operações bem 
definidas e ordenadas, destinadas à solução de um problema, ou de uma classe de 
problemas, em um número finito de etapas.".É importante lembrar que a descrição do problema deve ser feita sob a 
perspectiva da máquina. Uma vez que os computadores não entendem descrições 
de problemas em linguagem natural, é preciso codificá-las em linguagens que lhes 
são compreensíveis. Tais linguagens são chamadas de linguagens de programação. 
Nesta etapa aplica-se a conversão de uma forma de representação do algoritmo, o 
pseudocódigo para uma linguagem especifica. A solução de um problema de forma 
automática pode ser descrita pelos passos ilustrados na Figura 1. 
 
 
 
8 
 
 
Figura 1. Solução de um problema de forma automática. 
 
 
Todos nós sabemos construir algoritmos. Haja vista o fato de que saímos de 
casa pela manhã, definimos alternativas de transporte para ir ao trabalho, decidimos 
qual o melhor caminho para chegar a um lugar ou voltar para casa, etc. Cabe 
ressaltar que pode haver mais de um algoritmo para resolver um mesmo problema. 
Por exemplo, a decisão da escolha do transporte para ir ao trabalho poderia ser feita 
com base nas necessidades individuais. 
 
1.1. Descrição Narrativa 
É a forma de representação do Algoritmo através de frases, representando as 
ações a serem tomadas; as frases são os passos relacionados visando atender o 
objetivo. Vejamos alguns exemplos: 
 
a) Trocar uma lâmpada 
1º passo: Pegar a escada 
2º passo: Posicionar a escada embaixo da lâmpada 
3º passo: Buscar uma lâmpada nova 
4º passo: Subir na escada 
5º passo: Retirar a lâmpada velha 
6º passo: Colocar a lâmpada nova 
7º passo: Descer da escada 
8º passo: Guardar a escada 
 
b) Levar o cachorro para passear 
1º passo: Ir até o quintal 
2º passo: Pegar a coleira 
3º passo: Chamar o cachorro 
4º passo: Colocar a coleira no cachorro 
5º passo: Abrir o portão 
6º passo: Dar uma volta no quarteirão 
7º passo: Entrar em casa 
8º passo: Soltar a coleira do cachorro 
9º passo: Guardar a coleira 
 
 
 
9 
 
c) Torres de Hanói (Figura 2) 
Considere o enunciado: inicialmente têm-se três hastes, A, B, C, e na haste A 
possuem três anéis de diâmetros diferentes, em ordem decrescente por diâmetro. O 
objetivo é transferir os três anéis da haste A para a haste C, usando o B se 
necessário. As regras de movimentação são: 
1. Deve mover um único anel por vez. 
2. Um anel de diâmetro maior nunca pode ficar sobre algum anel de diâmetro 
menor. 
Figura 2. Exemplo da Torre de Hanói com 3 discos. 
 
Para saber o número de movimentos você pode utilizar a seguinte lei 
matemática: 
( ) 2 1nM n
. Onde M é o número de movimento e n o número de 
anéis. 
 
1.2. Diagrama em Blocos 
Conhecido como fluxograma, esta forma geométricas descrevem 
graficamente um algoritmo. Vejamos na Tabela 1, as principais formas geométricas 
empregadas na construção de um fluxograma: 
Tabela 1 – Formas geométricas de fluxogramas 
 
Terminador - Início/fim 
 
Processamento 
 
Entrada de dados (teclado) 
 
Tomada de decisão e usado para 
estrutura de repetição (Enquanto 
e Faça-Enquanto) 
 
Estrutura de Repetição (Para) 
 
 
10 
 
 
Saída de dados (tela) 
 
Saída de dados (impressora) 
 
Conector 
 Direção do fluxo 
Por exemplo, o fluxograma abaixo representa o algoritmo de cálculo das 
raízes de uma equação de 2º grau. 
 
 
 
 
 
 
 
 
 
 
 
 
1.3. Pseudocódigo 
Também conhecido como Português Estruturado Ou Portugol, é a 
representação do Algoritmo através de comandos, nele, já existem normas e regras 
a serem rigorosamente seguidas. Vejamos o exemplo a seguir: 
 
Programa Raizes_Eq_2g 
Var 
 a, b, c, Delta, x1, x2 : Real 
Início 
 Leia a, b, c 
 Delta b^2-4*a*c 
 x1 (-b + Sqrt(Delta))/(2*a) 
 x2 (-b - Sqrt(Delta))/(2*a) 
 Escreva x1, x2 
Fim 
a, b, c 
delta←b2-4 a c) 
x’← 
x’’← 
 
x', x’’ 
FIM 
ini 
INICIO 
ini 
 
 
11 
 
1.4. Linguagem de Programação 
A codificação de algoritmos é um assunto que será tratado mais adiante no 
curso. No entanto, para se ter uma ideia, a codificação do algoritmo dado no 
exemplo 3 “cálculo das raízes de uma equação de 2º grau”, em linguagem C, pode 
ser feita como segue: 
 
 
 
#include <stdio.h> /* biblioteca de entrada e saída de dados */ 
#include <math.h> /* biblioteca matematica */ 
int main() 
{ 
 float a, b, c; /* coeficientes da equacao */ 
float delta; /* delta da equacao */ 
float x1, x2; /* raizes da equacao */ 
printf ("Entre com os coeficientes da equacao.\n"); 
 scanf ("%f %f %f", &a, &b, &c); 
delta = pow(b,2) - 4 * a * c; 
delta = sqrt(delta); 
x1 = (-b + delta)/(2*a); 
x2 = (-b - delta)/(2*a); 
 printf("A raiz x1 vale %f.\n", x1); 
 printf("A raiz x2 vale %f.\n", x2); 
 return 0; 
} 
 
 
 
12 
 
Aula 2: Exercícios sobre o conceito básico de algoritmos 
Objetivo: Treinar o algoritmo em sua forma básica. 
 
1. Exercícios 
 
1) Crie um algoritmo simplificado para executar a tarefas de fazer um bolo. 
 
2) Escreva um algoritmo para resolver o problema das jarras de água, o qual pode 
ser descrito assim: Você tem 2 jarras, uma de 4 litros e uma de 3 litros. Nenhuma 
delas tem qualquer marcação de medidas. Há uma torneira que pode ser usada 
para encher as duas jarras com água. Como você consegue colocar exatamente 
2 litros de água na jarra de 4 litros? 
 
3) Escreva um algoritmo para resolver o problema “O fazendeiro e os animais”. A 
descrição do problema é: Um fazendeiro necessita atravessar um rio levando 
uma cabra, um saco de milho e um lobo. Para isso, dispõe de um barco que só é 
capaz de levar dois passageiros por vez. Ele enfrenta ainda, o seguinte dilema: 
se ele deixar de um lado da margem o lobo e a cabra sozinhos, o lobo come a 
cabra e se ele deixar a cabra e o milho, a cabra come o milho. Como o 
fazendeiro deve fazer para atravessar o rio com o milho e os animais (cabra e o 
lobo)? 
 
 
4) Escreva um algoritmo para resolver o problema “Os Missionários e os Canibais”, 
o qual é descrito assim: Três missionários e três canibais se encontram à 
margem direita de um rio. Todos precisam cruzar esse rio (ir para margem 
esquerda), e para isso dispõem de um barco onde cabem somente duas pessoas 
de cada vez. Os missionários precisam tomar cuidado ao fazer a travessia 
porque, se em qualquer instante houver mais canibais do que missionários em 
qualquer uma das margens (havendo missionários naquela margem), os canibais 
"devorarão" os missionários. Considerando estas restrições, escreva um 
algoritmo mostrando como fazer para que todas as pessoas cruzem o rio e 
cheguem ao lado esquerdo com segurança. 
 
 
13 
 
 
5) Uma família de 5 pessoas precisa atravessar uma ponte. No máximo dois 
integrantes por vez podem atravessar a ponte. Cada pessoa anda em uma 
velocidade diferente, demorando 1, 3, 6, 8 e 12 segundos na travessia sobre a 
ponte. A dupla anda na velocidade do mais lento, isto é, se na travessia for a 
pessoa que demora 1 segundo com a pessoa que demora 12 segundos, eles 
levarão 12 segundos para atravessar a ponte. Porém está escuro e eles 
precisam utilizar um lampião, que dura apenas 30 segundos. Levando em conta 
somente a soma do tempo gasto nas travessias, como você levaria esta família 
até o outro lado da ponte em até 30 segundos? 
 
 
 
 
14 
 
Aula 3: Conceitos de Variáveis 
Objetivo: Compreender os conceitos sobre o que são variáveis, para que servem e 
como criá-las, respeitando as regras necessárias. 
É importante informar que quando estamos trabalhando com programação de 
computadores, estamos dando instruções para o computador receber os dados de 
entradafornecidos pelo usuário, fazer algum processamento sobre estes dados e 
fornecer alguma informação ao usuário. Os dados manipulados durante a execução 
de um programa são armazenados na memória RAM (Random Access Memory ou 
Memória de Acesso Aleatório), que é a memória principal do computador. 
Para referenciar ou recuperar os dados armazenados utilizamos variáveis. 
Uma variável é uma entidade que serve para o armazenamento temporário de dados 
durante a execução de um programa. Para se definir uma variável deve-se definir 
um nome (identificador) e o tipo de dado a ser armazenado. O tipo de dado pode ser 
simples (numérico, caractere ou lógico) ou composto. Cabe salientar que uma 
variável armazena apenas um valor, o qual pode ser alterado ao longo da execução 
do programa. 
 
1. Tipos de Informações (Variáveis) 
As informações a serem processadas no computador devem ser classificadas 
de acordo com o tipo que ela representa no cotidiano. São estes: Numérico (inteiro e 
real), caractere ou lógico. 
a. Inteiro: São dados numéricos, sendo eles negativos ou positivos, que se 
exclui a parte fracionária do mesmo. Usamos este tipo quando precisamos 
representar uma informação que só pode absorver um valor inteiro, por 
exemplo: Idade 45; quantidade de filhos 2 entre outros; 
b. Real: Qualquer tipo de dado numérico que pode ser representado na forma 
fracionária, como –87,85; 25 e 0,0. É utilizado para representar informações, 
como: salário, comissão, inflação, entre outras. Numa linguagem de 
programação real, não usemos a vírgula como separador decimal e sim o 
ponto (ex: 1458.75); 
c. Caractere: Utilizado para armazenar um único caractere. Ex: „1‟, „a‟, „A‟, „*‟, „?‟, 
„:‟, etc; 
d. Booleano: Representado por apenas dois valores: verdadeiro e falso. 
 
 
15 
 
1.1. Regras para nomear Variáveis 
Como vimos acima, toda variável necessita de um nome próprio e estes 
nomes estão sujeitos a regras, são elas: 
a. Começar com letra; 
b. Não conter nenhum caractere especial, com exceção do sublinhado; 
c. Dependendo da linguagem de programação, as regras divergem. 
Concluímos que sempre quando houver a necessidade de armazenarmos 
informações, pedidas ou processadas pelo programa, usaremos uma variável ou 
uma constante. 
 
2. Exercícios de fixação 
1. Identifique quais os tipos que as seguintes variáveis teriam em um algoritmo 
qualquer: 
Variável Tipo de dados 
nomeDeRua 
numeroDeCasa 
idadeDeUmaPessoa 
pesoDeUmaPessoa 
valorDoSalario 
quantidadeDePessoasEmFila 
senhaCorreta 
 
2. Identifique quais os tipos dos valores listados a seguir: 
Variável Tipo de dados 
”F” 
V 
”FALSO” 
5.84 
”A*R*&” 
”Amarelo” 
2008 
”abril” 
 
 
 
 
 
16 
 
3. Verifique entre os itens abaixo quais não poderiam ser utilizados como nomes 
de variáveis. Justifique o motivo. 
 
Nome Variável É possível? Justifique 
1x 
fone# 
$salario 
x 
a-6 
2/3 
livro 
tipo_de_talher 
tipo de talher 
automóvel 
talher 
e-mail 
e_mail 
email 
nome_# 
time de futebol 
time_de_futebol 
 
 
 
 
17 
 
Aula 4: Operadores Aritméticos, Lógicos e Relacionais 
Objetivo: Apreender como utilizar os operadores aritméticos, lógicos e relacionais, 
entendendo o grau de prioridade e formas de utilização. 
 
1. Operadores Aritméticos 
Os operadores aritméticos básicos presentes nas linguagens de programação 
estão descritos na Tabela 1: 
Tabela 1 – Operadores aritméticos básicos 
Adição + 
Subtração - 
Multiplicação * 
Divisão / 
 
Para o presente estudo de algoritmo iremos adotar três operadores 
adicionais, descritos na Tabela 2: 
Tabela 2 – Operadores aritméticos básicos 
Potenciação pow() ou ^ pow(4,2) = 16 ou 4^2 = 16 
Raiz quadrada sqrt() sqrt(16) = 4 
Resto da divisão por inteiro % 5 % 2 = 1 
 
A ordem de prioridade dos operadores aritméticos é o mesmo expresso pela 
matemática, sendo eles: 
1º. Potenciação e radiciação 
2º. Multiplicação, divisão ou resto de divisão (a operação que vier primeiro na 
expressão) 
3º. Adição ou subtração (a operação que vier primeiro) 
Para atribuir prioridade a uma operação, utilizamos apenas parênteses. 
Exemplo: 4 + 3 * 3 = 13 
(4 + 3) * 3 = 21 
 
Uma expressão em notação matemática, para que o computador possa 
compreende lá, é necessário que seja feita uma conversão, passando de notação 
matemática ou cientifica para notação computacional. Vejamos alguns exemplos na 
Tabela 3 de como essa conversão é realizada: 
 
 
 
18 
 
Tabela 3 – Exemplos de conversão de equação (cientifica/ computacional) 
Expressão Matemática Expressão em algoritmo 
2
ba
media
 
2/)( bamedia 
2)3(2 bax
 
)2,3()2( bpowasqrtx 
 
 
1.1. Operadores Relacionais 
Os operadores relacionais são (Tabela 4): 
Tabela 4 – Operadores relacionais 
Igualdade 
== 
A == B 
Maior 
> 
A > B 
Maior ou igual 
>= 
A >= B 
Menor 
<
 
A < B 
Menor ou igual 
<=
 
A <= B 
Diferente 
!=
 
A != B 
 
Quando utilizamos os operadores aritméticos em uma expressão o resultado 
será um valor numérico, mas quando utilizamos os operadores relacionais o 
resultado será um valor booleano (verdadeiro ou falso). 
Exemplo: Seja A= 3 e B = 10. 
a) A == B Falso 
b) A != B Verdadeiro 
c) A >= B Falso 
d) A <= B Verdadeiro 
 
1.2. Operadores Lógicos 
Os operadores lógicos trabalham com a combinação de várias expressões 
aritméticas e relacionais, gerando um único resultado booleano. Em algoritmos 
iremos utilizar três operadores lógicos: E, OU e NÃO. 
 
 
 
19 
 
 
Tabela 4 – Tabela Verdade 
A B .NÃO.A .NÃO.B A.OU.B A.E.B 
V V F F V V 
V F F V V F 
F V V F V F 
F F V V F F 
 
2. Exercícios 
1) Resolva as expressões lógicas, determinando se a expressão é verdadeira ou 
falsa: 
a) 2>3 = 
b) (6<8) ou (3>7) = 
c) não(2<3) = 
d) (5>=6 ou 6<7) ou não(a+5-6 == 8) {onde a = 5} = 
e) (34>9 e 5+u == 34) ou (5 == 15/3 e 8>12) {onde u = 29} = 
 
2) Quais os valores de v1, v2 e v3 no final da execução do código abaixo? 
var v1, v2, v3:booleano 
v1 8 > 9 
v2 8 < 9 
v3 v1 OU v2 
v1 v3 E v2 
 
3) Dado os problemas a seguir defina: 
a) Calculo da área de um triângulo dada a fórmula T = (b * h) / 2. 
b) Calculo da média do peso de uma família de 5 pessoas. 
c) Calculo da área de uma circunferência dada a fórmula C = PI* raio^2. 
 Qual(is) será(ão) a(s) variável(eis) de entrada e saída do problema a e c? 
 Qual será o processamento do algoritmo b? 
 
4) Dada as equações matemáticas, reescreva usando a forma de expressão 
computacional: 
a) 
b) 
 
 
20 
 
c) 
d) 
e) 
2
10
16
a
c
a
 
f) 
)30( yzx
yx
 
g) 
a
acbb
2
42 
h) 
2
52 22 xx
x
yx
 
 
5) Dada as expressões computacionais, reescreva usando a forma de equações 
matemáticas convencional: 
a) 
b) 
c) 
d) = 
 
 
 
 
21 
 
Aula 5: Estrutura Sequencial 
Objetivo: Nesta aula iniciaremos o trabalho com pseudocódigo e fluxograma, tendo 
em vista o aprendizado inicialmente com uma estrutura sequencial, sem a tomada 
de decisão ou repetição no processo. 
 
1. Estrutura Sequencial 
Um algoritmo normalmente opera sobre um conjunto finito de entradas para 
gerar um conjunto finito de saídas. Por exemplo, considere um algoritmo para fazer 
a somatória de dois números inteiros quaisquer. Neste caso, claramente temos 
como entrada dois números inteiros (n1 e n2) e como saída, um número inteiro 
(soma) que recebeo resultado de n1+n2. Vejamos o fluxograma e seu 
pseudocódigo a seguir. 
 
Fluxograma Pseudocódigo 
 
 
 
Analisando o fluxograma pode-se observar a existência de dois terminadores 
(Inicio e Fim), esta é uma característica dos fluxogramas, sempre ele terá estes dois 
terminadores, nunca poderá ter mais ou menos terminadores, sempre exatamente 
dois, um iniciando o processo e um finalizando. Após o inicio do fluxograma, temos 
uma entrada de dados, para leitura via teclado dos dois valores, que são 
armazenados nas variáveis n1 e n2. O próximo passo é a realização da soma dos 
valores, em uma etapa de processamento, neste passo, o resultado da soma destes 
Programa soma_2_numeros 
Var 
 n1, n2, soma: Real 
Início 
 Leia n1, n2 
 soma n1+n2 
Escreva soma 
Fim 
 
 
 
22 
 
dois valores é armazenado em uma terceira variável, chamada de soma. Findo os 
processos de entrada de dados e processamento, tem-se então a saída de tela, para 
exibir a resposta ao usuário. 
Finalizada a explicação do fluxograma, pode-se partir para a interpretação do 
pseudocódigo. O pseudocódigo é uma forma onde os comandos são bem 
estruturados e definidos, e seguem algumas regras para sua criação. A primeira 
coisa a observar são os comandos destacados em vermelho, estes comandos fazem 
parte da estrutura para o algoritmo estudado. 
O primeiro passo para a construção do pseudocódigo é definir um nome para 
o programa, para isso utiliza-se a palavra Programa, como destacado e em seguida 
o nome para o programa. Devem ser seguidas as mesmas regras para criação de 
uma variável na definição de um nome de programa. A próxima etapa é a criação 
das variáveis, para tal coloca-se a palavra Var (de variável), e nas próximas linhas 
antes do inicio do programa são declaradas as variáveis, sendo elas separadas por 
linhas entre os tipos diferentes. Para se declarar mais de uma variável na mesma 
linha se separada por vírgula. Pode-se observar que foram criadas três variáveis do 
tipo Real neste programa, e por se tratarem de variáveis do mesmo tipo, estão todas 
na mesma linha. 
O próximo passo do pseudocódigo é o inicio do programa, para tal 
empregamos a palavra Inicio, e nas próximas linhas temos o desenvolver do 
programa. A primeira linha contém o comando de entrada de dados (Leia), nele está 
sendo adquiridos os valores para as variáveis n1 e n2. A linha a seguir é referente 
ao processo de soma das duas variáveis e esta soma esta sendo atribuída para a 
variável soma, neste caso lê-se “soma recebe n1+n2”. O passo seguinte é 
apresentar ao usuário por meio do comando Escreva a resposta, que está 
armazenado na variável soma. Finalizado todos os passos do programa tem-se que 
finalizar o programa, para isso utiliza-se o comando Fim. 
 
 
 
 
 
 
 
 
23 
 
 
 
2. Exercícios 
1) Crie um pseudocódigo para efetuar o cálculo do salário líquido de um profissional 
que trabalhe por hora. Para isso, é necessário ler alguns dados como: valor da 
hora trabalhada (VH), número de horas trabalhadas no mês (NH) e o percentual 
de desconto do INSS (PDI). O algoritmo deverá apresentar na tela o valor do 
salário bruto (SB), o valor descontado (VD) e o valor do salário líquido (SL). 
Considere: SB=VH*NH, VD=SB/100*PDI e SL=SB-VD. 
Exemplo: Se VH=10, NH=20, PDI=10%, então SB=200, VD=20 e SL=180. 
 
2) Calcular quantos azulejos são necessários para revestir uma piscina. O algoritmo 
deverá solicitar ao usuário: comprimento (CP), largura (LP) e profundidade (PP) 
da piscina para calcular sua área total e ainda largura (LA) e altura (AA) do 
azulejo para conhecer sua área. Deve-se considerar a mesma unidade de 
medida tanto para calcular a área da piscina quanto à área do azulejo. Por 
exemplo, centímetros. 
Obs.: A área total (AT) da piscina é composta de 5 faces, e a área do azulejo é 
apenas um valor. Estas áreas devem ser calculadas da seguinte forma: 
 Paredes laterais (PL) = 2*CP*PP; 
 Paredes das cabeceiras (PC) = 2*LP*PP; 
 Fundo da piscina (FP) = CP*LP; 
 AT = PL+PC+FP; 
 Área de um azulejo (AAZ) = LA*AA. 
Para calcular a quantidade de azulejos (QA) para revestir a piscina deve-se 
adotar o cálculo a seguir: 
QA = (AT / AAZ)*1.05 
 
3) Dado o fluxograma escreva o algoritmo respectivo para fazer leitura de dois 
números e apresentar na tela o resultado das quatro operações básicas 
efetuadas sobre estes números (soma (A), subtração (B), divisão (C) e 
multiplicação (D)). 
 
 
24 
 
 
 
4) Construa um fluxograma para ler uma temperatura em graus Fahrenheit e 
apresentá-la convertida em graus Centígrados. A fórmula de conversão é C(F-
32)*(5/9), onde C é a temperatura em Centígrados e F a temperatura em 
Fahrenheit. 
 
5) Construa o fluxograma que represente uma solução para o cálculo da área de 
um trapézio qualquer. Lembrando que: Área do trapézio = (Base Maior + Base 
Menor) x Atura / 2. 
 
 
N1, N2 
A←num1+num2 
B←num1-num2 
C←num1/num2 
D←num1*num2 
“O resultada da Soma de 
N1+N2 é: ”, A 
“O resultada da Subtração de 
N1-N2 é: ”, B 
“O resultada da Divisão de 
N1/N2 é: ”, C 
O resultada da Multiplicação 
de N1*N2 é: ”, D 
FIM 
ini 
INICIO 
ini 
 
 
25 
 
Aula 6: Estrutura condicional 
Objetivo: Esta aula tem como foco o entendimento de utilização de estruturas 
condicionais (decisão) simples e encadeada dentro de um algoritmo. 
Este tipo de estrutura permite que o algoritmo decida automaticamente entre 
dois caminhos possíveis, qual irá executar. Para tanto, um teste lógico é efetuado. 
Caso o teste seja verdadeiro, o algoritmo segue por um caminho. Caso o teste seja 
falso o algoritmo segue pelo outro. Dois exemplos de algoritmos envolvendo 
estruturas de decisão são mostrados a seguir. 
 
1. Estrutura condicional simples 
Na estrutura condicional simples, é empregado um teste lógico para verificar 
se uma condição é válida, tendo a resposta como verdadeiro ele executa um bloco 
de comandos, caso contrário, é possível adicionar outro bloco de comandos ou não 
a ser executado. 
Veja a seguir o emprego de um algoritmo para ler um número e exibir uma 
mensagem indicando se ele é negativo ou não. Neste caso temos como entrada um 
número e como saída apenas uma mensagem. 
Pseudocódigo Fluxograma 
 
 
 
Ao analisar o pseudocódigo do programa, as primeiras etapas são idênticas 
às estudadas anteriormente. Inicialmente existe a definição do nome do programa, 
em seguida a criação das variáveis, neste caso apenas uma variável de um tipo 
Programa Pos_Neg_Nulos 
Var 
 num: Real 
Início 
 Leia num 
 Se num < 0 então 
Escreva “É negativo” 
 Senão 
Escreva “Não é negativo” 
 Fim Se 
Fim 
 
 
26 
 
(Real). Ao iniciar o programa, a primeira linha de comando tem o comando para ser 
adquirido um valor numérico a ser atribuído na variável “num”. A linha seguinte tem 
o processo de decisão, como se pode observar, a linha inicia-se com a palavra “Se”, 
logo após é realizado um teste lógico (que verifica se o número é menor que zero) e 
em seguida a palavra “então”, finalizando o teste lógico. Caso a resposta deste teste 
lógico seja positivo, o programa então realizará o comando para exibir a mensagem 
avisando que o número é negativo, caso este teste retorne falso, o programa exibirá 
a mensagem que o número não é negativo, e para que o sistema entenda que 
deverá exibir esta mensagem caso o teste retorne falso, temos o emprego da 
palavra “senão”. Após finalizado os passos com os blocos de comando para 
resposta positiva e negativa, temos que finalizar a estrutura de decisão (SE) aberta, 
para isso aplica-sea frase “Fim Se” no final do ultimo bloco. Agora só resta a 
finalização do programa com a palavra “Fim”. 
Ao analisar o fluxograma deste algoritmo, tem-se o símbolo da decisão 
adicionado, dentro dele é incorporado o teste lógico, com duas possíveis respostas, 
uma indicada na seta com a letra “S”, que significa a resposta se positivo o teste 
lógico, e na segunda seta temos a letra “N”, que representa a resposta negativa do 
teste. Exibida as mensagens de resposta, então os dois processos, que agora estão 
separados, devem seguir para o terminador, finalizando o fluxograma. 
 
2. Estrutura condicional composta ou encadeada 
Um algoritmo com estrutura condicional composta tem como objetivo analisar 
casos que pode possuir mais de duas respostas, ou seja, um problema pode ter n 
respostas, sendo sempre necessários n-1 testes lógicos para tratar todas as 
possibilidades. Por exemplo, um problema que tenha 4 respostas, teremos que ter 3 
testes lógicos, ou seja, 3 decisões. 
Vejamos agora um algoritmo para ler um número qualquer a partir do teclado 
e exibir uma mensagem indicando se ele é positivo, negativo ou nulo. Como se pode 
notar, existem 3 respostas possíveis, então nesse caso n=3, serão necessários 2 
testes lógicos. Nesse tipo de estrutura é possível escrever o pseudocódigo de duas 
formas distintas, porém, com o mesmo teor no seu conteúdo. Uma desta utiliza 
apenas uma estrutura de decisão, e na outra empregam duas estruturas de decisão. 
 
 
 
27 
 
 
Fluxograma 
 
Pseudocódigo (1ª forma) Pseudocódigo (2ª forma) 
 
 
 
Iniciaremos a análise desta estrutura de decisão pelo fluxograma, neste caso, 
como pode ser observada a resposta da primeira decisão, se negativa, esta ligada 
diretamente a outra decisão, formando assim uma cadeia de decisões, por isso é 
chamado de estrutura de decisão composta ou encadeada. Para a solução deste 
caso, verificou-se primeiramente se o número digitado é positivo, se a resposta for 
Programa Pos_Neg_Nulos2 
Var 
 num: Real 
Início 
 Leia num 
 Se num > 0 então 
Escreva “É positivo” 
 Senão Se num < 0 então 
Escreva “É negativo” 
 Senão 
Escreva “É nulo” 
 Fim Se 
Fim 
Programa Pos_Neg_Nulos 
Var 
 num: Real 
Início 
 Leia num 
 Se num > 0 então 
Escreva “É positivo” 
 Senão 
Se num < 0 então 
Escreva “É negativo” 
 Senão 
Escreva “É nulo” 
 Fim Se 
 Fim Se 
Fim 
 
 
28 
 
sim, o sistema exibe ao usuário a mensagem que o número é positivo, caso 
contrário, é realizado outro teste, se o número é negativo, caso a resposta for 
positiva, obtém-se a mensagem informando que é negativo, caso contrário, informa 
que o número é nulo, sendo a única opção que restou. Neste caso temos o processo 
dividido em três partes, as quais devem ir para um único terminador. 
Temos agora que diferenciar as duas formas de representação do 
pseudocódigo uma sendo duas estruturas de decisão simples e a segunda sendo a 
estrutura encadeada, como pode ser observado na primeira após a primeira decisão 
temos o bloco de comandos, em seguida vem o senão, e na próxima linha contém 
a próxima decisão, sendo assim, é aberta uma nova estrutura de decisão, que irá 
possuir o seu próprio “Senão” e também seu “Fim Se”, como pode ser observado. 
Neste caso então abrimos duas estruturas de decisão e fechamos duas vezes, uma 
para cada estrutura de decisão. 
No segundo caso, a diferença é que possuí apenas uma estrutura de decisão, 
e se observamos, o “Senão Se” esta na mesma linha, indicando que este segundo 
“Se” faz parte da primeira estrutura, sendo assim, não é necessário fechar duas 
vezes o “Se”, e sim apenas uma vez como mostrado no exemplo acima, o que 
caracteriza uma estrutura encadeada. 
 
 
 
 
29 
 
Aula 7: Exercícios sobre estrutura condicional 
Objetivo: Treinar o uso de estrutura de decisão. 
 
1. Exercícios 
1) Ler 2 notas do aluno (N1 e N2), calcular a média aritmética das duas notas e 
exibir uma mensagem informando se o aluno foi “aprovado” ou “reprovado”. O 
aluno é aprovado se a média >= 6 e reprovado em caso contrário. 
 
2) Faça um algoritmo que receba o valor do salário (VS) de uma pessoa e o valor 
de um financiamento (VF) pretendido. Caso o financiamento seja menor ou igual 
a 5 vezes o salário da pessoa, o algoritmo deverá escrever "Financiamento 
Concedido"; senão, ele deverá escrever "Financiamento Negado". Independente 
de conceder ou não o financiamento, o algoritmo escreverá depois a frase 
"Obrigado por nos consultar." 
 
3) Elabore um fluxograma e codifique Português Estruturado que leia dois números 
inteiros distintos e escreva como resultado o maior deles. 
 
4) Faça um algoritmo que calcule a média aritmética de duas notas de um aluno e 
entre com o número de faltas alcançada no semestre e coloque a mensagem de 
acordo com as seguintes condições: 
Se a média >=6,0 e a falta <= 10, então o aluno está aprovado, caso esteja fora 
dessas condições o aluno está reprovado. 
 
5) Dado o algoritmo abaixo, montar um fluxograma equivalente. 
Início do algoritmo “Cálculo do zero da equação ax+b=0”. 
1. ler os coeficientes a, b 
2. se a é diferente de 0 então 
3. calcular o valor de x (ax+b=0) 
4. escrever “O valor de x é ”, x 
5. senão escrever ¨Não há zero” 
Fim do algoritmo “Cálculo do zero da equação ax+b=0”. 
 
 
 
30 
 
6) Escreva um programa que leia um número inteiro. Se o número lido for positivo, 
escreva uma mensagem indicando se ele é par ou ímpar. Se o número for 
negativo, escreva a seguinte mensagem “Este número não é positivo”. 
 
7) Faça um algoritmo que escreva o conceito de um aluno, dada a sua nota. Supor 
notas inteiras somente. O critério para conceitos é o seguinte: 
Nota Conceito 
0 a 2 E 
3 a 4 D 
5 a 6 C 
 7 a 8 B 
9 a 10 A 
 
8) A empresa XYZ decidiu conceder um aumento de salários a seus funcionários de 
acordo com a tabela abaixo: 
SALÁRIO ATUAL ÍNDICE DE AUMENTO 
0 – 400 15% 
401 – 700 12% 
701 – 1000 10% 
1001 – 1800 7% 
1801 – 2500 4% 
ACIMA DE 2500 SEM AUMENTO 
 
Escrever um algoritmo que lê, para cada funcionário, o seu nome e o seu salário 
atual. Após receber estes dados, o algoritmo calcula o novo salário e escreve na 
tela as seguintes informações: 
<nome do funcionário> <% de aumento> <salário atual> <novo salário> 
 
 
 
 
 
31 
 
9) Dado o pseudocódigo abaixo, montar um fluxograma equivalente. 
Pretende-se elaborar um programa que permita ler um número a partir do 
teclado, e apresentar a indicação de que é positivo, negativo ou nulo. 
Entradas: Num 
Saídas: mensagens 
Descrição do problema: 
Se N = 0 então  N é nulo 
Se N > 0 então  N é positivo; 
 senão  N é negativo 
 Este problema faz então uso de estruturas condicionais (estruturas de seleção). 
Então podemos escrever a seguinte sequência de passos para a resolução do 
problema: 
 
 
10) Represente-o por meio de um fluxograma e pseudocódigo o cálculo de uma 
equação de segundo grau seguindo respeitando as regras a seguir: 
a) Se o coeficiente a for igual a zero informar que esta não é uma equação do 2º 
grau e terminar o algoritmo. 
b) Se o valor de delta for negativo informar que a equação não tem raízes reais 
e terminar o algoritmo. 
 
11) Dados três valores A , B e C, verifique se eles podem ser os comprimentos dos 
lados de um triângulo e, se forem, verifique se é um triângulo equilátero, 
isósceles ou escaleno. Se não formarem um triângulo, escreva uma mensagem. 
Programa SeparaNum 
Var num:real 
Inicio 
Escreva "Introduza um número" 
 Leia numSe num = 0 então 
 Escreva "O número é nulo" 
Senão Se num > 0 então 
 Escreva num, " é um número positivo" 
Senão 
 Escreva num, " é um número negativo” 
Fim Se 
Fim. 
 
 
 
32 
 
Represente por pseudocódigo e por forma de fluxograma o problema. Considere 
que: 
 Não formam um triângulo: 
o Se um dos lados do triângulo é zero. 
o Se o comprimento de cada lado não deve ser maior que a soma dos 
outros dois lados. 
 Formam um triângulo: 
o Equilátero: quando possui os três lados iguais. 
o Isósceles: quando possui dois lados iguais. 
o Escaleno: quando possui os três lados diferentes. 
 
 
 
 
33 
 
Aula 8: Estrutura de repetição 
Objetivo: Esta aula tem como foco o entendimento de utilização de estruturas de 
repetição, tornando possível a repetição de um trecho do algoritmo por várias vezes. 
 
1. Estrutura de repetição 
Uma estrutura de repetição é empregada quando se deseja executar um 
conjunto de instruções varias vezes. Essa repetição esta vinculada a quantidade de 
vezes que se deseja repetir o trecho de instruções (PARA) ou de um teste lógico 
para parada, este pode ser efetuado no início (ENQUANTO) ou no fim (FAÇA-
ENQUANTO) do bloco de instruções. Quando o teste é feito no início, as instruções 
do bloco são executadas enquanto a condição testada seja verdadeira, sendo assim, 
pode acontecer das instruções contidas dentro do bloco não serem executas 
nenhuma vez. Por outro lado, quando o teste é realizado no final do bloco, as 
instruções são executadas no mínimo uma vez, visto que o teste a ser realizado fica 
logo após as instruções contidas no laço de repetição. Nesta estrutura, da mesma 
forma que na anterior, a repetição é finalizada quando o teste for verdadeiro, ou 
seja, o algoritmo fica executando as instruções que estiverem dentro deste laço 
enquanto o teste seja verdadeiro. 
Vale ressaltar a possibilidade de um laço de repetição mal definido, cujo 
código nunca modifique o estado da variável vinculado a condição de parada, a 
rotina será executada para sempre, essa situação é chamada de loop infinito. Outro 
ponto é quando esta mudança da variável nunca alcançara um estado de falso, esse 
caso também deixará o laço travado de forma infinita. 
Contudo, existem casos, por exemplo, trabalhando com microcontroladores, 
onde o laço infinito é bem vindo, ele é necessário para que o dispositivo não seja 
desativado. Outra condição que todos podemos verificar com clareza o uso do laço 
infinito, é o sistema operacional que aguarda uma ação do usuário, seja via teclado, 
mouse ou outro dispositivo qualquer, o sistema esta sempre verificando uma 
interação do usuário. 
Vejamos o emprego de um algoritmo único com o emprego das três técnicas 
de laço de repetição a seguir. O algoritmo deverá apresentar na tela todos os 
números positivos no intervalo de 1 a 100. 
 
 
 
34 
 
1.1. Estrutura de repetição com quantidade de repetições definidas (Para) 
 
Pseudocódigo Fluxograma 
 
 
 
Neste algoritmo, a variável cont é usada para realizar a contagem de 1 até 
100 e também é verificado seu valor em cada passagem do laço de repetição para 
apresentar os números positivos, ou seja, se o resto da divisão (%) do contador por 
dois for igual a zero, significa que ele é positivo. Uma variável desta natureza 
(controle de passagens por um laço de repetição) é chamada de "contador". Os 
motivos para contar algo em algoritmos são os mais diversos: contar quantas vezes 
um determinado ciclo é executado, realizar uma somatória para o cálculo de média, 
etc. 
Podemos verificar nesse caso o emprego do laço de repetição com o 
comando Para, esse tipo de laço o valor inicial do contador e o valor qual deve ser 
utilizado para parada do mesmo é especifico. Após entrar no laço de repetição, ele 
executa o teste para verificar se o valor do contador é positivo. Sendo verdade, o 
algoritmo apresenta o valor do contador na tela, e segue para o incremento do 
contador. Caso a resposta do teste seja falsa, ele vai diretamente para o incremento, 
desta forma, independente da resposta do teste, irá ser realizado o incremento do 
contador e o processo não entrará em loop infinito. Feito o incremento então o 
N 
INICIO 
ini 
cont 
FIM 
ini 
F 
V 
cont1; 100; 1 
S 
cont % 2 == 0 
cont  cont+1 
Programa Positivos 
Var 
 cont: Inteiro 
Início 
 Para cont1 até 100 Faça 
Se cont % 2 == 0 então 
 Escreva cont 
Fim Se 
cont  cont + 1 
 Fim Para 
Fim 
 
 
35 
 
algoritmo retorna para o comando Para e verificará se chegou em 100. Esse 
processo será repetido até essa condição ser verdade. 
 
1.3. Uso de estrutura de repetição com teste lógico no início (Enquanto) 
 
Pseudocódigo Fluxograma 
 
 
 
Neste caso, é possível notar algumas pequenas diferenças no pseudocódigo 
e no fluxograma, uma destas alterações importantes a se destacar, é a necessidade 
de iniciar a variável do contador com um valor. No exemplo, cont foi inicializado com 
o valor 1. 
Outra alteração é na estrutura de repetição utilizada, neste caso teve o 
emprego do laço condicional Enquanto. Este tipo de repetição, a parada esta 
vinculada ao teste lógico, neste caso, um teste lógico simples, com base em um 
contador. 
A diferença no fluxograma dos dois casos iniciais, é somente a inclusão da 
inicialização do contador com 1, e dentro do diagrama de repetição, não temos mais 
a inicialização do contador, mas sim apenas o teste com o critério de parada. O 
N 
INICIO 
ini 
cont 
FIM 
ini 
F 
V 
S 
cont % 2 == 0 
cont  cont+1 
cont  1 
cont <=100 
Programa Positivos 
Var 
 cont: Inteiro 
Início 
 cont  1 
 Enquanto cont <= 100 Faça 
Se cont % 2 == 0 então 
 Escreva cont 
Fim Se 
cont  cont + 1 
 Fim Enquanto 
Fim 
 
 
36 
 
F V cont <= 100 
N 
INICIO 
ini 
cont 
FIM 
ini 
S 
cont % 2 == 0 
cont  cont+1 
cont  1 
resto do fluxograma segue exatamente igual o primeiro, pois não existem outros 
pontos a serem alterados na troca do laço de repetição para e o laço enquanto. 
 
1.4. Estrutura de repetição com teste lógico no fim (Faça-Enquanto) 
 
Pseudocódigo Fluxograma 
 
 
 
Ao analisar este ultimo caso de repetição, podemos notar a sua diferença no 
pseudocódigo na localização do enquanto, no trecho onde estava o comando 
enquanto, ficou apenas o faça, ou seja, o algoritmo irá executar ao menos uma vez 
até chegar o comando enquanto, para verificar o critério de parada. 
No fluxograma, temos também o deslocamento para baixo do laço de 
repetição, esta é a única alteração se comparado com o fluxograma anterior. 
 
Programa Positivos 
Var 
 cont: Inteiro 
Início 
 cont  1 
 Faça 
Se cont % 2 == 0 então 
 Escreva cont 
Fim Se 
cont  cont + 1 
 Enquanto cont <= 100 
Fim 
 
 
37 
 
Aula 9: Exercícios sobre estrutura de repetição 
Objetivo: Treinar o uso de estrutura de repetição. 
 
1. Exercícios 
1) Desenvolva um fluxograma e pseudocódigo para calcular e exibir a somatória de 
todos os números inteiros no intervalo de 1 até 10 (1+2+,...,+10). 
 
2) Desenvolva um pseudocódigo e seu respectivo fluxograma para fazer a leitura de 
dez números quaisquer, calcular e exibir a soma apenas dos números positivos. 
 
3) Desenvolva um pseudocódigo para fazer a leitura de dez números quaisquer e 
exibir na tela a quantidade de valores positivos e a quantidade de valores 
negativos que foram lidos. 
 
4) Crie um fluxograma para ler um número inteiro no intervalo de 1a 10 e exibir na 
tela a sua tabuada. 
 
5) Faça um fluxograma e pseudocódigo que receba três notas de um número 
qualquer de alunos (que deve ser especificado pelo usuário), calcule e mostre 
sua média final e sua situação conforme tabela abaixo: 
 (AV1+Maior(AV2, AV3))/2 
Média Mensagem 
0,0 a 5,9 
Reprovado 
6,0 a 10,0 
Aprovado 
 
6) Faça um fluxograma que receba o salário de dez funcionários, calcule e mostre o 
valor do imposto a ser pago, usando a tabela a seguir: 
Salário 
Menor que R$ 500 
De R$ 500,00 a R$ 850,00 
Acima de R$ 850,00 
Percentual do imposto 
5% 
10% 
15% 
 
 
 
38 
 
7) Faça um pseudocódigo que mostre os vinte primeiros termos da sequencia de 
Fibonacci. 
0-1-1-2-3-5-8-13-21-34-55... 
 
8) Faça um pseudocódigo que receba a idade e o sexo de 12 pessoas, calcule e 
mostre: 
• A idade média do grupo; 
• A idade média das mulheres; 
• A idade média dos homens. 
 
9) Faça um pseudocódigo e seu fluxograma que calcule e escreva na tela o valor da 
série geométrica S, dada pela equação: 
10
1
2
i
iS
, ou seja, S=12 + 22 + 32 + ... 
+102. 
 
10) Crie um fluxograma e pseudocódigo para exibir na tela a soma de todos os 
múltiplos do número 3 no intervalo de 0 a 100, ou seja, o algoritmo deve calcular 
e exibir o resultado da seguinte soma: 0 + 3 + 6 + 9 + 12 + 15 + ... + 99. 
 
11) Desenvolva um fluxograma para fazer a leitura de um número inteiro, calcular e 
exibir o seu fatorial. Exemplo de um fatorial: 5! = 5 . 4 . 3 . 2 . 1 = 120 
 
12) Desenvolva um fluxograma e seu pseudocódigo para fazer a leitura de 5 
números quaisquer e exibir o maior valor lido. 
 
13) Escrever um pseudocódigo que leia informações sobre um grupo de 250 pessoas 
e calcule alguns dados estatísticos. Para cada pessoas do grupo deve ler o nome 
da pessoa, a altura, o peso e o sexo (“F” para feminino e “M” para o masculino). 
Calcular e escrever: 
 A quantidade total de homens e mulheres e o percentual de cada. 
 A média de peso das pessoas (somatório dos pesos de todas as pessoas 
pela quantidade de pessoas) 
 O nome da pessoa mais alta. 
 
 
 
39 
 
Aula 10: Breve visão da linguagem C 
Objetivo: Ao final desta aula o aluno estará apto a utilizar o compilador Dev-C++. 
 
1. Introdução 
Um programa de computador é um conjunto instruções que representam um 
algoritmo para a resolução de algum problema. Estas instruções são escritas através 
de um conjunto de códigos (símbolos e palavras). Este conjunto de códigos possui 
regras de estruturação lógica e sintática própria. A linguagem C é uma linguagem de 
alto nível genérica que nasceu juntamente com o advento da teoria de linguagem 
estruturada e do computador pessoal e tornou-se rapidamente uma linguagem 
“popular” entre os programadores. 
Foi originalmente projetada para ser implementada no sistema operacional 
UNIX no PDP-11 da DEC (Digital Equipment Corporation), por Dennis Ritchie. O 
sistema operacional, o compilador C e, essencialmente, todos os programas de 
aplicação do UNIX são escritos em C. Compiladores de produção também existem 
para várias outras máquinas, incluindo o IBM System/370, Honeywell 6000, e o 
Interdata 8/32. C, entretanto, não é ligada a nenhum hardware ou sistema particular, 
e é fácil escrever programas que rodarão sem mudanças em quaisquer máquinas 
que aceitem a linguagem C. 
Atualmente, além de todas as aplicações já existentes, é utilizada para 
desenvolver novas linguagens, entre elas a linguagem C++ e Java. Embora C seja 
uma linguagem onde é possível trabalhar em baixo nível, fazendo acesso a 
memória, por exemplo, tem a finalidade geral que permite economia de expressão, 
modernos fluxos de controle e estruturas de dados e um rico conjunto de 
operadores. Compiladores na internet e é possível encontrar diversos tipos de 
compiladores da linguagem C. Cabe ao programador decidir qual será mais 
adequado. Alguns fatores que podem influenciar na decisão são: 
 Custo do compilador. 
 Interface com o usuário. 
 Sistema operacional que será executado. 
 Manuais disponíveis etc. 
Dentre os diversos compiladores disponíveis para programação em C/ C++, 
existem alguns que são mais conhecidos, sendo eles: 
 
 
40 
 
 Compilador GCC – Este é o compilador da GNU, padrão do sistema 
operacional GNU/Linux, que também foi adotado por outros sistemas 
operacionais, tal como o próprio Windows. É um dos líderes do mercado e é 
gratuito. 
 Compilador C++ Builder – Borland – O compilador da Borland e ele é pago. 
Uma versão para testes pode ser baixada e avaliada por 60 dias sem custos 
no site da Borland. http://www.borland.com 
 Compilador Dev-C++ - É um compilador gratuito de plataforma Windows que 
será utilizado e apresentado nesta aula. Segue o link para download do site 
do desenvolvedor: http://www.bloodshed.net/dev/devcpp.html 
 Compilador Visual C/C++ da Microsoft – Possui a versão gratuita, chamada 
de Express Edition e a versão paga, chamada de Professional. A versão 
gratuita pode ser localizada facilmente no próprio site da Microsoft, na seção 
de downloads. 
Outro ponto interessante de ser citado é o histórico da linguagem C, que 
inicialmente em 1970 Denis Ritchie desenhou uma linguagem a partir do BCPL nos 
laboratórios da Bell Telephones, Inc. Chama a linguagem de B. Em 1978 Brian 
Kerningham junta-se a Ritchie para aprimorar a linguagem. A nova versão chama-se 
C. Pelas suas características de portabilidade e estruturação já se torna popular 
entre os programadores. Já em 1980 a linguagem é padronizada pelo American 
National Standard Institute: surge o ANSI C. Uma década a frente, 1990, a Borland 
International Co, fabricante de compiladores profissionais escolhe o C e o Pascal 
como linguagens de trabalho para o seu Integrated Development Enviroment 
(Ambiente Integrado de Desenvolvimento), e com isso surge o Turbo C. Alguns 
anos depois, em 1992, o C se torna ponto de concordância entre teóricos do 
desenvolvimento da teoria de Object Oriented Programming (programação 
orientada a objetos), surgindo então o C++, que é a evolução do C e os 
compiladores atuais trabalham com as duas estruturas. 
Podemos citar como exemplo da capacidade e potência da linguagem C, 
citando alguns programas escritos nesta linguagem, sendo eles: Unix; Dbase; 
Clipper; Windows; Excel; C++; Visual Basic; Java. 
 
 
 
 
41 
 
 
1.1. O compilador Dev-C++ 
Após efetuar a o download e instalação do Dev-C++, inicialize o programa. A 
interface com o usuário está apresentada na Figura 1, sendo que os principais 
ícones estão evidenciados e descritos. 
Figura 1 - Interface do Dev-C++ 
 
 Ícone 1 – Responsável pela abertura de arquivos salvos no computador. 
 Ícone 2 – Este ícone insere um novo arquivo fonte. Será usado 
constantemente para criar os arquivos de códigos. 
 Ícone 3 – Quando um código estiver pronto, deverá ser compilado. Compilar 
um código significa passar a linguagem que entendemos para a linguagem 
que o computador entende. O atalho CTRL + F9 também pode ser utilizado. 
 Ícone 4 – Após o código ter sido compilado sem erros, poderá ser executado. 
A tecla de atalho que executa o código é a CTRL + F10. 
 Ícone 5 – Este ícone faz o papel dos ícones 3 e 4. Também é possível 
compilar e executar o código pressionando F9. 
 Ícone 6 – Salva o arquivo criado no Dev-C++. 
1 
3 
4 
5 
6 
2 
 
 
42 
 
Como exemplo, vamos fazer os seguintes passos: 
a. Clique no ícone 2; 
b. Escreva o código a seguir no documento; 
 
c. Clique no ícone 6 para salvar o arquivo, nesta etapa, atente-se para 
não colocar caracteres especiais no nome doarquivo, caso deseje usar 
algum caractere que não seja letra ou número utilize apenas o 
sublinhado, a mesma regra descrita para criação de variáveis; 
d. Use a extensão .cpp para salvar o seu arquivo; 
e. Aperte o ícone 3 para compilar o seu programa; 
f. Se tudo estiver correto ele deverá apresenta a mensagem: 
 
g. Agora clicar no ícone 4 para executar o seu programa, com a seguinte 
resposta: 
 
 
#include <stdio.h> 
 #include <stdlib.h> 
int main() { 
printf("Ola Mundo!!!\n\n\n"); system("PAUSE"); 
return 0; 
} 
 
 
43 
 
Aula 11: Introdução a linguagem C 
Objetivo: Ao final desta aula o aluno entenderá a estrutura básica de um programa 
feito na linguagem C/ C++ e poderá montar programas básicos com entrada e saída 
de dados. 
 
1. Introdução 
Um programa de computador manipula objetos de dados básicos, tais como 
variáveis e constantes. No início de um programa, as declarações listam as variáveis 
que serão utilizadas, além de definir os tipos, o tamanho dos arranjos e até os seus 
valores iniciais. Os operadores especificam o que deve ser feito com as variáveis. As 
expressões combinam variáveis e constantes para produzir novos valores. 
É importante também, conhecer as principais características do C, dentre elas 
podem ser citados: 
 O C é uma linguagem de alto nível com uma sintaxe bastante estruturada e 
flexível; 
 Programas em C são compilados, gerando programas executáveis; 
 O C compartilha recursos tanto de alto quanto de baixo nível, pois permite 
acesso e programação direta do microprocessador; 
 O C é uma linguagem estruturalmente simples e de grande portabilidade; 
 Embora estruturalmente simples (poucas funções intrínsecas) o C não perde 
funcionalidade, pois permite a inclusão de uma farta quantidade de rotinas do 
usuário. 
 
2. Variáveis e Tipos de Dados 
Os nomes das variáveis são construídos a partir de letras e números, sendo 
que o primeiro caractere deve sempre ser uma letra. 
Letras em maiúsculo e minúsculo diferem-se entre si, ou seja, C é Case 
Sensitive, portanto, os nomes Meu_programa e meu_Programa são diferentes. 
Algumas palavras são reservadas, isto é, não podem ser utilizadas para 
nomear variáveis. Essas palavras são de uso interno, tais como: float, int, if, switch 
etc . 
 
 
44 
 
Aconselha-se a utilizar nomes de variáveis que tenham algum significado 
dentro do programa. Também é prática comum utilizar letras minúsculas para 
variáveis e maiúsculas para constantes simbólicas. 
 
2.1. Palavras reservadas em C 
Alguns nomes são reservados na linguagem C. Esses nomes são referentes 
às funções internas e não podem ser utilizados para outras finalidades. A Tabela 1 
apresenta as palavras reservadas. 
Tabela 1 - Palavras chave reservadas. 
auto break 
case char 
const 
continue 
default do 
double else 
enum extern 
float for goto 
if 
int long 
register 
return short 
signed sizeof 
static 
struct switch 
typedef 
union 
unsigned 
void volatile 
while 
 
2.2. Identificadores 
São nomes que identificam: variáveis, funções, etc... 
Regras: 
 Qualquer tamanho 
 Primeiro caractere: letra ou sublinhado. 
 Demais caracteres: letras, números ou sublinhados. 
Ex.: 
Corretos: soma, teste123, media_geral. 
Incorretos: 1nota, valor-max, tot!fem 
Lembre-se: Não pode ser uma das palavras reservadas nem o nome de uma 
função C já existente. (Como printf, por exemplo). 
 
2.3. Tipos de dados 
O tipo de uma variável informa a quantidade de memória que deve ser 
reservada, em bytes. 
Em C, há cinco tipos de variáveis básicas. Nos computadores da linha IBM-
PC a Tabela 2 é válida: 
 
 
 
 
 
45 
 
Tabela 2 - Especificação da quantidade de memória utilizada para cada tipo de dado. 
TIPO BIT BYTES ESCALA 
char 8 1 -128 a 127 
int 16 2 -32768 a 32767 
float 32 4 3.4E-38 a 
3.4E+38 
double 64 8 1.7E-308 a 
1.7E+308 
void 0 0 Sem valor 
 
 Com exceção do void, os tipos de dados básicos podem estar acompanhados 
por modificadores na declaração de variáveis. Os modificadores existentes estão 
apresentados a seguir: 
long ou long int (4 bytes) 
unsigned char (de 0 a 255) 
unsigned int (de 0 a 65535) 
short (2 bytes no IBM-PC) 
 
2.4. Variáveis de ponto flutuante 
Números de ponto flutuante correspondem mais ou menos aos que os 
matemáticos chamam de “números reais”. 
Existem várias maneiras de escrever números de ponto flutuante. A notação 
“3.16e7” é um e meio de indicar que 3.16 será multiplicado por 10 elevado à 
potência 7, isto é, 31600000. Essa indicação chama-se notação científica e é usada 
para armazenar números de ponto flutuante na memória do computador. 
 
2.5. Declaração de variáveis 
A declaração de uma variável é uma instrução que armazena uma 
determinada quantia de memória apropriada para o uso de uma variável. Toda 
declaração deve ser feita por um tipo seguido do nome da variável. 
Se você tiver mais de uma variável do mesmo tipo, poderá declará-las de uma 
única vez, separando-as por vírgulas: 
int navio, carro, moto; 
 
2.6. Inicialização de variáveis 
Atribuir um valor a uma variável. 
 
 
46 
 
Sempre inicialize as variáveis antes de usá-las. 
 
Tabela 3 – Exemplo de uso de variáveis 
 
Uso correto Exemplo que geraria erro. 
int soma=3; 
char letra = ‘A’; 
int x,y,z; 
z=y=z=0; 
int x,y; 
x = y + 5; /* erro, y não foi inicializado */ 
 
3. Operadores 
Um programa tem como característica fundamental a capacidade de 
processar dados. Processar dados significa realizar operações com estes dados. As 
operações a serem realizadas com os dados podem ser determinadas por 
operadores ou funções. Os operadores podem ser de atribuição, aritméticos, de 
atribuição aritmética, incrementais, relacionais, lógicos e condicionais. 
 
3.1. Operador de Atribuição 
A operação de atribuição é a operação mais simples do C. Consiste de 
atribuir valor de uma expressão a uma variável. 
Sintaxe: A sintaxe da operação de atribuição é a seguinte: 
identificador = expressão; 
onde identificador é o nome de uma variável e expressão é uma expressão 
válida (ou outro identificador). 
 Exemplos de atribuições válidas: 
 a = 1; 
 delta = b * b - 4 * a * c; 
 i = j; 
 Exemplos de atribuições inválidas: 
 1 = a; // constante! 
 b + 1 = a; // expressão! 
O operando esquerdo deve ser um identificador de variável, isto é, não pode 
ser uma constante ou expressão. 
Obs.: Não se pode confundir o operador de atribuição (=) com o operador 
relacional de igualdade (==). 
 
 
 
 
47 
 
 
3.2. Operadores Aritméticos 
Existem cinco operadores aritméticos em C. Cada operador aritmético está 
relacionado ao uma operação aritmética elementar: adição, subtração, multiplicação 
e divisão. Existe ainda um operador (%) chamado operador de módulo cujo 
significado é o resto da divisão inteira. Os símbolos dos operadores aritméticos são: 
Operador Operação 
+ adição. 
- subtração. 
* multiplicação 
/ divisão 
% módulo (resto da divisão inteira) 
 
 Sintaxe: A sintaxe de uma expressão aritmética é: 
 operando operador operando 
onde operador é um dos caracteres mostrados acima e operando é uma 
constante ou um identificador de variável. 
 Exemplo: Algumas expressões aritméticas: 
 1+2 a -4.0 b*c valor_1/taxa num%2 
 
 
 
 
48 
 
Aula 12: Introdução a linguagem C (Continuação) 
3.3. Operadores de Atribuição Aritmética 
Muitas vezes queremos alterar o valor de uma variável realizando alguma 
operação aritmética com ela. Como por exemplo: i= i + 1 ou val = val * 2. Embora 
seja perfeitamente possível escrever estas instruções, foram desenvolvidas na 
linguagem C, instruções otimizadas com o uso de operadores ditos operadores de 
atribuição aritmética. Os símbolos usados são (+=, -=, *=, /= , %=). Deste modo as 
instruções acima podem ser rescritas como: i += 1 e val *= 2, respectivamente. 
Sintaxe: A sintaxe da atribuição aritmética é a seguinte: 
var <operador atribuição aritmética> exp; 
onde var é o identificador da variável e exp é uma expressão válida. 
Exemplo: Observe as atribuições aritméticas abaixo e suas instruções 
equivalentes: 
Atribuição aritmética Instrução equivalente 
i += 1; i = i + 1; 
j -= val; j = j - val; 
num *= 1 + k; num = num * (1 + k); 
troco /= 10; troco = troco / 10; 
resto %= 2; resto = resto % 2; 
 
3.4. Operadores Incrementais 
Em programação existem instruções muito comuns chamadas de incremento 
e decremento. Uma instrução de incremento adiciona uma unidade ao conteúdo de 
uma variável. Uma instrução de decremento subtrai uma unidade do conteúdo de 
uma variável. 
Existem, em C, operadores específicos para realizar as operações de 
incremento (++) e decremento (--). Eles são genericamente chamados de 
operadores incrementais (Tabela 1). 
Tabela 1 –A sintaxe dos operadores incrementais é a seguinte: 
Instrução Equivalente 
++ var var = var + 1 
var ++ var = var + 1 
-- var var = var - 1 
var -- var = var - 1 
 
 
49 
 
onde var é o nome da variável da qual se quer incrementar ou decrementar 
um unidade. 
Observe que existem duas sintaxes possíveis para os operadores: pode-se 
colocar o operador à esquerda ou á direita da variável. Nos dois casos o valor da 
variável será incrementado (ou decrementado) de uma unidade. Porém se o 
operador for colocado á esquerda da variável, o valor da variável será incrementado 
(ou decrementado) antes que a variável seja usada em alguma outra operação. 
Caso o operador seja colocado à direita da variável, o valor da variável será 
incrementado (ou decrementado) depois que a variável for usada em alguma outra 
operação. 
Exemplo: Observe o fragmento de código abaixo e note o valor que as 
variáveis recebem após a execução da instrução: 
Valor das variáveis 
int a, b, c, i = 3; // a: ? b: ? c: ? i: 3 
a = i++; // a: 3 b: ? c: ? i: 4 
b = ++i; // a: 3 b: 5 c: ? i: 5 
c = --i; // a: 3 b: 5 c: 4 i: 4 
 
3.5. Operadores Relacionais e Lógicos 
A chave para a flexibilidade de um algoritmo é a tomada de decisões através 
da avaliação de condições de controle. Uma condição de controle é uma expressão 
lógica que é avaliada como verdadeira ou falsa. Uma expressão lógica é construída 
com operadores relacionais e lógicos. 
 
3.5.1. Operadores relacionais 
Operadores relacionais verificam a relação de magnitude e igualdade entre 
dois valores. Os operados relacionais em C são os mesmos estudos anteriormente. 
Sintaxe: A sintaxe das expressões lógicas é: 
expressão_1 operador expressão_2 
onde expressão_1 e expressão_2 são duas expressões numéricas quaisquer, 
e operador é um dos operadores relacionais. 
 
 
50 
 
Ao contrário de outras linguagens, em C não existem tipos lógicos, portanto o 
resultado de uma expressão lógica é um valor numérico: uma expressão avaliada 
verdadeira recebe o valor 1, uma expressão lógica avaliada falsa recebe o valor 0. 
Se os operandos forem de tipos diferentes haverá uma conversão de tipo 
antes da avaliação da expressão. 
 
3.5.2. Operadores lógicos 
São três os operadores lógicos de C: &&, || e !. Estes operadores possuem o 
mesmo significado dos operadores lógicos Booleanos AND, OR e NOT. 
Sintaxe: A sintaxe de uso dos operadores lógicos: 
expr_1 && expr_2 
expr_1 || expr_2 
!expr 
onde expr_1 , expr_2 e expr são expressões quaisquer. Exemplo if(a>10 && 
a<20) 
 
3.6. Operador Condicional 
 O operador condicional (?:) é usado em expressões condicionais. Uma 
expressão condicional pode ter dois valores diferentes dependendo de uma 
condição de controle. 
Sintaxe: A sintaxe de uma expressão condicional é: 
condição ? expressão_1 : expressão_2 
onde expressão_1 e expressão_2 são duas expressões quaisquer, e 
condição é uma expressão lógica que será avaliada primeiro. Se o valor de condição 
for 1, isto é, verdadeiro, então a expressão condicional assumirá o valor de 
expressão_1. Caso contrario assumirá o valor de expressão_2. Uma expressão 
condicional é equivalente a uma estrutura de decisão simples. 
Exemplo: Observe as expressões condicionais abaixo e verifique o resultado 
de sua avaliação. Admita que i, j e k são variáveis tipo int com valores 1, 2 e 3, 
respectivamente. 
Expressão Valor 
i ? j : k 2 
j > i ? ++k : --k 4 
k == i && k != j ? i + j : i - j -1 
i > k ? i : k 3 
 
 
51 
 
 
4. A estrutura básica de um programa em C/ C++ 
Um programa em C/ C++ consiste de uma ou mais funções. Abaixo segue um 
programa do que se pode chamar de o menor programa possível: 
void main() 
{ 
} 
A função que compõe este programa é chamada main. Os parênteses após o 
nome indicam que esta é uma função. A função main deve estar presente em 
qualquer programa na linguagem C e é a primeira função a ser executada. Se um 
programa tiver apenas uma função, ela deverá receber o nome main. 
As chaves de abertura “{“ e fechamento “}” devem compor o início e o fim do 
programa, respectivamente. 
 
5. Montando o primeiro programa 
Em vez de montar um programa vazio, como o apresentado acima, vamos 
adicionar uma instrução para que o programa faça algo. 
 
Após compilar e rodar o programa acima, a seguinte mensagem será exibida 
na tela: Ola Mundo! 
 
5.1. Análises sobre o 1º programa 
Sempre que uma função for utilizada, deve-se incluir a biblioteca que a contém. No 
exemplo acima, a função printf() é uma função do tipo saída de dados e, para ser 
executada, a linha #include <stdio.h> foi adicionada ao início do programa. O 
arquivo stdio.h possui declarações de funções úteis para entrada e saída de dados 
(std vem do inglês standard, e io vem de Input/Output, portanto significa entrada e 
saída padronizadas). Já a biblioteca stdlib.h inclui a função system(), que é 
responsável por executar comandos internos do sistema operacional ou um 
#include <stdio.h> 
#include <stdlib.h> 
int main() { 
printf("Ola Mundo!!!\n\n\n"); 
system("PAUSE"); 
return 0; 
} 
 
 
52 
 
programa (.EXE, .COM ou .BAT). Em nosso programa estamos executando o 
comando PAUSE. 
Sempre que um programa for escrito, é importante escrever comentários a 
respeito do que esperamos que aconteça em cada parte do programa. Comentários 
iniciam-se por /* e terminam em */. Sempre que o compilador encontrar esse 
comando, ele desconsiderará tudo que estiver depois dele. Um comentário pode, 
inclusive, ter várias linhas. 
A linha void main() define uma função de nome main. A palavra void indica 
que esta função não retorna nenhum valor. O conteúdo das chaves { } será 
executado de forma sequencial. 
O primeiro comando inserido nesse código é a função printf(), que possui o 
argumento “Ola Mundo!” A função do printf() é para imprimir um argumento na tela. 
Neste caso, o \n inserido na função printf() é a constante especial chamada de 
constante barra invertida. Essa constante é interpretada como uma mudança de 
linha e não é impressa na tela. O comando system(“PAUSE”) congela a tela com a 
impressão realizada. 
É extremamente importante notar que todos os comandos em C terminam em 
ponto e vírgula (;). 
 
 
 
 
53Aula 13: Comandos de entrada e saída de dados 
Objetivo: Compreender todo o uso da função scanf(), printf() e sprintf(), e ser capaz 
de ler informações do teclado e imprimir na tela, utilizando formatos pré-existentes. 
Na aula anterior foi explorado um pouco das funções printf(). Agora serão 
passados argumentos indispensáveis no uso destas funções. 
 
1. Função printf() 
A Tabela 1 apresenta como algumas funções ou caracteres especiais são 
passadas para a função printf(), por exemplo, se uma nova linha deve ser impressa 
na tela, então o argumento de printf() deve ser “\n”. 
Tabela 1 - Lista de códigos para se inserir os caracteres informados. 
Código printf() Significado 
\n Nova linha 
\r Retorno do cursor 
\t Tabulação 
\b Retrocesso 
\” Aspas 
\\ Barra 
\f Salta página de formulário 
\0 Nulo 
 
A Tabela 2 apresenta os códigos para impressão de dados formatada. 
Tabela 2 - Códigos de impressão formatada. 
Código printf() Formato 
%c Caractere simples. 
%d Decimal. 
%e Notação científica. 
%f Ponto flutuante. 
%g Opta pelo mais curto entre %e ou %f. 
%o Octal. 
%s Cadeia de caracteres. 
%u Decimal sem sinal. 
%x Hexadecimal. 
%ld Decimal longo. 
%lf Ponto flutuante longo (double). 
 
O programa a seguir exemplifica o uso das formatações acima. 
 
 
54 
 
 
 
Como já foi apresentado, a função prinft() utiliza o percentual (%) para 
identificar o formato da impressão. Para que o percentual seja realmente impresso 
na tela, deve-se digitar %%. Dessa forma, o compilador entenderá que o que se 
quer imprimir realmente é o caractere, e não um formato. 
O uso do printf() também permite estabelecer o tamanho mínimo para a 
impressão de um campo. Por exemplo, a saída do código: 
 
é: 
 
Pode-se também utilizar o tamanho do campo para obter precisão e 
arredondamento em ponto flutuante: 
 
é: 
#include <stdio.h> 
#include <stdlib.h> 
int main () 
{ 
 printf ("%4.2f\n",345.57); 
 printf ("%3.1f\n",345.57); 
 printf ("%7.1f",345.57); 
 system ("PAUSE"); 
} 
O numero correto e 100. 
O numero correto e 100. 
O numero correto e 100. 
#include <stdio.h> 
#include <stdlib.h> 
int main () 
{ 
 printf ("O numero correto e %2d.",100); 
 printf ("O numero correto e %4d.",100); 
 printf ("O numero correto e %5d.",100); 
 system ("PAUSE"); 
} 
#include <stdio.h> 
#include <stdlib.h> 
int main () 
{ 
printf ("A letra %c ",’j’); 
printf ("pronuncia-se %s.", "jota"); 
printf ("\nPara se imprimir uma barra invertida (\\) é necessário 
digitar duas barras."); 
system ("PAUSE"); 
} 
 
 
55 
 
 
 
2. Função scanf() 
A função scanf() é utilizada para fazer a leitura de dados através do teclado e 
utiliza o percentual (%) para identificar o formato da entrada de dados para a 
variável. Uma outro ponto que mão deve passar desapercebido, é o emprego do (&) 
antes da variável que esta sendo atribuído o valor na leitura. Veja o exemplo a 
seguir: 
 
 Como pode ser observado no exemplo, no comando scanf temos dentro das 
aspas a atribuição do tipo de dados que esta sendo lindo e em seguida, antes da 
variável existe o operador &. Este uso é obrigatório e serve para alocar um endereço 
na memória RAM do computador, pois uma variável em C deve sempre estar 
alocada em um endereço da memória do computador. Outro detalhe importante a 
respeito deste programa é o emprego do comando fflush(stdin) após a leitura da 
variável do tipo texto. Isso se faz necessário para a limpeza do buffer do teclado que 
deve sempre ser realizada após a leitura de variáveis do tipo texto. Caso não tenha 
o emprego deste comando pode ocorrer falha nas próximas leituras ou escritas na 
tela. 
 
3. Função sprintf() 
#include <stdio.h> 
#include <stdlib.h> 
int main () 
{ 
 int x; 
 char nome[50]; 
 printf ("Digite o nome: "); 
 scanf("%s", &nome); 
 fflush(stdin); 
 printf ("Digite um numero qualquer: "); 
 scanf("%d", &x); 
 printf ("%s digitou o valor %d\n", nome, x); 
 system ("PAUSE"); 
} 
345.57 
345.6 
345.6 
 
 
56 
 
A função sprintf é utilizada para imprimir em uma variável do tipo string 
(cadeia de caracteres, ou vetor de caracteres) na linguagem C. Com o uso deste 
comando é possível atribuir um valor qualquer a uma variável deste tipo sem usar a 
leitura via teclado. Veja o exemplo abaixo do uso da função sprintf na atribuição de 
um texto a uma variável qualquer. 
 
 Como pode ser observado no exemplo, no comando sprintf temos a variável 
no inicio do comando, depois do parênteses, logo em seguida um texto com 
formatação, e depois temos um texto para entrar no lugar da formatação (%s). 
 
4. Exemplo de uso das funções scanf e printf 
 
4.1. Análises sobre o programa 
Primeiramente são declaradas três variáveis do tipo float (ponto flutuante). A 
segunda linha imprime na tela uma mensagem para que seja inserido o 
comprimento da base do triângulo. 
Após a mensagem impressa, é necessário que alguma função leia o valor 
digitado. Esse papel é feito pela função scanf(), que guarda o valor na variável Base. 
A string “%f” informa à função que o dado de entrada será do tipo ponto flutuante. O 
#include <stdio.h> 
#include <stdlib.h> 
/* Cálculo da área de um triângulo. */ 
int main () 
{ 
 float Base, Altura, Area; //Declaracao de Variaveis 
 printf ("Entre com a base do triângulo em metros: "); 
 scanf ("%f”,&Base); //Entrada de Dados 
 printf ("Entre com a altura do triângulo em metros: "); 
 scanf ("%f",&Altura); //Entrada de Dados 
 Area=Base*Altura/2; /* Cálculo da área */ 
 printf ("\nBase:%f, altura:%f, área:%f m2.\n",Base, Altura, Area); 
 system ("PAUSE"); 
} 
#include <stdio.h> 
#include <stdlib.h> 
int main () 
{ 
 int numero=10; 
 char texto[50]; 
 sprintf(texto, "%s", "A UNINOVE e "); 
 printf("%s %d\n", texto, numero); 
 system ("PAUSE"); 
} 
 
 
57 
 
mesmo é feito para a entrada da altura do triângulo. É importante ressaltar a 
importância do uso do operador & na função scanf(). 
Mais tarde o uso desse operador ficará claro. Finalmente, a área é calculada 
e armazenada na variável Area. 
A impressão da área do triângulo fica a cargo novamente da função printf(). 
Note que é possível passar vários argumentos para essa função, separando-os por 
vírgulas. 
Para a entrada da base igual a dois e altura igual a cinco, o programa 
imprimirá na tela a mensagem: Um triângulo de base dois e altura cinco possui área 
de cinco metros quadrados. 
 
5. Exercícios 
Codifique os cinco exercícios da aula 5. 
 
 
 
 
58 
 
Aula 14: Comandos de decisão (Linguagem C) 
Objetivo: Compreender o uso dos comandos de decisão if, if-else e switch para 
montar programas mais complexos. 
Uma das mais importantes tarefas de um programa de computador é decidir o 
que deve ser executado. Os comandos de decisão permitem determinar qual ação 
será tomada baseada em um teste condicional. Isso significa que podemos 
selecionar entre ações alternativas, dependendo de critérios desenvolvidos no 
decorrer da execução do programa. 
A linguagem C oferece três comandos de decisão: 
If 
If-else 
Switch 
 
1. O comando if 
O comando if instrui o computador a tomar uma decisão simples. Veja o 
exemplo: 
 
 
O código acima imprime na tela o índice de massa corpórea (imc) e, caso o 
imc seja maior que 25, uma nova mensagem é impressa. 
 
 
 
 
/*Cálculo do IMC */ 
#include <stdio.h>#include <stdlib.h> 
int main(){ 
 float peso, altura, imc; 
 printf("Digite sua massa corpórea em kg: "); 
 scanf("%f", &peso); 
 printf("\nDigite sua altura em metros: "); 
 scanf("%f", &altura); 
 imc = peso / (altura * altura); 
 printf("\n\n\Seu imc é %f.",imc); 
 if( imc > 25) /* Toma uma decisão caso imc > 25 */ 
 printf("\n\n\nVocê precisa emagrecer!"); 
 system("PAUSE"); 
 return 0; 
} 
 
 
59 
 
1.1. Sintaxe do comando if 
O comando if consiste na palavra-chave if seguida de uma expressão de 
verificação entre parênteses. Caso a verificação seja verdadeira, a instrução é 
executada. 
Para que mais de uma instrução seja executada, é necessário o uso de 
chaves abrindo e fechando o bloco de execução. 
Veja a seguir: 
 
 
1.2. Comandos if encadeado 
Utilizar comandos if encadeados segue a mesma sintaxe dos comandos já 
apresentados. Veja o exemplo: 
 
O programa acima verifica se o caractere digitado é uma letra minúscula e, 
caso verdadeiro, imprime a frase “Você digitou uma letra minúscula”. 
 
1.3. O comando if-else 
Pode-se pensar no comando else como sendo um complemento do comando 
if. O comando if completo tem a seguinte forma geral: 
 
if (condição) 
 declaração_1; 
else 
 declaração_2; 
/* Exemplo de if encadeado */ 
#include <stdio.h> 
#include <stdlib.h> 
#include <conio.h> 
int main(){ 
 char ch; 
 printf("Digite uma letra de 'a' a 'z':"); 
 ch=getche(); 
 if(ch >= 'a') 
 if(ch <= 'z') 
 printf("\nVocê digitou uma letra minúscula.\n"); 
 system("PAUSE"); 
 return 0; 
} 
if (expressão de teste){ 
 Instrução 1; 
 Instrução 2; 
} 
 
 
60 
 
A execução do comando if-else pode ser resumida da seguinte forma: A 
condição é avaliada e, caso seja verdadeira a declaração 1 é executada. Se for 
falsa, a declaração 2 é executada. É importante não esquecer que, quando usamos 
a estrutura if-else, estamos garantindo que uma das duas declarações será 
executada. Nunca serão executadas as duas ou nenhuma delas. Veja o exemplo: 
 
Outro exemplo: 
O programa a seguir imprime um tabuleiro de xadrez utilizando caracteres 
gráficos: 
 
 
2. O comando switch 
A funcionalidade do comando switch é a de selecionar uma entre várias ações 
alternativas. Embora os mesmos testes possam ser executados por construções if-
else, muitas vezes são deselegantes. O comando switch tem um formato limpo e 
claro. 
/* Tabuleiro de xadrez */ 
#include <stdio.h> 
#include <stdlib.h> 
int main(){ 
 int lin, col; 
 system("cls");/* Limpa a tela */ 
 for(lin=1;lin<=8;lin++){ 
 for(col=1;col<=8;col++) 
 if((lin+col)%2==0) /* é número par? */ 
 printf("\xdb\xdb"); 
 else 
 printf(" "); 
 printf("\n"); 
 } 
 system("PAUSE"); 
 return 0; 
} 
#include <stdio.h> 
#include <stdlib.h> 
int main (){ 
 int num; 
 printf ("Digite um número inteiro qualquer: "); 
 scanf ("%d",&num); 
 if (num<10) 
 printf ("\n\nVocê digitou um número menor que 10!"); 
 else 
 printf ("\n\nVocê digitou um número maior que 10!"); 
 system("PAUSE"); 
 return 0; 
} 
 
 
61 
 
O comando switch consiste na palavra-chave switch seguida do nome de uma 
variável ou de um valor numérico constante entre parênteses. O corpo do comando 
é composto de vários casos a serem testados. 
A expressão entre parênteses após a palavra-chave switch determina para 
qual caso o comando será desviado. 
O corpo de cada caso pode conter qualquer quantidade de instruções sem a 
necessidade do uso de parênteses. Ao final de cada caso, normalmente usa-se o 
comando break. Se não for utilizado, todas as instruções a seguir serão executadas, 
mesmo não compreendendo o mesmo caso. Veja o exemplo: 
 
 
Se o rótulo de um caso for igual ao valor da expressão do switch, a execução 
começará nele. Se nenhum caso for satisfeito e existir um caso default (padrão), a 
execução começará nele. Um caso default é opcional. Não pode haver casos com 
rótulos iguais. 
O exemplo a seguir utiliza o comando switch para determinar qual dia da 
semana uma respectiva data representa. 
switch (variável ou constante) 
{ 
 case constante1: 
 Instrução 1; 
 Instrução 2; 
 ... 
 Instrução n – 1; 
 Instrução n; 
 Break; 
 case constante2: 
 Instrução 1; 
 Instrução 2; 
 ... 
 Instrução n – 1; 
 Instrução n; 
 Break; 
 default: 
 Instrução 1; 
Instrução 2; 
... 
Instrução n – 1; 
Instrução n; 
} 
 
 
 
62 
 
 
 
3. Exercícios 
Codifique exercícios da aula 7. 
 
 
/* Imprime o dia da semana a partir de uma data */ 
#include <stdio.h> 
#include <stdlib.h> 
#include <conio.h> /* para getch()*/ 
int main(){ 
 int dia, mes, ano, dSemana; 
 printf("Digite a data na forma dd/mm/aaaa: "); 
 scanf("%d%*c%d%*c%d",&dia, &mes, &ano); 
 dSemana = ano + dia + 3 * (mes - 1) - 1; 
 if( mes < 3) 
 ano--; 
 else 
 dSemana -= (int)(0.4*mes+2.3); 
 dSemana += (int)(ano/4) - (int)((ano/100 + 1)*0.75); 
 dSemana %= 7; 
 switch(dSemana){ 
 case 0: 
 printf("Domingo"); break; 
 case 1: 
 printf("Segunda-feira"); break; 
 case 2: 
 printf("Terca-feira"); break; 
 case 3: 
 printf("Quarta-feira"); break; 
 case 4: 
 printf("Quinta-feira"); break; 
 case 5: 
 printf("Sexta-feira"); break; 
 case 6: 
 printf("Sabado"); 
 } 
 system("PAUSE"); 
 return 0; 
} 
 
 
63 
 
Aula 15: Laços de Repetição (Linguagem C) 
Objetivo: Entender como um programa executa diversas vezes a mesma instrução e 
quais são suas utilidades. Nesta aula o laço ensinado será o laço for. 
Laços são comandos utilizados para repetir instruções, enquanto uma 
determinada condição for satisfeita. Em C existem três tipos de laços: 
 
a) for 
b) while 
c) do-while 
 
Nesta aula, apenas o laço for será abordado. 
 
1. O laço for 
O laço for é geralmente utilizado quando uma instrução deve ser repetida um 
número fixo de vezes. Isso significa que seu uso é válido quando se sabe de 
antemão a quantidade de vezes que a instrução deve ser repetida. 
Porém existe a possibilidade de colocar uma verificação dentro do laço for e 
sair da execução assim que uma condição for atingida, para tal, usa-se o comando 
break. 
Exemplo de uma execução sem interrupção condicional: 
 
 
A saída do programa acima é: (********************) 
 
Veja agora um exemplo de uma execução com uma interrupção condicional, 
no caso foi adicionado um verificador se o contador (i) é igual a 5, ou seja, o 
programa irá imprimir apenas seis asteriscos como resposta (******). 
/* Exemplo do uso do laço for */ 
#include <stdio.h> 
#include <stdlib.h> 
int main() 
{ 
 int i; 
 for (i=0; i<20; i++) 
 printf("%c",'*'); 
 printf("\n"); 
 system("PAUSE"); 
 return 0; 
} 
 
 
64 
 
 
 
1.1. Sintaxe do laço for 
A sintaxe do comando for consiste da palavra-chave ser seguida de 
parênteses que contêm três expressões separadas por ponto e vírgulas (;). A 
primeira expressão é chamada de inicialização, a segunda deteste e a terceira de 
incremento. 
A inicialização é uma instrução de atribuição (i=0). 
O teste é uma condição lógica avaliada como verdadeira ou falsa, fazendo o 
controle de quantas vezes a instrução será repetida (i<20). 
O incremento define como a variável de controle será alterada cada vez que o 
laço for repetido (i++). Esta instrução sempre é executada após a execução do corpo 
do laço. 
No exemplo da impressão dos asteriscos, o laço for é executado 20 vezes. Na 
primeira vez, a variável i recebe o valor zero. Na última vez, i vale 19. Em seguida, i 
passa a valer 20 e o teste lógico é falso, o que ocasiona o término do laço. Veja 
outro exemplo, agora exibindo a tabuada do 6: 
 
/* Imprime a tabuada do 6 */ 
#include <stdio.h> 
#include <stdlib.h> 
int main() 
{ 
 int i; 
 for (i=1; i<=10; i++) 
 printf("\n%2d x 6 = %2d", i, i * 6); 
 printf("\n"); 
 system("PAUSE"); 
 return 0; 
} 
/* Exemplo do uso do laço for */ 
#include <stdio.h> 
#include <stdlib.h> 
int main() 
{ 
 int i; 
 for (i=0; i<20; i++){ 
 printf("%c",'*'); 
 if (i==5) break; 
 } 
 printf("\n"); 
 system("PAUSE"); 
 return 0; 
} 
 
 
65 
 
A saída do exemplo acima é: 
 1 x 6 = 6 
 2 x 6 = 12 
 3 x 6 = 18 
 4 x 6 = 24 
 5 x 6 = 30 
 6 x 6 = 36 
 7 x 6 = 42 
 8 x 6 = 48 
 9 x 6 = 54 
 10 x 6 = 60 
 
1.2. Múltiplas instruções dentro do corpo de um laço for 
Até o momento, vimos a execução de apenas uma instrução em um laço for. 
Entretanto, esse comando pode executar diversas instruções. Para tanto, deve-se 
utilizar todas as instruções a serem executadas entre chaves. Sintaxe: 
 
 
1.3. Laço for encadeado 
Um laço for está encadeado (anilhado) quando ele está posicionado dentro do 
bloco de outro laço for. Observe o exemplo: 
 
 
/* Imprime as tabuadas do 2 ao 9 */ 
#include <stdio.h> 
#include <stdlib.h> 
int main() 
{ 
 int i, j, k; 
 for (k=0; k<=1; k++){ 
 printf("\n"); 
 for (i=1; i<=4; i++) 
 printf("TABUADA DO %3d ", i+4*k+1); 
 printf("\n"); 
 for (i = 1; i<=9; i++){ 
 for (j=2+4*k; j <=5+4*k; j++) 
 printf("%3d x%3d = %3d ",j,i,j*i); 
 printf("\n"); 
 } 
 } 
 system("PAUSE"); 
 return 0; 
} 
 for (i=0; i<10; i++) { 
 Instrução 1; 
 Instrução 2; 
 ............ 
 Instrução n; 
 } 
 
 
66 
 
O laço for mais externo (da variável k) é executado duas vezes: uma para 
imprimir o primeiro bloco de tabuadas (de 2 a 5); e outra, para imprimir o segundo 
bloco (de 6 a 9). 
O segundo laço for imprime os títulos. Os dois laços mais internos imprimem 
as tabuadas propriamente ditas. 
Programe o código acima e visualize o resultado. 
Em C, quando uma variável é declarada dentro de um bloco, ela só será 
visível dentro deste bloco. Exemplo: 
 
O programa apresentado acima possui a variável nota definida como ponto 
flutuante dentro do corpo do laço for, portanto, existe apenas dentro desse laço. 
 
2. Exercícios 
Codifique os exercícios 1, 2, 6, 7, 8, 11 e 13 da aula 9. 
 
 
/*Imprime a média aritmética de 10 notas */ 
#include <stdlib.h> 
#include <stdio.h> 
int main(){ 
 float soma = 0.0; 
 int max = 10; 
 int i; 
 for (i=0;i<max;i++){ 
 float nota; 
 printf("\nDigite a nota %d : ", i + 1); 
 scanf("%f", &nota); 
 soma = soma + nota; 
 } 
 printf("\nMédia = %.2f\n", soma/max); 
 system("PAUSE"); 
 return 0; 
} 
 
 
67 
 
Aula 16: Laços de Repetição 
Objetivo: Entender como um programa executa diversas vezes a mesma instrução e 
quais são suas utilidades. Os laços ensinados serão os laços while e do-while. 
 
1. O Laço while 
O segundo comando de laço em C é o while. While, do inglês, significa 
enquanto. De uma maneira geral, as instruções no corpo de um while são 
executadas enquanto as condições testadas são válidas. O laço while possui os 
mesmos argumentos de um laço for, porém, são distribuídos ao longo do corpo do 
comando. 
Utilizamos o laço while quando o laço pode ser terminado inesperadamente, 
por condições desenvolvidas dentro do corpo do laço. Veja o exemplo: 
 
 
Podemos ver que a estrutura do while testa uma condição. Se ela for 
verdadeira, a declaração é executada e o teste é feito novamente, e assim por 
diante. 
O programa acima faz a leitura dos caracteres digitados. Se a letra “u” for 
pressionada, o programa é encerrado. Note que, diferentemente do for, em um laço 
while não conhecemos de antemão a quantidade de iterações que serão 
executadas. Nesse caso, o laço while é mais apropriado que o laço for. 
 
1.1. Sintaxe do laço while 
O comando while consiste na palavra-chave while seguida de uma expressão 
de teste entre parênteses. Se o teste realizado for verdadeiro, o corpo do while será 
#include <stdio.h> 
#include <stdlib.h> 
#include <conio.h> 
 
int main (){ 
 char Ch; 
 Ch='\0'; 
 while (Ch!='u'){ 
 Ch = getch(); 
 } 
 printf("A letra u foi pressionada. Fim de programa."); 
 system("PAUSE"); 
 return 0; 
} 
 
 
68 
 
executado. É feito então um novo teste, sendo o corpo do while executado caso o 
teste retorne verdadeiro novamente. 
De uma forma geral, o laço for pode ser substituído da seguinte maneira: 
 
Na aula passada, uma sequência de 20 asteriscos foi impressa com o auxílio 
da função for. Agora veja a mesma impressão com o uso da função while: 
 
 
 
1.2. O laço while encadeado 
Uma das instruções do corpo de um laço while pode ser outro laço while, o 
que caracteriza o encadeamento de funções. Exemplo: 
 
/* Exemplo do uso de comandos while encadeados */ 
/* Programa de adivinhação */ 
#include <stdio.h> 
#include <stdlib.h> /* para system() e rand() */ 
#include <conio.h> /* para getch() */ 
int main(){ 
 char ch='s'; /* s de sim */ 
 char resp; /* resposta do usuário */ 
 char secreto; 
 int tentativas; 
 while(ch=='s'){ 
 secreto = rand() % 26 + 'a'; 
 tentativas = 1; 
 printf("\n\nDigite uma letra entre 'a' e 'z':\n"); 
 while((resp=getch())!= secreto){ 
 printf("%c é incorreto. Tente novamente\n",resp); 
 tentativas++; 
 } 
 printf("%c É CORRETO!!\n", resp); 
 printf("Voce acertou em %d tentativas\n", tentativas); 
#include <stdio.h> 
#include <stdlib.h> 
int main(){ 
 int i = 0; 
 while (i<20){ 
 printf("%c", '*'); 
 i++; 
 } 
 printf("\n"); 
 system("PAUSE"); 
 return 0; 
} 
while (Teste){ 
 Incremento; 
} 
 
 
69 
 
 
 
A função rand(), que utiliza a biblioteca stdlib.h, retorna um número inteiro 
aleatório. A expressão rand() % 26 resulta o resto da divisão do valor de rand() por 
26. O resultado é um número entre 0 e 25. A esse número é somado o caractere a 
para gerar uma letra minúscula aleatória. 
Codifique o programa acima e faça os testes. 
 
2. O Laço do-while 
O terceiro e último comando de laço em C é o laço do-while. De uma forma 
geral, a sua sintaxe é: 
 
Mesmo que a declaração seja apenas uma instrução, mesmo que 
desnecessário, é uma boa prática manter as chaves para melhorar o entendimento 
desse comando. Note que, ao final do comando, há um ponto e vírgula, que é 
obrigatório. 
Pela análise do bloco acima, épossível notar que a estrutura do-while 
executa a declaração, testa a condição e, caso verdadeiro, volta para a declaração. 
A importância do comando do-while é que ele, ao contrário do for e do while, garante 
que a declaração será executada pelo menos uma vez. 
Um bom uso do comando do-while é em menus, nos quais é necessário 
garantir que o valor digitado pelo usuário seja válido. 
O exemplo, a seguir, faz uso do laço do-while no programa de adivinhação 
apresentado nesta mesma aula: 
do{ 
 Incremento; 
} while (Teste); 
 printf("\nQuer jogar novamente? (s/n): "); 
 ch=getche(); 
 } 
 printf("\nAté logo e boa sorte!\n"); 
 system("PAUSE"); 
 return 0; 
} 
 
 
70 
 
 
 
3. Exercícios 
Codifique os exercícios 3, 4, 5, 9, 10 e 12 da aula 9. 
 
 
/* Exemplo do uso de comandos while aninhados */ 
/* Programa de adivinhação */ 
#include <stdio.h> 
#include <stdlib.h> /* para system() e rand() */ 
#include <conio.h> /* para getch() */ 
int main(){ 
 char ch='s'; /* s de sim */ 
 char resp; /* resposta do usuário */ 
 char secreto; 
 int tentativas; 
 do{ 
 secreto = rand() % 26 + 'a'; 
 tentativas = 1; 
 printf("\n\nDigite uma letra entre 'a' e 'z':\n"); 
 while((resp=getch())!= secreto){ 
 printf("%c é incorreto. Tente novamente\n",resp); 
 tentativas++; 
 } 
 printf("%c É CORRETO!!\n", resp); 
 printf("Voce acertou em %d tentativas\n", tentativas); 
 printf("\nQuer jogar novamente? (s/n): "); 
 ch=getche(); 
 } while(ch=='s'); 
 printf("\nAté logo e boa sorte!\n"); 
 system("PAUSE"); 
 return 0; 
} 
 
 
71 
 
Aula 17: Funções 
Objetivo: Ao final desta aula o aluno deverá estar apto a escrever funções que o 
auxiliem na montagem de programas mais longos. 
Uma função é um conjunto de instruções em um bloco à parte da função 
principal (main), referenciada no programa principal pelo seu nome seguido de (). A 
principal vantagem de utilizar funções é, além de deixar o programa mais claro, 
permitir que outros programas acessem a função criada evitando sempre o 
recomeço. 
Ao longo das últimas aulas utilizamos diversas funções previamente 
armazenadas, por exemplo, a função getch() que armazena o caractere digitado. Se 
toda vez o programador que quisesse armazenar o caractere digitado tivesse que 
montar um programa, o código final seria imenso. Isso nos dá outra vantagem: a 
existência de funções evita que o programador tenha de escrever o mesmo código 
repetidas vezes. 
Qualquer sequência de instruções que apareça mais de uma vez no programa 
é candidata a ser uma função. O código de uma função é agregado ao programa 
uma única vez e pode ser executado muitas vezes no decorrer do programa. O 
grande princípio das linguagens estruturadas é o de dividir um programa em 
funções. 
 
1. Chamando uma função 
Chamar uma função é similar a uma terceirização de serviço: ao invocar a 
função, deve-se passar alguns parâmetros para que o retorno seja o esperado. 
Desta forma, quando um programa encontra uma função, o desvio do controle é feito 
para a função e o seu retorno ocorre na linha subsequente à linha a qual houve a 
chamada. Considere o exemplo a seguir: 
 
 
#include <stdio.h> 
#include <stdlib.h> 
int main(){ 
 int n; 
 printf ("Digite um numero: "); 
 scanf ("%d", &n); 
 printf ("O numero elevado ao cubo e %d.\n",(n*n*n)); 
 system ("PAUSE"); return 0; 
} 
 
 
72 
 
O simples código acima possui quatro chamadas às funções previamente 
programadas: duas vezes a printf(), uma vez a scanf() e uma vez a system(). 
Podemos criar quaisquer funções que sejam úteis para nós mesmos. A 
sintaxe da instrução da chamada a uma função é a mesma tanto para funções 
escritas por outros programadores como para as que escrevemos. 
 
1.1. Funções simples 
Todo programa contém no mínimo uma função, sendo que a função main() 
deve estar presente em todos eles. A execução de um programa sempre começa na 
função main, sendo o seu controle desviado para outra função sempre que há uma 
chamada a outra função no corpo da função principal. Veja o exemplo a seguir: 
 
O exemplo numero_ao_cubo.cpp utiliza uma função simples para elevar um 
número ao cubo. Note que a chamada a essa função está dentro de uma outra 
função, o que é totalmente normal. A função é chamada dentro do printf(), então, o 
controle é desviado para a função cubo(), em que cálculo é feito. O retorno ocorre e 
o resultado é impresso na tela. 
Os componentes necessários para adicionar uma função a um programa são: 
o protótipo da função, a chamada à função e a definição desta. 
O comando return termina a execução da função e retorna o controle para a 
instrução seguinte do código de chamada. 
/* Exemplo numero_ao_cubo.cpp */ 
/* Exemplo do uso de funções */ 
#include <stdio.h> 
#include <stdlib.h> 
int cubo(int n); /* Protótipo ou declaração da função */ 
int main(){ 
 int n, a; 
 printf ("Digite um numero inteiro: "); 
 scanf("%d", &n); 
 a = cubo(n); /* Chamada à função */ 
 printf ("O numero elevado ao cubo e %d.\n",a); 
 system ("PAUSE"); 
 return 0; 
} 
/* Definição da função */ 
int cubo(int n){ 
 int c; 
 c = n*n*n; 
 return c; 
} 
 
 
73 
 
1.2. O protótipo da função 
Uma função deve sempre ser declarada antes de ter sido chamada. A 
declaração de uma função é o que chamamos de protótipo da função. O protótipo da 
função permite que o compilador verifique a sintaxe de chamada à função. 
O exemplo dado pelo programa numero_ao_cubo.cpp declara a função na 
instrução: 
 
 Essa declaração informa que a função de nome cubo() é do tipo int e recebe 
como argumento um valor int. 
 
1.3. A definição de uma função 
O código C que descreve o que a função faz é denominado definição da 
função. Sua forma geral é a seguinte: 
 
A primeira linha é o cabeçalho da definição da função, e tudo o que estiver 
entre as chaves constitui o corpo da definição da função. A definição de qualquer 
função C começa com o nome do tipo da função, o mesmo de seu protótipo. 
 
1.4. Passando vários argumentos para uma função 
Se vários argumentos são solicitados, eles podem ser passados entre os 
parênteses na chamada à função, separados por vírgulas. Uma função pode receber 
quantos argumentos forem necessários, porém sempre retornará apenas um valor. 
A seguir, vemos o exemplo de um programa que passa dois argumentos para 
a função retangulo(), cujo propósito é desenhar retângulos de vários tamanhos na 
tela. Os dois argumentos são a largura e a altura do retângulo; cada retângulo 
representa um cômodo de uma casa. 
tipo nome (declaração dos parâmetros) 
{ 
 instruções; 
} 
int cubo(int n); /* Protótipo ou declaração da função */ 
 
 
74 
 
 
 
 
1.5. Chamadas a funções usadas como argumentos de outras funções 
Uma função pode ser utilizada numa expressão da mesma forma que 
utilizamos valores numéricos e variáveis. Podemos também utilizar a chamada a 
uma função como argumento para outra função. O exemplo a seguir é a modificação 
do programa numero_ao_cubo.cpp visto na última aula. 
 
/* Exemplo do uso de funções dentro de funções */ 
#include <stdio.h> 
#include <stdlib.h> 
int cubo(int n); /* Protótipo ou declaração da função */ 
int main(){ 
 int n; 
 printf ("Digite um numero inteiro: "); 
 scanf ("%d", &n); 
 printf ("O numero elevado ao cubo e %d.\n", cubo(n)); 
 system ("PAUSE");return 0; 
} 
#include <stdio.h> 
#include <stdlib.h> 
void retangulo(int, int); 
int main(){ 
 printf("Sala\n"); 
 retangulo(22,12); 
 printf("Cozinha\n"); 
 retangulo(16,16); 
 printf("Banheiro\n"); 
 retangulo(6,8); 
 printf("Quarto\n"); 
 retangulo(12,12); 
 printf("\n"); 
 system("PAUSE"); 
 return 0; 
} 
/* retangulo() */ 
/* Desenha um retângulo na tela */ 
void retangulo(int largura, int altura){ 
 int j, k; 
 largura /= 2; 
 altura /= 4; 
 for (j=1; j<= altura; j++){ 
 printf("\t\t"); 
 for (k=1; k <= largura; k++) 
 printf("\xDB"); 
 printf("\n"); 
 } 
} 
 
 
75 
 
 
Note que a função cubo() está sendo chamada dentro da função printf(). 
Nesse caso, não há o armazenamento do retorno da função cubo(), pois ela é 
simplesmente impressa na tela. 
 
2. Macros 
Na linguagem C há um pré-processador que nada mais é do que um 
programa que examina o código e executa algumas modificações antes da 
compilação, com base em instruções chamadas diretivas. As diretivas devem fazer 
parte do texto-fonte que criamos, mas não farão parte do programa após compilado; 
elas são retiradas do texto pelo pré-processador antes da compilação. 
Há uma série de diretivas que são reconhecidas pelo pré-processador, como 
a #include que já conhecemos. Agora a #define será apresentada. 
 
2.1. A diretiva #define 
A diretiva #define, na sua forma mais simples, é usada para definir constantes 
com nomes apropriados. 
 
Quando o compilador encontra a diretiva #define, procura em cada linha 
abaixo dela a ocorrência da palavra PI e a substitui por 3,14. O nome que segue a 
#include <stdio.h> 
#include <stdlib.h> 
#define PI 3.14 
float area (float); 
int main(){ 
 float raio; 
 printf("Digite o raio de um circulo: "); 
 scanf("%f",&raio); 
 printf("\nA area do circulo e: %.2f\n\n", area(raio)); 
 system("PAUSE"); 
 return 0; 
} 
float area (float raio){ 
 return PI * raio * raio; 
} 
/* Definição da função */ 
int cubo(int n){ 
 int c; 
 c = n*n*n; 
 return c; 
} 
 
 
76 
 
palavra #define é chamado identificador. A frase escrita após o identificador é 
chamada texto. 
Por convenção, o identificador é sempre escrito em letras maiúsculas. 
Observe que não há pondo e vírgula após a diretiva do pré-processador. Cada 
diretiva deve ser escrita em uma nova linha. 
Por meio da diretiva #define, podemos definir mais do que apenas uma 
constante.Veja o exemplo: 
 Com a definição acima, onde for encontrada a palavra ERRO, haverá a 
substituição por printf(“\a\aERRO!!). 
 
2.2. Criação de macros 
A diretiva #define também pode ser utilizada para aceitar argumentos. A 
utilização de #define com este propósito é conhecida como macro. Veja o exemplo: 
 
Após o pré-processamento, nosso programa será o seguinte: 
 
#include <stdio.h> 
#include <stdlib.h> 
int main() { 
 int n1, n2; 
 n1 = 1416; 
 n2 = n1 / 2; 
 printf("%.2f\n", (float)n1); 
 printf("%.2f\n", (float)n2); 
 system("PAUSE"); 
 return 0; 
} 
#include <stdio.h> 
#include <stdlib.h> 
#define PRN(n) printf("%.2f\n", (float)n) 
int main(){ 
 int n1, n2; 
 n1 = 1416; 
 n2 = n1 / 2; 
 PRN(n1); 
 PRN(n2); 
 system("PAUSE"); 
 return 0; 
} 
#define ERRO printf(“\a\aERRO!!) 
 ... 
if (x) 
 ERRO; 
 ... 
 
 
77 
 
 
 
 
78 
 
Aula 18: O uso de Caracteres gráficos 
Objetivo: Compreender como utilizar os caracteres da tabela ASCII e obter qualquer 
tipo de caractere por meio de códigos. 
 
1. O uso de Caracteres gráficos 
Um computador representa todo caractere, podendo ser ele uma letra, um 
número ou um caractere de pontuação, sempre por um número. O código ASCII 
dispõe de números de 0 a 127 abrangendo letras, dígitos entre 0 e 9, caracteres de 
pontuação e caracteres de controle como salto de linha, tabulação etc. 
Os microcomputadores usam 128 caracteres adicionais, com códigos ASCII 
de 128 a 255, que consistem em símbolos de línguas estrangeiras e caracteres 
gráficos. 
Caracteres gráficos requerem outra maneira de escrita para serem impressos. 
A forma de representar um caractere de código acima de 127 é \xdd, em que dd 
representa o código do caractere na base hexadecimal. Para que a impressão seja 
realizada corretamente, \xdd deve estar entre aspas duplas. 
 
1.1. Imprimindo caracteres gráficos 
Veja o exemplo a seguir: 
 
A saída do código acima está apresentada na Figura 1: 
 
Figura 1 - Impressão de um carrinho utilizando caracteres gráficos. 
#include <stdio.h> 
#include <stdlib.h> 
int main() { 
 system("cls"); /* Limpa a tela */ 
 printf("\n\n"); 
 printf("\n\t\xDC\xDC\xDB\xDB\xDB\xDB\xDC\xDC"); 
 printf("\n\t\xDFO\xDF\xDF\xDF\xDFO\xDF\n\n"); 
 system("PAUSE"); 
 return 0; 
} 
 
 
79 
 
Diversos outros tipos de caracteres gráficos podem ser impressos. Veja a 
seguir: 
Código Caractere 
\xDF ▀ 
\xDC ▄ 
\xDB █ 
\xCD ═ 
\xBA ║ 
\xC8 ╚ 
\xBC ╝ 
\xBB ╗ 
\xC9 ╔ 
Figura 2 - Tabela de Caracteres Gráficos. 
 
 
1.2. Como obter os caracteres do código ASCII 
Como dito anteriormente, todo caractere é referenciado por um número nos 
computadores. Muitas vezes se torna útil saber que número uma determinada letra 
(ou tecla) representa. O código a seguir retorna o código ASCII da tecla digitada. 
 
 
 
 
 
 
 
 
#include <stdio.h> 
#include <stdlib.h> 
#include <conio.h> 
int main(){ 
 int c; 
 do{ 
 printf("Pressione uma tecla para obter o codigo ASCII: "); 
 c=getche(); 
 printf("\nO codigo ASCII da tecla pressionada e %d\n\n",c); 
 } while(c!=27); 
 system("PAUSE"); 
 return 0; 
} 
 
 
80 
 
Veja a tabela ASCII completa: 
 
 
 
81 
 
 
 
 
 
82 
 
Aula 19: Vetores 
Objetivo: Compreender como ocorre a declaração de vetores, seu uso, sua 
inicialização e quais as vantagens em relação às variáveis simples. 
Um vetor é uma coleção de variáveis de mesmo tipo que compartilham um 
mesmo nome. São frequentemente utilizados quando há a necessidade de cálculos 
que envolvem diversos valores ou retornam diversos resultados. 
 
1. O uso dos vetores 
Imagine o problema de calcular a média aritmética de cinco alunos. Um 
exemplo seria o dado a seguir: 
 
Com o código acima o problema estaria resolvido. Uma sala com apenas 
cinco alunos, porém, é quase impossível, não é verdade? Se a sala tiver 60 alunos, 
a tarefa já se torna mais complicada. 
Portanto, fica claro que é necessário encontrar uma maneira mais eficiente de 
abordar um problema desse tipo. Um vetor é o tipo de dado oferecido por C para 
esse propósito, pois é um conjunto de variáveis de mesmo tipo e referenciadas por 
um único nome. Cada variável é diferenciada por meio de um número chamado 
índice. Os colchetes são usados para conter o índice. 
Veja o novo código utilizando um vetor para calcular a média dos mesmos 
cinco alunos: 
#include <stdio.h> 
#include <stdlib.h> 
int main() { 
 int nota0, nota1, nota2, nota3, nota4; 
 float media; 
 printf("Digite a nota do aluno 1: "); 
 scanf("%d",&nota0); 
 printf("Digite a nota do aluno 2: "); 
 scanf("%d",&nota1); 
 printf("Digite a nota do aluno 3: "); 
 scanf("%d",&nota2); 
 printf("Digite a nota do aluno 4: "); 
 scanf("%d",&nota3); 
 printf("Digite a nota do aluno 5: ");scanf("%d",&nota4); 
 media = (nota0 + nota1 + nota2 + nota3 + nota4) / 5.0; 
 printf("Media das notas: %.2f\n",media); 
 system("PAUSE"); 
 return 0; 
} 
 
 
83 
 
 
 
1.1. Declaração de um vetor 
Assim como qualquer variável, um vetor também deve ser declarado. Dessa 
forma, o compilador pode reservar a quantia exata de memória que será necessária 
para que o programa funcione adequadamente. 
O que diferencia a declaração de uma matriz da de qualquer outra variável é 
a parte que acompanha seu nome, isto é, o par de colchetes ([ e ]) que envolve um 
número inteiro, indicando o tamanho do vetor. 
A instrução 
 
informa que o vetor nota é formado por cinco elementos do tipo int. Por definição, 
uma matriz é composta por elementos de um único tipo. 
 
1.2. Acessando os elementos de um vetor 
Como visto no código apresentado para o cálculo das médias utilizando um 
vetor, cada elemento do vetor pode ser acessado individualmente por um número 
inteiro, entre colchetes, após o nome da matriz. Quando se referencia um elemento, 
esse número tem um significado diferente daquele da declaração da matriz, o qual 
indica sua dimensão. Veja a seguir: 
 
atribui o valor 10 ao quarto elemento da matriz, pois a numeração sempre 
começa em zero. 
nota[3] = 10; 
int nota[5]; 
 
#include <stdio.h> 
#include <stdlib.h> 
int main(){ 
 int nota[5]; 
 int i; 
 float media = 0.0; 
 for (i=0; i<5; i++){ 
 printf("Digite a nota do aluno %d: ",i+1); 
 scanf("%d",&nota[i]); 
 media+=nota[i]; 
 } 
 media /= 5.0; 
 printf("Media das notas: %.2f\n",media); system("PAUSE"); 
 return 0; 
} 
 
 
84 
 
Quando escrevemos nota[i], estamos nos referindo a uma variável do tipo int 
como outra qualquer. Assim, em todo lugar em que o uso de uma variável do tipo int 
for necessária, podemos usar nota[i]. 
Apesar de termos definido a variável nota como sendo do tipo int, ela poderia 
ter sido definida como qualquer outro tipo de variável. 
Veja a seguir: 
 
Outro ponto importante é a inclusão da diretiva 
 
Usar #define no lugar de um número constante facilita a alteração do tamanho 
do vetor. Se o número de alunos for alterado de cinco para dez, pode-se facilmente 
fazer a alteração em uma única linha no código. 
 
1.3. Inicializando um vetor 
A inicialização de um vetor é similar à inicialização de uma variável qualquer, 
com a exceção de que temos de informar os valores das posições do vetor. 
Exemplo: 
 
A lista de valores é colocada entre chaves e os valores são separados por 
vírgulas. Eles são atribuídos na sequência em que são escritos, isto é, dmes[0] terá 
o valor inicial 31, dmes[1] terá o valor inicial 28 e assim por diante. 
int dmes[12] = {31,28,31,30,31,30,31,31,30,31,30,31}; 
#define TAMANHO 5 
#include <stdio.h> 
#include <stdlib.h> 
#define TAMANHO 5 
int main() { 
 float nota[TAMANHO], media = 0.0; 
 int i; 
 for (i=0; i<5; i++){ 
 printf("Digite a nota do aluno %d: ",i+1); 
 scanf("%f",&nota[i]); 
 media+=nota[i]; 
 } 
 media /= 5.0; 
 printf("Media das notas: %.2f\n",media); system("PAUSE"); 
 return 0; 
} 
 
 
85 
 
Se for informado uma quantidade menor de valores em relação ao tamanho 
do vetor, as posições restantes do vetor receberão o valor zero. Se for informado um 
valor maior, um erro será informado. 
 
2. Exercícios 
1) Desenvolva um pseudocódigo e seu respectivo código para fazer a leitura de dez 
números quaisquer, calcular e exibir a média destes números, a variância e o 
desvio padrão. 
Média: Somatória dos valores dividida pelo número de registros (10). 
Desvio: Diferença entre o valor e a média. 
Quadrado do desvio: O quadrado de cada valor de desvio. 
Variância: A soma dos quadrados dos desvios dividida pelo numero de registros. 
Desvio Padrão: Raiz quadrada da variância. 
n
i
xx
n
DesvPad
1
2)(
1
1 
 
 
 
 
86 
 
Aula 20: Matrizes 
Objetivo: Capacitar para trabalhar com matrizes, dado o acúmulo de conhecimento 
suficiente para declarar matrizes de diferentes dimensões e tipos, como inicializar 
matrizes, como referenciar um elemento particular da matriz e como passar uma 
matriz para uma função. 
Na aula passada foi apresentado o uso de vetores. Uma matriz pode ser 
definida como uma cadeia de vetores de mesmo tipo, ou seja, para ser uma matriz, 
a estrutura dela deve possuir ao menos 2 linhas e duas colunas de dados. Como 
veremos nesta aula, o estudo de matrizes é análogo ao de vetores. 
 
1. Definindo uma matriz 
Com dois pares de colchetes, obtemos uma matriz de duas dimensões e, com 
cada par de colchetes adicionais, obtemos matrizes com uma dimensão a mais. 
Um bom exemplo para o uso de uma matriz é a geração de jogos para a 
loteria. 
Veja o código a seguir: 
 
 
 
 
#include <stdio.h> 
#include <stdlib.h> 
#define JOGOS 20 
#define N 6 
// loteria.c 
// Imprime 20 combinações de jogos para a Sena 
int main(){ 
 int matriz[JOGOS][N], k, j; 
 for(k = 0; k < JOGOS; k++) 
 for(j=0; j < N; j++) 
 matriz[k][j] = rand()%60+1; 
 for(k=0; k < JOGOS; k++) 
 { 
 printf("Combinacao %2d: ",k+1); 
 for(j = 0; j < N; j++) 
 printf("%2d ",matriz[k][j]); 
 printf("\n"); 
 } 
 system("PAUSE"); 
 return 0; 
} 
 
 
87 
 
1.1. Inicialização de matrizes de duas dimensões 
Matrizes de duas dimensões são inicializadas da mesma forma que os 
vetores, isto é, os elementos são colocados entre as chaves depois do sinal de igual 
e separados por vírgulas. Como cada elemento de uma matriz de duas dimensões é 
por sua vez uma matriz, então, cada elemento deve estar entre chaves e os 
elementos internos devem ser separados por vírgulas. 
Veja o exemplo a seguir. 
 
 
1.2. Matrizes como argumentos de funções 
Até o momento vimos que quando uma função é chamada, devemos 
especificar quais variáveis serão transferidas para a função. As matrizes também 
podem ser passadas como argumento para uma função. 
Veja o programa a seguir: 
 
#include <stdio.h> 
#include <stdlib.h> 
void imprime(int[][3],int,int); 
int main() { 
int matriz[3][3] = {{1,2,3}, {2,3,4}, {3,3,5}}, i, k; 
 for (i=0;i<3;i++) 
 { 
 for (k=0;k<3;k++) 
 imprime(matriz,i,k); 
 printf("\n"); 
 } 
 system("PAUSE"); 
 return 0; 
} 
void imprime(int matriz[][3],int i,int k){ 
 printf("%d ",matriz[i][k]); 
} 
#include <stdio.h> 
#include <stdlib.h> 
int main() { 
int matriz[3][3] = {{1,2,3}, {2,3,4}, {3,3,5}}, i, k; 
 for (i=0;i<3;i++) 
 { 
 for (k=0;k<3;k++) 
 printf("%d ",matriz[i][k]); 
 printf("\n"); 
 } 
 system("PAUSE"); 
 return 0; 
} 
 
 
88 
 
O método de passagem de endereço da matriz para a função consiste em 
informar no protótipo o segundo elemento da matriz, ou seja, o elemento de colunas. 
Se esse elemento não for informado, será impossível saber onde estão os valores. 
Por que é feito dessa maneira? 
As matrizes são consideradas um tipo de dado bastante grande, pois são 
formadas por diversas variáveis. Por causa disso, em linguagem C, determina-se ser 
mais eficiente existir uma única cópia da matriz na memória, sendo, portanto, 
irrelevante o número de funções que a acessam. Assim, não são passados os 
valores contidos na matriz, somente o seu endereço de memória. 
Vetores são passados da mesma forma? Não, mas de uma forma muitosimilar. 
Veja o exemplo: 
 
Como a função usa o endereço para acessar os elementos da matriz original, 
significa que as alterações que a função efetuar nos elementos da matriz afetarão a 
matriz original. 
 
#include <stdio.h> 
#include <stdlib.h> 
#define TAMANHO 10 
void imprime(int[],int); 
int main() { 
int vetor[TAMANHO] = {1,2,3,4,5,6,7,8,9,10}, i; 
 for (i=0;i<TAMANHO;i++) 
 imprime(vetor,i); 
 printf("\n\n"); 
 system("PAUSE"); 
 return 0; 
} 
void imprime(int vetor[],int i){ 
 printf("%d ",vetor[i]); 
} 
 
 
89 
 
Referências 
DASGUPTA, Sanjoy; PAPADIMITRIOU, Christos; VAZIRANI, Umesh. Algoritmos. 
São Paulo: McGraw Hill, 2009. 
HEINEMAN, George T.; POLLICE, Gary; SELKOW, Stanley. Algoritmos: o guia 
essencial. Rio de Janeiro: Alta Books, 2009. 
MANZANO, André Luiz N. G.; MANZANO, Maria Izabel N. G. Estudo dirigido de 
informática básica. São Paulo: Érica, 2008. 
MANZANO, José Augusto N. G. Estudo dirigido de linguagem C. São Paulo: 
Érica, 2009. 
MANZANO, José Augusto N. G.; OLIVEIRA, Jayr Figueiredo de Oliveira. 
Algoritmos, Lógica para desenvolvimento de programação de computadores. 
São Paulo: Érica, 19 ed., 2006. 
MIZRAHI, Victorine Viviane. Treinamento em linguagem C. São Paulo: Pearson, 
2008. 2v. 
SCHILDT, Herbert. Mayer. C completo e total. São Paulo: Pearson, 2006. 
VILARIM, Gilvan. Algoritmos de programação para Iniciantes. São Paulo: Ciência 
Moderna, 2004.