Algoritmo I

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 linguagemespecifica. 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←b
2
-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 
entrada fornecidos 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çõesa 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 recebe o 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çãodo 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-se a 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, estaligada 
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 num 
 Se 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. 
 
http://www.prof2000.pt/users/famaral/ig/tlp/estruturas.htm
 
 
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çãode 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 1 a 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ésde 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 do arquivo, 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 chavereservadas. 
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 operadoresrelacionais. 
 
 
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 (;). 
 
 
 
 
53 
 
Aula 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