Livro - Algoritmos e Programação I

ALGORITIMOS E PROGRAMAÇÃO I
Algoritmos e programação I.indd 1 7/8/2013 16:00:32

Process Black
Conselho Editorial EAD
Dóris Cristina Gedrat
Thomas Heimman
Mara Salazar Machado
Andréa de Azevedo Eick
Astomiro Romais
Obra organizada pela Universidade Luterana do Brasil.

Informamos que é de inteira responsabilidade dos autores a
emissão de conceitos.
Nenhuma parte desta publicação poderá ser reproduzida por
qualquer meio ou forma sem a prévia autorização da Editora
da ULBRA.
A violação dos direitos autorais é crime estabelecido na Lei nº .610/98
e punido pelo Artigo 184 do Código Penal.
Dados Internacionais de Catalogação na Publicação (CIP)
I74a Isaia Filho, Eduardo.

Algoritimos e programação I / Eduardo Isaia Filho, Vanessa Lindemann. –
Canoas: Ed. ULBRA, 2013.
144p.
1. Algoritmo. 2. Programação. 3. Computação. 4. Informática.

I. Lindemann, Vanessa. II. Título.
CDU: 681.3.421.2
Setor de Processamento Técnico da Biblioteca Martinho Lutero - ULBRA/Canoas
ISBN 978-85-7528-510-7
Editoração: Roseli Menzen
Dados técnicos do livro

Fontes: Palatino Linotype, Franklin Gothic Demi Cond
Papel: o set 75g (miolo) e supremo 240g (capa)
Medidas: 15x22cm

Process Black
APRESENTAÇÃO
Prezado(a) aluno(a)
Seja bem-vindo(a) ao estudo da disciplina de Algoritmos e Programação I!

Esta disciplina introduz o aluno no universo da lógica de programação, de forma
que no final do semestre você estará capacitado a construir algoritmos. Para isso,
vamos estudar conceitos básicos como tipos de dados, variáveis, constantes,
operadores e expressões, formas de representação de algoritmos e, por fim,
estruturas de controle sequencial, de seleção e de repetição. A disciplina também
prevê uma introdução à linguagem de programação C, possibilitando que você
valide os algoritmos construídos durante o semestre.
Um algoritmo pode ser definido como uma sequência de passos que visam atingir
um objetivo. Algoritmos são comuns no nosso cotidiano como, por exemplo, uma
receita de bolo. Nela temos uma lista de ingredientes e uma sequência de passos que
devem ser seguidos para atingirmos o objetivo final: o bolo. Quando construímos
um algoritmo, devemos especificar ações claras e precisas, que a partir de um estado
inicial, após um período de tempo finito, produzem um estado final previsível e bem
definido. Isso significa que um algoritmo define um padrão de comportamento a
ser seguido visando resolver um problema, garantindo que sempre que executado,
sob as mesmas condições, produza o mesmo resultado.
O principal objetivo do estudo da lógica de programação é a construção de
algoritmos. Um algoritmo representa o raciocínio envolvido na lógica de
programação e, dessa forma, permite-nos abstrair detalhes computacionais
atrelados às linguagens de programação que podem ser acrescentados mais
tarde. Assim, podemos focar nossa atenção naquilo que é importante: a lógica
da construção de algoritmos. Vale lembrar que: uma vez concebida uma solução
algorítmica para um problema, esta pode ser traduzida para qualquer linguagem
de programação (processo denominado codificação).
O livro texto desta disciplina está organizado em dez capítulos, subdivididos
em seções, para facilitar sua leitura e compreensão e favorecer a realização das
atividades propostas ao final de cada capítulo.

Process Black
4
Só é possível aprender a construir algoritmos, construindo algoritmos! Portanto,

ULBRA – Educação a Distância
resolver os exercícios propostos no final de cada capítulo é fundamental para

desenvolver o raciocínio lógico e atingir o objetivo desta disciplina. A disciplina
possui conteúdos cumulativos, ou seja, no final do semestre ainda estaremos
utilizando conceitos estudados nas primeiras semanas de aula. Sendo assim, é
importante organizar o estudo, resolver os problemas propostos periodicamente
e não deixar as dúvidas para depois.
As referências bibliográficas sugerem obras de autores que fundamentam os
estudos realizados e oferecem a você possibilidades de aprofundamento com
leituras complementares.
Um bom trabalho!
Professora Vanessa Lindemann

Process Black
SOBRE O AUTOR
Eduardo Isaia Filho
Mestre, Coordenador dos Cursos de Computação da ULBRA unidade Canoas.

Professor titular da disciplina de Algoritmos e Programação I presencial.
Vanessa Lindemann
Mestre em Ciência da Computação - UFRGS - 2002; Doutora em Informática

na Educação - UFRGS - 2008. Professora dos cursos de Computação da ULBRA
Canoas.

Process Black
6

Process Black
SUMÁRIO
1 INTRODUÇÃO ............................................................................................................9
1.1 Conceito de algoritmo..........................................................................................9
1.2 Construção do algoritmo ....................................................................................10
1.3 Formas de representação de algoritmos..............................................................11
1.4 Estrutura básica de um algoritmo .......................................................................15
Atividades .............................................................................................................17
2 CONCEITOS FUNDAMENTAIS ....................................................................................19
2.1 Dados .............................................................................................................19
2.2 Variáveis ..........................................................................................................20
2.3 Constantes .......................................................................................................22
2.4 Expressões .......................................................................................................22
Atividades .............................................................................................................26
3 INSTRUÇÕES PRIMITIVAS ........................................................................................29
3.1 Instrução primitiva de atribuição ......................................................................29
3.2 Instrução primitiva de saída ..............................................................................32
3.3 Instrução primitiva de entrada ...........................................................................34
Atividades .............................................................................................................36
4 ESTRUTURA SEQUENCIAL ........................................................................................39
4.1 Estrutura básica de um algoritmo sequencial ......................................................39
4.2 Exemplo de um algoritmo com estrutura sequencial ............................................40
4.3 Construção de algoritmos sequenciais ...............................................................42
4.4 Teste de mesa de algoritmos com estrutura sequencial .......................................46
Atividades .............................................................................................................52
5 ESTRUTURA DE CONTROLE CONDICIONAL: SE ...........................................................53
5.1 Estrutura condicional SE simples........................................................................53
5.2 Estrutura condicional SE composta ....................................................................55
5.3 Estrutura condicional SE encadeada ..................................................................59
5.4 Formatação da solução do algoritmo ..................................................................65
Atividades .............................................................................................................66

Process Black
8
6 ESTRUTURA DE CONTROLE CONDICIONAL: ESCOLHA .................................................73

Atividades .............................................................................................................78
7 ESTRUTURA DE CONTROLE DE REPETIÇÃO: ENQUANTO ..............................................81
Atividades .............................................................................................................94
8 ESTRUTURA DE CONTROLE DE REPETIÇÃO: REPITA ....................................................99
Atividades ...........................................................................................................106
9 ESTRUTURA DE CONTROLE DE REPETIÇÃO: PARA.....................................................111
Atividades ...........................................................................................................117
10 INTRODUÇÃO À LINGUAGEM C ...............................................................................121
10.1 Identificadores ..............................................................................................122
10.2 Tipos de dados ..............................................................................................123
10.3 Modeladores .................................................................................................123
10.4 Declaração, inicialização e escopo de variáveis ...............................................124
10.5 Definição de constantes ................................................................................124
10.6 Códigos de formato .......................................................................................125
10.7 Caracteres especiais ....................................................................................127
10.8 Comando de atribuição .................................................................................127
10.9 Operadores e funções ....................................................................................128
10.10 Comentários................................................................................................130
10.11 Funções de entrada e saída ..........................................................................130
10.12 Estruturas de controle condicional ...............................................................131
10.13 Estruturas de controle de repetição .............................................................133
Atividades ...........................................................................................................137

Process Black
1
Eduardo Isaia Filho
INTRODUÇÃO
Um programa de computador é resultado da atividade intelectual de um

programador. Para isso, são necessários alguns conhecimentos prévios em
abstração, modelagem de problemas e lógica de programação. Todo programa
de computador começa a partir de um algoritmo, ou seja, através da organização
lógica das instruções que resolvem o problema. Neste capítulo, serão apresentados
os conceitos introdutórios para a construção de algoritmos, suas formas de
representação, seus métodos de construção e sua estrutura básica. Por fim, são
propostos alguns exercícios de fixação.
1.1 Conceito de algoritmo

Um algoritmo é uma sequência de passos finitos que visam solucionar um
determinado problema. Estamos acostumados a resolver algoritmos todos os
dias, mas os fazemos de forma tão automática que nem nos damos conta. Por
exemplo: trocar uma lâmpada, fazer um bolo, preparar um café passado, escovar
os dentes, trocar um pneu, entre outros. Todas as atividades do nosso dia a dia que
possuem uma sequência de passos para serem resolvidas podem ser consideradas
um algoritmo.
Se utilizarmos o exemplo do preparo de um café passado, teremos os seguintes
passos:
1° passo: reservar os utensílios filtro de café, chaleira e recipiente para colocar o
café passado;
2° passo: reservar o pó de café e a água;
3° passo: aquecer a água;

Process Black
10
4° passo: colocar o pó de café no filtro;

5° passo: despejar a água aquecida no filtro.

Se você seguir estes passos, ao final, você provavelmente terá um café passado.
O que pode ser observado é que alguns destes passos podem ser alterados em
sua ordem. Por exemplo, se reservarmos os ingredientes antes dos utensílios, não
teremos alteração no produto final. Porém, se colocássemos a água no filtro com
café antes de aquecê-la, o resultado seria indesejado.
Um algoritmo computacional pode ser definido como uma sequência lógica
de instruções ou comandos, que devem ser seguidas para se obter a solução de
um problema. Da mesma forma que um algoritmo do dia a dia, deve seguir
uma sequência de passos lógicos, que devem ser ordenados de forma clara para
solucionar o problema.
1.2 Construção do algoritmo

Para construir um algoritmo, temos que saber claramente qual o problema que
desejamos solucionar, ou seja, qual o objetivo do algoritmo. Para isso, precisamos
analisar o problema identificando três elementos básicos: entrada, processamento
e saída.
A entrada são os elementos necessários para dar início à solução do problema, o
processamento é a manipulação dos elementos de entrada para obtenção da saída
e a saída é o resultado esperado. Se considerarmos o exemplo do café passado,
apresentado anteriormente, podemos identificar:
• entrada: filtro de café, chaleira, recipiente para colocar o café passado, pó de
café e água;
• processamento: aquecer a água, colocar o pó no filtro e despejar a água no
filtro;
• saída: o café passado.
Se considerarmos os algoritmos computacionais, podemos descrever estes
elementos em:
• entrada de dados: são os dados que o algoritmo deverá receber;
• processamento de dados: são as fórmulas e a disposição lógica em que os dados
de entrada serão organizados para obter-se a solução do problema;
• saída de dados: é a apresentação do objetivo, ou seja, o resultado esperado.

Process Black
11
Por exemplo, se desejamos fazer um algoritmo para fazer a soma de dois números

quaisquer, podemos neste caso identificar:
• entrada de dados: perguntar ao usuário dois números quaisquer;
• processamento de dados: calcular a soma dos números informados;
• saída de dados: apresentar o resultado da soma.
Sempre que formos construir um algoritmo, devemos nos concentrar nestes três
elementos, eles sempre estarão envolvidos. Porém, nem sempre estarão nesta
ordem, podendo variar de algoritmo para algoritmo.
1.3 Formas de representação de algoritmos

Existem diversas formas de representarmos os algoritmos. Dentre elas, citamos
algumas abaixo.
• Linguagem natural: utiliza uma descrição narrativa para especificar os passos
a serem realizados para executar a tarefa. Por não possuir uma estrutura bem
definida, pode dar margem para más interpretações e ambiguidades.
• Português estruturado: utiliza uma linguagem estruturada e se assemelha a um
programa escrito em linguagem de programação. Também é denominado de
pseudocódigo e é bastante utilizado como passo inicial antes de descrever um
programa em uma linguagem de programação. Nesta disciplina, o português
estruturado será a forma utilizada para representar os algoritmos no decorrer
dos capítulos.
• Fluxograma: é uma forma universal de representação. Utiliza-se de figuras
geométricas para ilustrar os passos a serem seguidos para resolução de um
problema.
• Diagrama de Chapin: é uma variação do fluxograma permitindo ter-se uma
visão hierárquica e estruturada da lógica do algoritmo. Esta representação é
pouco utilizada nos dias de hoje.
1.3.1 Português estruturado

O português estruturado é um tipo de representação de algoritmo que utiliza
uma linguagem flexível, intermediária entre a linguagem natural e linguagem de
programação. Normalmente, é utilizado para organizar o raciocínio lógico antes
de implementar o mesmo em uma linguagem de programação. Todo algoritmo
representado em português estruturado deverá ter sua sintaxe pré-definida. O
exemplo 1.1 propõe um problema que será resolvido utilizando um algoritmo em
português estruturado.

Process Black
12
Exemplo 1.1. Faça um algoritmo que calcule e escreva a média final de um aluno
considerando duas notas; emita a mensagem “Aluno aprovado” ou “Aluno

reprovado”. Observação: um aluno é considerado aprovado se obtiver nota final
maior ou igual a 6.
algoritmo exemplo_11
variáveis
nota1, nota2, media: real
início
escrever (“Informe a 1ª nota do aluno = “)
ler (nota1)
escrever (“Informe a 2ª nota do aluno = “)
ler (nota2)
media (nota1 + nota2) / 2
se (media >= 6) então
escrever (“Média final = “, media, “Aluno aprovado”)
senão
escrever (“Média final = “,media, “Aluno reprovado”)
fim
1.3.2 Fluxograma
O fluxograma, também chamado de diagrama de blocos, é uma representação de
algoritmo que utiliza símbolos geométricos para representar as ações (comandos
ou instruções) a serem seguidas. Assim como português estruturado, é utilizado
para organizar o raciocínio lógico do problema antes de implementá-lo em uma
linguagem de programação. Os símbolos utilizados para representar estas ações
são apresentados na Tabela 1.1.

Process Black
13
Tabela 1.1 – Símbolos geométricos

Símbolo Nome Descrição
Indica o início e o fim do fluxo do

Terminal
algoritmo.
Indica o sentido do fluxo de dados e faz

Seta de fluxo de dados
a conexão dos blocos existentes.
Indica que serão recebidas informações

Entrada de dados
através do teclado.
Indica a realização de cálculos,

Processamento atribuições ou qualquer manipulação de
dados.
Indica que as informações serão exibidas

Saída de dados
na tela.
Indica a tomada de decisão, dividindo o

Desvio condicional
fluxo do algoritmo em dois caminhos.
Conector Serve para conectar dois fluxos.
Cabe destacar que é possível encontrar formas geométricas diferentes para

representar determinados comandos e/ou instruções. Entretanto, isso é apenas
uma convenção ou hábito de cada autor. O algoritmo do exemplo 1.1 representado
através de um fluxograma pode ser visto a seguir.

Process Black
14
1.3.3 Diagrama de Chapin

Os diagramas de Chapin foram criados para substituir os diagramas de blocos
(fluxograma) por um diagrama de quadros. A vantagem de se utilizar este tipo
de diagrama é a clareza quanto ao fluxo de execução e sua desvantagem é que é

Process Black
15
mais trabalhoso fazer desenhos do que escrever texto. O algoritimo do exemplo 1.1

representado através de um diagrama de Chapin pode ser visto a seguir.
início
ler nota1, nota2
S media >= 6 N
resultado “Aprovado” resultado “Reprovado”
escrever media, resultado
fim
1.3.4 Formalização de um algoritmo

Construir um algoritmo consiste em detalhar os dados que serão processados
e as instruções que vão operar sobre esses dados. Esta construção, como visto
anteriormente, pode ser feita por diferentes formas de representações, mas é
importante formalizarmos a descrição dos algoritmos segundo uma convenção
pré-definida, para que todas as pessoas envolvidas no processo possam entendê-
la. Para isso, é necessário definir o conjunto de regras que regulam a escrita do
algoritmo (sintaxe) e o conjunto de regras que definem a interpretação desta
escrita (semântica). Nos capítulos seguintes, serão definidas a sintaxe e a semântica
utilizadas nesta disciplina.
1.4 Estrutura básica de um algoritmo

Observe a receita de bolo de chocolate a seguir.
Bolo de chocolate
Ingredientes:
• 3 ovos
• 1 e 1/2 xícara de açúcar
• 2 xícaras farinha de trigo
• 1 xícara de chocolate em pó ou achocolatado
• 1/2 xícara de óleo
• 1 colher de fermento em pó

Process Black
16
• 1 pitada de sal
• 1 xícara de água quente

Modo de preparo:
1. Bata os ovos com o açúcar, o óleo, o achocolatado e a farinha, depois adicione a água
quente e por último o fermento em pó.
2. Asse em forno com temperatura média por 40 minutos, desenforme quente.
Se observarmos com atenção, veremos que esta receita possui uma estrutura
básica: nome da receita, ingredientes e modo de preparo. Podemos verificar que
esta estrutura facilita a localização da receita, permite verificar se possuímos todos
os ingredientes, antes de começar o preparo.
Um algoritmo, representado em português estruturado, possui uma estrutura
bastante semelhante a uma receita, organizada em três partes: identificação do
algoritmo, declaração de constantes e/ou variáveis e o corpo do algoritmo. Observe
o exemplo 1.1, reproduzido novamente a seguir.
Algoritmo exemplo_11 Identificador do algoritmo
variáveis Declaração de variáveis

nota1, nota2, media: real
início Corpo do algoritmo

escrever ("Informe a 1ª nota do aluno = ")
ler (nota1)
escrever ("Informe a 2ª nota do aluno = ")
ler (nota2)
se (media >= 6) então
escrever ("Média final = ", media, "Aluno aprovado")
senão
escrever ("Média final = ",media, "Aluno reprovado")
fim
Esta estrutura facilita a localização do algoritmo, permitindo saber quais variáveis

e/ou constantes serão usadas e como elas serão manipuladas para obter o resultado
esperado.
Glossário
• Programa: é uma sequência de instruções que podem ser executadas por
um computador. É um conjunto de ordens dadas a um computador para a

Process Black
17
realização de um determinado processo. É a implementação de um algoritmo

em uma determinada linguagem de programação.
• Linguagens de programação: são ferramentas (so wares) que permitem o
desenvolvimento de programas. Possuem um poder de criação ilimitado,
desde jogos, editores de texto, sistemas empresariais até sistemas operacionais.
Existem várias linguagens de programação, cada uma com suas características
próprias. Exemplos: Pascal, C, C++, C#, Java e outras.
Referências
ASCENCIO, A. F. G.; CAMPOS, E. A. V.. Fundamentos da Programação de Computadores:
algoritmos, Pascal, C/C++ (padrão ANSI) e Java. 3.ed. São Paulo: Pearson Education do
Brasil, 2012.
BERG, A. C.; FIGUEIRÓ, J. P.. Lógica de Programação. 2.ed. Canoas: Ed. ULBRA, 2001.
FORBELLONE, A. L. V.; EBERSPÄCHER, H. F.. Lógica de Programação: a construção de
algoritmos e estruturas de dados. 3.ed. São Paulo: Pearson/Prentice Hall, 2005.
GOODRICH, M. T.; TAMASSIA, R.. Projeto de Algoritmos. Porto Alegre: Bookman, 2004.
MIZRAHI, V. V.. Treinamento em Linguagem C. 2.ed. São Paulo: Pearson/Prentice Hall, 2008.
PUGA, S.; RISSETTI, G.. Lógica de Programação e Estruturas de Dados. São Paulo: Pearson/
Prentice Hall, 2003.
Atividades
1. Vamos construir alguns algoritmos? Descreva os passos necessários para
solucionar os seguintes desafios.
a. Descreva como você troca uma lâmpada.
b. Um camponês precisa atravessar um rio utilizando um barco com

capacidade para carregar ele mesmo e mais uma de suas três cargas,
que são: um lobo, uma ovelha e um maço de pasto. Quais os passos
que o camponês deve seguir para atravessar o rio sem perder a sua
carga? Sabendo que o lobo come a ovelha e a ovelha come o pasto, ou
seja, em momento algum o lobo pode ficar sozinho com a ovelha e a
ovelha ficar sozinha com o pasto. DICA: procure no Google (www.
google.com.br) as palavras “jogo camponês ovelha pasto” ou “jogo
pastor ovelha feno” e teste sua solução de maneira online.

Process Black
18
c. Três jesuítas e três canibais precisam atravessar um rio, para isso

dispõem de um barco com capacidade para duas pessoas. Por medida
de segurança, em nenhuma das margens do rio, o número de canibais
pode ser maior que o número de jesuítas. Qual a solução para efetuar
a travessia de forma segura? DICA: procure no Google (www.google.
com.br) as palavras “jogo jesuítas canibais” e teste sua solução de
maneira online.
d. A Torre de Hanói consiste em uma base com três pinos, onde em

um deles, estão dispostos três discos uns sobre os outros, em ordem
crescente de diâmetro, de cima para baixo. Descreva como passar todos
os discos de um pino para outro qualquer, usando um dos pinos como
auxiliar, de maneira que um disco maior nunca fique em cima de outro
menor em nenhuma situação. DICA: procure no Google (www.google.
com.br) as palavras “jogo torre de hanói” e teste sua solução de maneira
online.
e. Pedro possui dois baldes: um com capacidade para comportar 5 litros,

e outro que comporta 3 litros. Ele não possui outros recipientes e os
baldes não possuem marcações de volume. Como Pedro, utilizando
os dois baldes, pode retirar exatamente sete litros de água de uma
fonte?1
Resposta:
Encha o balde de 5 litros e despeje a água no balde de 3 litros, enchendo-o.
Agora, restaram 2 litros no balde de 5 litros. Jogue fora a água do balde de 3
litros e coloque nele os 2 litros que estavam no balde de 5 litros. A seguir, encha
o balde de 5 litros novamente e pronto! No balde de 3 litros estão, agora, 2
litros de água, enquanto o balde de 5 litros está cheio, totalizando 7 litros!

Process Black
2
Eduardo Isaia Filho
CONCEITOS FUNDAMENTAIS
Neste capítulo, serão apresentados os conceitos de dados, variáveis e constantes;

os tipos básicos de dados; os operadores aritméticos, relacionais e lógicos. Por fim,
são propostos alguns exercícios de fixação.
2.1 Dados
O objetivo da maioria dos algoritmos é manipular dados, transformando os dados
de entrada em dados de saída (resultados). Um dado é um atributo que descreve
entidades ou características, por exemplo: o nome de uma pessoa, sua idade, seu
peso ou o número de páginas de um livro.
Quando vamos desenvolver um algoritmo, precisamos previamente identificar o
tipo do dado que está sendo manipulado. Isso é necessário, pois, quando formos
converter o algoritmo para uma linguagem de programação, os dados serão
armazenados na memória principal do computador e um espaço de memória
específico (tamanho) deve ser reservado a cada tipo de dado. Os principais tipos
de dados são: inteiro, real, caractere, cadeia e lógico.
2.1.1 Tipos básicos de dados

Os tipos de dados podem ser classificados de acordo com o tipo de informação
contida neles: dados numéricos (inteiros e reais), dados literais (caractere e cadeia)
e dados lógicos.
• Inteiro: os dados do tipo inteiro pertencem ao conjunto de números inteiros
relativos, ou seja, são aqueles que não possuem componentes decimais ou
fracionários, podendo ser positivos, nulos ou negativos. Exemplos: quantidade

Process Black
20
de alunos em uma turma (alunos = 24); idade de uma pessoa (anos = 25); o ano
(ano = 2013); outros.

• Real: os dados do tipo real pertencem ao conjunto dos números reais. Portanto,
podem ter componentes decimais ou fracionários e ser positivos, nulos ou
negativos. Exemplos: o salário de uma pessoa (salário = 3.450,34); a temperatura
(temperatura = 12); a altura de um prédio (altura = 120,50); outros.
• Caractere: os dados do tipo caractere são compostos por um único caractere
alfanumérico (0..9, A..Z, a..z) ou caractere especial (#, $, %, *, ?, >, ...). Os dados
do tipo caractere são delimitados por aspas. Exemplos: código de acesso a um
sistema (código = “#”); resposta a uma pergunta (resposta = “S”); seleção entre
alternativas (alternativa = “a”); o sexo de uma pessoa (sexo = “M”).
• Cadeia: os dados do tipo cadeia são formados por um conjunto de caracteres
alfanuméricos (0..9, A..Z, a..z) e/ou caracteres especiais (#, $, %, *, ?, >, ...).
Os dados do tipo cadeia são delimitados por aspas. Exemplos: nome de um
funcionário (nome = “Alberto Malazowski”); endereço de um cliente (rua = “Av.
Julio de Castilhos, 990”); senha de acesso a um sistema (senha = “9125ax”);
outros.
• Lógico: um dado do tipo lógico só pode assumir dois estados: verdadeiro ou
falso. Exemplos: resposta = verdadeiro (ou, simplesmente resposta = v); teste
= falso (ou, simplesmente teste = f).
2.2 Variáveis
Uma variável pode ser definida como um local, na memória principal, utilizado
para armazenar o conteúdo de um determinado dado, podendo receber muitos
valores diferentes durante a execução do algoritmo, mas em um dado instante ela
só pode apresentar um valor único.
O conceito de variável foi criado para permitir, que através do nome (identificador),
os algoritmos possam armazenar, localizar e manipular as informações na
memória dos computadores. São, portanto, formadas por três atributos: um nome
(identificador), um tipo de dado, e um valor.
Toda variável possui um nome único que a diferencia das demais. A escolha do
nome de uma variável cabe ao programador, porém algumas regras devem ser
observadas. São elas:
• devem sempre começar com uma letra;
• podendo ser seguida de letras e/ou números;

Process Black
21
• não é permitido espaços em branco, caso haja necessidade de separador o

sublinhado baixo (underscore) pode ser utilizado, exemplo: nome_aluno;
• não é permitido utilizar símbolos, operadores, acentos e caracteres especiais,
por exemplo: &, %, #, +, /, ?, @;
• não é permitido utilizar uma palavra reservada, ou seja, uma palavra que é
um comando do algoritmo.
Exemplos de nomes de variáveis:
• Salario : correto;
• 1ANO : errado, pois não começou com uma letra;
• ANO1 : correto;
• a casa : errado, pois contém o espaço em branco;
• SAL/HORA : errado, pois contém o caracter “/”;
• SAL_HORA : correto;
• _DESCONTO : errado, pois não começou com uma letra.
Uma consideração importante quanto ao nome das variáveis é que este deve ser
um nome representativo, de forma que ao ler o nome da variável seja possível
lembrar o que ela armazena.
2.2.1 Sintaxe da declaração de variáveis

Todas as variáveis utilizadas em um algoritmo devem ser declaradas antes de
serem utilizadas, através da definição de um nome (identificador) e do tipo de
dado que será armazenado nela. A seguir veja como é a sintaxe da declaração de
uma variável:
variáveis
<nome da variável ou lista de nomes> : <tipo de dado>
Exemplo
variáveis
nome, endereco: cadeia
idade: inteiro
peso, altura: real

Process Black
22
2.3 Constantes
Ao contrário das variáveis, o conteúdo armazenado em uma constante não é

alterado durante a execução de um algoritmo.
2.3.1 Sintaxe da declaração de constantes

As constantes também são definidas antes de serem utilizadas e seus nomes
(identificadores) seguem as mesmas regras das variáveis. A seguir veja como é a
sintaxe da declaração de uma constante.
constantes
<nome da constante> = <conteúdo>
Exemplo
constantes
pi = 3.1416
2.4 Expressões
Operadores são elementos fundamentais que, quando relacionados com operandos,
produzem uma expressão. Por exemplo, a expressão 3 + 2 relaciona dois operandos
(os números 3 e 2) por meio do operador (+) que representa a operação de adição.
Os operandos dividem-se em aritméticos, relacionais e lógicos. Esta divisão está
diretamente relacionada com o tipo de expressão onde aparecem os operadores.
2.4.1 Expressões aritméticas

As expressões aritméticas são formadas por variáveis numéricas e operadores
aritméticos, cujo resultado da avaliação é do tipo numérico (inteiro ou real). Os
operadores aritméticos e sua ordem de prioridade são apresentados na Tabela 2.1.
Tabela 2.1 – Operadores aritméticos

Operador Operação Prioridade Exemplo
** Exponenciação 1 3 ** 2 = 9
// Radiciação 1 25 // 2 = 5
* Multiplicação 2 7 * 2 = 14
/ Divisão 2 20 / 4 = 5
div Quociente da divisão inteira 2 20 div 6 = 3
mod Resto da divisão inteira 2 20 mod 6 = 2
+ Adição 3 3 + 8 = 11
- Subtração 3 30 – 12 = 18

Process Black
23
Como pode ser observado, nos algoritmos podemos utilizar três operadores

relacionados à divisão, são eles: /, div e mod. Vamos entender qual a diferença de
cada um deles, relembrando alguns conceitos:
14 4
-12 3,5 quociente
20
- 20
0 resto da divisão
Observe que a divisão de 14 por 4 é a divisão tradicional, onde fracionamos o

quociente até obtermos um resultado nulo ou uma dízima periódica. Ao utilizarmos
os operadores div e mod, estamos fazendo a divisão inteira, ou seja, devemos
encerrar o processo de divisão quando o quociente necessitar ser fracionado. Veja
o exemplo da divisão inteira:
14 4
-8 3 quoiente inteiro (div)
2 resto da divisão inteira (mod)
Outros exemplos são apresentados na Tabela 2.2.
Tabela 2.2 – Exemplos de divisão, div e mod
10 / 2 = 5 20 / 3 = 6,666... 105 / 10 = 10,5 32 / 6 = 5, 333...

10 div 2 = 5 20 div 3 = 6 105 div 10 = 10 32 div 6 = 5
10 mod 2 = 0 20 mod 3 = 2 105 mod 10 = 5 32 mod 6 = 2
A prioridade entre os operadores define a ordem em que os mesmos devem ser

executados dentro de uma mesma expressão. Quando há dois ou mais operadores
de mesma prioridade em uma expressão, a execução se dá da esquerda para
direita. Para alterar a ordem em que os operadores são executados, pode-se utilizar
parênteses, por exemplo:
(2 + 3) * 2 = 2+3*2=
5*2= 2+6=
10 8
Temos que ter um cuidado especial quando convertemos uma expressão matemática
para utilizá-la em um algoritmo. Considere a expressão a seguir.
3+5
2

Process Black
24
Podemos observar que o resultado desta expressão é 4, pois primeiro somamos 3

e 5 e depois dividimos por 2. Quando convertemos a expressão para utilizarmos

em um algoritmo, temos que ter cuidado com a prioridade dos operadores, um
programador desatento poderia muito bem, converter a expressão matemática para
3 + 5 / 2. Observe que agora o resultado é 5,5 diferente da expressão original, pois
o operador prioritário é a divisão e não a soma, ou seja, primeiro iríamos dividir
5 por 2, para somente depois somarmos a 3. Quando convertemos uma expressão
matemática, para utilizarmos nos algoritmos, normalmente, teremos que adicionar
parênteses para determinar a prioridade de execução. A conversão correta para
expressão é (3 + 5) / 2.
2.4.2 Expressões lógicas

As expressões lógicas têm como resultado um valor lógico (verdadeiro/V ou
falso/F). Elas podem ser formadas por operadores relacionais, operadores lógicos
ou pela combinação de ambos.
2.4.2.1 Operadores relacionais

Estes operadores, listados na Tabela 2.3, são utilizados quando se deseja efetuar
comparações entre objetos de mesma natureza (variáveis do mesmo tipo de dado).
O resultado de uma comparação é sempre um valor lógico (verdadeiro ou falso).
Tabela 2.3 – Operadores relacionais
Operador Comparação Exemplo
= Igual 3=2 falso
<> Diferente 10 <> 20 verdadeiro
< Menor 4 < 18 verdadeiro
> Maior 10 > 20 falso
<= Menor ou igual 4 <= 7 verdadeiro
>= Maior um igual 7 >= 7 verdadeiro
2.4.2.2 Operadores lógicos

Os operadores lógicos ou booleanos também resultam em valores lógicos e,
normalmente, são usados para combinar expressões relacionais. Os operadores
lógicos e suas relações de precedência são mostrados na Tabela 2.4.

Process Black
25
Tabela 2.4 – Operadores lógicos

Operador Operação Prioridade Exemplo
NÃO Negação 1 não(2>7) não(F) V
E Conjunção 2 (2=2) e (3<7) (V) e (V) V
OU Disjunção 3 (2<5) ou (9<20) (F) ou (V) V
Se considerarmos duas variáveis, representadas por variável1 e variável2, podemos

descrever as três operações lógicas a seguir:
• variável1 E variável2: o operador E resulta em verdadeiro somente se ambas
variáveis forem verdadeiras. Se uma for falsa, ou se ambas forem falsas, a
operação E também será falsa.
• variável1 OU variável2: o operador OU resulta em verdadeiro se pelo menos
uma das variáveis for verdadeira. Só resultam em valores falsos se ambas
variáveis forem falsas.
• NÃO variável1: o operador NÃO é unário, ou seja, só se aplica a uma variável.
É avaliado verdadeiro se a variável for falsa; de modo contrário, o operador
NÃO resultará em falso, se a variável for verdadeira.
A Tabela 2.5, chamada de tabela-verdade, exemplifica o uso dos operadores lógicos,
considerando duas variáveis lógicas (A e B). Uma vez que uma variável lógica só
pode assumir dois valores (verdadeiro ou falso), há exatamente quatro combinações
possíveis entre A e B. As colunas contêm os resultados das operações lógicas sobre
as combinações de A e B.
Tabela 2.5 – Tabela-verdade dos operadores lógicos
A B Não A Não B AeB A ou B
V V F F V V
V F F V F V
F V V F F V
F F V V F F

Process Black
26
Referências

Brasil, 2012.
Atividades
1) Marque com um (X) somente os identificadores válidos.
a) ( ) nome b) ( ) endereço c) ( ) 3x4
d) ( ) soma e) ( ) salário_líquido f) ( ) a
g) ( ) nomedaempresa h) ( ) ah! i) ( ) salario total
j) ( ) média k) ( ) x2 l) ( ) data
2) Observe os dados listados a seguir e identifique o seu tipo, marcando com “I”
os inteiros, “R” os reais e “C” as cadeias.
a) ( ) nome de uma pessoa b) ( ) o tamanho de uma mesa
c) ( ) preço de um produto d) ( ) o número de cadeiras de uma mesa
e) ( ) um dia do mês f) ( ) o código de um produto
3) Assinale com um (X) a resposta certa. Ao convertermos a expressão 3 x y para

utilizarmos em um algoritmo, como fica a expressão?
a) ( ) x//3 + y//3; b) ( ) x + y //3; c) ( ) (x + y) // 3; d) ( ) 3 // x+y.
4) Qual o resultado da expressão 9 + 4 / 2 + 3?

a) 9,5; b) 2,6; c) 14; d) 9,8; e) 9.

Process Black
27
5) Considere as expressões lógicas e assinale (V) quando o resultado for

“Verdadeiro” e (F) quando o resultado for “Falso”.
a) ( ) V e F ou V b) ( ) não (V e V) c) ( ) (V ou F ) e V d) ( ) não F e não F
Gabarito:
1. As respostas corretas são: a, d, f, g, k e l.
2. a) C; b) R; c) R; d) I; e) I; f) C
3. b
4. c
5. a) V; b) F; c) V; d) V

Process Black
28

Process Black
3
Vanessa Lindemann
INSTRUÇÕES PRIMITIVAS
Instruções primitivas são comandos básicos utilizados para efetuar a entrada e a

saída de dados e sua movimentação na memória. Estes comandos, presentes na
maioria absoluta dos algoritmos, garantem a comunicação do algoritmo com o
mundo exterior. Neste capítulo, serão apresentadas as instruções primitivas de
atribuição, de entrada de dados (comando LER) e de saída de dados (comando
ESCREVER).
3.1 Instrução primitiva de atribuição

A sintaxe do comando de atribuição, representado pelo símbolo , é apresentada
a seguir e exemplificada nos Quadros 3.1 e 3.2.
<variável> <expressão>
<variável> <variável>
<variável> <constante>
Seu funcionamento consiste em avaliar a expressão (variável ou constante) que
está à direita do comando e armazenar o valor resultante desta expressão (variável
ou constante) na posição de memória correspondente à variável que aparece à
esquerda do comando. Para isso, é necessário que o tipo de dado resultante da
expressão (variável ou constante) avaliada e o tipo de dado da variável sejam
compatíveis. No exemplo media 6.8 (lê-se “média recebe seis e oito”), o valor
6,8 é armazenado na posição de memória reservada à variável media, que deverá
ser do tipo real. Outros exemplos da instrução primitiva de atribuição podem ser
observados no Quadro 3.1.

Process Black
30
Quadro 3.1 Exemplos da instrução primitiva de atribuição

Declaração de variáveis Exemplos de comandos de atribuição
x, y: lógico 01 x verdadeiro
codigo, qtde: inteiro
02 y x
desconto, total: real
nome, telefone: cadeia 03 codigo 2089
resposta1: caractere 04 qtde 3
resposta2: caractere
05 total qtde * 5
06 desconto total * 0.1
07 nome "Ana Lu"
08 telefone "(99)3333-0123"
09 resposta1 "S"
10 resposta2 resposta1
As variáveis x e y foram declaradas do tipo lógico, então podem armazenar

os valores lógicos verdadeiro ou falso. No exemplo 01, x recebe o valor lógico
verdadeiro. No exemplo 02, y recebe o valor armazenado na variável x, ou seja, o
valor lógico verdadeiro.
As variáveis codigo e qtde, declaradas como inteiro, só podem armazenar valores
do tipo inteiro, como ilustram os exemplos 03 e 04 do Quadro 3.1. No caso de uma
variável do tipo real, esta poderá armazenar tanto valores reais (como ilustra o
exemplo 06), quanto valores inteiros. Esta situação pode ser observada no exemplo
05, onde a variável total que é do tipo real, recebe o resultado da expressão
qtde*5 que, neste exemplo, resulta em 15.
Os últimos exemplos do Quadro 3.1 ilustram a atribuição de valores a variáveis
declaradas como literais. É importante observar que quando as variáveis forem
do tipo cadeia ou caractere, a expressão a ser atribuída à variável deve estar entre
aspas, como nos exemplos 07, 08 e 09. No exemplo 10, a variável resposta2 recebe
o valor armazenado na variável resposta1, ou seja, um S.
Retomando a questão da compatibilidade de tipo, destaca-se que: (a) o resultado
de uma expressão com operadores de divisão e/ou radiciação sempre deverá ser
armazenado em uma variável do tipo real, como ilustram os exemplos 03, 04 e 05
do Quadro 3.2; (b) os operadores mod e div só podem ser utilizados com operandos
do tipo inteiro, conforme exemplos 06 e 07 do Quadro 3.2; (c) o resultado de uma
expressão com operadores mod e/ou div deve ser armazenado em uma variável do
tipo inteiro situações também observáveis nos exemplos 06 e 07 do Quadro 3.2.

Process Black
31
Quadro 3.2 Exemplos da instrução primitiva de atribuição

Declaração de variáveis Exemplos de comandos de atribuição
op1, op2: inteiro 01 op1 10

r1, r2, r3: real
02 op2 2
r4, r5: inteiro
03 r1 op1 / op2
04 r2 18 / 4
05 r3 25 // 2
06 r4 8 mod 3
07 r5 op1 div 3
Nos exemplos 01 e 02 do Quadro 3.2, as variáveis o p 1 e o p 2 recebem,

respectivamente, 10 e 2. Em seguida, a variável r1 recebe o resultado da divisão de
op1 por op2 que, neste caso, é 5. Como foi explicado anteriormente, independente
do resultado da expressão ser inteiro ou não, a variável r1 foi declarada do tipo real
e irá armazenar este resultado como real. O mesmo ocorre nos exemplos 04 e 05, em
que as variáveis r2 e r3 armazenam, respectivamente, os valores 4,5 (resultado de
uma divisão) e 5 (resultado de uma radiciação). O Quadro 3.3 ilustra os resultados
dos exemplos 06 e 07, em que as variáveis r4 e r5 recebem, respectivamente, 2
(resto da divisão) e 3 (quociente inteiro).
Quadro 3.3 Exemplo dos operadores mod e div
r4 8 mod 3 r5 op1 div 3

8 3 10 3
-6 2 -9 3
2 resto da divisão 1 quociente inteiro
(a) Exemplo 06 - Quadro 3.2 (b) Exemplo 07 - Quadro 3.2
Por fim, vale lembrar que uma sequência de atribuições modifica o conteúdo da
variável armazenada na memória, como ilustra o exemplo do Quadro 3.4.
Quadro 3.4 Exemplo de uma sequência de atribuições
Comandos de atribuição Memória

01 x 10 x
02 x x + 1 10
11
03 x 20 20

Process Black
32
No exemplo 01 do Quadro 3.4 a variável x é inicializada com o valor 10 e,

consequentemente, a representação da variável x na memória armazenava 10; em

seguida, é atribuído à variável x o valor resultante da expressão x + 1, que é 11,
substituindo o valor anterior na memória; finalmente, no exemplo 03, a variável
x recebe o valor 20, que substituiu o valor anterior na memória como ilustra o
Quadro 3.4.
O Quadro 3.5 apresenta um algoritmo que exemplifica o uso da instrução
primitiva de atribuição. Este algoritmo tem por objetivo calcular a média final
de um aluno, considerando duas notas. Para isso, foram realizadas as seguintes
atribuições: a variável nota1 recebe 7, a variável nota2 recebe 9 e o resultado
da expressão que calcula a média, (nota1+nota2)/2, é armazenado na
variável media.
Quadro 3.5 Exemplo da aplicação do comando de atribuição
Exemplo 3.1 - Calcula a média de um aluno, considerando duas notas.
01 algoritmo exemplo31
02 variáveis
03 nota1, nota2, media: real
04 início
05 nota1 7
06 nota2 9
07 media (nota1 + nota2) / 2
08 fim
A solução do exemplo 3.1 apresenta duas limitações significativas: (a) a média do

aluno é calculada e armazenada na memória, porém não é exibida para o usuário
do programa; (b) se o programa for executado mais de uma vez, o resultado será
sempre o mesmo, pois os valores armazenados nas variáveis nota1 e nota2
permanecem inalterados. Estas limitações serão resolvidas com o uso das instruções
primitivas de saída e de entrada, respectivamente, conforme descrevem as seções
3.2 e 3.3.
3.2 Instrução primitiva de saída

A instrução primitiva de saída de dados tem por objetivo prover a interação entre o
programa e o usuário (ou outros dispositivos), emitindo mensagens e/ou exibindo
valores armazenados em variáveis na memória do computador.
A sintaxe do comando de saída de dados é apresentada a seguir e exemplificada
no Quadro 3.6. Como pode ser observado, o argumento da instrução primitiva

Process Black
33
de saída pode ser uma única variável, uma lista de variáveis, um literal ou uma

mistura de ambos.
escrever(<variável>)
escrever(<lista de variáveis>)
escrever(<literal>)
escrever(<literal>,<variável>)
Quadro 3.6 Exemplos da sintaxe do comando de saída
Variáveis Exemplos de comandos de saída
media: real 01 escrever(media)

nome: cadeia 02 escrever("Digite o nome do aluno: ")
03 escrever("Média final = ",media)
04 escrever(nome," obteve média final = ",media)
No exemplo 01 do Quadro 3.6, o comando de saída exibirá apenas o valor

armazenado na variável media (considerando a variável media do exemplo 3.1,
o valor exibido seria 8). No segundo exemplo, o comando de saída contém apenas
um literal, que será reproduzido no dispositivo de saída. O exemplo 03 contém um
literal (“Média final = “) e uma variável (media), separados por vírgula, resultando
em Média final = 8. Supondo que a variável nome armazene Joana e a variável media
armazene 8, a saída do exemplo 04 seria Joana obteve média final = 8.
A aplicação do comando de saída pode ser observada no exemplo 3.2, que reescreve
a solução do exemplo 3.1 resolvendo uma das limitações citadas anteriormente.
Nesta solução, descrita no Quadro 3.7, a média do aluno é calculada e armazenada
na memória (linha 07) e, por fim, exibida ao usuário (linha 08).
Quadro 3.7 Exemplo da aplicação de comandos de atribuição e saída de dados
02 variáveis
04 início
05 nota1 7
06 nota2 9
08 escrever ("Média do aluno = ", media)
09 fim

Process Black
34
3.3 Instrução primitiva de entrada

A instrução primitiva de entrada permite que dados fornecidos pelo usuário via
teclado (ou por outros dispositivos) sejam armazenados em variáveis na memória
do computador.
A sintaxe do comando de entrada de dados é exibida a seguir e exemplificada no
Quadro 3.8.
ler(<variável>)
ler(<lista de variáveis>)
Quadro 3.8 Exemplos da sintaxe do comando de entrada
Variáveis Exemplos de comandos de saída
nota1: real 01 ler(nome,nota1,nota2)

nota2: real 02 escrever("Digite o nome do aluno: ")
nome: cadeia ler(nome)
escrever("Digite a primeira nota do aluno: ")
ler(nota1)
escrever("Digite a segunda nota do aluno: ")
ler(nota2)
No primeiro exemplo do Quadro 3.8, as três variáveis são lidas em um único

comando de entrada, sem nenhuma informação prévia ao usuário sobre o que ele
deverá digitar. Ao contrário, o exemplo 02 lê uma variável de cada vez e, antes
de cada comando de entrada, emite uma mensagem ao usuário indicando o que
deve ser informado ao programa. Esta solução facilita a interação do usuário com
o programa, garantindo que as informações sejam fornecidas na ordem correta.
Retomando o exemplo que calcula a média do aluno, proposto na seção 3.1, o
Quadro 3.9 apresenta a solução ideal para o problema, incluindo o comando de
entrada para resolver a segunda limitação mencionada anteriormente, com relação
às variáveis nota1 e nota2 que permaneciam inalteradas, resultando sempre o
mesmo valor para média. Este algoritmo inicia solicitando que o usuário digite a
primeira nota do aluno (linha 05) e, em seguida, lê o valor digitado e armazena na
variável nota1 (linha 06). O mesmo acontece com a segunda nota (linhas 07 e 08).
A média do aluno é calculada e armazenada na variável media (linha 09) e, por
fim, exibida ao usuário (linha 10).

Process Black
35
Quadro 3.9 Exemplo da aplicação de comandos de atribuição, entrada e saída

02 variáveis
04 início
05 escrever("Digite a primeira nota: ")
06 ler(nota1)
07 escrever("Digite a segunda nota: ")
08 ler(nota2)
11 fim
Um programador deve se preocupar em facilitar a interação do usuário com o

programa. Então, é importante utilizar o comando de saída antes do comando
de entrada, para indicar o que o usuário deve digitar (como nas linhas 05 e 07
do exemplo 3.3). Outro detalhe importante a ser observado é a apresentação dos
resultados que deve conter, além do resultado em si, mensagens explicando seu
significado (como acontece na linha 10 do exemplo 3.3).
Referências
Brasil, 2012.

Process Black
36
Atividades
1) Assinale (V) para as assertivas Verdadeiras e (F) para as Falsas.
(a) ( ) Instruções primitivas são comandos básicos utilizados para

efetuar a entrada e a saída de dados e sua movimentação na
memória, presentes apenas em alguns algoritmos.
(b) ( ) São instruções primitivas: o comando de atribuição, o comando
de entrada de dados e o comando de saída de dados.
(c) ( ) O funcionamento do comando de atribuição consiste em avaliar
a expressão, variável ou constante que está à esquerda do
comando e armazenar o valor resultante na posição de memória
correspondente à variável que aparece à direita do comando.
(d) ( ) A instrução primitiva de saída de dados tem por objetivo
prover a interação entre o programa e o usuário (ou outros
dispositivos).
(e) ( ) A instrução primitiva de entrada permite que dados fornecidos
pelo usuário via teclado (ou por outros dispositivos) sejam
armazenados em variáveis na memória do computador.
2) Sobre a instrução primitiva de atribuição...
(I) O resultado de uma operação de divisão sempre deve ser armazenado

em uma variável declarada do tipo real, pois mesmo que o resultado
desta operação seja um valor inteiro (exemplo: 10 / 5, cujo resultado
será 2), este será armazenado como real.
(II) Os operandos de uma expressão com operadores mod e/ou div podem
ser do tipo real, mas o resultado da expressão deve ser armazenado
em uma variável do tipo inteiro.
(III) No comando de atribuição, o literal atribuído a uma variável do tipo
cadeia ou caractere deve estar entre aspas conforme o exemplo: nome
“Luciene”.
Quais assertivas são VERDADEIRAS?
(a) Apenas I e II
(b) Apenas II.
(c) Apenas I e III.
(d) I, II e III.
(e) Nenhuma das respostas anteriores.

Process Black
37
3) Considerando a declaração de variáveis a seguir, assinale os comandos de

atribuição considerados INVÁLIDOS.
variáveis
nome, aluno: cadeia
resp: caractere
a, b, c: inteiro
total, preco, resto: real
teste, flag: lógico
(a) ( ) resp "sim" (f) ( ) total resto mod 5

(b) ( ) a b / 5 (g) ( ) a b + c
(c) ( ) teste "verdadeiro" (h) ( ) preco qtde * 5.00
(d) ( ) nome "Roberto" (i) ( ) flag teste
(e) ( ) b b + 1 (j) ( ) preco total - c
4) Assinale a opção em que uma ou mais das instruções primitivas está(ão)

INCORRETA(s), considerando a declaração de variáveis a seguir.
variáveis
nome: cadeia
idade: inteiro
peso, altura, imc: real
(a) escrever(“Informe o nome, o peso e a altura do paciente: “)

ler(nome, peso, altura)
imc peso / (altura * altura)
escrever(“IMC do paciente “,nome,” = “, imc)
(b) idade 10
nome “Solano Só”
escrever(nome,” tem “, idade, “ anos”)
(c) escrever(Informe o nome do paciente: )
ler(nome)
escrever(Informe a idade do paciente: )
ler(idade)
(d) ler(nome, peso, altura)
imc peso / (altura * altura)
escrever(imc)

Process Black
38
5) Considerando os comandos de atribuição a seguir, marque a opção que

contenha a declaração de variáveis CORRETA.

a 10
b 2
c a mod b
teste "S"
desconto 500 * 0.1
x 50
y 10
z x / y
(a) variáveis
a, b, x, y: inteiro
c, desconto, z: real
teste: caractere
(b) variáveis
teste: caractere
a, b, c, x, y: inteiro
desconto, z: real
(c) variáveis
teste: cadeia
a, b, c, x, y: inteiro
desconto, z: real
(d) variáveis
teste: caractere
a, b, x, y: inteiro
c, desconto, z: real
Respostas
1) a = F; b = V; c = F; d = V; e = V.
2) c.
3) a, b, c, f, h.
4) c.
5) b

Process Black
4
Vanessa Lindemann
ESTRUTURA SEQUENCIAL
Ao criar um algoritmo, tem-se como objetivo a solução de um determinado

problema. Para que este problema seja resolvido, os conceitos básicos e as instruções
primitivas estudados nos capítulos anteriores, devem estar organizados de forma a
representar um conjunto de ações, que seguirá um fluxo de execução determinado
por três estruturas básicas de controle: sequencial, condicional e repetitiva.
Este capítulo é dedicado à estrutura sequencial, que contém um conjunto de
instruções que serão executadas de forma linear, de cima para baixo, da esquerda
para a direita, sem nenhum desvio entre as diretivas de início e fim do algoritmo.
As estruturas de controle condicional e repetitiva serão estudadas nos capítulos
subsequentes.
4.1 Estrutura básica de um algoritmo sequencial

A estrutura básica de um algoritmo sequencial é apresentada no Quadro 4.1. Na
linha 01, tem-se a identificação do algoritmo, seguida da declaração de variáveis
(linhas 02 e 03) e, por fim, entre as diretivas de início e fim encontra-se o corpo do
algoritmo (linhas 04 a 08).
Quadro 4.1 Estrutura básica de um algoritmo sequencial

01 algoritmo <nome>
02 variáveis
03 <lista de variáveis>: <tipo>
04 início
05 <instrução 1>
06 <instrução 2>
07 <instrução n>
08 fim

Process Black
40
Como pode ser observado na estrutura apresentada no Quadro 4.1, o fluxo de

execução de um algoritmo sequencial é linear.
4.2 Exemplo de um algoritmo com estrutura sequencial

O algoritmo apresentado no capítulo 3, que calcula a média de um aluno a partir
de duas notas fornecidas pelo usuário, é um exemplo da aplicação da estrutura
sequencial. Este exemplo, escrito em português estruturado, foi reproduzido
novamente no Quadro 4.2.
Quadro 4.2 Exemplo de algoritmo sequencial em português estruturado
Exemplo 3.3. Calcula a média de um aluno, considerando duas notas.
02 variáveis
04 início
06 ler(nota1)
08 ler(nota2)
11 fim
As instruções que compõem o corpo do algoritmo serão executadas uma após a

outra, na mesma ordem em que foram escritas, sem qualquer tipo de desvio. Através
da instrução primitiva de saída na linha 05, o usuário receberá uma mensagem
solicitando que a primeira nota do aluno seja digitada. O valor digitado pelo
usuário será lido e armazenado na variável nota1 (linha 06). Os mesmos passos
são repetidos para a segunda nota (linhas 07 e 08), que é lida e armazenada na
variável nota2. Em seguida, a variável media recebe a média do aluno, calculada
na linha 09 a partir da expressão (nota1+nota2)/2.
A solução do algoritmo, apresentada no Quadro 4.2, foi escrita em português
estruturado, mas também é possível utilizar outras formas de representação, como
ilustra o fluxograma da Figura 4.1. O fluxograma de um algoritmo sequencial
permite, a partir do símbolo de início, a execução das instruções contidas nos
símbolos subsequentes sem nenhum desvio, até alcançar o símbolo de fim.

Process Black
41
Figura 4.1 Exemplo de algoritmo sequencial em fluxograma

Process Black
42
4.3 Construção de algoritmos sequenciais

O primeiro passo, para chegar à solução de um problema, é identificar no seu

enunciado quais são os dados de entrada e de saída e, a partir daí, definir o
processamento necessário para gerar o resultado esperado.
No exemplo apresentado na seção anterior, os dados de entrada são as notas do
aluno e a saída esperada é a sua média. Para chegar a esse resultado, foi realizado o
cálculo da média aritmética entre as duas notas fornecidas pelo usuário, conforme
pode ser observado no esquema da Figura 4.2.
Figura 4.2 Elementos básicos para construção do algoritmo de cálculo da média

Entrada Processamento Saída
Notas do aluno Calcular a média Média do aluno

nota1 nota2 media (nota1+nota2)/2 media
A prévia identificação dos elementos básicos, ilustrados na Figura 4.2, é importante

para a construção da solução do problema. Outros exemplos são apresentados
a seguir com o objetivo de ilustrar passo a passo como construir soluções para
algoritmos sequenciais. A partir do enunciado de cada problema são identificados os
elementos básicos para a construção do algoritmo (entrada / processamento / saída)
e, em seguida, apresenta-se a solução do problema em português estruturado.
Exemplo 4.1
Descrição do problema: construa um algoritmo que: (a) leia o nome de um
funcionário, a quantidade de horas por ele trabalhadas e o valor que ele recebe por
hora; (b) calcule o salário bruto, o valor do INSS (8% sobre o salário bruto) e o salário
líquido do funcionário; (c) escreva o nome do funcionário e os valores calculados.
A partir deste enunciado, monta-se o esquema da Figura 4.3 que contém os
elementos básicos para a construção da solução.
Figura 4.3 Elementos básicos para construção do algoritmo do exemplo 4.1

Calcular salário bruto
nome sb ht*vh nome
ht Calcular INSS sb
vh inss
inss sb*0.08 sl
Calcular salário líquido
sl sb-inss

Process Black
43
Foram identificados, a partir do enunciado do problema (exemplo 4.1), três dados de

entrada: nome do funcionário, horas trabalhadas e valor da hora (representados na
Figura 4.3 pelas variáveis nome,ht e vh, respectivamente). Como saída, espera-se:
nome do funcionário, salário bruto, inss e salário líquido (o nome do funcionário
será informado pelo usuário e os outros dados serão calculados). No processamento,
é necessário definir como, a partir dos dados de entrada, gerar o resultado esperado.
Neste exemplo, foram criadas as variáveis sb, inss e sl para armazenar os
valores calculados para o salário bruto, o INSS e o salário líquido. O salário bruto
é calculado multiplicando a quantidade de horas trabalhadas pelo valor da hora
(ht*vh), o valor do INSS representa 8% do salário bruto (sb*0.08) e, por fim, o
salário líquido é o salário bruto menos o valor do INSS (sb-inss).
Com o esquema da Figura 4.3, portanto, é possível construir a solução para o
problema, descrita em português estruturado no Quadro 4.3.
Quadro 4.3 Solução do exemplo 4.1 em português estruturado
Exemplo 4.1 - Calcula o salário de um funcionário.
02 variáveis
03 nome: cadeia
04 ht: inteiro
05 vh,sb,inss,sl: real
06 início
07 escrever("Nome do funcionário: ")
08 ler(nome)
09 escrever("Quantidade de horas trabalhadas: ")
10 ler(ht)
11 escrever("Valor da hora: ")
12 ler(vh)
13 sb ht * vh
14 inss sb * 0.08
15 sl sb - inss
16 escrever ("Funcionário: ", nome)
17 escrever ("Salário bruto: R$", sb)
18 escrever ("INSS: R$", inss)
19 escrever ("Salário líquido: R$", sl)
20 fim
O algoritmo inicia com a definição de um identificador (linha 01), que deve seguir
as mesmas regras usadas para definir nomes de variáveis - como não é permitido o
uso de espaço em branco e caracteres especiais, o exemplo 4.1 é identificado como
exemplo41. Entre as linhas 02 e 05, consta a declaração de variáveis: o nome do
funcionário é do tipo cadeia, a quantidade de horas trabalhadas foi declarada do

Process Black
44
tipo inteiro e as demais variáveis são do tipo real (valor da hora, salário bruto, inss
e salário líquido). O corpo do algoritmo está entre as linhas 06 e 20, onde estão
organizados os elementos básicos de entrada/processamento/saída do esquema
apresentado na Figura 4.3. Os comandos que representam a entrada de dados
estão entre as linhas 07 e 12 - antes de cada instrução primitiva de entrada (linhas
08, 10 e 12), e será emitida uma mensagem para o usuário, indicando os dados a
serem digitados (linhas 07, 09 e 11). Os cálculos do processamento aparecem entre
as linhas 13 e 15, cujos resultados serão escritos entre as linhas 16 e 19 - comandos
que representam a saída de dados.
Exemplo 4.2
Descrição do problema: sabe-se que na cidade X o índice de natalidade anual é
30% maior do que na cidade Y. Construa um algoritmo que, a partir do índice de
natalidade anual da cidade Y, calcule e escreva o valor estimado da natalidade
anual na cidade X.
O esquema da Figura 4.4 contém os elementos básicos para a construção da solução
deste problema.
Índice de Calcular o índice de Índice de

natalidade anual natalidade da cidade X, natalidade anual
da cidade Y que é 30% superior ao da da cidade X
cidade Y
y x
x y*1.3
A entrada é o índice de natalidade da cidade Y (representada pela variável y).

O objetivo do algoritmo é calcular e escrever o índice de natalidade da cidade X
(representada pela variável x), que é 30% superior ao da cidade Y. A solução para
o problema está descrita em português estruturado no Quadro 4.4.

Process Black
45

Exemplo 4.2 - Calcula o índice de natalidade de uma cidade.
02 variáveis
03 x, y: real
04 início
05 escrever("Índice de natalidade da cidade Y: ")
06 ler(y)
07 x y * 1.3
08 escrever ("Índice de natalidade da cidade X: ", x)
09 fim
Exemplo 4.3
Descrição do problema: faça um algoritmo que converta uma temperatura de graus
Centígrados para graus Fahrenheit. A fórmula de conversão é F=(9*C+160)/5, onde
F é a temperatura em Fahrenheit e C é a temperatura em Centígrados.
Os dados de entrada e saída, bem como o processamento necessário para resolver
o problema, podem ser observados na Figura 4.5. A partir destes dados, chega-se à
solução para o problema, apresentada em português estruturado no Quadro 4.5.

Temperatura em Converter a temperatura Temperatura em

graus Centígrados de graus Centígrados para graus Fahrenheit
Fahrenheit
C F
F (9*C+160)/5
Exemplo 4.3 - Conversão de graus Centígrados para graus Fahrenheit.
02 variáveis
03 C, F: real
04 início
05 escrever("Temperatura em graus Centígrados: ")
06 ler(C)
07 F (9*C+160)/5
08 escrever ("Temperatura em graus Fahrenheit: ", F)
09 fim

Process Black
46
4.4 Teste de mesa de algoritmos com estrutura sequencial

O teste de mesa tem por objetivo detectar, caso existam, erros semânticos na
solução do algoritmo (ou seja, erros de lógica). Para realizar o teste de mesa, as
variáveis utilizadas no algoritmo devem ser listadas, uma simulação da execução do
algoritmo é realizada e todos os valores assumidos pelas variáveis são registrados.
No final, compara-se a resposta obtida com a resposta esperada. Caso não haja
coincidência entre estas respostas, detectou-se um erro de lógica.
Os exemplos descritos a seguir apresentam o algoritmo e seu teste de mesa.
Exemplo 4.4
Descrição do problema: faça um algoritmo para calcular a área de um triângulo.

Base e altura Calcular a área do triângulo Área do triângulo

b h area (b*h)/2 area
Mesmo que não esteja explícito na descrição do problema, os dados de entrada podem
ser identificados a partir da fórmula usada para calcular a área de um triângulo.
Assim, como ilustra a Figura 4.6, os dados necessários para calcular esta área são a
base e a altura do triângulo. No processamento, simplesmente, aplica-se a fórmula
e, por fim, o resultado deverá ser exibido ao usuário. O algoritmo que resolve este
problema é descrito no Quadro 4.6 e seu teste de mesa é explicado na sequência.
Exemplo 4.4 - Cálculo da área de um triângulo.
02 variáveis
03 b, h, area: real
04 início
05 escrever("Base: ")
06 ler(b)
07 escrever("Altura: ")
08 ler(h)
09 area (b*h)/2
10 escrever ("Área = ", area)
11 fim

Process Black
47
Para testar a solução apresentada, é preciso definir valores para os dados de entrada.

Neste caso, a base e a altura do triângulo (no teste apresentado a seguir definiu-se
b = 12 e h = 5, que resultará em uma área de 30). Em seguida, é necessário montar a
tabela onde devem constar todas as variáveis utilizadas na solução e o registro dos
valores assumidos por elas na simulação da execução do algoritmo. Esta etapa do
teste pode ser observada no Quadro 4.7. À esquerda, aparecem os valores definidos
como dados de entrada; no centro, a tabela do teste de mesa que será preenchida
durante a simulação de execução do algoritmo; e à direita, um espaço onde será
registrada a saída do algoritmo.
Quadro 4.7 – Teste de mesa do exemplo 4.4 etapa 1

Entrada Teste de mesa Saída

b = 12 variáveis
h=5 linha
b h area
Feito isto, a simulação de execução deve ser iniciada, passando linha a linha do
algoritmo e registrando os valores assumidos pelas variáveis. Na linha 05 do
algoritmo (Quadro 4.6), primeira instrução a ser executada, será emitida uma
mensagem ao usuário para que ele informe a base do triângulo. Esta instrução não
altera o valor de nenhuma das variáveis, portanto, não gera registro na tabela do
teste de mesa. Na linha 06 (Quadro 4.6), o valor digitado pelo usuário será lido e
armazenado na variável b, gerando um registro no teste de mesa, conforme ilustra
o Quadro 4.8. Este registro contém o número da linha da instrução executada no
algoritmo e o valor de entrada da variável b, definido como 12 neste teste.
Quadro 4.8 – Teste de mesa do exemplo 4.4 etapa 2, passo 1

b = 12 variáveis
linha
h=5 b h area
06 12

Process Black
48
Na linha 07 (Quadro 4.6), uma mensagem será emitida ao usuário solicitando que
ele digite a altura do triângulo, valor que será lido e armazenado na variável h
(linha 08 - Quadro 4.6), gerando um novo registro na tabela do teste de mesa, que
pode ser observado no Quadro 4.9.

b = 12 variáveis
h =5 linha
b h area
06 12
08 5
A área do triângulo é calculada na linha 09 (Quadro 4.6). Considerando os valores

armazenados nas variáveis b e h, tem-se (12*5)/2, que resulta em 30. Este valor
é armazenado na variável area, devendo, portanto, ser registrado na tabela do
teste de mesa.

b = 12 variáveis
h=5 linha
b h area
06 12
08 5
09 30
Por fim, na linha 10 (Quadro 4.6), consta a instrução primitiva de saída que irá
exibir ao usuário o valor da área do triângulo, calculado no algoritmo. O Quadro
4.11 apresenta, à direita, a saída do algoritmo.

Process Black
49


b = 12 variáveis
linha
h=5 b h area Área = 30
06 12
08 5
09 30
Encerrada a simulação de execução, verifica-se que a resposta obtida coincide com

a resposta esperada (área = 30). Portanto, o algoritmo está correto.
Exemplo 4.5
Descrição do problema: escreva um algoritmo para calcular a quantidade de
combustível necessária para um automóvel percorrer determinada distância.
Considerar um consumo médio de um litro de combustível para cada 12 km
rodados.
Para calcular a quantidade de combustível necessária para um automóvel percorrer
uma distância qualquer, é necessário saber a distância a ser percorrida e o consumo
médio do veículo. No enunciado do problema, consta apenas o consumo médio do
veículo. Portanto, a distância a ser percorrida deverá ser informada pelo usuário.
A Figura 4.7 apresenta os elementos básicos para a construção deste algoritmo.
Distância a ser Calcular a quantidade de Quantidade de

percorrida combustível combustível
distancia litros distancia/12 litros
A partir destes dados, constrói-se o algoritmo com a solução para o problema

(Quadro 4.12) e, em seguida, realiza-se o teste de mesa (Quadros 4.13 e 4.14).

Process Black
50

02 variáveis
03 distancia, litros: real
04 início
05 escrever("Informe a distância a ser percorrida: ")
06 ler(distancia)
07 litros distancia/12
08 escrever ("Serão necessários ",litros," de combustível.")
09 fim
Para testar a solução apresentada, definiu-se que a distância a ser percorrida é de

200 km. Assim, o valor esperado como resultado é de 16,7 litros de combustível
(200/12=16,7). O Quadro 4.13 apresenta a primeira etapa do teste de mesa, que
consiste em montar o esquema para registrar os valores assumidos pelas variáveis
durante a simulação da execução do algoritmo.

distancia = 200 variáveis
linha
distância litros
A simulação de execução é iniciada na linha 05 (Quadro 4.12), que exibirá uma

mensagem ao usuário, para que ele digite a distância a ser percorrida com o veículo.
Na sequência (linha 06 - Quadro 4.12), este valor será lido e armazenado na variável
distancia, gerando um registro na tabela do teste de mesa, conforme pode ser
observado no Quadro 4.14.

Process Black
51


distancia = 200 variáveis
linha
distância litros
06 200
Na linha 07 (Quadro 4.12), a quantidade de litros necessária para percorrer a

distância informada pelo usuário é calculada e o resultado é armazenado na variável
litros. O registro desta execução aparece na tabela do teste de mesa do Quadro
4.15, onde também consta a saída de dados executada na linha 08 (Quadro 4.12),
considerando o resultado obtido.

distancia = 200 Serão necessários 16,7
variáveis
linha litros de combustível.
distância litros
06 200
07 16,7
Encerrada a simulação de execução do algoritmo, verifica-se que a resposta obtida

coincide com a resposta esperada (16,7 litros). Portanto, o algoritmo está correto.
Referências
ASCENCIO, A. F. G.; CAMPOS, E. A. V.. Fundamentos da Programação de Computadores: algoritmos,
Pascal, C/C++ (padrão ANSI) e Java. 3.ed. São Paulo: Pearson Education do Brasil, 2012.

Process Black
52
Atividades
Para cada um dos exercícios a seguir, monte o esquema com os elementos

básicos (entrada / processamento / saída), construa o algoritmo com a solução
para o problema e, por fim, realize o teste de mesa, para assegurar que a resposta
esteja correta.
(1) O custo final de um carro novo para o consumidor é a soma do

custo de fábrica, dos impostos e da porcentagem do distribuidor.
Supondo que os impostos totalizam 45% sobre o custo de fábrica e a
porcentagem do distribuidor seja de 20% sobre o valor total, escreva
um algoritmo que leia o custo de fábrica de um carro, calcule e escreva
o custo final ao consumidor.
(2) Sabe-se que, para iluminar de maneira correta os cômodos de uma
casa, para cada m2, deve-se usar 18W de potência. Faça um algoritmo
que receba as duas dimensões de um cômodo (em metros), calcule e
apresente a sua área (em m2) e a potência de iluminação que deverá
ser utilizada.
(3) Uma empresa que promove espetáculos teatrais precisa de um
programa para definir o valor mínimo para o convite, considerando
o custo total do espetáculo e o número de lugares disponíveis para
o público no local da apresentação.
(4) Sabe-se que
1 pé = 12 polegadas;
1 jarda = 3 pés;
1 milha = 1760 jardas.
Faça um algoritmo que receba uma medida em pés, faça as conversões

conforme a descrição acima e mostre os resultados em polegadas,
jardas e milhas.
(5) Considerando uma aplicação de P reais à taxa de juros i constante
por um período de N meses, calcule e escreva qual será o montante
M após o término da aplicação, sendo M = P * (1 + i) N.

Process Black
5
Vanessa Lindemann
ESTRUTURA DE CONTROLE CONDICIONAL:
SE
Como foi explicado anteriormente, os algoritmos seguem um fluxo de execução

determinado por três estruturas básicas de controle: sequencial (tema do capítulo
4), condicional e repetitiva.
A estrutura condicional é utilizada para desviar o fluxo de execução do algoritmo
para diferentes partes da solução. Ela divide-se em estrutura SE e estrutura
ESCOLHA - a primeira delas abordada neste capítulo. A estrutura SE é mais flexível,
podendo utilizar na sua condição todos os operadores relacionais (<, >, <=, >=, =, <>)
e, quando forem necessárias, mais de uma condição com os operadores lógicos (E
e OU) entre elas. Esta estrutura também é classificada como estrutura condicional
SE simples, composta ou encadeada, como descrevem as próximas seções.
5.1 Estrutura condicional SE simples

A sintaxe da estrutura condicional SE simples é apresentada a seguir.
se(<condição ou lista de condições>)então
<instrução ou bloco de instruções>
A condição é testada e resultará verdadeiro ou falso. Quando resultar verdadeiro, a

instrução da cláusula então é executada. Esta estrutura pode conter mais de uma
condição com operadores lógicos entre elas e, também, pode conter um bloco de
instruções a ser executado, ao invés de uma instrução única. Vale lembrar que um
bloco é composto por duas ou mais instruções, delimitado pelas diretivas de início e
fim. O Quadro 5.1 apresenta três exemplos da estrutura condicional SE simples.

Process Black
54
Quadro 5.1 Exemplos da sintaxe da estrutura condicional SE simples

Com instrução única Com bloco de instruções Mais de uma condição e bloco de
instruções
se(a>b)então se(a>b)então se(a>b)e(a<>0)e(b<>0)então

escrever(a) início início
a a-b a a/b
escrever(a) escrever(a)
fim fim
No primeiro exemplo do Quadro 5.1, a estrutura condicional SE possui apenas

uma condição (a>b) e, quando esta resultar verdadeiro, uma única instrução a ser
executada (escrever(a)). O segundo exemplo também testa uma única condição.
Entretanto, quando esta resultar verdadeiro, um bloco de instruções será executado.
E, por fim, o terceiro exemplo apresenta uma situação em que três condições
deverão ser verdadeiras para que o bloco de comandos seja executado.
Para exemplificar a aplicação desta estrutura condicional, propõe-se a ampliação
do exemplo que calcula a média de um aluno, cuja solução foi apresentada nos
capítulos anteriores. Além de calcular e exibir a média do aluno, o algoritmo deverá
emitir a mensagem “Aluno aprovado” sempre que a média for igual ou superior
a 6.0 (seis). A solução para este problema, denominado exemplo 5.1, pode ser
observada no Quadro 5.2.
Quadro 5.2 Exemplo de algoritmo com estrutura condicional SE simples
Exemplo 5.1. Calcula a média de um aluno e emite mensagem “Aluno aprovado”.
02 variáveis
04 início
06 ler(nota1)
08 ler(nota2)
11 se(media>=6)então
12 escrever("Aluno aprovado!")
13 fim
As instruções das linhas 11 e 12 foram acrescentadas à solução inicial e, sempre

que a condição (media>=6) for verdadeira, a mensagem Aluno aprovado! será
exibida ao usuário.

Process Black
55
Na solução apresentada, entretanto, quando o aluno obtiver média inferior a

6.0 (seis), nenhuma mensagem será exibida ao usuário informando sobre sua
reprovação. Esta limitação pode ser resolvida utilizando a estrutura condicional
SE composta, descrita na próxima seção.
5.2 Estrutura condicional SE composta

A sintaxe da estrutura condicional SE composta pode ser observada a seguir.
senão
Quando a condição avaliada resultar verdadeiro, a instrução da cláusula então

será executada; caso contrário, quando resultar falso, é a instrução da cláusula
senão que será executada.
Com esta estrutura é possível acrescentar à solução do exemplo anterior, a emissão
da mensagem “Aluno reprovado.” quando a média for menor que 6.0 (seis). A
solução para este problema, denominado exemplo 5.2, pode ser observada no
Quadro 5.3.
Quadro 5.3 Exemplo de algoritmo com estrutura condicional SE composta
Exemplo 5.2. Calcula a média de um aluno e emite mensagem “Aluno aprovado” ou

“Aluno reprovado”.
02 variáveis
04 início
06 ler(nota1)
08 ler(nota2)
10 escrever("Média do aluno = ", media)
11 se(media>=6)então
12 escrever("Aluno aprovado!")
13 senão
14 escrever("Aluno reprovado!")
15 fim

Process Black
56
As instruções das linhas 13 e 14 foram acrescentadas à solução anterior. Desta forma,

quando a condição (media>=6) for verdadeira, a mensagem Aluno aprovado!

será exibida; e quando a condição resultar falso, o algoritmo emitirá a mensagem
Aluno reprovado.
Na sequência, mais um problema será resolvido para exemplificar a aplicação da
estrutura SE composta e destacar a necessidade da estrutura SE encadeada.
Exemplo 5.3
Descrição do problema: escreva um algoritmo que verifique se um valor qualquer
digitado pelo usuário é positivo ou negativo.
Comparar o valor com zero para Imprimir uma

valor verificar se é positivo ou negativo das mensagens:
se(valor<0)então Negativo
escrever("Negativo") ou
senão
escrever("Positivo") Positivo
Quadro 5.4 Solução do exemplo 5.3
Exemplo 5.3 - Verifica se um valor é negativo ou positivo.
02 variáveis
03 valor: real
04 início
05 escrever("Informe um valor qualquer: ")
06 ler(valor)
07 se(valor<0)então
08 escrever("Negativo")
09 senão
10 escrever("Positivo")
11 fim
Antes de iniciar o teste de mesa, vale lembrar que a escolha dos dados de testes é
muito importante na simulação. Os dados escolhidos devem garantir a execução

Process Black
57
de todas as instruções do algoritmo, testando todas as possibilidades de saída.

Neste exemplo, duas possibilidades serão testadas: um valor negativo e um valor
positivo.
No primeiro teste realizado, definiu-se como dado de entrada 80. Assim, o
resultado esperado é “Negativo”. O Quadro 5.5 apresenta a primeira etapa do teste
de mesa, que consiste em montar o esquema para registrar os valores assumidos
pelas variáveis durante a simulação da execução do algoritmo.
Quadro 5.5 – Teste de mesa do exemplo 5.3

valor = 80 variáveis
linha
valor

mensagem ao usuário solicitando que ele digite um valor qualquer. Na sequência
(linha 06 Quadro 5.4), este valor será lido e armazenado na variável valor,
gerando um registro na tabela do teste de mesa, conforme pode ser observado
no Quadro 5.6.
Quadro 5.6 – Teste de mesa do exemplo 5.3 com valor negativo

valor = 80 variáveis Negativo
linha
valor
06 - 80
Na linha 07 (Quadro 5.4), a condição (valor<0) é testada. Como 80 é menor do

que zero, esse teste resulta verdadeiro e, consequentemente, a instrução da cláusula
então será executada, emitindo a mensagem “Negativo”. A saída gerada, portanto,
coincide com a resposta esperada.
Ao testar um valor positivo como 22, por exemplo, a condição da linha 07 (Quadro
5.4) não será satisfeita, resultando falso. Neste caso, a instrução da cláusula senão
será executada, emitindo a mensagem “Positivo”. Neste caso, o resultado obtido

Process Black
58
também coincide com o resultado esperado. Os dados deste teste podem ser
observados no Quadro 5.7.
Quadro 5.7 – Teste de mesa do exemplo 5.3 com valor positivo

valor = 22 variáveis Positivo
linha
valor
06 22
Os testes de mesa realizados demonstram que os resultados obtidos através da

simulação de execução do algoritmo, com valores negativos e positivos, coincidem
com os resultados esperados. Mas o que aconteceria se o valor digitado pelo usuário
fosse um 0 (zero)? Neste caso, o algoritmo emitiria a mensagem “Positivo”, que
não condiz com o resultado esperado já que o zero é neutro. Para corrigir este
problema, será necessário usar a estrutura condicional SE encadeada, descrita na
próxima seção.
5.3 Estrutura condicional SE encadeada

A aplicação da estrutura condicional SE encadeada, cuja sintaxe é apresentada
a seguir, pode ser observada no Quadro 5.8 que reescreve a solução do exemplo
anterior e nos exemplos apresentados na sequência.
senão
senão
A solução do exemplo anterior, que verifica se um valor é positivo ou negativo,

foi reescrita no Quadro 5.8, utilizando a estrutura SE encadeada (linhas 07 a 13).
As modificações realizadas aparecem entre as linhas 10 e 13, onde mais um teste
foi incluído para garantir que quando o dado de entrada for 0 (zero), o algoritmo
emita uma mensagem “Zero é neutro”.

Process Black
59

02 variáveis
03 valor: real
04 início
05 escrever("Informe um valor qualquer: ")
06 ler(valor)
07 se(valor<0)então
08 escrever("Negativo")
09 senão
10 se(valor>0)então
11 escrever("Positivo")
12 senão
13 escrever("Zero é neutro")
14 fim
Para testar todas as possibilidades de saída desta solução, o teste de mesa deve ser
realizado considerando três valores: um positivo, um negativo e o zero.
Exemplo 5.4
Descrição do problema: escreva um algoritmo para encontrar o maior entre dois
valores quaisquer digitados pelo usuário.
valor1 Comparar os valores para maior

valor2 encontrar o maior entre eles ou mensagem:
valores iguais
O algoritmo do Quadro 5.9 foi construído a partir dos dados do esquema da Figura
5.2. Em seguida, apresenta-se o teste de mesa realizado (Quadros 5.5 e 5.6).

Process Black
60

Exemplo 5.4 - Encontra o maior entre dois valores quaisquer.
02 variáveis
03 valor1,valor2:real
04 início
05 escrever("Informe o primeiro valor: ")
06 ler(valor1)
07 escrever("Informe o segundo valor: ")
08 ler(valor2)
09 se(valor1>valor2)então
10 escrever("Maior = ", valor1)
11 senão
12 se(valor2>valor1)então
13 escrever("Maior = ", valor2)
14 senão
15 escrever("Valores iguais!")
16 fim
Neste exemplo, três possibilidades devem ser testadas: valor1 maior; valor2
maior; valor1 e valor2 iguais.
No teste realizado, descrito a seguir, definiu-se como dados de entrada 8 e 5.
Assim, o resultado esperado é “Maior = 8”. O Quadro 5.10 apresenta a primeira
etapa do teste de mesa, que consiste em montar o esquema para registrar os valores
assumidos pelas variáveis durante a simulação da execução do algoritmo.

valor1 = 8 variáveis
valor2 = 5 linha
valor1 valor2

mensagem ao usuário solicitando que ele digite o primeiro valor. Na sequência
(linha 06 Quadro 5.9), este valor será lido e armazenado na variável valor1,
gerando um registro na tabela do teste de mesa, conforme pode ser observado no
Quadro 5.11.

Process Black
61
Quadro 5.11 – Teste de mesa do exemplo 5.4 etapa 2, passo1


valor1 = 8 variáveis
valor2 = 5 linha
valor1 valor2
06 8
A execução da linha 07 (Quadro 5.9) exibe uma mensagem solicitando que o

usuário digite o segundo valor, que é lido e armazenado na variável valor2
(linha 08 Quadro 5.9). O registro desta execução aparece na tabela do teste de
mesa do Quadro 5.12.
Quadro 5.12 – Teste de mesa do exemplo 5.4 etapa 2, passo2

valor1 = 8 variáveis Maior = 8
valor2 = 5 linha
valor1 valor2
06 8
08 5
Na linha 09 (Quadro 5.9) acontece a comparação entre os dois valores armazenados

na memória, 8 e 5. A condição testada verifica se o primeiro valor é maior que o
segundo. Neste caso, a condição testada é 8>5, que resulta em verdadeiro e permite
a execução da instrução da cláusula então. A saída gerada, portanto, é “Maior =
8”, que coincide com a resposta esperada.
Exemplo 5.5
Descrição do problema: tendo como dados de entrada a altura e o gênero de uma
pessoa, escreva um algoritmo para calcular seu peso ideal, utilizando as seguintes
fórmulas: para homens (72,7 x altura) 58; para mulheres (62,1 x altura) 44.7.

Process Black
62

Exemplo 5.5 - Calcula o peso ideal de uma pessoa.
02 variáveis
03 genero: caractere
04 altura, peso_ideal: real
05 início
06 escrever("Qual o seu gênero(M ou F)? ")
07 ler(genero)
08 escrever("Qual a sua altura? ")
09 ler(altura)
10 se(genero="M")então
11 peso_ideal (72.7*altura)-58
12 senão
13 se(genero="F")então
14 peso_ideal (62.1*altura)-44.7
15 senão
16 início
17 peso_ideal 0
18 escrever("Gênero inválido.")
19 fim
20 escrever("Peso ideal = ", peso_ideal)
21 fim
A solução deste exemplo será usada para relembrar alguns fundamentos já

estudados: (a) a variável genero foi declara do tipo caractere (linha 03), por isso,
ao compará-la com M ou com F, estes devem estar entre aspas, como pode ser
observado nas linhas 10 e 13; (b) a cláusula senão da linha 15 possui um bloco de
instruções a ser executado, delimitado pelas diretivas de início (linha 16) e fim (linha
19); (c) o texto do algoritmo está indentado, facilitando a sua leitura e compreensão
a instrução primitiva de saída da linha 20 está alinhada às instruções anteriores à
estrutura SE, ou seja, ela não faz parte desta estrutura e será executada sempre.
Exemplo 5.6
Descrição do problema: leia um valor inteiro e verifique se ele é par ou ímpar.

Process Black
63

Exemplo 5.6 - Verifica se um valor é par ou ímpar.
02 variáveis
03 valor: inteiro
04 início
05 escrever("Digite um valor inteiro: ")
06 ler(valor)
07 se(valor mod 2 = 0)então
08 escrever(valor, " é par.")
09 senão
10 escrever(valor, " é ímpar.")
11 fim
Neste caso, a variável valor deve ser do tipo inteiro para ser utilizada com o
operador mod, que retorna o resto de uma divisão.
Exemplo 5.7
Descrição do problema: um banco concederá um crédito especial aos seus clientes,
variável conforme o saldo médio no último ano. Construa um algoritmo que leia
o saldo médio de um cliente, calcule e escreva o valor do crédito de acordo com
a tabela a seguir.
Saldo médio Crédito
Até R$ 500,00 sem crédito
Entre R$ 501,00 e 1.000,00 20% sobre o valor do saldo médio
Entre R$ 1.000,00 e 3.000,00 30% sobre o valor do saldo médio
Acima de R$ 3.000,00 40% sobre o valor do saldo médio

Process Black
64

Exemplo 5.7 - Calcula o valor de crédito disponível para um cliente.
02 variáveis
03 saldo_medio, credito: real
04 início
05 escrever("Digite o saldo médio do cliente no último ano: ")
06 ler(saldo_medio)
07 se(saldo_medio<=500)então
08 credito 0
09 senão
10 se(saldo_medio>500)e(saldo_medio<=1000)então
11 credito saldo_medio*0.2
12 senão
13 se(saldo_medio>1000)e(saldo_medio<=3000)então
15 senão
17 escrever ("O cliente tem R$", credito," de crédito.")
18 fim
Neste exemplo, as estruturas SE das linhas 10 e 13 possuem duas condições com o

operador lógico E entre elas. Desta forma, para que a instrução da cláusula então
seja executada, as duas condições devem resultar verdadeiro.
Exemplo 5.8
Descrição do problema: faça um algoritmo que execute as operações básicas de uma
calculadora. Leia dois valores numéricos e um símbolo; caso o símbolo seja um dos
relacionados a seguir efetue a operação correspondente com os valores digitados
pelo usuário; caso contrário, digite a mensagem “Operador inválido!”. Símbolos:
+ soma, - subtração, * multiplicação, / divisão. Atenção para a divisão por 0!

Process Black
65

Exemplo 5.8 - Executa as operações básicas de uma calculadora.
02 variáveis
03 valor1, valor2: real
04 op: caractere
05 início
06 escrever("Valor 1: ")
07 ler(valor1)
08 escrever("Operador (+ - * /): ")
09 ler(op)
11 ler(valor2)
12 se(op="+")então
13 escrever("Resultado = ", valor1+valor2)
14 senão
15 se(op="-")então
16 escrever("Resultado = ", valor1-valor2)
17 senão
18 se(op="*")então
19 escrever("Resultado = ", valor1*valor2)
20 senão
21 se(op="/")então
22 se(valor2<>0)então
23 escrever("Resultado = ", valor1/valor2)
24 senão
25 escrever("Não é possível dividir por 0.")
26 senão
27 escrever("Operador inválido!")
28 fim
A solução apresentada neste exemplo possui várias estruturas SE encadeadas, onde

a variável op foi comparada a quatro operadores diferentes (linhas 12, 15, 18 e 21).
Nesta situação, quando a variável é do tipo inteiro lógico, ou caractere e precisa ser
comparada com vários valores, também é possível resolver o problema utilizando
a estrutura condicional ESCOLHA, tema do próximo capítulo.
5.4 Formatação da solução do algoritmo

Como pode ser observado nos exemplos apresentados até agora, as soluções têm
seu texto indentado (indentar significa inserir determinado espaço entre a margem
da página e o início do texto de um parágrafo). Recomenda-se o uso de indentação
no texto do algoritmo para facilitar a sua leitura. O Quadro 5.17 apresenta o mesmo
trecho de um algoritmo sem e com indentação, ilustrando o quanto a segunda
opção deixa o algoritmo mais legível.

Process Black
66
Quadro 5.17 Formatação do texto do algoritmo

Sem indentação Com indentação
se(valor1>valor2)então se(valor1>valor2)então
escrever(valor1) escrever(valor1)
senão senão
se(valor2>valor1)então se(valor2>valor1)então
escrever(valor2) escrever(valor2)
senão senão
escrever("Valores iguais!") escrever("Valores iguais!")
Referências
Brasil, 2012.
Atividades
Parte I - Questões objetivas e testes de mesa
1) Após executar o teste a seguir:
x 0
se (a <= b) e (c > b) então
x 5
senão
x 10
x estará armazenando 10 se:

(a) a = b < c;
(b) a > b <= c;
(c) a <= b < c;
(d) a < b < c;
(e) Nenhuma das alternativas anteriores.

Process Black
67
2) Após executar o teste a seguir:

w 10
se (g <= m) ou (h < m) então
w w * 5
senão
w w / 5
W estará armazenando 2 se:
(a) h <= m < g;
(b) h = m < g;
(c) g < m < h;
(d) h < m <= g;
3) Considerando o algoritmo apresentado a seguir...

algoritmo teste_de_mesa
variáveis
x, y, z: lógico
início
ler(x,y,z)
se(x=V)então
se(y=V)então
início
comando 1
se(z=F)então
comando 2
senão
comando 3
comando 4
fim
senão
comando 5
comando 6
fim

Process Black
68
(a) Se x = V, y = F e z = V, quais os comandos serão executados?

(b) Se x = V, y = V e z = V, quais os comandos serão executados?

(c) Quais os valores de x, y e z para que somente o comando 5 seja
executado?
(d) Quais os valores de x, y e z para que somente o comando 6 seja
executado?
4) Indique a saída dos trechos de algoritmo apresentados a seguir,

considerando
A = 20, B = 5, C = 5 e D = 5.
(a) se NÃO(D > 5) então Saída:

X (A+B)*D
senão
X (A–B)/C
escreva X
(b) se(A>2)E(B<7)então Saída:

X (A+2)*(B–2)
senão
X (A+B)/D*(C+D)
escreva X
(c) se(A=2)OU(B>7)então Saída:

X (A+2)*(B–2)
senão
X (A+B)/D*(C+D)
escreva X
(d) se NÃO(A>3)E NÃO(B<7)então Saída:

X A+B
senão
X A/B
escreva X

Process Black
69
5) O algoritmo apresentado a seguir calcula a quantidade de latas de tinta

necessárias e o custo para pintar tanques cilíndricos de combustível. Os dados
de entrada são a altura (h) e o raio (r) do cilindro. A lata de tinta custa R$ 24,00,
cada lata contém 5 litros e cada litro pinta 3 metros quadrados.
algoritmo exercicio5
variáveis
h, r, c, qtde, area, litro: real
início
ler (h, r)
area (3.14*r**2)+(2*3.14*r*h)
litro area/3
qtde litro/5
c qtde*24
escrever ("Custo = R$ ", c)
escrever ("Quantidade de latas de tinta = ", qtde)
fim
Qual a saída do algoritmo, considerando h = 6 e r = 2? Considere duas casas
decimais para fazer os cálculos.
Parte II - Resolução de problemas

Para cada um dos exercícios a seguir, monte o esquema com os elementos básicos
(entrada / processamento / saída), construa o algoritmo com a solução para o
problema e, por fim, realize o teste de mesa para assegurar que a resposta esteja
correta.
1) Construa um algoritmo que verifique se o nome e a senha informados pelo

usuário são válidos considerando a tabela a seguir. Emita uma das mensagens
“Acesso liberado” ou “Acesso negado”.
Usuário Senha
analuisa 990123
luciano 714460
josue 134895

Process Black
70
2) A empresa “1001 Utilidades” precisa de um algoritmo para calcular o salário de

seus funcionários. O salário bruto de cada funcionário é calculado com base

no nº de horas por ele trabalhadas no mês e o valor que ele recebe por hora.
O salário líquido deve considerar a comissão de 2% sobre o total das vendas
realizadas pelo funcionário no mês, o bônus por tempo de serviço (conforme a
tabela abaixo) e, finalmente, o desconto de INSS (8% sobre o total a receber).
Para a empresa, é importante ter os seguintes valores disponíveis em R$:
salário fixo, total de adicionais (comissão + bônus), desconto INSS e salário
líquido.
Tempo de serviço Bônus
Entre 2 e 4 anos 2%
Entre 5 e 10 anos 5%
Maior que 10 anos 10%
3) Faça um algoritmo que, tendo como dados de entrada um ponto qualquer,

determine e escreva o seu quadrante.
2 1
3 4

Process Black
71
4) João Papo-de-Pescador, homem de bem, comprou um microcomputador

para controlar o rendimento diário de seu trabalho. Toda vez que ele volta de
um dia de pescaria e traz um peso de peixes maior que o estabelecido pelo
regulamento de pesca do estado Rio Grande do Sul (100 quilos) deve pagar
uma multa por quilo excedente, que varia de acordo com a tabela abaixo.
Peso em excesso (E) Valor da multa p/ quilo excedente

1 <= E < 28 R$ 2,50
28 <= E < 50 R$ 7,80
E >= 50 R$ 13,00
Faça um algoritmo que leia a variável P (peso de peixes) e verifique se há

excesso. Se houver, armazene o excesso de peso na variável E e o valor da multa
que João deverá pagar na variável M, caso contrário tais variáveis deverão
receber 0 (zero). Apresente o peso em excesso e o valor da multa.
5) Faça um algoritmo que leia três valores (A, B e C) e verifique se eles formam
ou não um triângulo. Se for um triângulo, indique de que tipo é: equilátero,
escaleno ou isósceles.
Triângulo: forma geométrica composta por três lados, sendo que cada lado
é menor que a soma dos outros dois lados (isto é uma regra, ou seja, uma
condição). Logo, é triângulo quando A< B+C, B<A+C e C<A+B.
Isósceles: dois lados iguais (A=B) ou (A=C) ou (B=C).
Escaleno: todos os lados diferentes (A<>B) e (B<>C).
Equilátero: todos os lados iguais (A=B) e (B=C).
Respostas dos exercícios da Parte I

1-b
2-b
3 (a) Comandos 5 e 6;
3 (b) Comandos 1, 3, 4 e 6;
3 (c) x = V, y = F, z = não é testado;
3 (d) Impossível executar apenas o comando 6.

Process Black
72
4 (a) 3
4 (b) 66
4 (c) 50
4 (d) 4
5 - Custo = R$ 140,64
Quantidade de latas de tinta = 5,86

Process Black
6
Vanessa Lindemann
ESTRUTURA DE CONTROLE CONDICIONAL:
ESCOLHA
O capítulo anterior apresentou a estrutura condicional SE, que avalia uma expressão
lógica que resulta verdadeiro ou falso. Se o resultado desta expressão for verdadeiro,
as instruções da cláusula então são executadas. Caso contrário, o fluxo é desviado
para executar as instruções da cláusula senão. Tem-se, portanto, dois caminhos
possíveis a serem seguidos. Em situações de igualdade para uma mesma variável,
em que é necessário comparar a variável com vários valores, utiliza-se a estrutura
condicional SE encandeada (como ilustrou o exemplo 5.8). Neste caso, tem-se uma
seleção de múltipla escolha.
O uso da estrutura condicional ESCOLHA, tema deste capítulo, pode simplificar
bastante a “cascata” de estruturas SE, necessária em situações de seleção de múltipla
escolha. A estrutura ESCOLHA pode ser utilizada, portanto, em situações de
igualdade para uma mesma variável, desde que esta variável seja do tipo inteiro,
caractere ou lógico.
A sintaxe da estrutura condicional ESCOLHA é apresentada a seguir.
escolha(<variável>)
caso <1>: <instrução ou bloco de instruções>
caso <2>: <instrução ou bloco de instruções>
caso <n>: <instrução ou bloco de instruções>
senão
fim

Process Black
74
Se a variável avaliada tiver um dos valores listados nas opções, a instrução (ou
bloco de instruções) correspondente ao caso será executada. Quando a variável

for diferente de todas as opções listadas, a instrução (ou bloco de instruções) da
cláusula senão será executada. A cláusula senão é opcional nesta estrutura.
Para demonstrar a aplicação da estrutura condicional ESCOLHA, a solução do
exemplo 5.8 (descrita no capítulo 5), que executa as operações básicas de uma
calculadora, foi reescrita no Quadro 6.1 substituindo a estrutura SE encadeada
pela estrutura ESCOLHA.
Quadro 6.1 Solução do exemplo 5.8 com estrutura ESCOLHA
Exemplo 5.8 - Executa as operações básicas de uma calculadora.
02 variáveis
03 valor1, valor2: real
04 op: caractere
05 início
07 ler(valor1)
08 escrever("Operador (+ - * /): ")
09 ler(op)
11 ler(valor2)
12 escolha(op)
13 caso "+": escrever("Resultado = ", valor1+valor2)
14 caso "-": escrever("Resultado = ", valor1-valor2)
15 caso "*": escrever("Resultado = ", valor1*valor2)
16 caso "/": se(valor2<>0)então
17 escrever("Resultado = ", valor1/valor2)
18 senão
19 escrever("Não é possível dividir por 0.")
20 senão
21 escrever("Operador inválido!")
22 fim
23 fim
Comparando esta solução à apresentada no capítulo 5, que utilizou estrutura

SE encadeada, é possível observar o quanto a estrutura condicional ESCOLHA
simplifica a leitura e a compreensão do algoritmo.
Na sequência, são apresentados mais alguns exemplos para demonstrar a aplicação
da estrutura condicional ESCOLHA.

Process Black
75
Exemplo 6.1

Descrição do problema: faça um algoritmo que leia um valor inteiro entre 0 e 10
e escreva o valor por extenso.
Exemplo 6.1 - Escreve um valor entre 0 e 10 por extenso.
02 variáveis
03 valor: inteiro
04 início
05 escrever("Digite um valor entre 0 e 10: ")
06 ler(valor)
07 escolha(valor)
08 caso 0: escrever("Zero")
09 caso 1: escrever("Um")
10 caso 2: escrever("Dois")
11 caso 3: escrever("Três")
12 caso 4: escrever("Quatro")
13 caso 5: escrever("Cinco")
14 caso 6: escrever("Seis")
15 caso 7: escrever("Sete")
16 caso 8: escrever("Oito")
17 caso 9: escrever("Nove")
18 caso 10: escrever("Dez")
19 senão
20 escrever("Valor inválido!")
21 fim
22 fim
Exemplo 6.2
Descrição do problema: faça um algoritmo que leia um código (COD) e duas
variáveis (X e Y). Quando o código for A: teste e informe se X é par ou ímpar; B:
teste e informe qual o menor valor (X ou Y); C: verifique e informe se os valores
são múltiplos.

Process Black
76

Exemplo 6.2 - Executa instruções conforme um código (A, B ou C).
02 variáveis
03 codigo: caractere x, y: inteiro
04 início
05 escrever("Qual o código (A, B ou C)? ") ler(codigo)
06 escrever("Qual o valor de x? ") ler(x)
07 escrever("Qual o valor de y? ") ler(y)
08 escolha(codigo)
09 caso "A": se(x mod 2 = 0)então
10 escrever(x, " é par.")
11 senão
12 escrever(x, " é ímpar.")
13 caso "B": se(x<y)então
14 escrever("x=",x," é menor do que y=",y)
15 senão
16 se(x>y)então
17 escrever("y=",y," é menor do que x=",x)
18 senão
19 escrever(x," e ",y," são iguais")
20 caso "C": se(x mod y = 0)ou(y mod x = 0)então
21 escrever(x," e ",y," são múltiplos)
22 senão
23 escrever(x," e ",y," não são múltiplos)
24 senão
25 escrever("Código inválido! Digite A, B ou C.")
26 fim
27 fim
Como foi explicado anteriormente, o algoritmo é executado de cima para baixo e

da esquerda para a direita, então é possível escrever mais de uma instrução por
linha como ilustram as linhas 03, 05, 06 e 07.
Exemplo 6.3
Descrição do problema: considerando o cardápio de uma lanchonete, apresentado
a seguir, construa um algoritmo que calcule e informe o valor a ser pago por um

Process Black
77
determinado cliente. O algoritmo deve ler o código do produto e a quantidade

adquirida, calcular e escrever o total a pagar.
Código Descrição Preço
001 Cachorro-quente 8,00
002 Torrada 6,00
003 Xis 12,00
004 Refrigerante 3,00
005 Suco 3,00
006 Água mineral 2,00
Exemplo 6.3 - Calcula o total a pagar em uma lanchonete.
02 variáveis
03 codigo, qtde: inteiro
04 início
05 escrever("Digite o código do produto: ")
06 ler(codigo)
07 escrever("Digite a quantidade: ")
06 ler(qtde)
08 escolha(codigo)
09 caso 001: escrever("Total a pagar = R$",qtde*8)
24 senão
25 escrever("Código inválido!")
26 fim
27 fim
A solução apresentada está correta. Entretanto, possui limitações, pois só é possível

registrar a compra de um produto a cada execução do algoritmo. Para resolver
este problema, permitindo o registro de vários produtos em uma mesma compra,
é necessário utilizar as estruturas de repetição, tema dos próximos capítulos.

Process Black
78
Referências

Brasil, 2012.
Atividades
Para cada um dos exercícios a seguir, monte o esquema com os elementos básicos
(entrada / processamento / saída), construa o algoritmo com a solução para o problema
e, por fim, realize o teste de mesa para assegurar que a resposta esteja correta.
1) Construa um algoritmo que leia o código de um produto e imprima sua descrição
e seu preço, conforme a tabela a seguir. O algoritmo deverá emitir uma mensagem
de alerta, caso o código do produto digitado não esteja cadastrado.
1485 Camiseta 35,00

2395 Camisa 70,40
3400 Calça 120,00
4197 Jaqueta 190,00
5266 Moletom 90,00
2) Uma empresa concederá um aumento de salário aos seus funcionários, variáveis

de acordo com o cargo, conforme a tabela abaixo. Escreva um algoritmo que leia o
salário e o código do cargo de um funcionário, calcule o valor do novo salário. Se
o cargo do funcionário não estiver na tabela, ele deverá receber 40% de aumento.
Imprima a descrição do cargo, o salário antigo, o novo salário e a diferença.
Código Cargo % de aumento

101 Gerente 10%
102 Engenheiro 20%
103 Técnico 30%

Process Black
79
3) Escrever um algoritmo que leia os seguintes dados:

- o código do estado de origem da carga de um caminhão (conforme a Tabela 1);
- o peso da carga do caminhão em toneladas;
- o código da carga (conforme a Tabela 2).
Com base nestas informações, o algoritmo deve calcular e escrever:

- o peso da carga convertido em quilos;
- o preço da carga do caminhão;
- o valor do imposto, considerando o preço da carga e o estado de origem;
- o valor total transportado pelo caminhão (valor da carga + imposto).
Tabela 1 Tabela 2
Código do Estado Imposto Código da Carga Preço por quilo
1 35% 10 50,00
2 25% 20 100,00
3 15% 30 200,00
4 5%
5 isento
4) Escreva um algoritmo que calcule o que deve ser pago por um produto,
considerando como dados de entrada o preço normal de etiqueta e a escolha
da condição de pagamento. Utilize os códigos da tabela a seguir para efetuar
o cálculo do valor a ser pago dependendo da condição de pagamento.
Código Condição de pagamento

1 A vista, em dinheiro ou cheque, recebe 10% de desconto
2 A vista, no cartão de crédito, recebe 5% de desconto
3 Em 2 vezes, preço normal de etiqueta, sem juros
4 Em 3 vezes, preço de etiqueta mais juros de 10%
5) Faça um algoritmo que leia um número entre 1 e 7 e informe o dia da semana

correspondente, sendo domingo o número 1. Caso o número não corresponda
a um dia da semana, o algoritmo deverá emitir mensagem de erro.

Process Black
80

Process Black
7
Vanessa Lindemann
ESTRUTURA DE CONTROLE DE REPETIÇÃO:
ENQUANTO
Este capítulo dá continuidade à discussão a respeito de estruturas de controle

do fluxo de execução dos algoritmos. Enquanto as estruturas condicionais,
estudadas nos capítulos anteriores, têm como objetivo escolher entre diferentes
fluxos de execução, a partir da avaliação de uma expressão, as estruturas de
repetição possibilitam que uma ou mais instruções sejam executadas mais de
uma vez no algoritmo, enquanto uma condição de interrupção for satisfeita.
Como foi destacado no último exemplo do capítulo anterior (exemplo 6.3), em
determinadas situações, é necessário que um conjunto de instruções possa ser
repetido várias vezes. O exemplo mencionado deveria calcular o total gasto
por um cliente em uma lanchonete. Entretanto, na solução apresentada, só é
possível registrar a compra de um tipo de produto cada vez que o algoritmo é
executado. Não é possível, por exemplo, registrar a compra de uma torrada e
um refrigerante. Para resolver essa limitação, faz-se necessário o uso de uma das
estruturas de controle de repetição, como pode ser observado mais adiante.
As estruturas de controle de repetição dividem-se em ENQUANTO, REPITA
e PARA. Elas diferenciam-se em relação ao momento em que a condição de
interrupção será avaliada, que pode ser antes ou depois da primeira iteração.
Outro fator a ser considerado na escolha da estrutura de repetição a ser
usada refere-se ao conhecimento prévio sobre o número de iterações a serem
realizadas.
A estrutura de controle de repetição ENQUANTO é o objeto de estudo do presente
capítulo, as outras duas estruturas serão abordadas nos capítulos subsequentes. A
estrutura ENQUANTO permite executar uma ou mais instruções repetidamente

Process Black
82
enquanto sua condição de interrupção resultar verdadeiro. A sintaxe da estrutura

de repetição ENQUANTO é apresentada a seguir.

enquanto(<condição>)faça
Como pode ser observado, a condição de interrupção é verificada antes da execução

da instrução ou bloco de instruções a ser repetido. Se o resultado desta condição
for verdadeiro, a instrução ou bloco de instruções é executado e, logo após esta
iteração, o fluxo de execução retorna para o início da estrutura ENQUANTO e a
condição é avaliada novamente. Este processo é repetido até que a condição de
interrupção resulte falso. Neste caso, o fluxo de execução do algoritmo continuará
a partir da instrução imediatamente após à estrutura ENQUANTO. Vale destacar
que, como a condição de interrupção é avaliada no início da estrutura de controle,
quando esta resultar falso na primeira vez em que for verificada, a instrução ou
bloco de instruções da estrutura não será executado nenhuma vez.
Para exemplificar a aplicação da estrutura ENQUANTO, o problema descrito
no exemplo 6.3 será resolvido novamente a seguir neste capítulo denominado
exemplo 7.1.
Exemplo 7.1
Descrição do problema: considerando o cardápio de uma lanchonete, apresentado
a seguir, construa um algoritmo que calcule e informe o valor a ser pago por um
determinado cliente. O algoritmo deve ler o código do produto e a quantidade
adquirida, calcular e escrever o total a pagar.
001 Cachorro-quente 8,00
002 Torrada 6,00
003 Xis 12,00
004 Refrigerante 3,00
005 Suco 3,00
006 Água mineral 2,00

Process Black
83

Exemplo 7.1 - Calcula o total a ser pago por um cliente em uma lanchonete.
02 variáveis
03 codigo, qtde: inteiro
04 total: real
05 resp: caractere
06 início
07 total 0
08 resp "S"
09 enquanto(resp="S")faça
10 início
11 escrever("Digite o código do produto: ")
12 ler(codigo)
13 escrever("Digite a quantidade adquirida: ")
14 ler(qtde)
15 escolha(codigo)
16 caso 001: total total + (qtde*8.00)
22 senão
23 escrever("Código inválido!")
24 fim
25 escrever("Continuar o registro de produtos? S/N ")
26 ler(resp)
27 fim
28 escrever("Total a pagar = R$",total)
29 fim
Antes de iniciar a solução do algoritmo, é necessário ler com atenção o seu

enunciado para identificar os dados de entrada e saída e definir como processá-
los para resolver o problema. Neste caso, por exemplo, a partir da descrição
do problema não é possível saber previamente o número de iterações a serem
realizadas. Um cliente pode comprar dois itens diferentes (torrada + refrigerante),
outro cliente pode comprar quatro itens (torrada + refrigerante + xis + suco). Diante
deste contexto, após cada iteração, o usuário irá informar se deseja continuar o
registro de produtos ou totalizar a compra. A resposta do usuário é testada na
condição de interrupção (linha 09), de forma que enquanto sua resposta for S
(sim), o bloco de instruções (entre as linhas 10 e 27) que permite o registro de

Process Black
84
uma compra será repetido. Quando o usuário responder N (não), a condição de

interrupção não será satisfeita e o fluxo de execução continuará a partir da instrução

imediatamente após o bloco da estrutura ENQUANTO, ou seja, na linha 28, que
exibirá uma mensagem ao usuário com o valor total a ser pago.
Considerando que as estruturas de controle de repetição permitirão a criação
de algoritmos mais complexos, para os quais a necessidade de testes se faz mais
presente, propõe-se a realização do teste de mesa deste algoritmo, cujo resultado
pode ser observado no Quadro 7.2. Para simular a execução deste algoritmo foi
considerada a compra dos seguintes produtos: duas torradas, um xis e três sucos
- dados de entrada, listados à esquerda no Quadro 7.2.
Quadro 7.2 – Teste de mesa do exemplo 7.1

2 torradas variável Total a pagar = R$ 33,00
linha
1 xis resp cod qtde total
3 sucos 07 0
08 S
12 002
14 2
17 12.00
26 S
12 003
14 1
18 24.00
26 S
12 005
14 3
20 33.00
26 N
A simulação de execução é iniciada na linha 07 (Quadro 7.1), onde a variável

total é inicializada com 0 (zero), gerando o primeiro registro na tabela do teste
de mesa (Quadro 7.2). Na sequência (linha 08), a variável resp é inicializada com o
caractere S. Esta variável irá armazenar a resposta do usuário referente a continuar

Process Black
85
ou não o registro de produtos (linha 26) que, consequentemente, será a condição

de interrupção da estrutura ENQUANTO (linha 09). Entretanto, na primeira
verificação da condição de interrupção (linha 09), o usuário ainda não respondeu
se deseja continuar ou não e, por isso, a variável resp está vazia. Para que o bloco
de instruções da estrutura seja executado, a condição de interrupção da estrutura
deverá resultar verdadeiro, ou seja, a variável resp deve ser inicializada com S.
A condição de interrupção da linha 09 (Quadro 7.1) é avaliada e resulta verdadeiro
porque, neste momento, a variável resp está armazenando S, como pode ser
observado na segunda linha da tabela do teste de mesa, no Quadro 7.2. Na
sequência, o usuário irá informar o código do produto escolhido pelo cliente
(valor lido na linha 12 do Quadro 7.1 e armazenado na variável codigo) e a
quantidade adquirida (valor lido na linha 14 do Quadro 7.1 e armazenado na
variável qtde). A estrutura de seleção ESCOLHA é usada para desviar o fluxo
de execução para o caso 002, que representa a torrada comprada pelo cliente.
Neste momento, na linha 17 (Quadro 7.1), total total + (qtde*6.00),
ou seja, a variável total recebe o que ela já tinha armazenado (zero), mais o valor
resultante de (qtde*6.00) (ou seja, 2 torradas x 6,00 = 12,00), funcionando
como um acumulador (as variáveis usadas com a função de acumular valores
sempre devem ser inicializadas).
A execução terá continuidade na linha 25 (Quadro 7.1), na instrução imediatamente
após a estrutura ESCOLHA, quando o usuário será questionado se deseja continuar
o registro de produtos. Considerando os dados de entrada escolhidos para esta
simulação, a resposta do usuário deverá ser S pois ainda faltam registrar dois tipos
de produtos: xis e suco. Esta resposta é lida na linha 26 (Quadro 7.1) e armazenada
na variável resp, como pode ser observado no primeiro registro da linha 26 na
tabela do teste de mesa (Quadro 7.2). Encerra-se, portanto, a primeira iteração
desta simulação.
Ao encontrar o final do bloco de instruções da estrutura ENQUANTO (linha
27 Quadro 7.1), o fluxo de execução retorna para a linha 09, onde sua condição
de interrupção é testada novamente. Como a variável resp está armazenando S
neste momento, a condição resultará verdadeiro e, consequentemente, o bloco de
instruções da estrutura ENQUANTO será executado novamente nesta segunda
iteração será registrada a compra do produto de código 003 (xis). Uma terceira
iteração será executada para registrar a compra do produto de código 005 (suco).
Depois de registrar os sucos, o usuário deverá responder que não quer continuar
registrando produtos e a variável resp estará armazenando N, como mostra
a última linha da tabela do teste de mesa (Quadro 7.2). Logo, a condição de
interrupção não será satisfeita, ou seja, resp não é mais igual a S. O total a pagar
(R$ 33,00) é exibido ao usuário através da instrução da linha 28 (Quadro 7.1) e a
simulação do algoritmo é encerrada (linha 29 Quadro 7.1).

Process Black
86
Na sequência, outros exemplos da aplicação da estrutura de controle ENQUANTO

são apresentados. Serão encontradas, a partir da descrição dos problemas, três

situações diferentes em relação ao número de iterações a serem executadas: situação
01, quando o número de iterações é conhecido; situação 02, quando o número
de iterações não é conhecido, mas a descrição do problema define a condição de
interrupção; situação 03, quando nem o número de iterações, nem a condição de
interrupção são conhecidos.
Na construção de algoritmos não existe “receita de bolo” para resolver um
problema. Um mesmo problema pode ser resolvido de n formas diferentes e todas
as soluções estarem igualmente corretas. Entretanto, considerando as três situações
descritas acima, referentes ao número de iterações e à condição de interrupção
estarem ou não previamente definidos no enunciado do problema, algumas dicas
podem auxiliar na resolução dos problemas. Visando contribuir neste sentido, as
soluções apresentadas a seguir são classificadas conforme as situações descritas e
as instruções do algoritmo referentes a elas aparecem em negrito.
Exemplo 7.2
Descrição do problema: construa um algoritmo que leia 10 valores do tipo inteiro,
calcule e escreva a média dos valores lidos.
Este é um exemplo da primeira situação, ou seja, o número de iterações está
especificado na descrição do problema o bloco de instruções da estrutura de
repetição deverá ser executado 10 vezes. Nesta situação, cria-se uma variável
do tipo contador para controlar o fluxo da estrutura de repetição. Esta variável,
denominada cont, deverá: (a) ser inicializada no início do algoritmo (cont 0);
(b) ser validada na condição de interrupção para que sejam executadas 10 iterações
(cont <10); (c) para cada valor lido, contar um (cont cont + 1). Estas
instruções aparecem em negrito na solução em português estruturado apresentada
no Quadro 7.3. Na sequência, a Figura 7.1 ilustra esta mesma solução representada
em fluxograma.

Process Black
87

Exemplo 7.1 - Calcula a média de 10 valores lidos.
02 variáveis SITUAÇÃO 01
03 valor, soma, cont: inteiro N° de iterações determinado.
04 media: real
05 início
06 cont 0
07 soma 0
08 enquanto(cont<10)faça
09 início
10 escrever(“Digite um valor: “)
11 ler(valor)
12 cont cont + 1
13 soma soma + valor
14 fim
15 media soma / 10
16 escrever(“Média = “, media)
17 fim
Figura 7.1 Solução do exemplo 7.2 representada em fluxograma

Process Black
88
A Situação 02, em que o número de iterações não é conhecido mas a descrição do

problema define a condição de interrupção, pode ser observada no Quadro 7.4.

Neste exemplo, a entrada de dados deverá ser encerrada quando o usuário digitar
0 (zero). Portanto, a condição de interrupção irá testar a variável de entrada. A
variável valor é lida no início do algoritmo (linha 09 Quadro 7.4) e avaliada na
condição da linha 10 Quadro 7.4. Se a condição resultar verdadeiro, o bloco de
instruções da estrutura ENQUANTO será executado. Este bloco possui um contador
e um acumulador (linhas 12 e 13 Quadro 7.4), que serão usados para calcular a
média no final do algoritmo (linha 17 Quadro 7.4), além da instrução primitiva
de entrada (linha 15 Quadro 7.4) que irá ler um valor para cada nova iteração.
Exemplo 7.3
Descrição do problema: construa um algoritmo que leia vários valores do tipo
inteiro (0 encerra a entrada de dados), calcule e escreva a média dos valores
lidos.
Exemplo 7.3 - Calcula a média de vários valores lidos.
03 valor, soma, cont: inteiro N° de iterações determinado, com
04 media: real condição de interrupção definida.
05 início
06 cont 0
07 soma 0
08 escrever("Digite um valor: ")
09 ler(valor)
10 enquanto(valor<>0)faça
11 início
12 cont cont + 1
15 ler(valor)
16 fim
17 media soma / cont
18 escrever("Média = ", media)
19 fim

Process Black
89
O Quadro 7.5 ilustra a Situação 03, quando nem o número de iterações, nem a

condição de interrupção, são conhecidos. Como foi visto no exemplo 7.1, nestes
casos, é necessário criar uma variável auxiliar para controlar o fluxo de execução
nos exemplos deste capítulo usou-se a variável resp para tal função.
Exemplo 7.4
inteiro, calcule e escreva a média dos valores lidos.
Exemplo 7.4 - Calcula a média de vários valores lidos.
SITUAÇÃO 03
02 variáveis
N° de iterações indeterminado, sem
03 valor, soma, cont: inteiro
condição de interrupção definida.
04 media: real
05 resp: caractere
06 início
07 cont 0
08 soma 0
09 resp "S"
11 início
13 ler(valor)
14 cont cont + 1
16 escrever("Continuar? S/N ")
17 ler(resp)
18 fim
20 escrever("Média = ", media)
21 fim

Process Black
90
Exemplo 7.5
Descrição do problema: construa um algoritmo que leia 10 valores do tipo inteiro

e verifique quantos são múltiplos de três.
Exemplo 7.5 - Verifica quantos valores são múltiplos de três.
03 valor, cont, mult: inteiro N° de iterações determinado.
04 início
05 cont 0
06 mult 0
07 enquanto(cont<10)faça
08 início
09 cont cont + 1
10 escrever("Digite o ",cont,"° valor: ")
11 ler(valor)
12 Se(valor mod 3 = 0) então
13 mult mult + 1
14 fim
15 escrever(mult, " valores são múltiplos de 3.")
16 fim
Exemplo 7.6
Descrição do problema: escreva um algoritmo que leia um número não
determinado de valores (qualquer valor negativo encerra a entrada de dados),
encontre e escreva o menor entre eles.
Exemplo 7.6 - Encontra o menor entre os valores digitados pelo usuário.
SITUAÇÃO 02
02 variáveis
03 valor, menor: real N° de iterações indeterminado, com
04 início condição de interrupção definida.
06 ler(valor)
07 menor valor
08 enquanto(valor>=0)faça
09 início
10 se(valor<menor)então
11 menor valor
13 ler(valor)
14 fim
15 escrever("Menor valor = ", menor)
16 fim

Process Black
91
Exemplo 7.7

Descrição do problema: uma empresa deseja aumentar o preço de seus produtos
em 20%. Faça um algoritmo que leia o código e o preço atual de cada produto
da empresa, calcule e escreva o preço novo; calcule e escreva a média dos preços
com o aumento.
Exemplo 7.7 - Calcula o preço novo dos produtos e a média destes valores.
SITUAÇÃO 03
02 variáveis
03 cod, cont: inteiro
condição de interrupção definida.
04 preco,preconovo,soma,media:real
05 resp: caractere
06 início
07 cont 0
08 soma 0
09 resp "S"
11 início
12 escrever("Digite o código e o preço atual: ")
13 ler(cod, preco)
14 preconovo preco * 1.2
15 escrever("Preço com 20% de aumento = R$ ",preconovo)
16 soma soma + preconovo
17 cont cont + 1
19 ler(resp)
20 fim
22 escrever("Média dos preços com aumento = ", media)
23 fim
Exemplo 7.8
Descrição do problema: escreva um algoritmo para calcular a média final de cada
um dos alunos de uma turma de Algoritmos, considerando 03 notas: trabalho A
com peso 3, trabalho B com peso 2 e a prova com peso 5. Além disso, é importante
saber a média geral da turma.

Process Black
92

Exemplo 7.8 - Calcula a nota final dos alunos de uma turma e a média geral da turma.
03 cont: inteiro N° de iterações indeterminado, sem
04 n1, n2, n3, soma, media: real condição de interrupção definida.
05 resp: caractere
06 início
07 cont 0
08 soma 0
09 resp "S"
11 início
12 escrever("Digite as três notas do aluno: ")
13 ler(n1, n2, n3)
14 media (n1*3 + n2*2 + n3*5)/10
15 escrever("Média do aluno = ",media)
16 soma soma + media
17 cont cont + 1
19 ler(resp)
20 fim
22 escrever("Média geral da turma = ", media)
23 fim
Exemplo 7.9
Descrição do problema: Chico tem 1,5m e cresce 2cm por ano, enquanto Zé tem
1,1m e cresce 3cm ao ano. Construa um algoritmo que calcule e mostre quantos
anos serão necessários para que Zé seja maior que Chico.

Process Black
93

Exemplo 7.9 - Calcula quantos anos são necessários para que Zé seja maior que
Chico.
02 variáveis
03 cont: inteiro
04 chico, ze: real
06 início
07 cont 0
08 chico 1.5
08 ze 1.1
10 enquanto(ze<chico)faça
11 início
12 chico chico + 0.02
13 ze ze + 0.03
14 cont cont + 1
20 fim
22 escrever("São necessários", cont," anos para Zé > Chico.")
23 fim
Referências
Brasil, 2012.

Process Black
94
Atividades
Parte I - Questões objetivas

1) O algoritmo a seguir imprime os números pares entre 1 e 20.
( ) Certo
( ) Errado
algoritmo exerc1
variáveis
i,x,y: inteiro
início
i 10 x 20 y 1
se(i>=y)então
início
i y
y x
fim
enquanto(i<y)faça
início
i i + 1
escrever(i)
i i + 1
fim
fim
2) Simulando a execução do algoritmo a seguir,

algoritmo exerc2
variáveis
a: inteiro
início
ler(a)
enquanto(a<=100)faça
início
se(a > -10)então
escrever(a)
ler(a)
fim
fim

Process Black
95
tendo como dados de entrada 2, 9, 47, -7, -11, -49, 47, 30, 100, -100, -120, -47, 14,

114, 13, quantos números serão impressos?
(a) 8;
(b) 9;
(c) 7;
(d) 15;
(e) 6.
3) Qual a saída do algoritmo a seguir, se as entradas forem 1 e 9 e, depois, 5 e 3?

algoritmo exerc3
variáveis
i,v1,v2: inteiro
início
ler(v1,v2)
se(v1>v2)então
escrever(“O primeiro valor deve ser menor que o
segundo.”)
senão
início
i v1
enquanto(i<=v2)faça
início
se(i mod 2 <> 0)então
escrever(i,”, “)
i i + 1
fim
fim
fim

Process Black
96
(a) 1, 3, 5, 7, 9,
O primeiro valor deve ser menor que o segundo.
(b) 1, 3, 5, 7, 9
(c) 1, 3, 5, 7, 9,
3, 5
(d) 2, 4, 6, 8,
(e) 1, 3, 5, 7, 9,
4,
4) Quantos valores serão lidos no algoritmo a seguir?

algoritmo exerc4
variáveis
valor: inteiro
início
valor 0
enquanto(valor<>0)faça
início
escrever(“Digite um valor inteiro: “)
ler(valor)
fim
fim
(a) Tantos quantos forem digitados.
(b) Tantos quantos forem digitados, até ser digitado 0 (zero).
(c) Tantos quantos forem digitados, até ser digitado um valor negativo.
(d) Tantos quantos forem digitados, até ser digitado um valor que não é
inteiro.
(e) Nenhum.

Process Black
97
5) Considerando que X e Y são números inteiros positivos, assinale a alternativa

CORRETA que descreve a tarefa executada pelo algoritmo abaixo.
algoritmo exerc5
variáveis
x,y,z,w: inteiro
início
escrever(“Digite os valores de x e y: “)
ler(x,y)
z 1
enquanto(z*y<=x)faça
z z+1
z z-1
w x-z*y
escrever(z,w)
fim
(a) Exibe, respectivamente, o quociente e o resto da variável x pela variável y.
(b) Exibe, respectivamente, os dois primeiros números primos menores que x e y.
(c) Exibe, respectivamente, o resto e o quociente da variável x pela variável y.
(d) Exibe, respectivamente, o valor correspondente às variáveis y e x.
(e) Exibe, respectivamente, o valor correspondente às variáveis x e y.

Para cada um dos exercícios a seguir, construa o algoritmo com a solução
para o problema e realize o teste-de-mesa para assegurar que a resposta esteja
correta.
(1) Escreva um algoritmo que leia vários valores, conte e informe quantos
são positivos e quantos são negativos. A entrada de dados deve encerrar
quando o usuário digitar 0 (zero).
(2) Escreva um algoritmo que leia 20 valores, encontre e escreva o maior

entre eles.

Process Black
98
(3) Escreva um algoritmo que calcule a média dos números pares digitados
pelo usuário. A entrada de dados deve encerrar quando o usuário

digitar um valor menor ou igual a 0 (zero).
(4) Faça um algoritmo que lei um valor inteiro e positivo, calcule e escreva
o seu fatorial.
Exemplos: !4 = 1 x 2 x 3 x 4 = 24
!5 = 1 x 2 x 3 x 4 x 5 = 120
Por definição, !0 = 1
(5) Em uma eleição presidencial existem 4 candidatos. Os votos são

informados através de códigos, que obedecem a seguinte regra: 1, 2, 3,
4 = voto para os respectivos candidatos; 5 = voto nulo; 6 = voto branco.
Elabore um algoritmo que leia o voto de cada um dos eleitores, calcule
e escreva: total de votos para cada candidato; total de votos nulos; total
de votos em branco. Como finalizador do conjunto de dados tem-se o
valor 0 (zero).

1 - Certo
2-a
3-a
4-e
5-a

Process Black
8
Vanessa Lindemann
REPITA
Ao contrário da estrutura ENQUANTO, estudada no capítulo anterior, a condição

de interrupção da estrutura REPITA é verificada no final de cada iteração, como
pode ser observado na sua sintaxe, apresentada a seguir.
repita
até(<condição>)
Uma ou mais instruções serão executadas repetidamente até que sua condição
resulte verdadeiro. Como a condição só é avaliada no final de cada iteração, a
instrução ou bloco de instruções a ser repetido será executado pelo menos uma vez,
independente do valor inicial da condição de interrupção. Depois de cada iteração,
se o resultado da condição for falso, o fluxo de execução retorna para o início da
estrutura REPITA. Este processo é repetido até que a condição de interrupção resulte
verdadeiro. Neste caso, o fluxo de execução do algoritmo continuará a partir da
instrução imediatamente após à estrutura REPITA.
Como a estrutura de repetição REPITA é delimitada pela diretiva ATÉ, as diretivas
de início e fim não são utilizadas para delimitar seu bloco de instruções como nas
estruturas estudadas nos capítulos anteriores.
Para exemplificar a aplicação da estrutura REPITA, são apresentados na sequência
seis exemplos. Os três primeiros têm o mesmo objetivo, calcular e escrever o
percentual de valores negativos digitados pelo usuário. Entretanto, cada um
representa uma situação diferente em relação ao número de iterações ou à condição
de interrupção ser ou não previamente conhecido.

Process Black
100
No exemplo 8.1, a descrição do problema indica que deverão ser lidos 25 valores,
ou seja, o número de iterações é previamente conhecido cenário denominado

Situação 01. No exemplo 8.2, não é possível prever quantos valores serão digitados,
mas a condição de interrupção está definida (o valor zero deverá encerrar a entrada
de dados) cenário denominado Situação 02. Por fim, a descrição do problema do
exemplo 8.3 não contempla nenhuma destas informações, ou seja, não é possível
prever o número de iterações necessárias, nem a condição para encerrar o laço de
repetição cenário denominado Situação 03.
Como no capítulo anterior, os problemas são classificados em uma destas situações
e as instruções referentes a como prover o fluxo de repetição em tal situação
aparecem em negrito.
Exemplo 8.1
Descrição do problema: construa um algoritmo que leia 25 valores, calcule e escreva
o percentual de valores negativos.
Exemplo 8.1 - Calcula o percentual de valores negativos.
SITUAÇÃO 01
02 variáveis
N° de iterações determinado.
03 cont, negativo: inteiro
04 valor, perc: real
05 início
06 cont 0
07 negativo 0
08 repita
10 ler(valor)
11 cont cont + 1
12 se(valor < 0)então
13 negativo negativo + 1
14 até(cont=25)
15 perc (negativo*100)/25
16 escrever("% de negativos = ",perc)
17 fim

Process Black
101
Exemplo 8.2

inteiro (0 encerra a entrada de dados), calcule e escreva o percentual de valores
negativos.
03 cont, negativo: inteiro N° de iterações indeterminado, com
04 valor, perc: real condição de interrupção definida.
05 início
06 cont 0
07 negativo 0
08 repita
10 ler(valor)
11 cont cont + 1
14 até(valor=0)
15 perc (negativo*100)/cont
17 fim

Process Black
102
Exemplo 8.3

inteiro, calcule e escreva o percentual de valores negativos.
03 cont, negativo: inteiro N° de iterações indeterminado, sem
04 valor, perc: real condição de interrupção definida.
05 resp: caractere
06 início
07 cont 0
08 negativo 0
09 repita
11 ler(valor)
12 cont cont + 1
16 ler(resp)
17 até(resp="N")
18 perc (negativo*100)/cont
20 fim

Process Black
103
Exemplo 8.4

Descrição do problema: uma pesquisa realizada em um clube coletou informações
sobre as características físicas de 40 atletas, quais sejam: gênero (F- feminino, M -
masculino), idade, peso e altura. Escreva um algoritmo para identificar: a maior
idade entre os atletas; a porcentagem de mulheres e de homens; o nº de homens
com menos de 1,70m; o peso médio das mulheres.
Exemplo 8.4 - Pesquisa sobre as características físicas de atletas.
SITUAÇÃO 01
02 variáveis
04 peso, altura, soma, media: real
05 cont, idade, maior, fem, masc, alt: inteiro
06 início
07 cont 0
08 maior 0 fem 0 masc 0 soma 0 alt 0
09 repita
10 escrever("Digite gênero, idade, peso e altura: ")
11 ler(genero, idade, peso, altura)
12 se(idade>maior)então
13 maior idade
15 início
16 fem fem + 1
17 soma soma + peso
18 fim
19 senão
21 início
22 masc masc + 1
23 se(altura<1.70)então
24 alt alt + 1
25 fim
26 cont cont + 1
27 até(cont=40)
28 fem (fem*100)/40
29 masc (masc*100)/40
30 media soma/fem
31 escrever("Maior idade = ", maior)
32 escrever(fem,"% são mulheres e ", masc, "% homens")
33 escrever("Peso médio das mulheres = ", media)
34 escrever(alt, " homens medem menos que 1,70m")
35 fim

Process Black
104
Exemplo 8.5
Descrição do problema: construa um algoritmo que repita a leitura de uma senha

até que ela seja válida. Para cada senha incorreta escrever a mensagem “SENHA
INVÁLIDA”. Quando a senha for informada corretamente deve ser impressa a
mensagem “ACESSO PERMITIDO” e o algoritmo encerrado. Considere que a
senha correta é a76dk09.
Exemplo 8.5 - Valida senha.
03 senha: cadeia N° de iterações indeterminado, com
05 início condição de interrupção definida.
08 repita
09 escrever("Digite a senha: ")
10 ler(senha)
12 se(senha<>"a76dk09")então
13 escrever("Senha inválida")
14 até(senha="a76dk09")
16 escrever("Acesso permitido")
17 fim

Process Black
105
Exemplo 8.6

Descrição do problema: realizou-se uma pesquisa com professores de uma
universidade. Foram coletados os seguintes dados de cada professor: idade, tempo
de serviço na universidade (em anos) e quantidade de disciplinas que ministra.
Faça um programa que, a partir desses dados, calcule e informe: o percentual de
professores com idade entre 30 e 50 anos, a quantidade de professores com mais
de 10 anos de serviço e a média de disciplinas ministrada por professor.
Exemplo 8.6 - Pesquisa com professores de uma universidade.
SITUAÇÃO 03
02 variáveis
03 resp: caractere condição de interrupção definida.
04 perc, media: real
05 idade, ts, disc, qtde, cont, soma: inteiro
06 início
07 perc 0 qtde 0 soma 0 cont 0
08 repita
09 escrever("Digite idade: ")
10 ler(idade)
11 escrever("Digite tempo de serviço: ")
12 ler(ts)
13 escrever("Digite qtde de disciplinas que ministra: ")
14 ler(disc)
15 se(idade>=30)e(idade<=50)então
16 perc perc + 1
17 se(ts>10)então
18 qtde qtde + 1
19 soma soma + disc
20 cont cont + 1
22 ler(resp)
23 até(resp="N")
24 perc (perc*100)/cont
25 media soma/cont
26 escrever(perc,"% dos professores têm entre 30 e 50 anos")
27 escrever(qtde," prof. com tempo de serviço superior a 10")
28 escrever("Média de disciplinas por professor = , media")
29 fim

Process Black
106
Referências

Brasil, 2012.
Atividades
1) O algoritmo a seguir imprime a sequência de pares entre 1 e 100.
( ) Certo
( ) Errado
algoritmo exerc1
variáveis
n: inteiro
início
n 1
repita
escrever(i)
i i + 2
até(i=100)
fim
2) Simulando a execução do algoritmo a seguir,

algoritmo exerc2
variáveis
a: inteiro
início
repita
ler(a)
se(a > -10)então
escrever(a)
até(a>100)
fim

Process Black
107
tendo como dados de entrada 2, 9, 47, -7, -11, -49, 47, 30, 100, -100, -120, -47, 14,

114, 13, quantos números serão impressos?
(a) 8
(b) 9
(c) 7
(d) 15
(e) 6
3) O algoritmo a seguir tem como objetivo calcular a média dos valores lidos.
Entretanto, isto não acontece corretamente devido a um erro.
01 algoritmo exerc3
02 variáveis
03 n,s,m: real
04 i: inteiro
05 início
06 s 0
07 i 0
08 repita
09 ler(n)
10 s s + n
11 i i + 1
12 até(i=10)
13 m s/2
14 escrever(m)
15 fim
O erro está na linha:
(a) 3
(b) 10
(c) 13
(d) 9
(e) 12

Process Black
108
4) Quantos valores serão lidos no algoritmo a seguir?

algoritmo exerc4
variáveis
valor: inteiro
início
valor 0
repita
escrever(“Digite um valor inteiro: “)
ler(valor)
até(valor=0)
fim
(a) Tantos quantos forem digitados.
(b) Tantos quantos forem digitados, até ser digitado 0 (zero).
(c) Tantos quantos forem digitados, até ser digitado um valor negativo.
(d) Tantos quantos forem digitados, até ser digitado um valor que não é
inteiro.
(e) Nenhum.
5) Assinale a assertiva INCORRETA.

(a) Estruturas de repetição são necessárias para repetir uma instrução (ou
bloco de instruções), que represente um comportamento padrão, várias
vezes.
(b) Utilizando a estrutura de repetição REPITA, escreve-se uma instrução

uma única vez e ela pode ser executada várias vezes.
(c) Na estrutura REPITA o fluxo de repetição é controlado por um

contador.
(d) É imprescindível que haja uma instrução dentro do bloco de instruções

da estrutura REPITA que permita alterar o valor lógico da condição.
(e) A diferença entre as estruturas ENQUANTO e REPITA é que na segunda

as instruções são executadas no mínimo uma vez porque sua condição
só é verificada ao final de cada iteração.

Process Black
109

para o problema e realize o teste de mesa para assegurar que a resposta esteja
correta.
(1) Escreva um algoritmo que leia uma série não determinada de dois
valores. O primeiro valor é um código que significa: (1) débito, (2)
crédito e (0) fim. O segundo valor é uma quantia numérica real. O
programa deve calcular o total de débito e crédito e, ao final, mostrar
o saldo (crédito – débito).
(2) Durante uma pesquisa realizada entre os habitantes de uma região,

foram coletados os seguintes dados: idade, gênero e salário. Faça um
algoritmo que calcule e informe: a média salarial do grupo; a maior
idade do grupo; quantidade de mulheres com salário superior a R$
5.000,00.
(3) Um hotel cobra R$ 360,00 a diária e mais uma taxa de serviços. A taxa
é de: R$ 5,50 por diária, se o número de diárias for maior que 15; R$
6,00 por diária, se o número de diárias for igual a 15; R$ 8,00 por diária,
se o número de diárias for menor que 15. Construa um algoritmo que
imprima o nome e a conta (total das diárias, total da taxa e total a pagar)
de cada um dos clientes com reserva no hotel.
(4) Em um laboratório, usam-se dois tipos de cobaias: ratos e coelhos. O

código para ratos é 1, e para coelhos é 2. Foram feitas 30 experiências
que usaram essas cobaias. Faça um algoritmo que leia, para cada uma
das experiências, o código e a quantidade de cobaias utilizadas. Deseja-
se saber: o total de cobaias utilizadas e o percentual de cada tipo de
cobaia.
(5) Elabore um algoritmo que repita a leitura de uma data até que ela
seja válida. Para cada data incorreta escrever a mensagem “DATA
INVÁLIDA”. Quando a data for informada corretamente deve ser
impressa a mensagem “ACESSO DATA VÁLIDA” e o algoritmo
encerrado. Para resolver este problema, use três variáveis para
representar a data: dia, mês e ano; não esqueça de considerar ano
bissexto, quando o mês de fevereiro tem 29 dias.

Process Black
110

1 - Errado
2-b
3-c
4-b
5-c

Process Black
9
Vanessa Lindemann
PARA
A estrutura de repetição PARA, diferente das outras duas já estudadas, é controlada

por uma variável de controle, como pode ser observado na sintaxe apresentada
a seguir.
para <v> de <vi> até <vf> passo <p> faça
Onde:
• v representa a variável de controle;
• vi indica o valor inicial da variável de controle;
• vf indica o valor final da variável de controle;
• p define o incremento ou decremento da variável de controle.
A variável de controle assumirá, a cada iteração, um dos valores da faixa que inicia
com o valor vi e encerra no valor vf. O p corresponde ao incremento ou decremento
dado à variável de controle. O padrão é incrementar 1 a cada iteração, caso em que
a diretiva passo p pode ser omitida.
Nos capítulos anteriores, foram identificados três cenários onde são utilizadas as
estruturas de repetição: Situação 01, quando o número de iterações é previamente
conhecido; Situação 02, quando o número de iterações é indeterminado, mas tem-
se uma condição de interrupção definida; Situação 03, quando nem o número de
iterações, nem a condição de interrupção são previamente conhecidos - caso em
que é necessário usar uma variável auxiliar na condição de parada do laço de
repetição. Em português estruturado, a estrutura PARA só pode ser usada para

Process Black
112
resolver problemas em que o número de iterações é conhecido, ou seja, na Situação

01. Algumas linguagens de programação, entretanto, possibilitam a implementação

das outras situações.
Na Situação 01, o processo de repetição é denominado “laço contado” e, como
foi visto nos capítulos anteriores, este pode ser resolvido utilizando as estruturas
ENQUANTO e REPITA. Para isso, utiliza-se uma variável do tipo contador, que
tem seu conteúdo alterado a cada iteração como ilustram os trechos de algoritmos
apresentados no Quadro 9.1.
Quadro 9.1 Laço contado utilizando ENQUANTO e REPITA
ENQUANTO REPITA
01 cont 0 01 cont 0
02 enquanto(cont<25)faça 02 repita
03 início 03 <demais instruções>
04 <demais instruções> 04 cont cont + 1
05 cont cont + 1 05 até(cont=25)
06 fim
Como pode ser observado, nos dois exemplos do Quadro 9.1 a variável cont
é inicializada (linha 01), incrementada (linha 05 no exemplo com a estrutura
ENQUANTO e linha 04 com a estrutura REPITA) e testada para controlar o final
do laço de repetição (linha 02 na estrutura ENQUANTO, linha 05 na estrutura
REPITA). A estrutura PARA é a mais adequada para esta situação, pois há uma
economia de instruções, a própria estrutura se encarrega de inicializar, incrementar
e encerrar a variável de controle, como ilustra o Quadro 9.2. Estes três processos
ocorrem na linha 01.
Quadro 9.2 Laço contado utilizando PARA
PARA
01 para cont de 1 até 25 faça

02 início
03 <instruções>
04 fim
O valor inicial da variável de controle é definido como 1; em seguida, verifica-

se se a condição de interrupção foi atingida (ou seja, se a variável de controle já
chegou ao seu limite final que, neste caso, é 25): se a condição de interrupção foi

Process Black
113
atingida, a repetição se encerra e o algoritmo continuará sua execução na instrução

imediatamente seguinte à estrutura PARA; se a condição de interrupção não foi
atingida, o bloco de instruções da estrutura será executado e a variável de controle
é incrementada. Este processo será repetido até que a variável de controle atinja o
valor definido como limite final (25).
Para exemplificar a aplicação da estrutura de repetição PARA, os quadros a
seguir apresentam a solução de cinco problemas que utilizam esta estrutura na
sua solução.
Exemplo 9.1
Descrição do problema: construa um algoritmo que leia 10 valores, um de cada
vez, conte e escreva quantos estão no intervalo [10,20] e quantos estão fora deste
intervalo.
Exemplo 9.1 - Verifica quantos valores pertencem a um intervalo.
03 valor, cont, dentro, fora: inteiro N° de iterações determinado.
04 início
05 dentro 0 fora 0
07 início
09 ler(valor)
10 se(valor>=10)e(valor<=20)então
11 dentro dentro + 1
12 senão
13 fora fora + 1
14 fim
15 escrever(dentro, " números dentro do intervalo")
16 escrever(fora, " números fora do intervalo")
17 fim
Exemplo 9.2
Descrição do problema: construa um algoritmo que escreva os números pares
entre 1 e 100.

Process Black
114

Exemplo 9.2 - Soma os número ímpares de um intervalo.
SITUAÇÃO 01
02 variáveis
03 cont: inteiro
04 início
05 para cont de 2 até 100 passo 2 faça
06 escrever(cont)
07 fim
Exemplo 9.3
Descrição do problema: construa um algoritmo que escreva a soma dos números
ímpares entre dois valores quaisquer informados pelo usuário.
SITUAÇÃO 01
02 variáveis
03 cont, vi, vf, soma: inteiro
04 início
05 soma 0
06 escrever("Digite o valor inicial: ")
07 ler(vi)
08 escrever("Digite o valor final: ")
09 ler(vf)
10 para cont de vi até vf faça
11 início
12 se(cont mod 2 = 1)então
13 soma soma + cont
14 fim
15 escrever("Soma dos ímpares do intervalo = ", soma)
16 fim
Exemplo 9.4
Descrição do problema: construa um algoritmo que leia um valor inteiro, entre 1
e 10, e escreva a sua tabuada.

Process Black
115
Exemplo: 5

1x5=5
2 x 5 = 10
3 x 5 = 15
4 x 5 = 20
5 x 5 = 25
6 x 5 = 30
...
10 x 5 = 50
Exemplo 9.4 - Escreve a tabuada de um valor.
03 valor, cont: inteiro N° de iterações determinado.
04 início
05 escrever("Digite um valor inteiro entre 1 e 10: ")
06 ler(valor)
07 se(valor>=1)e(valor<=10)então
09 escrever(cont,"x",valor,"=",cont*valor)
10 senão
11 escrever("Valor inválido. Digite valore entre 1 e 10.")
12 fim
Exemplo 9.5
Descrição do problema: em uma pesquisa realizada com 1000 habitantes de
uma região, foram coletados os seguintes dados: idade, gênero e salário. Faça
um algoritmo que calcule e informe: a idade média do grupo, o percentual de
mulheres e de homens e, também, a quantidade de pessoas com salário superior
a R$ 5.000,00.

Process Black
116

03 cont, idade, soma, pessoa: inteiro N° de iterações determinado.
04 salario, media, fem, masc: real
06 início
07 soma 0 fem 0 masc 0 pessoa 0
09 início
10 escrever("Digite idade, gênero (M ou F) e salário: ")
11 ler(idade, genero, salario)
12 soma soma + idade
14 fem fem + 1
15 senão
17 masc masc + 1
18 se(salario>5000)então
19 pessoa pessoa + 1
20 fim
21 media soma/1000
22 fem (fem *100)/1000
23 masc (masc *100)/1000
24 escrever("Idade média = ", media)
25 escrever("Feminino = ", fem,"%")
26 escrever("Masculo = ", masc,"%")
27 escrever(pessoa, " pessoas possuem salário > 5.000,00")
28 fim
Referências
Brasil, 2012.

Process Black
117
Atividades

1) Considerando o algoritmo a seguir,
algoritmo exerc1
variáveis
num, cont, aux, e: inteiro
início
aux 1 e 1
repita
escrever("Digite um número inteiro positivo: ")
ler(num)
até(num>0)
para cont de 1 até num faça
início
aux aux * cont
e e + aux
fim
escrever(e)
fim
qual a saída se a entrada for 3 e depois 5?
(a) 3 e 5;
(b) 10 e 154;
(c) 9 e 153;
(d) 11 e 155;
(e) 4 e 34.
2) Considerando o algoritmo a seguir,

algoritmo exerc2
variáveis
v1, v2, s, x: inteiro
início
s 0
ler(v1, v2)
para x de v1 até v2 faça
s s + 2
escrever(s)
fim

Process Black
118
qual a saída, tendo como entrada 3 e 8?

(a) 7;
(b) 8;
(c) 6;
(d) 10;
(e) 12.
3) O algoritmo a seguir...
algoritmo exerc3
variáveis
i: inteiro
início
para i de 100 até 1 passo -2 faça
escrever(i)
fim
(a) imprime os números de 1 a 100 em ordem decrescente;
(b) imprime os números pares entre 100 e 1 em ordem crescente;
(c) imprime os números ímpares entre 1 e 100 em ordem crescente;
(d) imprime os números entre 1 e 100;
(e) imprime os números pares entre 1 e 100 em ordem decrescente.
4) Considerando o trecho de algoritmo a seguir,

k 0
escrever(“Digite o valor de n: “)
ler(n)
para z de 1 até n faça
para i de 1 até n faça
para j de i até n faça
k k + 1
pode-se afirmar que o valor de k para qualquer valor de n, ao final da execução será:
(a) n3 ;
(b) n2 ;

Process Black
119
(c) n2 + log n;

(d) n2(n+1)/2;
(e) (n3-n)/3.
5) No final da execução do trecho de algoritmo a seguir,

k 0
para i de 1 até n faça
para j de i até n faça
k k + 1
quanto vale k?
(a) n3 ;
(b) (n2–n)/2;
(c) n(n+1)/2;
(d) n-1;
(e) n.

para o problema e realize o teste-de-mesa para assegurar que a resposta esteja
correta.
1) Escrever um algoritmo que gere números entre 1000 e 1999 e escreva
aqueles que divididos por 11 dão resto 5.
2) Foi feita uma pesquisa em 20 cidades brasileiras para coletar dados

sobre os acidentes de trânsito ocorridos no ano de 2012. Em cada
cidade, foram obtidos os seguintes dados referentes a 2012: código da
cidade, número de veículos de passeio, número de acidentes de trânsito
com vítimas e número de acidentes de trânsito sem vítimas. Deseja-se
saber:
(a) o total de acidentes de trânsito nas 20 cidades que participaram da

pesquisa;

Process Black
120
(b) o maior e o menor número de acidentes de trânsito com vítimas e

a que cidades pertencem;
(c) o percentual de acidentes de trânsito sem vítimas em cada uma das

20 cidades que participaram da pesquisa;
(d) a média de veículos nas 20 cidades juntas.
3) Faça um algoritmo que leia um valor inteiro e positivo, calcule e escreva

o seu fatorial.
Exemplos: !4 = 1 x 2 x 3 x 4 = 24
!5 = 1 x 2 x 3 x 4 x 5 = 120
Por definição, !0 = 1
4) Elabore um algoritmo que leia um valor inteiro, verifique e informe se

ele é primo.
5) Faça um algoritmo para calcular e escrever o valor de R.

5x6 6x5 5x6 6x5 ... 5x6 6x5
R= + + + + + +
10 9 8 7 ... 2 1

1-b
2-e
3-e
4-e
5-b

Process Black
10
Vanessa Lindemann
INTRODUÇÃO À LINGUAGEM C
A linguagem C, criada por Dennis Ritchie na década de 70, resultou de um processo

evolutivo de linguagens e, durante alguns anos, teve seu padrão baseado na versão
5 do sistema operacional UNIX. Com a popularização dos microcomputadores,
várias versões de C foram criadas, gerando muitas discrepâncias entre elas. Para
resolver essa situação, em 1983, o ANSI (American National Standards Institute)
estabeleceu um comitê para definir um padrão que guiasse todas as implementações
da linguagem C.
A popularização da linguagem C deve-se a vários fatores, dentre os quais
destacam-se: (a) o poderoso conjunto de operadores e tipos de dados disponíveis;
(b) a portabilidade, podendo ser usada em máquinas de portes e de sistemas
operacionais diferentes; (c) as características de linguagens de alto nível
(comandos com sintaxe próxima à linguagem humana e tipos de dados inteiro,
real e caractere) como, por exemplo, as linguagens Pascal, Delphi e Visual Basic,
aliadas às características de linguagens de baixo nível (também conhecidas como
linguagem de máquina, manipulam bits, bytes e endereços) como a linguagem
Assembler, por exemplo.
C é uma linguagem de propósitos gerais, estruturada e compilada (o compilador
lê o código-fonte do programa inteiro e converte-o em um código executável).
Ela é utilizada para a construção de sistemas operacionais (UNIX e LINUX, por
exemplo), compiladores, interpretadores, editores de textos, planilhas eletrônicas,
aplicativos para dispositivos móveis, etc.

Process Black
122
Um programa em linguagem C consiste em uma ou mais funções. A função

principal, denominada main, indica onde o programa inicia. A estrutura básica

de um programa em C é apresentada a seguir.
#inlcude <nome da biblioteca>

void main( ) {
// bloco de comandos
}
Bibliotecas são arquivos contendo várias funções que podem ser incorporadas aos
programas escritos em C. A diretiva #include faz com que as funções inseridas na
biblioteca especificada possam ser utilizadas no programa. As bibliotecas stdio.h
e conio.h permitem a utilização de diversos comandos de entrada e saída e de
funções de tela, respectivamente. São exemplos de funções de tela, os comandos
usados para limpar a tela, posicionar o cursor em uma determinada posição na
tela, trocar a cor da fonte e/ou do fundo.
Os parênteses ao lado da palavra main indicam que ela é uma função, o tipo void
indica que ela não retornará nenhum valor, enquanto as chaves delimitam o seu
início e o seu fim. O bloco de comandos que estiver entre as chaves é executado
sequencialmente quando a função for chamada.
É importante salientar que a linguagem C é case sensitive, ou seja, é sensível a letras
maiúsculas e minúsculas (por exemplo, a é diferente de A) e todos os programas
devem, obrigatoriamente, ser escritos em letras minúsculas. Outro detalhe
importante é que cada comando é finalizado com um ponto-e-vírgula.
As seções a seguir são dedicadas à apresentação de conceitos e definições
importantes e necessárias para o início da programação em linguagem C.
10.1 Identificadores
Em linguagem C, os nomes utilizados para referenciar variáveis, constantes e
funções definidas pelo usuário são chamados de identificadores.
A criação de um identificador deve seguir as seguintes regras: podem ser formados
por letras, números e sublinhado; devem iniciar com uma letra; letras minúsculas
e maiúsculas são consideradas caracteres distintos; não podem ser palavras
reservadas; podem conter qualquer tamanho, porém apenas os 32 primeiros
caracteres são significativos.
Além disso, é importante criar identificadores considerando a sua aplicação
para facilitar a leitura do código-fonte e, consequentemente, o trabalho do
programador. A quantidade de horas trabalhadas por uma pessoa durante uma

Process Black
123
semana de trabalho pode ser armazenada em uma variável chamada qtde_horas;

enquanto uma função que irá verificar se uma data é válida ou não pode ter como
indentificador valida_data.
10.2 Tipos de dados

Os tipos de dados mais utilizados em linguagem C são: int (número inteiro),
float (número real) e char (caractere). A linguagem C não possui tipo de dado
lógico (que pode assumir verdadeiro ou falso), pois considera qualquer valor
diferente de 0 (zero) como verdadeiro; e também não possui um tipo especial para
armazenar cadeias de caracteres (string), estas são armazenadas em um vetor de
caracteres. A Tabela 10.1 apresenta a lista de tipos básicos utilizados em C.
Tabela 10.1 Tipos de dados mais utilizados em Linguagem C
Tipo Faixa de valores Tamanho (aproximado)
char -127 a 127 8 bits
int -32.767 a 32.767 16 bits
float 3.4 E-38 a 3.4 E+38 32 bits
double 1.7 E-308 a 1.7 E+308 64 bits
void sem valor 0
A faixa de valores apresentada está de acordo com o padrão ANSI e é considerada

a faixa mínima. Dependendo do processador e do compilador C que estiver sendo
utilizado, o tamanho e a faixa de valores podem variar.
10.3 Modeladores
É possível forçar que o resultado de uma expressão seja de um tipo específico
usando o conceito de modelador. A forma geral de um modelador é
(tipo)expressão
onde tipo é um dos tipos padrão da linguagem C.
Sendo r uma variável declarada do tipo float, as expressões a seguir resultam
em valores diferentes.
r=9/2; // essa expressão resulta 4
r=(float)9/2; // com o uso do modelador, resulta 4.5

Process Black
124
10.4 Declaração, inicialização e escopo de variáveis

Variável é uma posição de memória, identificada por um nome (identificador),

usada para armazenar um dado de um determinado tipo por vez. As variáveis
são declaradas após a especificação de seus tipos, como pode ser observado nos
exemplos a seguir.
float total;
int idade, cont;
char resposta;
A primeira linha da declaração de variáveis do exemplo cria uma variável chamada
total, que pode armazenar valores do tipo real; na segunda linha, são criadas
duas variáveis para armazenar valores do tipo inteiro, idade e cont; por último,
resposta é criada para armazenar caracteres (um por vez). Cada variável
armazenará um único valor por vez.
As variáveis podem ser inicializadas no momento da sua declaração, colocando o
sinal de atribuição seguido da informação desejada, como no exemplo apresentado
a seguir, em que cont é inicializada com 0 e resposta com S. É importante
destacar que os dados atribuídos a variáveis do tipo caractere são envolvidos por
apóstrofes.
int cont=0;
char resposta=’S’;
O local em que as variáveis são declaradas definem o seu escopo, que pode ser
global ou local. As variáveis de escopo global, denominadas variáveis globais, são
declaradas fora de qualquer função, inicializadas automaticamente com 0 (zero)
e podem ser usadas em qualquer ponto do programa. As variáveis locais são
declaradas dentro de uma função, não são inicializadas automaticamente e valem
enquanto esta função estiver ativa. As variáveis de escopo local têm preferência
em relação às de escopo global.
10.5 Definição de constantes

Uma constante irá representar um valor fixo, previamente definido pelo
programador e inalterável no programa. Uma das formas de definir constantes
em C é através da diretiva #define, seguida do nome da constante e do valor que
esta representará no programa. No exemplo a seguir, apresenta-se a declaração
da constante pi cujo valor é definido como 3.141516. Observe que na definição de
uma constante não se usa o ponto-e-vírgula no final.
#define pi 3.141516
Desta forma, o programador usará pi no programa ao invés de usar 3.141516.

Process Black
125
10.6 Códigos de formato

Os códigos de formato, apresentados na Tabela 10.2, são constantes que definem
o formato dos dados a serem lidos e exibidos na tela.
Tabela 10.2 Códigos de formatação
Código Formato
%c Caractere
%i Inteiro
%l Inteiro longo
%d Inteiro em formato decimal
%ld Decimal longo
%u Decimal sem sinal
%f Ponto flutuante em formato decimal
%lf Ponto flutuante longo (double)
%s Cadeia de caracteres (string)
%e Valor em notação científica
%o Valor em notação octaldecimal
%x Valor em notação hexadecimal
%p Ponteiro
%% Símbolo %
Eles são usados em funções de entrada e de saída de dados (descritas na seção 10.11).
A função de entrada scanf, por exemplo, possui dois parâmetros: o código de
formato e uma variável. Neste caso, o valor digitado pelo usuário será armazenado
na variável denominada peso, declarada e formatada como float.
scanf(“%f”,&peso);
A função printf, exemplificada a seguir, também contém dois parâmetros: o
primeiro é uma constante, apresentada entre aspas; o segundo é uma variável,
denominada dias. O valor armazenado na variável dias será exibido na posição
em que aparece o código de formato usado na mensagem, neste caso o %i.
printf(“Sua idade em dias e: %i”, dias);

Process Black
126
Os códigos de formato podem ter modificadores que especifiquem o tamanho do

campo, o número de casas decimais e um indicador de justificação à esquerda.

Especificador de largura mínima do campo: um valor entre o símbolo % e o
caractere de formato indica a largura mínima do campo, preenchendo a saída com
brancos (padrão) ou com zeros (coloca-se um 0 antes do especificador de tamanho).
Quando um valor é maior que o mínimo definido, este será impresso por completo.
Exemplos: %05d preencherá um número com menos de cinco dígitos com zeros à
esquerda, de maneira que seu tamanho total seja cinco.
Especificador do número de casas decimais: para definir o número de casas
decimais a serem exibidas em um ponto flutuante, usa-se um ponto entre o
especificador de tamanho e o número de casas decimais desejadas. Por exemplo:
%6.2f exibirá um valor com, no mínimo, seis dígitos de comprimento e duas
casas decimais.
Especificador para justificar informação à esquerda: por definição, toda saída é
justificada à direita. O uso do sinal – depois do % faz com que a saída seja justificada
à esquerda. Exemplo: %-6.2f justificará à esquerda um valor de ponto flutuante,
com no mínimo seis dígitos e duas casas decimais.
A Tabela 10.3 apresenta exemplos da utilização dos especificadores de tipos. O
caractere especial \n, usado nos exemplos, é explicado na próxima seção.
Tabela 10.3 Exemplo da utilização dos especificadores de tipos
Código Resultado
float valor=136.472;
printf(“\n %f”,valor); 136.472000

printf(“\n %8.1f”,valor); 136.5
printf(“\n %08.1f”,valor); 000136.5
printf(“\n %-8.1f”,valor); 136.5
int valor=790;
printf(“\n %i”,valor); 790

printf(“\n %5i”,valor); 790
printf(“\n %05i”,valor); 00790
printf(“\n %-5i”,valor); 790
printf(“\n O valor total é %2d.”,350); O valor total é 350.


Process Black
127
10.7 Caracteres especiais

Os caracteres especiais são usados para representar alguma formatação em
particular e caracteres especiais que seriam impossíveis de usar diretamente no
código-fonte. Esses caracteres devem ser precedidos da barra invertida, como
o \n que representa nova linha. A Tabela 10.4 apresenta os caracteres e seus
significados.
Tabela 10.4 Códigos de caracteres de escape
Código Significado Código Significado
\a alerta (beep) \v tab vertical
\b retrocesso (backspace) \\ exibe barra invertida
\f avanço de página \’ exibe aspa única
\n nova linha \“ exibe aspas duplas
\r retorna ao início da linha \? exibe ponto de interrogação
\t tab horizontal \0 nulo
10.8 Comando de atribuição

O comando de atribuição, representado por = (sinal de igualdade), é utilizado para
atribuir valores a variáveis. É importante lembrar que os valores atribuídos a uma
variável devem ser compatíveis com o seu tipo. Alguns exemplos de atribuição
podem ser observados a seguir.
total=345.60;
idade=20;
resp=’s’;
cont=cont+1;
Os caracteres são representados entre apóstrofos ( ‘ ) e as cadeias de caracteres
entre aspas ( “ ).
É possível atribuir um valor a duas ou mais variáveis através de um único comando,
como no exemplo a seguir, em que as variáveis x e y recebem 10.
x=y=10;
Caso seja necessário atribuir uma cadeia de caracteres a uma variável, utiliza-se
a função strcpy.
strcpy(nome,“Ana Paula Rocha”);

Process Black
128
Para utilizar strcpy (abreviação de string copy) é preciso inserir no programa,

através da diretiva include, a biblioteca string.h.
10.9 Operadores e funções

A linguagem C possui operadores e funções predefinidas destinadas a cálculos
matemáticos e à manipulação de caracteres. Alguns deles são apresentados nas
Tabelas 10.5 e 10.6. Para utilizar as funções matemáticas, a biblioteca math.h deve
ser incluída no programa através da diretiva include. Os operadores lógicos são
apresentados na Tabela 10.7.
Tabela 10.5 Operadores aritméticos
Operadores Matemáticos
Operador Exemplo Comentário
+ a + b Soma o conteúdo de a e de b.
- a – b Subtrai o conteúdo de b do conteúdo de a.
* a * b Multiplica o conteúdo de a pelo conteúdo de b.
/ a / b Divide o conteúdo de a pelo conteúdo de b.
% a % b Obtém o resto da divisão de a por b.*
* O operador % só pode ser utilizado com operandos do tipo inteiro.
Tabela 10.6 Operadores relacionais
Operadores Relacionais
Operador Exemplo Comentário
== a == b Testa se o conteúdo de a é igual ao conteúdo de b.
!= a != b Testa se o conteúdo de a é diferente do conteúdo de b.
<= a <= b Testa se o conteúdo de a é menor ou igual que o conteúdo de b.
>= a >= b Testa se o conteúdo de a é maior ou igual que o conteúdo de b.
< a < b Testa se o conteúdo de a é menor que o conteúdo de b.
> a > b Testa se o conteúdo de a é maior que o conteúdo de b.

Process Black
129
Tabela 10.7 Operadores lógicos

Operador Símbolo Descrição
e && Conjunção
ou || Disjunção
não ! Negação
Em C, também pode-se utilizar operadores reduzidos, exemplificados na Tabela 10.8.
Tabela 10.8 Operadores reduzidos
Expressão Equivalente com operadores reduzidos
total=total+valor; total+=valor;
num=num*5; num*=5;
d=d-valor; d-=valor;
x=x/5; x/=5;
Além dos operadores apresentados anteriormente, a linguagem C disponibiliza

operadores de pré e pós incremento e decremento, descritos na Tabela 10.9. O
operador ++ incrementa 1 ao valor do seu operando, enquanto –- decrementa 1.
Estes operadores podem ser usados antes (pré-fixados) ou depois (pós-fixados) do
nome da variável. Em ambos os casos a variável é incrementada ou decrementada.
Entretanto, ++n incrementa o valor da variável n antes que n seja usada e n++
usa o valor de n e depois o incrementa.
Tabela 10.9 Operadores pré e pós-fixados
Operador Descrição Pré-fixado Pós-fixado
++ Incrementa ++n n++
-- Decrementa --n n--

Process Black
130
Resumindo:
++i incrementa o valor de i em 1 e depois o utiliza;

i++ utiliza o valor de i e depois incrementa-o em 1.
Logo, conclui-se que:
z=a; a=a+1; é equivalente a z=a++;
z=a; a=a-1; é equivalente a z=a--;
a=a+1; z=a; é equivalente a z=++a;
a=a-1; z=a; é equivalente a z=--a;
10.10 Comentários
Os comentários são textos que podem ser inseridos no programa com o objetivo de
documentá-lo e não são analisados pelo compilador. Os comentários de uma linha
são precedidos do símbolo //, enquanto o comentário de várias linhas é envolvido
por /* e */, conforme pode ser observado nos exemplos a seguir.
// Este é um comentário de uma linha.
/* Este é um comentário
de mais de uma linha. */
10.11 Funções de entrada e saída

As funções de entrada de dados são utilizadas para receber dados digitados pelo
usuário. Os dados recebidos são armazenados em variáveis já declaradas no início
do programa. As funções de entrada mais utilizados em C são scanf, fgets
e getche.
A função scanf é utilizada para ler dados dos tipos numérico e caractere, enquanto
a função fgets é utilizada para ler uma cadeia de caracteres e a função getche
pode ser utilizada para ler um caractere por vez.
O trecho de código a seguir apresenta um exemplo da utilização das funções scanf
e getche. Os dois valores do tipo float são lidos com a função scanf (linhas 2
e 6) e o dado do tipo caractere é lido com getche (linha 4).
1 printf(“Digite o primeiro valor: “);
2 scanf(“%f”,&valor1);
3 printf(“Digite o operador: “);
4 operador = getche();
5 printf(“Digite o segundo valor: “);
6 scanf(“%f”,&valor2);

Process Black
131
A sintaxe das duas funções é diferente. A função scanf tem dois parâmetros: o

primeiro indica o tipo do dado a ser lido (Tabela 10.2 – códigos de formatação),
especificado por uma letra depois do símbolo % entre as aspas; e o nome da
variável, antecedido do símbolo & (sem espaço) que referencia um endereço de
memória. A função getche lê um caractere pressionado no teclado pelo usuário
e o escreve na tela. Na linha 4, a variável operador recebe o valor lido através da
função getche.
Um exemplo da utilização da função fgets pode ser observado nas linhas de
código apresentadas a seguir. A função fgets possui três parâmetros – o nome
da variável, o tamanho máximo da variável e a entrada de dados padrão (stdin
= standard input) – e antes de utilizá-la é preciso liberar o buffer do dispositivo de
entrada de dados, o que é feito através da função fflush.
1 printf(“Nome do aluno...: “);
2 fflush(stdin);
3 fgets(nome,60,stdin);
A função de saída é utilizada para apresentar dados na tela, seja uma mensagem, o
resultado de uma expressão ou o conteúdo armazenado em uma variável. A função
de saída mais utilizada em C é o printf, que pode ser observado nos dois trechos
de códigos apresentados anteriormente e na linha de código a seguir.
printf(“Sua idade em dias e: %i”, dias);
Nesse exemplo, o comando printf tem dois parâmetros: a mensagem e a variável.
O valor armazenado na variável dias será apresentado na tela no lugar em que
está o %i na mensagem (o %i é a formatação do dado a ser exibido, que neste caso
é um inteiro).
10.12 Estruturas de controle condicional

A seguir, são apresentados dois exemplos que utilizam estruturas de controle
condicional - o exemplo 10.1 exemplifica a aplicação da estrutura SE (em C, if) e
o exemplo 10.2 da estrutura ESCOLHA (em C, switch). Na coluna da esquerda
dos Quadros 10.1 e 10.2, aparece a solução em português estruturado, enquanto a
coluna da direita apresenta a mesma solução em linguagem C.

Process Black
132
Quadro 10.1 Exemplo da estrutura de controle condicional SE
Exemplo 10.1 - Ler um valor do tipo inteiro e verificar se ele é par ou ímpar.
Português estruturado – SE Linguagem C - if
#include <stdio.h> //bibliotecas
Algoritmos e programação I.indd 132

#include <conio.h>
algoritmo exemplo101 void main() {

variáveis
valor: inteiro int valor;
Process Black
início
clrscr(); //limpa a tela
gotoxy(10,10); //posiciona o cursor
escrever("Digite um valor: ") printf("Digite um valor: ");
ler(valor) scanf("%i",&valor);
gotoxy(10,14);
se(valor mod 2 = 0)então if(valor%2==0)
escrever(valor," é par.") printf("%i é par.", valor);
senão else
escrever(valor," é ímpar.") printf("%i é ímpar.", valor);
getch(); //pausa
fim }
7/8/2013 16:01:22
133
Quadro 10.2 Exemplo da estrutura de controle condicional ESCOLHA

Exemplo 10.2 - Construir uma calculadora que contenha as operações: +, - , * e /.
Português estruturado - ESCOLHA Linguagem C - switch

#include <conio.h>
algoritmo exemplo102 void main(){

variáveis
valor1,valor2,r: real float valor1,valor2, r;
operador: caractere char operador;
início
gotoxy(10,5); //posiciona o cursor
escrever("Digite o 1º valor: ") printf("Digite o primeiro valor: ");
ler(valor1) scanf("%f",&valor1);
gotoxy(10,8);
escrever("Digite o operador: ") printf("Digite o operador: ");
ler(operador) operador = getche();
gotoxy(10,11);
escrever("Digite o 2º valor: ") printf("Digite o segundo valor: ");
ler(valor2) scanf("%f",&valor2);
escolha(operador) switch(operador){
caso "+": r valor1 + valor2 case'+': r = valor1 + valor2; break;
caso "-": r valor1 - valor2 case'-': r = valor1 - valor2; break;
caso "*": r valor1 * valor2 case'*': r = valor1 * valor2; break;
caso "/": se(valor2<>0)então case'/': if(valor2!=0)
r valor1/valor2 r = valor1 / valor2;
senão else
r 0 r = 0;
break;
senão else{
gotoxy(10,20);
escrever("Operador inválido!") printf("Operador inválido!");
}
fim }
gotoxy(10,24);
escrever ("Resultado = ", r) printf("Resultado = %3.2f", r);
getch(); //pausa
fim }
10.13 Estruturas de controle de repetição

As estruturas de controle de repetição são exemplificadas nos quadros a seguir.
Para facilitar o entendimento, a coluna da esquerda dos Quadros 10.3, 10.4 e 10.5
apresenta a solução em português estruturado e a da direita em linguagem C.

Process Black
134
Quadro 10.3 Exemplo da estrutura de controle de repetição ENQUANTO

Exemplo 10.3 - Ler 10 valores do tipo inteiro, calcular e escrever a média dos valores
lidos.
Português estruturado – ENQUANTO Linguagem C – while

#include <conio.h>

variáveis
valor,soma,cont: inteiro int valor, soma, cont;
media: real float media;
início
cont 0 cont = 0;
soma 0 soma = 0;
enquanto(cont<10)faça while(cont<10)
início {
gotoxy(10,10); //posiciona cursor
escrever("Digite um printf("Digite um valor: ");
valor: ") scanf("%i",&valor);
ler(valor) cont = cont + 1;
cont cont + 1 soma = soma + valor;
soma soma + valor }
fim media = soma / 10;
media soma / 10 gotoxy(10,14);
printf("Media = %.2f", media);
escrever("Média = ", media) getch(); //pausa
fim }

Process Black
135
Quadro 10.4 Exemplo da estrutura de controle de repetição REPITA

Exemplo 10.4 - Ler 25 valores, calcular e escrever o percentual de valores negativos.
Português estruturado – REPITA Linguagem C – do while

#include <conio.h>

variáveis
cont: inteiro int cont;
valor, negativo, perc: real float valor, negativo, perc;
início
cont 0 cont = 0;
negativo 0 negativo = 0;
repita do{
clrscr();
gotoxy(10,10);
escrever("Digite um valor: ") printf("Digite um valor: ");
ler(valor) scanf("%f",&valor);
cont cont + 1 cont = cont + 1;
se (valor < 0) então if(valor < 0)
negativo negativo + 1 negativo = negativo + 1;
até(cont=25) } while(cont<25);
perc (negativo*100)/25 perc = (negativo*100)/25;
gotoxy(10,14);
escrever("% negativos = ",perc) printf("%%denegativos=%.2f",perc);
getch(); //pausa
fim }

Process Black
136
Quadro 10.5 Exemplo da estrutura de controle de repetição PARA

Exemplo 10.5 - Ler 10 valores do tipo inteiro, calcular e escrever a média dos valores lidos.
Português estruturado – PARA Linguagem C – for

#include <conio.h>

variáveis
valor,soma,cont: inteiro int valor, soma, cont;
media: real float media;
início
soma 0 soma = 0;
para cont de 1 até 10 faça for(cont=1;cont<=10;cont++)
início {
gotoxy(10,10);//posiciona cursor
escrever("Digite um valor: ") printf("Digite o %i valor: ",cont);
ler(valor) scanf("%i",&valor);
soma soma + valor soma = soma + valor;
fim }
media soma / 10 media = soma / 10;
gotoxy(10,14);
escrever("Média = ", media) printf("Media = %.2f", media);
getch(); //pausa
fim }
Referências
Brasil, 2012.
MATTOS, Patrícia Noll de. Linguagem de Programação II (Caderno Universitário 027). 2.ed.
Canoas: Ed. ULBRA, 2001.
SCHILDT, Herbert. C Completo e Total. 3. ed. São Paulo: Makron Books, 1997.

Process Black
137
Atividades

1) A sintaxe das declarações de variáveis em C inclui o nome da variável seguido
de um tipo.
( ) Certo
( ) Errado
2) São nomes válidos para variáveis na linguagem C:

(a) if, a*b_2, H789, &ya;
(b) A, b, Y, count;
(c) 9xy, a36, x*y, --j;
(d) 2_ou_1, \fim, h, j;
(e) i, j, int, obs.
3) Em C, os nomes cont e Cont não podem ser empregados para representar a

mesma variável ao longo de um programa.
( ) Certo
( ) Errado
4) Uma string é uma sequência de caracteres armazenada em um vetor de

caracteres.
( ) Certo
( ) Errado

Process Black
138
5) O que faz o seguinte programa em C ?

#include <stdio.h>
void main( ){
int i =2;
printf (“O valor de i = %i \n”, i);
}
(a) Imprime: O valor de i = 2 e pula para a próxima linha;
(b) Imprime: O valor de i = 2 \n;
(c) Pula para a próxima linha e imprime: O valor de i = 2 ;
(d) Imprime: O valor de i = 2 ;
6) Qual o resultado das variáveis j, k e l depois da seguinte sequência de

operações?
int j,k,l; j=k=10; l=++j; j=-j; k++; j=j+k-l--;
(a) j = -10, k = 10, l = 10;
(b) j = -11, k = 11, l = 10;
(c) j = -10, k = 11, l = 10;
(d) j = 11, k= 11, l = 11;
7) if(var) é equivalente a if(var!=0).

( ) Certo
( ) Errado

Process Black
139
8) Considerando o conceito de variáveis em Linguagem C, leia as afirmações a

seguir e indique a afirmativa correta.
I. As variáveis de um programa em C estão associadas a posições de
memória, previamente identificadas, que armazenam informações
II. O primeiro caractere de um identificador deve ser uma letra e o
restante do nome pode conter letras, números e sublinhado. Além
disto, palavras-chaves não podem ser usadas como identificadores.
III. As variáveis são classificadas, quanto ao seu escopo, como globais
ou locais. As globais são declaradas fora de qualquer função e são
reconhecidas em todo o programa; as locais são declaradas dentro da
função em que serão utilizadas e valem enquanto esta estiver ativa.
IV. O tipo de uma variável define os valores que ela pode assumir e as
operações que podem ser realizadas com ela.
V. A linguagem C não faz distinção entre as variáveis Cont, cont e
CONT.
(a) II e III estão incorretas.
(b) I, II e IV estão corretas.
(c) V está incorreta.
(d) I, II e III estão corretas.
(e) Todas estão corretas.
9) Na Linguagem C, os códigos de formação de tipo de dados NÃO estão

corretamente associados na alternativa:
(a) int - %i;
(b) double - %d;
(c) float - %f;
(d) char - %c;

Process Black
140
10) Na expressão condicional A>=P||P>A , está correto afirmar que a mesma

(a) nunca será verdadeira.

(b) somente será verdadeira quando P for menor ou igual a A.
(c) somente será verdadeira quando P for maior que A.
(d) nunca será falsa.
11) Considerando os especificadores de tipo usados nos comandos de saída

apresentados a seguir, assinale a alternativa INCORRETA.
(a) printf(“Total = %05i”,794);

T o t a l = 0 0 7 9 4
(b) printf(“Total = %-5i”,469);
T o t a l = 4 6 9
(c) printf(“Total = %.2f”,280.338);
T o t a l = 2 8 0 . 3 4
(d) printf(“Total = %4i”,258);
T o t a l = 2 5 8
(e) printf(“Total = %4.2f”,587.222);
T o t a l = 5 8 7 . 2 2
12) Para que faixa de valores da variável x o seguinte segmento de código imprime
a letra C? (Questão da prova do POSCOMP 2003)
if(x<=200)
if(x<100)
if(x<0) printf(“A”)
else printf(“B”)
else printf(“C”)
else printf(“D”)
(a) 0<x<100;
(b) x<=100;
(c) 100<x<=200;
(d) x>200;
(e) 100<=x<=200.

Process Black
141

Escolha um exercício de cada um dos capítulos anteriores e reescreva sua solução
em Linguagem C (utilize um compilador de Linguagem C para executar os
programas resolvidos).

1 - Errado
2-b
3 - Certo
4 - Certo
5-a
6-b
7 - Certo
8-c
9-b
10 - d
11 - d
12 - e

Process Black
142

Process Black
143

Process Black
144

Process Black

Livro - Algoritmos e Programação I

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Livro - Algoritmos e Programação I

Enviado por

Direitos autorais:

Formatos disponíveis

ALGORITIMOS E PROGRAMAÇÃO I

Algoritmos e programação I.indd 1 7/8/2013 16:00:32

Obra organizada pela Universidade Luterana do Brasil.

Dados Internacionais de Catalogação na Publicação (CIP)

I74a Isaia Filho, Eduardo.

1. Algoritmo. 2. Programação. 3. Computação. 4. Informática.

Setor de Processamento Técnico da Biblioteca Martinho Lutero - ULBRA/Canoas

Editoração: Roseli Menzen

Dados técnicos do livro

Algoritmos e programação I.indd 2 7/8/2013 16:00:54

Seja bem-vindo(a) ao estudo da disciplina de Algoritmos e Programação I!

Algoritmos e programação I.indd 3 7/8/2013 16:00:55

Só é possível aprender a construir algoritmos, construindo algoritmos! Portanto,

resolver os exercícios propostos no final de cada capítulo é fundamental para

Professora Vanessa Lindemann

Algoritmos e programação I.indd 4 7/8/2013 16:00:55

Eduardo Isaia Filho

Mestre, Coordenador dos Cursos de Computação da ULBRA unidade Canoas.

Mestre em Ciência da Computação - UFRGS - 2002; Doutora em Informática

Algoritmos e programação I.indd 5 7/8/2013 16:00:55

Algoritmos e programação I.indd 6 7/8/2013 16:00:55

Algoritmos e programação I.indd 7 7/8/2013 16:00:55

6 ESTRUTURA DE CONTROLE CONDICIONAL: ESCOLHA .................................................73

Algoritmos e programação I.indd 8 7/8/2013 16:00:56

Um programa de computador é resultado da atividade intelectual de um

1.1 Conceito de algoritmo

Algoritmos e programação I.indd 9 7/8/2013 16:00:56

4° passo: colocar o pó de café no ﬁltro;

5° passo: despejar a água aquecida no ﬁltro.

1.2 Construção do algoritmo

Algoritmos e programação I.indd 10 7/8/2013 16:00:56

ULBRA – Educação a Distância

1.3 Formas de representação de algoritmos

1.3.1 Português estruturado

Algoritmos e programação I.indd 11 7/8/2013 16:00:56

considerando duas notas; emita a mensagem “Aluno aprovado” ou “Aluno

Algoritmos e programação I.indd 12 7/8/2013 16:00:56

Tabela 1.1 – Símbolos geométricos

ULBRA – Educação a Distância

Indica o início e o fim do fluxo do

Indica o sentido do fluxo de dados e faz

Indica que serão recebidas informações

Indica a realização de cálculos,

Indica que as informações serão exibidas

Indica a tomada de decisão, dividindo o

Conector Serve para conectar dois fluxos.

Cabe destacar que é possível encontrar formas geométricas diferentes para

Algoritmos e programação I.indd 13 7/8/2013 16:00:56

1.3.3 Diagrama de Chapin

Algoritmos e programação I.indd 14 7/8/2013 16:00:57

ULBRA – Educação a Distância

ler nota1, nota2

media (nota1 + nota2) / 2

resultado “Aprovado” resultado “Reprovado”

escrever media, resultado

1.3.4 Formalização de um algoritmo

1.4 Estrutura básica de um algoritmo

Algoritmos e programação I.indd 15 7/8/2013 16:00:58

• 1 xícara de água quente

Algoritmo exemplo_11 Identificador do algoritmo

variáveis Declaração de variáveis

início Corpo do algoritmo

Esta estrutura facilita a localização do algoritmo, permitindo saber quais variáveis

Algoritmos e programação I.indd 16 7/8/2013 16:00:58