Técnicas de Programação - IFPB

7e&1,&$6B'(B352*5$0$d®2BBBSGISDJH#3UHIOLJKW$XJXVW3*
Técnicas de
programação
Anderson Emídio de Macedo Gonçalves

Veronice de Freitas
© 2014 by Editora e Distribuidora Educacional S.A.
Todos os direitos reservados. Nenhuma parte desta publicação poderá ser reproduzida
ou transmitida de qualquer modo ou por qualquer outro meio, eletrônico ou mecânico,
incluindo fotocópia, gravação ou qualquer outro tipo de sistema de armazenamento e
transmissão de informação, sem prévia autorização, por escrito, da Editora
e Distribuidora Educacional S.A.
Diretor editorial e de conteúdo: Roger Trimer

Gerente de produção editorial: Kelly Tavares
Supervisora de produção editorial: Silvana Afonso
Coordenador de produção editorial: Sérgio Nascimento
Editor: Casa de Ideias
Editor assistente: Marcos Guimarães
Revisão: Mariana David
Capa: Katia Megumi Higashi, Fernanda Caroline de Queiroz Costa
e Mariana Batista de Souza
Diagramação: Casa de Ideias
Dados Internacionais de Catalogação na Publicação (CIP)
Freitas, Veronice de
F866t Técnicas de programação / Veronice de Freitas,
Anderson Emídio de Macedo Gonçalves. – Londrina:
Editora e Distribuidora Educacional S.A., 2014.
192 p.
ISBN 978-85-68075-94-4
1. Lógica. 2. Estrutura. I. Gonçalves, Anderson Emídio

de Macedo. II. Título.
CDD 005.133
Sumário
Unidade 1 — Lógica proposicional ................................1

Seção 1 Proposição ............................................................................4
1.1 Classificação de proposições lógicas....................................................4
1.2 Tabela verdade ....................................................................................6
1.3 Exemplos de proposições .....................................................................7
Seção 2 Conectivos ..........................................................................10
2.1 Negação ...........................................................................................10
2.2 Conjunção .........................................................................................11
2.3 Disjunção ..........................................................................................12
2.4 Disjunção exclusiva ...........................................................................12
2.5 Implicação ou condicional ................................................................13
2.6 Implicacação bicondicional ...............................................................13
2.7 Exemplos ...........................................................................................14
Seção 3 Construção da tabela verdade ............................................19
Seção 4 Equivalências proposicionais ..............................................24
4.1 Tautologia, contradição e contingência ..............................................24
4.2 Tautologias.........................................................................................24
4.3 Contradição ......................................................................................25
4.4 Contingência .....................................................................................25
4.5 Equivalências lógicas .........................................................................26
Unidade 2 — Introdução a algoritmos .........................43

Seção 1 Introdução ao desenvolvimento de algoritmos ...................46
1.1 Fases para desenvolvimento de algoritmos .........................................46
1.2 Formas de representação de algoritmos..............................................46
1.3 Variáveis e tipo de dado .....................................................................54
iv TÉCNICAS DE PROGRAMAÇÃO
Seção 2 Instruções primitivas ..........................................................62

2.1 Comandos de atribuição ....................................................................62
2.2 Comandos de saída de dados (escreva) ..............................................62
2.3 Comando de entrada de dado (leia) ...................................................63
Seção 3 Tipos de operadores ...........................................................67
3.1 Operadores aritméticos .....................................................................67
3.2 Operadores relacionais .....................................................................68
3.3 Operadores lógicos ...........................................................................68
Seção 4 Estrutura sequencial............................................................72
4.1 Estrutura sequencial — exemplo (pseudocódigo e fluxograma) ..........72
4.2 Estrutura sequencial — exemplo (simulação — teste de mesa) ...........74
4.3 Estrutura sequencial — exemplo (resolução) ......................................75
Unidade 3 — Estrutura de controle..............................89

Seção 1 Estrutura condicional ..........................................................92
1.1 Estrutura condicional — simples ........................................................92
1.2 Estrutura condicional composta — se-então-senão ............................93
1.3 Estrutura condicional encadeada .......................................................97
Seção 2 Estrutura caso ...................................................................102
2.1 Exemplos de algoritmos — múltipla escolha ....................................102
Seção 3 Laço enquanto (while) .....................................................105
3.1 Variáveis contadoras e acumuladoras ...............................................105
3.2 Exemplos — pseudocódigo — simulação ........................................107
3.3 Exemplos — enquanto / faça (pseudocódigo) ...................................109
Seção 4 Repetição com teste no final.............................................114
4.1 Exemplo — repita / até (pseudocódigo / simulação) .............................. 114
4.2 Exemplo — pseudocódigo ...............................................................115
Seção 5 Repetição incondicional — número predefinido
de repetições ....................................................................118
5.1 Exemplos — para / fimpara (pseudocódigo / simulação)...................118
5.2 Exemplo — para / para (pseudocódigo) ............................................120
Sumário v
Unidade 4 — Estrutura de dados homogênea

e heterogênea ......................................137
Seção 1 Matrizes de uma dimensão ou vetores ..............................141
1.1 Delaração de matriz unidimencional ..............................................141
1.2 Atribuição de uma matriz do tipo vetor ............................................142
1.3 Leitura de dados de uma matriz do tipo vetor ..................................142
1.4 Escrita de dados de uma matriz do tipo vetor ...................................143
1.5 Exemplo de algoritmos ....................................................................144
Seção 2 Estrutura de dados homogênea (matrizes) ........................150
2.1 Representação dos índices de uma matriz bidimencional ................150
2.2 Delaração de matriz bidimencional ................................................151
2.3 Atribuição de uma matriz de duas dimensões ..................................151
2.4 Leitura de dados de uma matriz de duas dimensões .........................152
2.5 Apresentando dados de uma matriz de duas dimensões...................153
2.6 Estrutura homogênea em C# ............................................................160
Seção 3 Estrutura de dados heterogêneas (registros) ......................167
Apresentação
Um algoritmo é uma sequencia de instruções finita e ordenada de forma lógica

para a resolução de uma determinada tarefa ou problema. Como exemplo é pos-
sível citar os algoritmos das operações básicas (adição, multiplicação, divisão e
subtração). Até mesmo as coisas mais simples podem ser descritas por sequências
lógicas. Por exemplo:
Uma dona de casa: preparar um bolo.
Um motorista: trocar um pneu furado.
Um matemático: resolver uma equação.
Os algoritmos podem ser representados de várias formas, como:
Através de uma língua (português, inglês, etc.): forma utilizada nos manuais
de instruções, nas receitas culinárias, bulas de medicamentos etc.
Através de uma linguagem de programação (Pascal, C, Delphi etc.): esta forma
é utilizada por alguns programadores experientes, que “pulam” a etapa do
projeto do programa (algoritmo) e passam direto para a programação em si;
Através de representações gráficas: são indicados para elaboração de algo-
ritmos na fase inicial de programação. É considerado de fácil compreensão,
já que são representados em forma de “desenho” (diagrama, fluxograma).
Cada uma dessas formas de representar um algoritmo tem suas vantagens e
desvantagens, cabe à pessoa escolher a forma que melhor lhe convir. Neste livro,
serão apresentadas três formas de representação de algoritmos, são elas:
Narrativa (forma descritiva);
Fluxograma (diagrama de fluxo);
Português Estruturado (Pseudocódigo, Portugol ou Pseudolinguagem).
É comum que professores da área de computação observem a grande dificul-
dade que seus alunos têm em formalizar o raciocínio. Seu aprendizado requer o
aprendizado dos fundamentos da lógica. Por esse motivo, optamos por iniciar o
livro com uma exposição da lógica matemática, apresentando uma introdução à
lógica proposicional.
viii TÉCNICAS DE PROGRAMAÇÃO
Na metodologia adotada, busca-se, por meio da narrativa do livro, introduzir o lei-

tor ao contexto do desenvolvimento de algoritmos de forma que ele vá se habituando
a este meio, dominando gradualmente os conceitos que envolvem a complexidade
dessa disciplina.
Com este intuito, na Unidade 1, são abordados conceitos relacionados à lógica
matemática. Essa abordagem contempla o estudo das sentenças declarativas, tam-
bém conhecidas como proposições, e tem o objetivo de elaborar procedimentos que
permitam obter um raciocínio correto na investigação da verdade, distinguindo os
argumentos válidos daqueles que não o são. Essa lógica tem sido utilizada em todas
as áreas das ciências exatas, biológicas e humanas. Nessa unidade serão abordados
conceitos básicos de raciocínio lógico: proposições, valores lógicos das proposições,
número de linhas da tabela verdade, conectivos, proposições simples e proposições
compostas.
Na Unidade 2, iniciam-se os estudos dos conceitos relacionados à programação,
que é a arte de fazer com que o computador faça exatamente o que desejamos que
ele faça. Dessa forma, programar é criar uma rotina para que, seguindo uma lógica,
possamos alcançar a resolução de um problema computacional. Nessa unidade são
apresentadas três formas de representação de algoritmos: narrativa, fluxograma e
pseudocódigo. Além de conceitos de variáveis, tipos de dados, instruções primitivas
e algoritmos sequenciais.
Na Unidade 3 é apresentado outro grupo de estrutura: as estruturas de controle
condicional e as estruturas de controle de repetição. A estrutura Condicional possi-
bilita a escolha de um grupo de ações e estruturas a serem executadas quando deter-
minadas condições são ou não satisfeitas. A Estrutura Condicional pode ser simples,
composta ou encadeada. Em relação às estruturas de repetição, o objetivo é executar
uma instrução (ou conjunto de instruções) repetidas vezes, enquanto (ou até que)
uma dada condição seja satisfeita. Serão abordados três tipos de repetição: com teste
condicional no início, com teste condicional no final e com variável de controle.
Na Unidade 4, são incluídas as estruturas de dados homogêneas e heterogêneas.
Até esta unidade foram utilizados tipos de dados básicos, com variáveis simples:
real, inteiro, literal, caractere e lógico. Nessa unidade serão apresentadas situações
em que os tipos de dados básicos não são suficientes para resolver os problemas.
As estruturas homogêneas podem ser classificadas como vetores (unidimensionais) e
matrizes (bidimensionais). Nesse tipo de estrutura é possível armazenar um conjunto
de informações de um mesmo tipo em uma única variável. Para casos que necessitam
de vários dados com tipos diferentes dentro de uma mesma estrutura serão utilizadas
as estruturas heterogêneas (registros).
Unidade 1
Lógica proposicional
Anderson Emídio de Macedo Gonçalves
Veronice de Freitas
Objetivos de aprendizagem: A lógica matemática (ou lógica simbó-

lica) trata do estudo das sentenças declarativas também conhecidas
como proposições, as quais devem satisfazer aos dois princípios funda-
mentais seguintes: Princípio do terceiro excluído — uma proposição só
pode ser verdadeira ou falsa, não havendo outra alternativa. Princípio
da não contradição — uma proposição não pode ser ao mesmo tempo
verdadeira e falsa. O objetivo desta unidade é abordar os conceitos
de proposição, proposição simples e composta, conectivos lógicos e
tabelas verdade.
Seção 1: Proposições
Todo conjunto de palavras ou símbolos que exprimem
um pensamento de sentido completo. As proposições
podem ser classificadas em simples ou atômicas e com-
postas ou moleculares. Chama-se proposição simples ou
proposição atômica aquela que não contém nenhuma
outra proposição como parte integrante de si mesma.
As proposições simples são geralmente designadas pe-
las letras latinas minúsculas p, q, r, s ..., chamadas letras
proposicionais. As proposição composta ou proposição
molecular é aquela formada pela combinação de duas
ou mais proposições. As proposições compostas são ha-
bitualmente designadas pelas letras latinas P, Q, R, S...,
também chamadas de letras proposicionais. Estas pro-
posições são unidas por conectivos: “e”, “ou”, “se ...
então”, “se e somente se” etc.
Seção 2: Conectivos
Conectivos lógicos são palavras que usamos para
formar novas proposições a partir de outras exis-
tentes. As proposições compostas são formadas
por proposições simples interligadas por conectivo.
Usando conectivos, é possível criar proposições maio-
res (ditas compostas) a partir de menores, de modo
que o valor da proposição obtida dependa apenas do
valor das proposições iniciais. Os principais conectivos
lógicos são: não; e; ou; se ... então, e se e somente
se, simbolizados respectivamente por: ¬, ol.
Seção 3: Construção da tabela verdade

Com o emprego das tabelas verdade das operações
lógicas fundamentais ~p, p ^ q, p v q, poq, p l q,
é possível construir a tabela verdade correspondente
a qualquer proposição composta dada. O número de
linhas da tabela verdade de uma proposição com-
posta depende do número de proposições simples
que a integram. E deve ser calculado utilizando a
potência: 2n, sendo n o número de proposições
simples.
Seção 4: Equivalências proposicionais

Se duas proposições compostas possuem os mesmos
valores verdade, então elas são equivalentes. Isso
permite, por exemplo, que se substitua uma propo-
sição composta por outra equivalente na constru-
ção de argumentos matemáticos. Uma proposição
composta que é sempre verdadeira, independente
dos valores verdade de suas proposições, é chamada
de tautologia. Uma proposição composta que é
sempre falsa, independente dos valores verdade de
suas proposições, é chamada de contradição. Uma
proposição composta que não é nem tautologia,
nem contradição, é chamada de contingência.
Lógica proposicional 3
Introdução ao estudo
Em lógica e matemática, uma lógica proposicional (ou cálculo sentencial) é um sis-
tema formal no qual as fórmulas representam proposições que podem ser formadas
pela combinação de proposições atômicas usando conectivos lógicos e um sistema
de regras de derivação, que permite que certas fórmulas sejam estabelecidas como
“teoremas“ do sistema formal. As proposições são sentença declarativa com valores
verdadeiro ou falso. Por exemplo: “Maria gosta de João e de Pedro”; “Todos os seres
humanos têm uma mãe”; “Cinco é maior que quatro”.
As proposições transmitem pensamentos, isto é, afirmam fatos ou exprimem juízos
que formamos a respeito de determinados entes. Exemplos:
O Japão está situado no continente africano.
A lâmpada da sala está acesa.
A cidade de Recife é a capital de Pernambuco.
Na linguagem natural nos acostumamos com vários tipos de proposições ou

sentenças (JÚNIOR, 2013):
a) Declarativas
Márcio é engenheiro.
Todos os homens são mortais.
b) Interrogativas
Será que o Roberto vai ao cinema hoje?
Quantos alunos faltaram hoje à aula de lógica?
O Brasil ganhará a copa do mundo de 2006?
c) Exclamativas
Feliz Natal!
Vencemos!
Passamos no vestibular!
d) Imperativas
Não falte as aulas de lógica.
Feche a porta.
Fique calado.
Estudaremos somente as proposições declarativas, pois elas podem ser facilmente
classificadas em verdadeiras ou falsas.
4 TÉCNICAS DE PROGRAMAÇÃO
Seção 1 Proposição
Sentença declarativa afirmativa sobre a qual tenha sentido afirmar que seja
verdadeira ou falsa. Ou seja, conjunto de palavras ou símbolos que exprimem um
pensamento de sentido completo.
Exemplos:
A Lua é um satélite da Terra. (V)
A copa do mundo em 2014 será realizada na Alemanha. (F)
Recife é a capital de Pernambuco. (V)
3/5 é um número inteiro. (F)
3 2 = 9 (V)
Princípios ou axiomas: a lógica matemática adota, como regras fundamentais do
pensamento, os dois seguintes princípios (GENEROSO, 2013):
Princípio da não negação: uma proposição não pode ser verdadeira ou falsa
ao mesmo tempo.
Princípio do terceiro excluído: toda proposição ou é verdadeira ou é falsa, isto
é, verifica-se sempre um destes casos e nunca um terceiro.
Quando pensamos, efetuamos muitas vezes certas operações sobre proposições,
chamadas de operações lógicas. Estas obedecem a regras de um cálculo, denominado
CÁLCULO PROPOSICIONAL. A linguagem de um cálculo proposicional consiste em:
um conjunto de símbolos primitivos, definidos como fórmulas atômicas, pro-
posições atômicas, ou variáveis; e
um conjunto de operadores, interpretados como operadores lógicos ou conec-
tivos lógicos.
1.1 Classificação de proposições lógicas

As proposições lógicas podem ser classificadas em dois tipos: simples e compostas.
1.1.1 Proposições simples ou atômicas

Proposições simples (unitárias) são aquelas que não estão acompanhadas de
outras proposições.
Exemplos:
Pedro é estudante.
A Lua é um satélite da Terra.
Aristóteles era grego.
O número 25 é quadrado perfeito.
Eu estudo Lógica.
Lógica não é difícil.
Pedro Álvares Cabral descobriu o Brasil.
A Beija-Flor foi a escola de samba campeã no carnaval do Rio em 2008.
Além das proposições, a Lógica dispõe de uma função, chamada de “valor ló-
gico”, que associa a cada proposição simples um de dois valores lógico, chamado
“verdadeiro” (representado por V) ou “falso” (representado por F). Geralmente, o
valor lógico V ou F é associado à proposição, em consonância com o significado
da proposição no mundo real, embora isso não seja essencial (PINHO, 1999). Com
esse sentido, podemos dizer que as proposições: “A Lua é o satélite da Terra”, “Pedro
Álvares Cabral descobriu o Brasil” são verdadeiras, isto e, assumem o valor lógico V,
e que as proposições: “Dante escreveu Os Lusíadas”, “O Brasil é uma monarquia”
são claramente falsas e, portanto, assumem o valor lógico F.
As proposições simples são designadas pelas letras latinas minúsculas p, q, r, s...,
chamadas letras proposicionais.
Exemplos:
p: Minha casa é grande
q: Seus olhos são azuis.
r: Está calor.
1.1.2 Proposições compostas ou moleculares

As proposições compostas são obtidas combinando proposições simples por meio
de certos termos chamados de conectivos. A Lógica dispõe de cinco conectivos: “e”,
“ou”, “não”, “se – então”, e “se e somente se”. Utilizando esses conectivos podemos
construir as seguintes proposições compostas:
Exemplos:
O número 6 é par e o número 8 é cubo perfeito.
João é magro e José é alto.
Carlos é farmacêutico e Pedro é estudante.
Mário foi ao cinema, João foi ao teatro e Marcelo ficou em casa.
Maria foi à praia ou ao mercado.
O programa é bom e a internet é lenta.
Mário foi ao cinema ou Marcelo ficou em casa.
São designadas pelas letras latinas maiúsculas P, Q, R, S..., chamadas de letras

proposicionais.
Exemplos:
P: Minha casa é grande e meu carro é azul.
Q: Seus olhos são azuis ou verdes.
R: Se está calor, então é verão.
Também são chamadas de fórmulas proposicionais ou fórmulas.

Notação: P(q, r, s) – significa que P é uma proposição composta das proposições
atômicas q, r e s.
Em geral, de acordo com Pinho (1999), as proposições simples são constituídas

por um sujeito, um verbo, e seus complementos. Proposições como “se não cho-
ver, vou à praia”, ou “vou aprender a dirigir e comprar um carro” são chamadas de
proposições compostas, e são o resultado de operações sobre proposições simples.
1.2 Tabela verdade

Uma tabela verdade é uma tabela que contém as proposições nas colunas, e as
possibilidades de valores verdade nas linhas. É comum expressar os resultados de
uma proposição composta por meio de tabelas verdade, que permitem analisar seus
valores verdade.
As proposições podem ser avaliadas como verdadeiras (V) ou falsas (F). Por exemplo:
Quadro 1.1 Avaliando as proposições
Todo chumbo é metal (V)

Todo metal é corpo (V)
Todo chumbo é corpo (V)
Todo corpo é um metal (F)
Fonte: Do autor (2014).
A quantidade de linhas de uma tabela verdade é determinada por 2n, onde n é o nú-
mero de proposições simples (termos) que compõem a proposição composta (fórmula).
Quadro 1.2 Tabela das possíveis combinações das proposições
p: “João é competente.” p q
q: “Maria é bonita.” V V
A tabela ao lado representa todas as possíveis combina- V F
ções entre os valores lógicos (verdadeiros ou falsos) das
proposições “p” e “q”. A partir dela, é possível utilizar F V
diversos operadores para unir as duas proposições. F F
Na Seção 3, é exemplificado o processo para construir a tabela verdade.

1.3 Exemplos de proposições
Uma proposição é uma sentença declarativa que admite um e somente um

dos dois valores lógicos o Verdadeiro ou Falso.
Observe alguns exemplos de proposições:

Curitiba é a capital do Paraná.
É uma proposição cujo valor lógico é verdadeiro.
Todos os animais são mamíferos.
É uma proposição cujo valor lógico é falso.
Quero mais café!
Traduz um desejo. Logo, não é uma proposição e, portanto, não é possível atribuir
um valor lógico.
5+3=8
É uma proposição cujo valor lógico é verdadeiro.
4>6
É uma proposição cujo valor lógico é falso.
8–3
Não é uma proposição. Não se pode atribuir um valor lógico a sentença.
Y>4
Não é uma proposição, pois não é possível verificar a veracidade, uma vez que
não se conhece o valor da variável Y. Trata-se de uma sentença aberta.
Ele é médico.
Não é uma proposição, pois a palavra “ele” não esclarece de quem se fala e,
portanto, não se pode atribuir o valor lógico à declaração.
Maria é fisioterapeuta.
É uma proposição, pois declara especificadamente a profissão da Maria.
Você gosta de melão?
Trata-se de uma sentença interrogativa. Logo, não é uma proposição, pois não
pode ser classificada em verdadeira ou falsa.
Atividades de aprendizagem
1. Quais das sentenças abaixo são proposições?
a) A lua é feita de queijo verde.
b) Dois é um número primo.
c) O jogo vai acabar logo?
d) X 2 – 4 = 0.
2. Determinar o valor lógico de cada uma das seguintes proposições:
a) Tiradentes morreu afogado.
b) As diagonais de um paralelogramo são iguais.
c) O número 125 é cubo perfeito.
d) O produto de dois números ímpares é um número ímpar.
3. Determinar o valor lógico ( V ou F ) de cada uma das seguintes proposições.
a) Goiânia é a capital de Tocantins.
b) O número 25 é quadrado perfeito.
c) Todo número divisível por 5 termina com 5.
4. Determine se as proposições são Simples (S) ou Compostas (C):
a) Maria estuda e trabalha.
b) Mário é feio.
c) 3 é um número ímpar.
d) Márcia é jogadora ou estudante.
e) Paulo é rico e feliz.
f) 32 é múltiplo de 4.
g) Paris é a capital da França.
h) Pedro é estudioso e Maria é bonita.
i) Celso é pobre então é infeliz.
j) João é velho.
k) Ou Carla vai à festa ou fica em casa.
l) 13 é número e primo.
5. Marque as sentenças abaixo que são proposições, simples ou compostas.
Para as sentenças que não são proposições, explique porque não o são:
a) João é alto.
b) Ela é bonita.
c) A casa é pequena.
d) Quem está batendo à porta?

e) Talvez eu vá ao teatro.
f) 2 + 2 = 4.
g) x + y = 8.
h) O planeta Marte é habitado.
i) Possivelmente choverá hoje.
Para saber mais

Introdução à lógica matemática
<http://www.fernandozaidan.com.br/pit-grad/2011/MC/Aulas/Aula%201-%20Logica%20
Matematica.pdf>.
Casa do concurso
<http://concursos.acasadoconcurseiro.com.br/wp-content/uploads/2011/05/Apostila_
Secretaria_da_Saude_Raciocinio_Logico_Edgar_Abreu_2.pdf>.
Método dinâmico de ensino
<http://equipe-exclusiva.com.br/downloads/raciocinio_logico.pdf>. Acessos em: 7 jun. 2014.
Questões para reflexão

Toda frase a que você consiga atribuir um valor lógico é preposição, ou seja,
frases que podem ser VERDADEIRAS OU FALSAS.
Por exemplo:
Pedro é Feliz.
Carlos Estuda.
Obs.: analise as frases a seguir: o elas são proposições?
Que preguiça!
Quanto falta para as onze horas?
Independência ou morte!
Seção 2 Conectivos
Em Lógica Simbólica, a ação de combinar proposições é chamada “operação”,
e os conectivos são chamados “operadores”, e são representados por símbolos es-
pecíficos; apresentamos a seguir as cinco operações lógicas, com seus respectivos
conectivos e símbolos:
Quadro 1.3 Conectivos e símbolos
Operação Conectivo Símbolo Exemplo

Conjunção E pq João é ator e Alagoano.
Disjunção Ou pq Irei ao cinema ou à praia.
Ou Tiago é médico ou dentista,
Disjunção exclusiva Xor pq
mas não ambos.
Negação Não ou ~ ~p Não está chovendo
Condicional se ... então o poq Se chove, então faz frio.
Bicondicional se e somente se l p lq Vivo se e somente se sou feliz.
Quando a precedência não estiver explicitada através de parênteses, a seguinte

ordem de precedência deve ser utilizada:
Quadro 1.4 Precedência / Exemplos
Operador Precedência Exemplos Interpretação

¬ 1 pqr p(qr)
2 pqorz (pq)o(rz)
3 poqrlz (po(qr))lz
o 4
l 5
Exemplo: A expressão p q r significa p (q r) e não (p q) r.
2.1 Negação
Chama-se de negação de uma proposição p a proposição representada por ~p
(não p) cujo valor lógico é verdadeiro (V) quando p é falsa e falso (F) quando p é
verdadeiro. A negação também pode ser representada por : ¬. Simbolicamente:
“ ~ p “ = não p.
Quadro 1.5 Negação (~) e sua tabela da verdade
p ~p
V F
F V
Para uma proposição p, podemos formar a sua negação de qualquer um dos se-
guintes modos (JÚNIOR, 2013):
“não é verdade que p”
“é falso que p”
“não“ em p
Exemplo:
p: Lídia é estudiosa.
~p: Não é verdade que Lídia é estudiosa.
~p: É falso que Lídia é estudiosa.
~p: Lídia não é estudiosa.
p: João não foi ao cinema.

~p: É falso que João não foi ao cinema.
p: Matemática discreta é fundamental para Ciência da Computação.

~p: Matemática discreta não é fundamental para Ciência da Computação.
p: Hoje é Quarta.
~p: Hoje não é Quarta.
2.2 Conjunção
Chama-se conjunção de duas proposições p e q a proposição representada por p e
q cujo valor lógico é verdadeiro quando ambas as proposições p e q são verdadeiras
e falsas nos demais casos. Simbolicamente: “p q” = p e q.
Quadro 1.6 Conjunção () e sua tabela da verdade
p Q pq
V V V
V F F
F V F
F F F
Exemplo 1:
p: Brasília é a capital do Brasil.
q: Hoje é sexta-feira.
p q: Brasília é a capital do Brasil e hoje é sexta-feira.
Exemplo 2:
p: Hoje é sexta.
q: Está chovendo hoje.
p ^: Hoje é sexta e está chovendo hoje.
2.3 Disjunção
Chama-se disjunção de duas proposições p e q a proposição representada por
p ou q cujo valor lógico é verdadeiro quando ao menos uma das proposições p e
q é verdadeira e falso quando ambas as preposições são falsas. Simbolicamente:
“p q” = p ou q.
Quadro 1.7 Disjunção () e sua tabela da verdade
p Q pq
V V V
V F V
F V V
F F F
Exemplo:
p: Ele cursará Cálculo.
q: Ele cursará Álgebra linear.
p q: Ele cursará Calculo ou Álgebra linear.
Exemplo:
p: Brasília é a capital do Brasil.
q: Hoje é sexta feira.
p v q: Brasília é a capital do Brasil ou hoje é sexta-feira.
2.4 Disjunção exclusiva

Chama-se disjunção exclusiva de duas proposições p e q a proposição repre-
sentada por p ou q, mas não ambas, cujo valor lógico é verdadeiro (V) quando as
proposições p e q têm valores lógicos diferentes. Simbolicamente: “p q” = p ou q,
mas não ambos.
Quadro 1.8 Disjunção exclusiva (v) e sua tabela da verdade
p Q pvq
V V F
V F V
F V V
F F F
Exemplo: “O novo aluno nasceu no Brasil ou na Argentina”. Note que a sentença

é verdadeira somente quando o aluno for brasileiro ou argentino, mas não os dois,
pois não é possível alguém nascer em dois países ao mesmo tempo.
2.5 Implicação ou condicional

Chama-se condicional de duas proposições p e q a proposição cujo valor lógico
é falso (F) se a proposição p é verdadeira e q é falsa, e verdadeira nos demais casos.
Simbolicamente: “p o q” = se p então q.
Quadro 1.9 Tabela verdade: Condicional (o)
p Q poq
V V V
V F F
F V V
F F V
Exemplo 7: “Se ele for eleito, aumentará o salário mínimo”.

Exemplo:
p: NONONO é eleito.
q: NONONO vai reduzir os impostos.
p o q: Se NONONO for eleito, então NONONO vai reduzir os impostos.
2.6 Implicacação bicondicional

Chama-se proposição bicondicional uma proposição cujo valor lógico é verda-
deiro (V) quando p e q são ambas verdadeiras ou ambas falsas, e falsa (F) nos demais
casos. Simbolicamente: “p l q” = p se e somente se q.
Quadro 1.10 Tabela verdade: bicondicional (l)
p Q plq
V V V
V F F
F V F
F F V
Exemplo: “Você pode entrar na faculdade se e somente se for aprovado no

vestibular”.
2.7 Exemplos
O Quadro 1.11 representa várias formas juntamente com a interpretação e seu
correspondente valor lógico.
Quadro 1.11 Exemplos
Fórmula Fatos Interpretação Valor lógico

P P: Chove em Lisboa V V
¬P P: Chove em Lisboa V F
P: Chove em Lisboa V
PQ V
Q: Faz sol em Coimbra V
P: Chove em Lisboa F
PQ F
PQ V
PQ F
Q: Faz sol em Coimbra F
P: Choveu V
PoQ V
Q: O piso está molhado V
P: Choveu V
PoQ F
Q: O piso está molhado F
P: Choveu F
PoQ V
Q: O piso está molhado V
P: Choveu F
PoQ V
Q: O piso está molhado F
P: João é irmão de Pedro V
PlQ V
Q: Pedro é irmão de João V
P: João é irmão de Pedro V
PlQ F
Q: Pedro é irmão de João F
P: João é irmão de Pedro F
Pl Q V
Q: Pedro é irmão de João F
Fonte: Reis (2013).
Para saber mais

Faculdades Pitágoras de Uberlândia Sistemas de Informação
Prof. Walteno Martins Parreira Júnior
Lógica matemática e computacional
<http://www.waltenomartins.com.br/lmc_apo.pdf>.
Os fundamentos: lógica e demonstrações
<http://www.mat.ufmg.br/~michel/inicmat2010/livros/Rosen1.pdf>. Acessos em: 7 jun. 2014.
1. Dê a negação das seguintes proposições:
a) O processador é rápido, mas a impressora é lenta.
b) O processador é rápido ou a impressora é lenta.
c) Pepinos são verdes e não têm sementes.
d) A comida é boa ou o serviço é excelente.
e) Nem a comida é boa nem o serviço é excelente.
2. Dê o valor verdade das proposições abaixo:
a) Se a Lua é um satélite então a terra é um planeta.
b) Um corpo celeste não é um satélite se gira em torno de um planeta.
c) Se Lilo é um gato, então tem quatro patas. (considere que existe um
gato chamado Lilo).
d) Se a Terra é uma estrela então a Lua é um planeta.
3. Dê o valor verdade das seguintes proposições:
a) Amarelo será preto se, e somente se, vermelho for branco.
b) 3 + 4 = 7 se e somente se 8 x 5 = 50.
c) 1 + 1 = 4 se, e somente se, 7 + 3 = 10.
d) Azul não é verde se, e somente se, preto for lilás.
e) Não é verdade que 1 + 1 = 3 se, e somente se, 2 + 2 = 5.
4. Sejam as proposições:
p: Marcos é alto e q: Marcos é elegante.
Traduzir para a linguagem simbólica as proposições abaixo:
a) Marcos é alto e elegante.
b) Marcos é alto, mas não é elegante.
c) Não é verdade que Marcos é baixo ou elegante.

d) Marcos não é nem alto e nem elegante.
e) Marcos é alto ou é baixo e elegante.
5. Sejam as proposições p e q, traduzir para a linguagem simbólica as seguin-
tes proposições:
a) Carlos é alto e elegante.
b) Carlos é alto, mas não é elegante.
c) Não é verdade que Carlos é baixo ou elegante.
d) Carlos não é nem alto e nem elegante.
e) Carlos é alto ou é baixo e elegante.
f) É falso que Carlos é baixo ou que não é elegante.
tes proposições
p: Paula é rica e q: Paula é feliz.
a) Paula é pobre, mas feliz.
b) Paula é rica ou infeliz.
c) Paula é pobre e infeliz.
d) Paulo é pobre ou rica, mas infeliz.
tes proposições:
p: Felipe fala francês e q: Felipe fala inglês e r: Felipe fala alemão.
a) Felipe fala francês ou inglês, mas não fala alemão.
b) Felipe fala francês e inglês, ou não fala francês e alemão.
c) É falso que Felipe fala francês, mas que não fala alemão.
d) É falso que Felipe fala inglês ou alemão, mas que não fala francês.
8. Sejam as proposições p e q, traduzir para a linguagem corrente as seguintes
proposições:
p: Está frio e q: Está chovendo.
a) ~p d) q l p g) ~p ^ ~q
b) p ^ q e) p o ~q h) p l ~q
c) p v q f) p v ~q i) p ^ ~q o p
proposições:
p: Eduardo é rico e q: Murilo é feliz.
a) q p c) q l ~p e) ~p ^ q o p
b) p v ~q d) ~p o q

proposições:
p: Roberto fala inglês e q: Roberto fala alemão.
a) q v p c) p ^ ~q e) ~(~p ^ ~q)
b) p ^ q d) ~p ^ ~q
proposições:
p: Matheus é gaúcho e q: Thiago é paulista.
a) ~(~p ^ ~q) c) p o ~q
b) ~(~p v ~q) d) ~p o ~q
12. Sejam as seguintes proposições simples:
p: “Tiradentes morreu afogado” e q: “Jaime é gaúcho”.
Traduzir para linguagem natural, as seguintes proposições compostas:
a) p q
b) p o q
c) ~p q
p: João joga futebol. q: Pedro joga tênis.
Traduzir as fórmulas lógicas para o português.
a) p q c) p ~q e) ~p ~q
b) p q d) po ~q f) ~p l ~q
p: A bola é vermelha. q: O bambolê é amarelo.
Traduzir as fórmulas lógicas para o português.
a) p q c) p ~q e) ~p l ~q
b) p q d) ~p ~q
15. Considere as proposições:
p: Está frio e q: Está chovendo.
Traduza para a linguagem corrente as seguintes proposições apresentadas
na linguagem simbólica:
a) ~p d) q p g) ~p / ~q
b) p / q e) p ~q h) p ~q
c) p v q f) p v ~q
16. Considere as proposições p: Está frio e q: Está chovendo. Traduza para a
linguagem corrente as seguintes proposições:
a) p v ~q c) ~p ^ ~q e) (p v ~q) l (q
b) p o q d) p l ~q ^~p)

Como exemplificado nesta seção, os conectivos lógicos são muito utilizados
nas sentenças matemáticas. Qual o seu relacionamento com linguagens de
programação de computadores?
Seção 3 Construção da tabela verdade

Teorema: A tabela verdade de uma proposição composta com n proposições
simples componentes contém 2 n linhas.
Para determinar unicamente a tabela verdade, podemos estabelecer certas con-
venções para sua construção:
a) Para as colunas:
1. Dispor as proposições componentes em ordem alfabética.
2. Dispor as operações na ordem de precedência determinada pelo Algoritmo
Ordem de Precedência (com parênteses, se for o caso).
b) Para as linhas:
1. Alternar V e F para a coluna do último componente.
2. Alternar V V e F F para a coluna do penúltimo componente.
3. Alternar V V V V e F F F F para a coluna do antepenúltimo componente.
4. Prosseguir dessa forma, se houver mais componentes, sempre dobrando o
numero de V’s e F’s para cada coluna à esquerda.
Exemplo: criando a tabela para duas; três e quatro proposições.
Exemplo: 3 proposições
p q r
Exemplo: 2 proposições V V V
p q V V F
V V V F V
V F V F F
F V F V V
F F F V F
F F V
F F F

2 proposições 3 proposições
22 = 4 combinações 23 = 8 combinações
Exemplo: 4 proposições
9 r s t
V V V V
V V V F
V V F V
V V F F
V F V V
V F V F
V F F V
V F F F
F V V V
F V V F
F V F V
F V F F
F F V V
F F V F
F F F V
F F F F

4 proposições
24 = 16 combinações
Exemplo 1: P(p, q) = ~(p ~q)

Montando a tabela da verdade:
p q ~p p ~q ~(p ~q)
V V
V F
F V
F F
Resolução:
p q ~p p ~q ~(p ~q)
V V F F V
V F V V F
F V F F V
F F V F V
Exemplo 1: Para exemplificar, considere a expressão proposicional

(p oq) ~ ((p l r)o ~ r)
A precedência das operações é dada por:
(p o q) ~ ((p l r) o ~ r)
1 6 5 2 4 3
Montando a tabela da verdade:
p q r poq plr ~r (plr) o~r ~((p l r)o ~r) (p oq) ~ ((p l r) o ~r)
V V V
V V F
V F V
V F F
F V V
F V F
F F V
F F F
Resolução:
p q r poq plr ~r (plr) o~r ~ ((p l r)o ~r) (p o q) ~ ((p l r) o~r)
V V V V V F F V V
V V F V F V V F V
V F V F V F F V V
V F F F F V V F F
F V V V F F V F V
F V F V V V V F V
F F V V F F V F V
F F F V V V V F V
Para saber mais

Calculadora – tabela verdade:
Monte qualquer tabela verdade automaticamente com esta prática calculadora
<http://www.calculadoraonline.com.br/tabela verdade>.
Método dinâmico de ensino
<http://equipe-exclusiva.com.br/downloads/raciocinio_logico.pdf>.
Construção da tabela verdade
<http://www.fernandozaidan.com.br/pit-grad/2011/MC/Aulas/Aula%202-%20tabelas%20
verdade.pdf>. Acessos em: 7 jun. 2014.
1. Construa a tabela verdade para as proposições a seguir:
a) pl ~q
p q ~q p l ~q
b) ~p v q
p q ~p ~p v q
c) (p ^ q) o ~(p v q)
p q p^q pvq ~(p v q) (p ^ q)o ~(p v q)
d) (p ^ q) l (p v r)
p q r p^q pvr (p ^ q)l(p v r)

2. Construa a tabela verdade de cada uma das seguintes proposições:

a) p q p c) p ~q e) p (~p ~q)
b) p q p d) ~p ~q f) ~p q l ~q o p
3. Construir as tabelas verdade das seguintes proposições:
a) ~ p r o q ~ r c) p o r l q ~ r
b) p o (p o ~ r) l q r d) (p q o r) (~ p l q ~ r)

Qual a regra para criar a tabela verdade?
Para qual finalidade é utilizada?
Seção 4 Equivalências proposicionais

Se duas proposições compostas possuem os mesmos valores verdade, então elas
são equivalentes. Isso permite, por exemplo, que se substitua uma proposição com-
posta por outra equivalente na construção de argumentos matemáticos.
4.1 Tautologia, contradição e contingência

Uma proposição composta que é sempre verdadeira, independente dos valores
verdade de suas proposições, é chamada de tautologia. Uma proposição composta
que é sempre falsa, independente dos valores verdade de suas proposições, é cha-
mada de contradição. Uma proposição composta que não é e nem tautologia nem
contradição é chamada de contingência.
As fórmulas proposicionais são classificadas quanto aos valores lógicos, em pro-
posições tautológicas, proposições contraválidas e proposições contingentes, que
são assim definidas.
4.2 Tautologias
Chama-se tautologia toda proposição composta cuja última coluna da sua tabela
verdade seja totalmente verdadeira, ou seja, é toda proposição composta que assume
somente o valor V para todas as combinações possíveis de suas proposições simples.
As tautologias são também denominadas proposições tautológicas ou proposições
logicamente verdadeiras.
Exemplos:
a) p v ~p: “Hoje vai chover ou hoje não vai chover”. Neste caso, a proposição
apresentada tem que ser sempre verdadeira, já que uma ou outra das duas
coisas tem que acontecer (é o chamado princípio do terceiro excluído).
p ~p p v ~p
V F V
F V V
b) ~(p ^ ~p) é tautológica (é o chamado princípio da não contradição):

p ~p p ~p ~(p ~p)
V F F V
F V F V
c) pv (q ~ q) l p
p q ~q q ~ q pv (q ~ q) p v (q ~ q) l p
V V F F V V
V F V F V V
F V F F F V
F F V F F V
Portanto, dizer que uma proposição ou é verdadeira ou é falsa é sempre verdadeiro.
4.3 Contradição
É chamada de contradição toda proposição composta cuja última coluna da sua
tabela verdade contenha somente a letra F (falsidade), ou seja, é toda proposição
composta que assume somente o valor F para todas as combinações possíveis de suas
proposições simples.
As contradições são também denominadas proposições contraválidas ou propo-
sições logicamente falsas.
Exemplos:
a) p ^ ~p: “hoje é sábado e hoje não é sábado
p ~p p ~p
V F F
F V F
b) p l ~p
p ~p pl~p
V F F
F V F
c) ~ p (p ~ q)
p q ~q p ~ q ~p ~ p (p ~ q)
V V F F F F
V F V V F F
F V F F V F
F F V F V F
Portanto, dizer que uma proposição pode ser simultaneamente verdadeira e falsa
é sempre falso.
4.4 Contingência
Chama-se contingência toda proposição composta em que em sua tabela ver-
dade, na última coluna, aparecem as letras V e F, pelo menos uma vez cada uma, ou
seja, contingência é toda proposição composta que não pode ser classificada como
tautologia nem como contradição.
As contingências são também denominadas proposições contingentes ou propo-
sições indeterminadas.
Exemplos:
a) p o ~p
p ~p p o ~p
V F F
F V V
b) p v q o p
p q pvq p v q op
V V V V
V F V V
F V V F
F F F V
4.5 Equivalências lógicas

As proposições compostas p e q são chamadas logicamente equivalentes se p l
q é uma tautologia. A notação p { q indica que as proposições p e q são logicamente
equivalentes.
Uma das formas de veriﬁcar se duas proposições p e q são equivalentes consiste
em usar a tabela verdade. Elas serão equivalentes se as colunas que fornecem seus
valores verdade forem idênticas.
(Teorema): P (p, q, r, ...) Q (p, q, r, ...) se e somente se a bicondicional P (p,
q, r, ...) lQ (p, q, r, ...) foi tautológica.
É importante lembrar que os símbolos e lsão distintos, pois, o bicondicio-
nal é o resultado de uma operação lógica, enquanto a equivalência estabelece uma
relação. Por exemplo, que a condicional p l q é tautologia.
Exemplo:
1. Demonstre, mediante o teorema acima descrito, que a proposição bicondicional
(p ~ q o c) l (p o q) é uma equivalência; onde V(c) = F.
Resolução:
Para provarmos que (p ~ q o c)l (poq) representa (p ~ q o c) (p o q)
deve-se mostrar que (p ~ q oc)l (p o q) é tautológica. Da tabela verdade têm-se:
p q c ~q p ~ q p ~ q o c po q (p ~ q o c) l (p o q)
V V F F F V V V
V F F V V F F V
F V F F F V V V
F F F V F V V V
Assim, pelo teorema tem-se que (p ~ q o c) (p o q).

2. Considerando as seguintes proposições verifique a equivalência mediante a
tabela verdade:
a) ~~ p p
Resolução: a tabela verdade para a proposição é dada como:
p ~p ~p
V F V
F V F

idênticas
b) ~ p o p p
p ~p ~ pop
V F V
F V F

idênticas
c) po q ~ p v q
p q ~p ~pvq poq
V V F V V
V F F F F
F V V V V
F F V V V

idênticas
d) p l q (p o q ) (q o p)
p q poq ~pvq (p o q) (q o p) plq
V V V V V V
V F F V F F
F V V F F F
F F V V V V

idênticas
e) Sejam as proposições p o q e ¬q o ¬p. Mostre, pela tabela verdade, que

estas proposições são logicamente equivalentes.
Resolução: tabela verdade para as proposições (p o q e ¬q o ¬p)
p q ¬p ¬q (p o q) (¬q o ¬p) (p o q) l (¬q o ¬p)
V V F F V V V
V F F V F F V
F V V F V V V
F F V V V V V
Assim, a proposição condicional (p o q) e sua contrapositiva (¬q o ¬p) são

equivalentes.
Para saber mais

Faculdades Pitágoras de Uberlândia Sistemas de Informação
Prof. Walteno Martins Parreira Júnior
Lógica matemática e computacional
<http://www.waltenomartins.com.br/lmc_apo.pdf>.
Raciocínio lógico — tautologia e contradição (aula 8 — 1/2) — Vídeo
<https://www.youtube.com/watch?v=Gz50NFYS0vc>.
Noções Lógica 2 — conectivos e tabela verdade — Vídeo
<https://www.youtube.com/watch?v=3aMT_rygF18>. Acessos em: 7 jun. 2014.
1. Exercícios — Tautologia:
Preencha as tabelas a seguir:
a) P(p) = ~(p~p)
Tabela verdade:
p ~q p ~p ~(p ~p)
V
F
b) P(p, q) = p ~(p q)
Tabela verdade:
p q pq ~(p q) p ~(p q)

V V
V F
F V
F F
2. Exercícios — Contradição:
Preencha as tabelas a seguir:
a) P(p) = p ~p
Tabela verdade:
p ~p p ~p
V
F
b) P(p, q) = ~p (p ~q)

Tabela verdade:
p q ~p ~q p ~q ~p (p ~q)
V V
V F
F V
F F
3. Exercícios — Contingência:
Preencha as tabelas abaixo:
a) P(p) = p o ~p
Tabela verdade:
p ~p p o ~p
V
F
b) P(p, q) = p q op
p q pq pqop
V V
V F
F V
F F
4. Definir as proposições abaixo como Tautologias, Contradições ou

Contingências:
a) (p o q) p o q
b) p q o p q
c) (p o q)o (p ro q)
5. Mostre que as equivalências são verdadeiras
a) (p q or) (p o (q o r)) é: _____________________________
p q r pq pqor qor po(q o r) (p q o r) l (p o (q o r))
b) p lq (p q) v (~ p ~ q) é: ____________________________
p q pl q pq ~p ~q ~ p ~ q (p q) v (~ p ~ q)
6. Quais das proposições abaixo são tautologias (verdadeiras), quais são

contradições (logicamente falsas) e quais não são nem tautologias nem
contradições?
a) (p q) v (~ p ~ q)
b) ~(p ~ q)
c) p o(p o q)
d) (p v q) o((p ~q) v (~p q))

As fórmulas proposicionais são classificadas quanto aos valores lógicos, em
proposições tautológicas, proposições contraválidas e proposições contin-
gentes. Qual a particularidade de cada uma?
Fique ligado!
A lógica matemática (ou lógica simbólica) trata do estudo das sentenças de-
clarativas, também conhecidas como proposições, que devem satisfazer aos
dois princípios fundamentais seguintes: Princípio do terceiro excluído, uma
proposição só pode ser verdadeira ou falsa, não havendo outra alternativa.
Princípio da não contradição, uma proposição não pode ser ao mesmo tempo
verdadeira e falsa.
Diz-se então que uma proposição verdadeira possui valor lógico V (verdade)
e uma proposição falsa possui valor lógico F (falso). Os valores lógicos também
costumam ser representados por 0 (zero) para proposições falsas (0 ou F) e 1
(um) para proposições verdadeiras (1 ou V).
As proposições podem se classificadas como simples ou compostas. A pro-
posição simples é aquela que não contém nenhuma outra proposição como
parte integrante de si mesma. A proposição composta é formada pela combi-
nação de duas ou mais proposições simples através de um elemento de ligação
denominado conectivo.
Exemplos de proposições simples e proposições compostas:
Proposição simples Proposições compostas

p: Carlos é careca P: Carlos é careca e Pedro é estudante
q: Pedro é estudante Q: Carlos é careca ou Pedro é estudante
r: O número 25 é quadrado perfeito R: Se Carlos é careca, então é infeliz
Os conectivos são expressões utilizadas para compor novas proposições.

Exemplos:
P: O número 6 é par e o número 8 é cubo perfeito.
Q: Não está chovendo.
R: O triângulo é retângulo ou isósceles.
S: O triângulo é equilátero se e somente se é equiângulo.
T: Se Jorge é engenheiro, então sabe cálculo.
Assim, na lógica, destacam-se os conectivos usuais representados na tabela
a seguir:
Ação Conectivo Estrutura Lógica Exemplos

Maria não está usando
Negação ~ Não p
tênis preto.
Murilo é médico e
Conjunção ^ Peq
Ricardo é Engenheiro
Murilo é médico ou
Disjunção Inclusiva v P ou q
Ou Murilo é Médico ou
Disjunção Exclusiva v Ou p ou q
Se Murilo é Médico
Condicional o Se p então q então Ricardo é
Engenheiro
Murilo é médico se e
Bicondicional l P se e somente se q somente se Ricardo é
Médico
A tabela a seguir representa a tabela verdade dos principais conectivos:
Conectivo Tabela Verdade
p q p^q
V V V
CONJUNÇÃO: “p e q” V F F
F V F
F F F
continua
continuação
p q pvq
V V V
DISJUNÇÃO: “p ou q” V F V
F V V
F F F
p q poq
V V V
DISJUNÇÃO EXCLUSIVA:
V F F
“ou p ou q, mas não ambos”
F V V
F F V
p q pvq
V V F
CONDICIONAL: “Se p, então q” V F V
F V V
F F F
p q plq
V V V
BICONDICIONAL: “p se e
V F F
somente se q”
F V F
F F V
Para determinar o valor lógico de uma proposição composta, recorre-se quase

sempre a um dispositivo denominado TABELA VERDADE. Na tabela verdade fi-
guram todos os possíveis valores lógicos da proposição, correspondentes a todas
as possíveis atribuições de valores lógicos às proposições simples componentes.
Assim, por exemplo, uma proposição composta cujas proposições simples com-
ponentes são p e q pode ter as possíveis atribuições:
p q
1 V V
2 V F
3 F V
4 F F
Neste caso, as combinações entre os elementos são: VV, VF, FV e FF. As tabelas
verdade são construídas como arranjos dos elementos componentes, e como um
elemento pode receber somente os valores V ou F, o tamanho de uma tabela é
dado pela quantidade de elementos combinados. No caso de uma proposição
composta com 3 elementos, teríamos 8 combinações possíveis: VVV, VVF, VFV,

VFF, FVV, FVF, FFV, FFF.
p q r
1 V V V
2 V V F
3 V F V
4 V F F
5 F V V
6 F V F
7 F F V
8 F F F
Há certas proposições compostas, chamadas de tautologias, que assumem

valores lógicos V em todos os casos possíveis. E também ocorre o oposto: certas
proposições compostas, chamadas de contradições, assumem valores lógicos F
em todos os casos. O meio termo entre os dois casos anteriores são chamadas
contingências.
Tautologia é uma proposição cujo valor lógico é sempre verdadeiro inde-
pendentemente dos valores lógicos das proposições simples que as compõem.
Para verificar se uma proposição é uma tautologia basta fazer a tabela verdade
da proposição composta.
Exemplo: a proposição (p ~p) é uma contradição, pois é sempre falsa para
qualquer valor lógico da proposição p.
p ~p p ~p
V F V
F V V
Contradição é uma proposição cujo valor lógico é sempre falso indepen-

dentemente dos valores lógicos das proposições simples que as compõem. Para
verificar se uma proposição é uma contradição, basta fazer a tabela verdade da
proposição composta.
Exemplo: a proposição (p ~p) é uma contradição, pois é sempre falsa para
qualquer valor lógico da proposição p.
p ~p (p ~p)
V F F
F V F
São as proposições compostas em que os valores lógicos dependem dos

valores das proposições simples. Para verificar se uma proposição é uma contin-
gência basta fazer a tabela verdade da proposição. Se na tabela verdade alguns
valores lógicos forem verdadeiros e outros falsos, teremos uma contingência.
Exemplo: a proposição (p ~q) é uma contingência, pois a proposição pode
ser verdadeira ou falsa dependendo dos valores lógicos de p e q.
p q ~q p ~q
V V F F
V F V V
F V F F
F F V F
Para concluir o estudo da unidade

Caro aluno,
Esta seção contém alguns exercícios (ARAMAM, 2011) que contemplam os
conteúdos desta unidade.
A tabela a seguir contém a tabela verdade da negação; conjunção; disjunção;
disjunção exclusiva; condicional e bicondicional. Essas tabelas visam revisar
as tabelas utilizadas nesta unidade.
Tabela 1.1 Tabela verdade
NEGAÇÃO CONJUNÇÃO
p q pq
p ~p V V V
V F V F F
F V F V F
F F F
DISJUNÇÃO DISJUNÇÃO EXCLUSIVA
p q p q p q pq
V V V V V F
V F V V F V
F V V F V V
F F F F F F
continua
continuação
CONDICIONAL BICONDICIONAL
p q poq p q pl q
V V V V V V
V F F V F F
F V V F V F
F F V F F V
Fonte: Do Autor (2014).
Bloco 1:
1. Extraia a conclusão dos raciocínios a seguir:
a) Se Carlos estudar, então não irá ao jogo. Se Carlos não for ao jogo, seu
time ficará desfalcado. Como o time de Carlos não ficou desfalcado,
conclui-se que...
b) Se Raquel viajar nas férias, então sua conta no banco ficará descoberta.
Como Raquel viajou nas férias, conclui-se que...
c) Se os eclipses são previsíveis, então a órbita dos planetas é exata. Se
a órbita dos planetas é exata, então o sistema solar funciona como um
relógio. Ora, os eclipses não são previsíveis, portanto...
d) Se meu time for campeão, darei uma festa. Se der uma festa, gastarei
muito dinheiro agora. Se gastar muito dinheiro agora, terei dificuldades
para viajar. Meu time não foi campeão, logo...
2. Indicar a estrutura dos seguintes enunciados usando a linguagem lógica:
a) Meu gato é amarelo ou meu gato é preto, mas o gato de Maria é branco.
b) Eu não irei à festa, mas Pedro irá ou Antônio irá.
c) Vá com a família ou vá só; e divirta-se.
d) Costumo ir ao cinema ou visitar os amigos, mas hoje não irei ao cinema.
e) Não é verdade que Pedro não tenha ido ver a família.
3. Verificar se os raciocínios são válidos ou não válidos.
Se Maria casar com José, Vilma ficará contente. Se Vilma ficar contente,
Marcos poderá descansar. Como Marcos não pode descansar, Maria não
casou com José.
Se Paulo começar a trabalhar na feira, Vilma ficará em casa. Se Vilma
ficar em casa, Zezinho não irá à escola. Ora, Zezinho continua indo à
escola, portanto Paulo começou a trabalhar na feira.
4. Traduzir para a linguagem corrente as seguintes proposições:
p: Pelé é atacante.
q: Dida é goleiro.
Bloco 2:
Analise as proposições abaixo:
As seguintes proposições são verdadeiras:
O time do Bahia perdeu o jogo no domingo.
O time do Remo ganhou o jogo no domingo.
Marcos gosta de cantar óperas.
Júlia não come beterraba.
As seguintes proposições são falsas:

Carlos perdeu seu par de chinelos.
Maria possui um par de sandálias douradas.
Júlia come batata frita.
O time do Bahia é dirigido por Zagalo.
Com base nas informações acima, resolva as questões de 1 a 3:

1. Determinar a veracidade das seguintes conjunções:
a) O time do Bahia perdeu o jogo domingo e o time do Remo ganhou o jogo
domingo.
b) O time do Bahia perdeu o jogo domingo e o time do Remo perdeu o jogo
domingo.
c) Maria possui um par de sandálias douradas e Marcos gosta de cantar
óperas.
d) O time do Bahia perdeu o jogo no domingo e Zagalo dirige o time do
Bahia.
2. Determinar a veracidade das seguintes disjunções:
a) O time do Bahia perdeu o jogo domingo ou o time do Remo ganhou
o jogo domingo.
b) Júlia come beterraba ou batata frita.
c) Carlos perdeu seu par de chinelos ou Marcos gosta de cantar óperas.
d) O time do Bahia ganhou o jogo domingo ou é dirigido por Zagalo.
3. Determinar a veracidade das seguintes disjunções exclusivas:
a) Ou o time do Bahia perdeu o jogo domingo ou o time do Remo ganhou
o jogo domingo.
b) Ou Maria possui um par de sandálias douradas ou Marcos gosta de
cantar óperas.
c) Ou Júlia come beterraba ou come batata frita.
d) Ou Carlos perdeu seu par de chinelos ou Marcos gosta de cantar óperas.
4. Construa a tabela verdade para cada proposição composta:

a) P (p, q): ~ p v q o p
p q ~p ~pvq ~pvqop
V V
V F
F V
F F
b) P (p, q): ( p / ~ q) v (~ p /q)

p q ~p ~q ( p/ ~ q) (~ p /q) ( p /~ q) v (~ p/q)
V V
V F
F V
F F
c) P (p,q): p v ( p / q)l p
p q ( p / q) p v ( p /q) p v ( p/ q) l p
V V
V F
F V
F F
Bloco 3:
1. Construa a tabela verdade para as proposições compostas:

a) P (p, q, r): ~ p / (q v ~ r)
p q r ~p ~r (q v ~ r) ~ p/ (q v ~ r)
V V V
V V F
V F V
V F F
F V V
F V F
F F V
F F F
b) P (p, q, r): (p v q o r) o q v ~ r
p q r ~r pvq pvqor qv~r (p v q o r)o q v ~ r
V V V
continua
continuação
V V F
V F V
V F F
F V V
F V F
F F V
F F F
2. Resolva o seguinte problema por meio da construção de tabelas verdade:

Três amigos resolveram ir ao cinema ver um filme, mas naquele horário só
tinha a opção “Tudo é uma questão de lógica”. Então, surgiu uma discussão,
pois alguns afirmavam já ter assistido ao filme:
Tuca: Se Joca não assistiu, então Kika também não assistiu.
Joca: Tuca não assistiu ao filme, mas Kika assistiu.
Kika: Eu assisti ao filme ou não assisti.
Sejam as proposições:
p: Tuca assistiu ao filme.
q: Joca assistiu ao filme.
r: Kika assistiu ao filme.
Usando a tabela verdade, responda as seguintes questões:

a) Se todos assistiram ao filme, quem está mentindo?
b) Se todos estão dizendo a verdade, quem não assistiu ao filme?
Atividades de aprendizagem da unidade

1. Sejam as proposições p: Marcos é alto e q: Marcos é elegante. Traduzir
para a linguagem simbólica as seguintes proposições:
a) Marcos é alto e elegante.
b) Marcos é alto, mas não é elegante.
c) Não é verdade que Marcos é baixo e elegante.
d) Marcos é alto ou é baixo e elegante.
e) Marcos não é nem alto e nem elegante.
f) É falso que Marcos é baixo ou que não é elegante.
2. Dadas às proposições:
P – Adriana é bonita
Q – Adriana é inteligente
Escrever na linguagem simbólica as seguintes proposições:
a) Adriana é bonita e inteligente.
b) Adriana é bonita, mas não inteligente.
c) Não é verdade que Adriana não é bonita ou inteligente.
d) Adriana não é bonita nem inteligente.
e) Adriana é bonita ou não é bonita e inteligente.
f) É falso que Adriana não é bonita ou que não é inteligente.
3. Sejam as proposições p: está frio e q: está chovendo. Traduzir para a lin-
guagem corrente as seguintes proposições:
a) ~ p
b) p q
c) p v q
d) ql p
e) ~ p ~ q
f) p o ~ q
g) p l ~q
h) p v ~ q
i) p ~ q o p
4. Sejam as proposições p: Jorge é rico e q: Carlos é feliz. Traduzir para lin-
guagem corrente as seguintes proposições:
a) p v q
b) p q
c) p ~ q
d) ~ p ~q
5. Verificar se as proposições a seguir são tautologias:
a) p v ~(p ^ q)
b) p ^ q o (p l q)
c) p v (q ^ ~q) l p
d) p ^ r o ~q v r
6. Determine quais proposições são tautologias, contradições ou contingências:
a) (p o p) v (p o ~p)
b) (p oq) ^ p o q
c) po (q o (q o p))
d) ~p v qo(p o q)
e) p o (p o q ^ ~q)
f) (p ^ q o r) l (p o (q o r))
7. Determinar o valor lógico de P em cada um dos casos abaixo, considerando
a informação fornecida.
a) Q é falsa e P ^ Q é falsa.
b) Q é falsa e P v Q é falsa.
c) Q é falsa e P o Q é falsa.
d) Q é falsa e P o Q é verdadeira.
e) Q é falsa e P l Q é verdadeira.
f) Q é verdadeira e P l Q é falsa.
8. Construir a tabela verdade para as seguintes proposições:
a) p q o p q
b) ~p o (q o p)
c) (p l ~q) l q op
9. Determinar P(VV, VF, FV, FF) em cada um dos seguintes casos:
a) P(p,q) = ~(~p l q)
b) P(p,q) = (p q) ~(p q)
c) P(p,q) = ~((p q) (~p ~q))
10. Determinar P(VFV) em cada um dos seguintes casos:
a) P(p,q,r) = p ~q o ~q
b) P(p,q,r) = ~p (q ~r)
Referências
ARAMAM, Eliana Maria Oliveira. Matemática discreta. Curso de Graduação — Unopar
Virtual, 2011.
JÚNIOR, Walteno Martins Parreira. Lógica matemática e computacional. 2013. Disponível
em: <http://www.waltenomartins.com.br/lmc_apo.pdf>. Acesso em: 25 mar. 2014.
PINHO, Antonio A. Introdução à lógica matemática. 1999. Disponível em: <ftp://ftp.
cefetes.br/cursos/Matematica/Oscar/introducao_logica/Apostila%20de%20Logica.pdf>.
Acesso em: 29 mar. 2014.
REIS, Joaquim. Introdução à lógica simbólica. 2013. Disponível em: <http://iscte.pt/~luis/
aulas/ia/IA-LogicaSimbolica.pdf>. Acesso em: 29 mar. 2014.
GENEROSO. Ruy Alexandre. Cálculo proposicional. 2013. Disponível em: <http://
ruyalexandre.zzl.org/arquivos/lmintrologica.pdf>. Acesso em: 29 mar. 2014.
Leitura complementar
DIDÁTICA dos Concursos. Raciocínio lógico. Disponível em: <http://www.
guiadoconcursopublico.com.br/apostilas/24_81.pdf>. Acesso em: 29 mar. 2014.
Unidade 2
Introdução a
algoritmos
Veronice de Freitas
Objetivos de aprendizagem: Esta unidade aborda conceitos introdu-

tórios para o desenvolvimento de algoritmos: formas de representação
de algoritmo (narrativa, fluxograma, pseudocódigo), tipos de dados,
variáveis, instruções primitivas (entrada, saída, atribuição).
Seção 1: Introdução ao desenvolvimento de

algoritmos
Dentre as principais formas de representação de al-
goritmos, destacam-se: a descrição narrativa, o fluxo-
grama convencional e o pseudocódigo (ou linguagem
estruturada).
Seção 2: Instruções primitivas

As instruções primitivas são os comandos básicos
que efetuam tarefas essenciais para a operação dos
computadores, como entrada e saída de dados (co-
municação com o usuário e com dispositivos perifé-
ricos), e sua movimentação na memória.
Seção 3: Tipos de operadores

Operadores são sinais utilizados nos algoritmos para
indicar a realização de operações que podem ser de
três tipos: aritmético, relacionais e lógico.
Seção 4: Estrutura sequencial

No algoritmo sequencial, os comandos de um algo-
ritmo são executados em uma sequência preestabe-
lecida. Cada comando é executado somente após o
término do comando anterior.
Introdução a algoritmos 45
Um algoritmo é formalmente uma sequência finita de passos que levam à execu-
ção de uma tarefa. Essas tarefas não podem ser redundantes nem subjetivas na sua
definição, devem ser claras e precisas. São exemplos de algoritmos: instruções de
montagem, receitas, manuais de uso etc.
Até mesmo as coisas mais simples podem ser descritas por sequências lógicas.
Por exemplo:
Algoritmo 1 “Chupar uma bala”.
Pegar a bala.
Retirar o papel.
Chupar a bala.
Jogar o papel no lixo.
Algoritmo 2 "Troca de pneu do carro".
Desligar o carro.
Pegar as ferramentas (chave e macaco).
Pegar o estepe.
Suspender o carro com o macaco.
Desenroscar os 4 parafusos do pneu furado.
Colocar o estepe.
Enroscar os 4 parafusos.
Baixar o carro com o macaco.
Guardar as ferramentas.
Os programas de computadores são algoritmos escritos em uma linguagem de

computador (C, Pascal, Cobol, entre outras).
Para armazenar um algoritmo na memória de um computador e para que ele possa,
em seguida, comandar as operações a serem executadas, é necessário que ele seja
transcrito para uma linguagem que o computador possa “entender”. A escolha da
linguagem de programação depende, antes de tudo, da existência de um programa
compilador (que traduza o algoritmo escrito na linguagem escolhida para a lingua-
gem de máquina) ou de um programa interpretador (que interprete cada comando
do programa e execute uma série de instruções que a ele correspondem).
Seção 1 Introdução ao desenvolvimento

de algoritmos
Os algoritmos são independentes das linguagens de programação. Ao contrário
de uma linguagem de programação, não existe um formalismo rígido de como deve
ser escrito o algoritmo.
1.1 Fases para desenvolvimento de algoritmos

Para desenvolver um algoritmo, precisamos primeiro dividir o problema em três
fases fundamentais.
ENTRADA PROCESSAMENTO SAÍDA
Onde temos:
ENTRADA: são os dados de entrada do algoritmo, os valores que ele vai usar
no processamento para chegar à solução do problema. São fornecidos pelo
usuário, fazendo uso de algum dispositivo de entrada de dados, tal como um
teclado, um mouse ou um leitor de código de barras.
PROCESSAMENTO: são os procedimentos utilizados para chegar ao resultado
final, para alcançar a resolução do problema. Esses procedimentos são execu-
tados no processador do computador e os valores parciais são armazenados
na memória (memória RAM).
SAÍDA: São os dados já processados. É o resultado do processamento. Estes
dados de saída são apresentados em algum dispositivo de saída. Por exemplo,
a tela de um monitor.
Para se criar um programa que seja executável dentro de um computador, deve ter
em mente três pontos de trabalho: a entrada de dados, o seu processamento e a saída
dos mesmos. Sendo assim, todo programa estará trabalhando com esses três conceitos.
1.2 Formas de representação de algoritmos

Dentre as formas de representação de algoritmos, as mais conhecidas são:
Descrição Narrativa;
Fluxograma Convencional;
Pseudocódigo, também conhecido como Linguagem Estruturada ou Portugol.
1.2.1 Descrição narrativa

Nesta forma de representação, os algoritmos são expressos diretamente em lin-
guagem natural. O algoritmo pode ser escrito de forma mais abstrata (exemplo 01
— versão 01) ou com um nível maior de detalhamento (exemplo 01 — versão 02).
Exemplo 1: algoritmo para troca de um pneu furado — versão 1:
Obs.: é um algoritmo com um nível de abstração maior que descreve as principais

tarefas para trocar o pneu furado.
1. Pegar o pneu reserva.

2. Afrouxar ligeiramente as porcas.
3. Suspender o carro.
4. Retirar as porcas e o pneu.
5. Colocar o pneu reserva.
6. Apertar as porcas.
7. Abaixar o carro.
8. Dar o aperto final nas porcas.
Exemplo 1: algoritmo para troca de um pneu furado — versão 2:
Obs.: é um algoritmo com um nível maior de detalhamento que descreve as

tarefas para trocar o pneu furado.
1. Estacionar o carro no acostamento.

2. Desligar o carro.
3. Ligar o pisca alerta.
4. Retirar o cinto de segurança.
5. Abrir a porta.
6. Sair do veículo.
7. Abrir o porta-malas.
8. Pegar o triângulo de sinalização.
9. Montar o triângulo.
10. Colocar o triângulo no asfalto para fazer a sinalização.
11. Retirar o macaco do porta-malas.
12. Colocar o macaco ao lado do carro.
13. Retirar o estepe do porta-malas.
14. Colocar o estepe ao lado do carro.
15. Colocar o macaco sob o carro.

16. Girar a manivela para levantar o carro.
17. Pegar a chave.
18. Retirar os parafusos.
19. Retirar os pneus.
20. Colocar o estepe.
21. Parafusar o estepe.
22. Girar a manivela do macaco ao contrário.
23. Colocar o pneu no porta-malas.
24. Colocar o macaco no porta-malas.
25. Guardar o triângulo.
26. Fechar o porta-malas.
27. Abrir a porta do carro.
28. Entrar no carro.
29. Colocar o cinto de segurança.
30. Ligar o carro.
31. Continuar a viagem.

É possível alterar o algoritmo para trocar o pneu furado e criar uma terceira
versão, levando em consideração a falta de algum item?
Exemplo 2: algoritmo para fazer um sanduíche:
Obs.: o algoritmo também pode ser escrito de várias formas, dependendo da

resolução do problema. O exemplo do algoritmo para fazer um sanduíche é
descrito em duas formas. Na versão 1 o algoritmo é escrito na forma sequencial
e na versão 2 apresenta condições como, por exemplo, se não gostar de maio-
nese a instrução “Passar a maionese no pão” não será executada. E também a
estrutura de repetição que irá repetir a instrução “Colocar alface e tomate no
pão” enquanto a quantidade de salada for insuficiente.
Fazer um sanduíche — versão 1 Fazer um sanduíche — versão 2

1. Pegar o pão. 1. Pegar o pão.
2. Cortar o pão ao meio. 2. Cortar o pão ao meio.
3. Passar a maionese no pão. 3. Se gostar de maionese então.
4. Pegar e cortar alface e tomate. 4. Passar a maionese no pão.
5. Colocar alface e tomate no pão. 5. Se gostar de salada então.
6. Pegar o Hambúrguer. 6. Pegar e cortar alface e tomate.
7. Fritar o Hambúrguer. 7. Enquanto qtde insuficiente então.
8. Colocar o Hambúrguer no pão. 8. Colocar alface e tomate no pão.
9. Pegar o Hambúrguer.
10. Fritar o Hambúrguer.
11. Colocar o Hambúrguer no pão.
Exemplo 3: receita de bolo
Obs.: no algoritmo receita de bolo — versão 1: o algoritmo está na forma se-

quencial (todas as instruções são executadas) — na versão 2: faz uso da estrutura
condicional para verificar se existe coco ralado e a estrutura de repetição para
verificar se o bolo está corado para depois retirar do forno.
Receita de bolo — versão 1 Receita de bolo — versão 2

1. Misturar os ingredientes. 1. Misturar os ingredientes.
2. Untar a forma com manteiga. 2. Untar a forma com manteiga.
3. Despejar a mistura na forma. 3. Despejar a mistura na forma.
4. Despejar o coco ralado sobre a mistura. 4. Se houver coco ralado então
5. Levar a forma para o forno. despejar sobre a mistura.
6. Deixar o bolo 30 minutos no forno. 5. Levar a forma para o forno.
7. Retirar a forma do forno. 6. Enquanto não corar.
8. Deixar esfriar. 7. Deixar a forma no forno.
8. Retirar a forma do forno.
9. Deixar esfriar.
Exemplo 4: sacar dinheiro em caixa eletrônico
No exemplo do saque eletrônico — versão 1 é utilizada a estrutura condicio-

nal (se ... senão ... ) para testar se o saldo é suficiente para efetuar o saque. Na
versão 2, existe a estrutura de repetição para validar a senha (enquanto senha
incorreta repete a leitura da senha).
Sacar dinheiro — versão 1 Sacar dinheiro — versão 2

1. Ir até um caixa eletrônico. 1. Ir até um caixa eletrônico.
2. Colocar o cartão. 2. Colocar o cartão.
3. Digitar a senha. 3. Digitar a senha.
4. Solicitar a quantia desejada. 4. Enquanto senha incorreta então
5. Se o saldo for maior ou igual à quantia apresentar a mensagem de senha inválida e
desejada, sacar o dinheiro. senão, mostrar digitar a senha.
mensagem de impossibilidade de saque. 5. Solicitar a quantia desejada.
6. Retirar cartão. 6. Se o saldo for maior ou igual à quantia dese-
7. Sair da agência. jada, sacar o dinheiro; caso contrário, mostrar
mensagem de impossibilidade de saque.
7. Retirar cartão.
8. Sair da agência.
Esta representação é pouco usada na prática porque o uso de linguagem natural

muitas vezes dá oportunidade a más interpretações, ambiguidades e imprecisões.
Por exemplo, a instrução “afrouxar ligeiramente as porcas”, no algoritmo da troca de
pneus, está sujeita a interpretações diferentes por pessoas distintas. Uma instrução
mais precisa seria: “afrouxar a porca, girando-a de 30º no sentido anti-horário”.
A descrição narrativa pode ser usada como apoio às outras formas de represen-
tação de algoritmos (fluxograma, pseudocódigo, etc.) para estabelecer a lógica que
irá utilizar para resolução do problema.
VANTAGENS:
O português é bastante conhecido por nós.
DESVANTAGENS:
Imprecisão: pode ser interpretado de forma diferente o exemplo: “afrouxar a
porca” na troca do pneu.
1.2.2 Fluxograma convencional

É uma representação gráfica de um algoritmo por meio de símbolos. Cada símbolo
tem uma forma geométrica que define sua função genérica e no seu interior haverá
uma descrição do passo do algoritmo. Os símbolos são ligados por flechas que indicam
o fluxo. Os principais símbolos de fluxograma estão representados no Quadro 2.1:
Quadro 2.1 principais formas geométricas utilizadas em fluxograma
Símbolo Função
Indica o início ou fim de um processamento. Exemplo:

Início do algoritmo.
TERMINAL
continua
continuação
Processamento em geral. Exemplo: x m 7+4
PROCESSAMENTO
Indica entrada de dados pelo usuário via teclado.

Exemplo: Digite a nota 01.
ENTRADA MANUAL DE DADO
Saída: informações exibidas no vídeo.
SAÍDA
Setas: indica o sentido do processamento.
SETAS
Conector: utilizado quando é precioso particionar o

diagrama.
CONECTOR
Exemplo 1 — Fluxograma: efetua a leitura de duas notas, calcula a média e apre-

senta uma mensagem “aprovado” ou “reprovado” dependendo do valor da MÉDIA.
Início
INICIO
N1, N2 Entrada das notas
MEDIA <- (N1 + N2) / 2 Cálculo da MÉDIA
não sim Condição para verificar se

MEDIA >= 7
O aluno foi “APROVADO” ou “REPROVADO ”
“REPROVADO” “APROVADO” Impressão de acordo com o valor da MÉDIA
FIM Final
A principal vantagem de se utilizar fluxogramas para construir algoritmos é que

é mais fácil entender um conteúdo descrito de forma gráfica do que um descrito
textualmente.
Já as desvantagens são: os dados não são suficientemente detalhados, dificultando,
assim, a transcrição do algoritmo para o programa a ser desenvolvido; é necessário
aprender a simbologia dos fluxogramas; e, para algoritmos mais extensos, a constru-
ção do fluxograma pode se tornar mais inviável devido à dificuldade para alteração.

No fluxograma do exemplo 5, um aluno com MÉDIA menor que SETE obtém o
conceito “REPROVADO”. O que poderia ser alterado no fluxograma para algoritmo
solicitar uma nota de EXAME e efetuar novos testes (NOVA_MÉDIA maior ou igual
a 5, “APROVADO EM EXAME”, caso contrário, “REPROVADO EM EXAME”)?
1.2.3 Linguagem algoritma — pseudocódigo

Esta forma de representação de algoritmos, também conhecida como português
estruturado ou portugol, é rica em detalhes e, por assemelhar-se à forma em que os
programas são escritos, é a mais utilizada.
Quadro 2.2 Estrutura — pseudocódigo
Algoritmo é uma palavra que indica o início

da definição de um algoritmo em forma de
Algoritmo “<nome_do_algoritmo>” pseudocódigo.
<nome_do_algoritmo> é um nome simbólico dado
ao algoritmo.
<declaração_de_variáveis> consiste na seção
<declaração_de_variáveis> onde são declaradas as variáveis globais usadas no
algoritmo.
<subalgoritmos> consiste nas seções opcionais do
<subalgoritmos>
pseudocódigo onde são definidos os subalgoritmos.
Início é a palavra que delimitam o início do
início
conjunto de instruções do corpo do algoritmo.
<corpo do algoritmo> São as instruções.
Fim é a palavra que delimitam o final do conjunto
fimalgoritmo
de instruções do corpo do algoritmo.
Exemplo 1: pseudocódigo — Calcula a média aritmética de um aluno
algoritmo "Calcula-média“
var
N1, N2, N3, N4, MÉDIA, SOMA: real
início
// ---------- ENTRADA DE DADOS---------
leia(N1,N2,N3,N4)
// ------------ PROCESSAMENTO-----------
SOMA <- N1 + N2 + N3 + N4
MÉDIA <- SOMA / 4
// --------------- SAÍDA--------------
escreva("Média Final: ", MÉDIA)
fim Algoritmo
Exemplo 2: determinar se uma pessoa é maior ou menor de idade
Algoritmo “Maioridade”
var
idade: inteiro
início
// ---------- ENTRADA DE DADOS---------

escreva(“Digite a idade (maior do que zero): “)
leia(idade)
// --------------- SAÍDA--------------
se (idade > 0) então
se ( idade >= 18 ) então

escreva ( “Maior de idade. “)
senão
escreva( “Menor de idade. “)
fimse
senão
Escreva (“ Idade incorreta. “)
Fimse
fimalgoritmo
VANTAGENS:
Independência física da solução (solução lógica apenas).
Usa o português como base.
Pode-se definir quais e como os dados vão estar estruturados.
Passagem quase imediata do algoritmo para uma linguagem de programação.
DESVANTAGENS:
Exige a definição de uma linguagem não real para trabalho.
Não padronizado.
Para saber mais

Conceitos sobre formas de representação de algoritmos:
SALIBA (1992). Capítulo 02 — Formas de representação de algoritmos (SALIBA, 1992).
1.3 Variáveis e tipo de dado

Uma variável é um local com um nome dentro da memória do computador que
armazena um tipo específico de conteúdo.
Uma analogia muito comum é imaginar uma variável como uma caixinha den-
tro da memória do computador. Esta caixa tem a capacidade de guardar um dado
de certo tipo; e o nome da variável é como uma etiqueta colada na frente da caixa
exemplificado na Figura 2.1:
Figura 2.1 Uma representação abstrata das variáveis na memória do computador
Rafael
Rafael é a informação
NOME é a variável do tipo caractere
NOME
55
55 é a idade
IDADE é a variável do tipo inteiro
IDADE
1250,55 1250,55 é o salário

SALÁRIO é a variável do tipo real
SALÁRIO (pode conter casas decimais)
Memória
Os dados são representados pelas informações a serem processadas por um com-

putador. Um tipo de dado especifica as características, ou seja, os valores e operações
possíveis de serem utilizados com um dado desse tipo.
As variáveis existem na memória durante a execução do algoritmo. Quando ele
termina a execução, todos os dados são apagados, e as caixas destruídas.
1.3.1 Tipos de dados

Os tipos de dados mais básicos (também conhecidos como tipos primitivos) estão
representados no Quadro 2.3:
Quadro 2.3 Tipos primitivos de dados
Tipo Descrição
Representa valores inteiros.
INTEIRO
Exemplos: 15, 25, -15, -25
Representa valores reais (com a parte decimal).
REAL
Exemplos: 20.555, 40.4, -13.58
Representa uma sequência de um ou mais caracteres.
CARACTERE Exemplos: “Esse é um exemplo de caractere”, “A”, “2540”, “Unopar”
OBS: sempre colocamos os caracteres entre “ “ (aspas duplas)
Representa valores lógicos, os quais possuem apenas 2 estados:
LÓGICO
VERDADEIRO (true) ou FALSO (false)
Para saber mais

Apostila de Linguagem C (Conceitos Básicos):
<http://www.facom.ufu.br/~gustavo/ED1/Apostila_Linguagem_C.pdf>.
Capítulo I — Introdução ao Turbo Pascal:
<http://w3.impa.br/~zang/uerj/ipd/material/apostila-pascal.pdf>. Acessos em: 7 jun. 2014.
1.3.2 Definição de variáveis em algoritmos

Todas as variáveis utilizadas em algoritmos devem ser definidas antes de serem
utilizadas. Isto se faz necessário para permitir que o compilador reserve um espaço
na memória para as mesmas.
Sintaxe:
<variável 1>, <variável 2>, ... : tipo de dados
Exemplos de definição de variáveis:
VAR
NOME: caractere
IDADE: inteiro
SALÁRIO: real
No exemplo anterior foram declaradas três variáveis:

A variável NOME, capaz de armazenar dados caracteres.
A variável IDADE, capaz de armazenar um número inteiro.
A variável SALÁRIO, capaz de armazenar um número real.

Qual a relação entre tipos de dados e variáveis?
Qual é o valor máximo que pode ser atribuído a uma variável do tipo inteiro
levando em consideração que esse tipo ocupa dois bytes de memória?
Para saber mais

Conceitos sobre variáveis e tipos de dados:
Parte II — Técnicas Básicas de Programação — Capítulo 3 (MANZANO, 2008).
1.3.3 Operação de atribuição

A operação de atribuição permite fornecer um valor a uma variável. Se for atribuída
uma expressão à variável, será armazenado o resultado da expressão.
Sintaxe:
variável m expressão
Exemplos:
Inteiro Carácter Real
A <- 2 NOME <- “Veronice” X <- 2.5
B <- A + 5 SENHA <- “X3Y9” SALÁRIO <- 1500.50
C <- B + A DPTO <- “FINANCEIRO” NOTA <- 8.5
D <- 6 / 3 CURSO <- “ADS” PRECO <- 25.30
Exemplos: algoritmo em pseudocódigo para calcular a média aritmética de três

notas do tipo real.
Algoritmo “Exemplo Atribuição” Reservar 3 espaços de memória do tipo

var real para as três variáveis com nome.
N1,N2, N3: real
início
N1 <- 8.5 Atribuição de valores iniciais às variáveis
N2 <- 7.5
N3 <- 9.5
MÉDIA <- (N1 + N2 + N3) /3 Calcula a MÉDIA

aritmética das três notas
Escreva(MÉDIA)
Fimalgoritmo
Imprime a MÉDIA
1.3.4 Memória x variável

Cada variável definida no programa usa um local da memória, que é acessada por
meio do nome da variável. O espaço de memória ocupado pelo conteúdo da variável
depende do tamanho destes tipos de dados, que pode variar dependendo da lingua-
gem de programação. Como referência inicial (em algoritmo) para este estudo sobre
variáveis, pode-se considerar o seguinte:
Tipo Inteiro ocupa 2 bytes de memória.
Tipo real ocupa 4 bytes de memória.
Tipo caractere com 1 byte para cada caractere.
Como exemplo, pode-se representar a memória como uma matriz, como a Figura
2.2, onde cada célula possui tamanho de 1 byte (8 bits):
Figura 2.2 Representação da memória
Exemplo:
Var
NUMDEP: INTEIRO // irá utilizar dois bytes
SALÁRIO: REAL // irá utilizar quatro bytes
NUMDEP SALÁRIO
2 BYTES 4 BYTES
Exemplos: algoritmo em portugol para somar dois valores inteiros (20 + 10).
Algoritmo “Exemplo Variáveis” Reservar 3 espaços de memória do tipo inteiro

var para três variáveis com nome: A, B e C.
A,B,C: inteiro
início Atribuição de valores iniciais às variáveis
A <- 20
B <- 10
C <- A + B O resultado da soma de A + B será armazenado
Fimalgoritmo
no espaço de memória C
Representação das células de memória ocupadas pelas três variáveis considerando

que o endereço inicial é zero.
0 1 2 3 4 6 6 7 8 ..
A B C
20 10 30
Endereços representados no
sistema decimal para facilitar
a análise.
Considerando que a representação da memória se inicia na posição 0, as variáveis

representam:
a) inicia no endereço 0 (ocupa 2 bytes) e contém o valor 20.
b) inicia no endereço 2 (ocupa 2 bytes) e contém o valor 10.
c) inicia no endereço 4 (ocupa 2 bytes) e contém o valor 30.
1.3.5 Formação de variáveis

As variáveis e as constantes têm um nome (rótulo) que as identificam dentro do
código/pseudocódigo. Esse nome é definido conforme as regras:
a) O primeiro caractere deve ser SEMPRE uma letra.
b) Os nomes devem ser formados por caracteres pertencentes às letras do al-
fabeto e aos números. Se o identificador for mais de uma palavra, podemos
separá-los com o underline “_”.
c) Nomes de variáveis longos dificultarão a codificação (verificar tamanho de-
pendendo da linguagem que for programar).
d) Não deve utilizar acentuação ou cedilha.
e) Não pode haver espaços em branco entre os caracteres do identificados.
f) Os nomes escolhidos devem ser explicativos do seu conteúdo.
g) Os nomes dados às variáveis não podem ser os mesmos nomes das palavras
reservadas da linguagem que será utilizada.
Exemplos de nomes de variáveis:

SALÁRIO — correto.
1ANO — errado (não começou uma letra).
ANO1 — correto.
A CASA — errado (contém o caractere branco).
SAL/HORA — errado (contém o caractere “/”).
SAL_HORA — correto.
Para saber mais

Conceitos sobre variáveis e tipos de dados:
Parte II — Técnicas Básicas de Programação — Capítulo 03 (MANZANO, 2008).
Capítulo 03 — Tipos de Dados, Capítulo 04 — Variáveis (SALIBA, 1992).
1. Escreva um algoritmo na forma narrativa para fazer uma salada de frutas.
2. A tabela abaixo contém algumas instruções que têm por objetivo calcular
o total de uma venda. Na coluna tipo, identifique os dados de entrada (E),
processamento (P) e saída (S). Na coluna sequência lógica, estabeleça a
sequência numérica das instruções (ordem para serem executadas).
Algoritmo venda
Instrução (Identifique a ordem correta) Tipo Sequência lógica
Calcular o valor total da peça (Quantidade * Valor da peça)
Mostrar o código da peça e seu valor total
Receber valor da peça
Receber quantidade de peças
3. Crie o fluxograma do algoritmo abaixo:

algoritmo “exemplo”
var
PRECO_UNIT, PRECO_TOT : real
QUANT : inteiro
Início
escreva(“Digite o preço unitário: ”)
leia (PRECO_UNIT)
escreva (“Digite a quantidade: ”)

leia(QUANT)
PRECO_TOT PRECO_UNIT * QUANT
escreva(“Preço total: “, PRECO_TOT)

fimalgoritmo
4. Diferencie tipo de dados e variáveis.

5. Identifique o tipo dos dados:
a) inteiro; b) real; c) lógico; d) cadeia ou literal.
( ) Verdadeiro ( ) “Maria”
( ) “c*d” ( ) -23
( ) Falso ( ) 35.23
( ) “1 2 3 4“ ( ) -18.589
( ) “aula” ( ) 345
( ) 897 ( ) 0.342
6. Quais são as regras básicas para criar nomes (identificadores) das variáveis?
7. Marque com X os identificadores válidos:
( ) A ( ) 5B
( ) NOTA ( ) DATA
( ) PROGRAMA ( ) PROGRAM
( ) NOTA[1] ( ) A32B
( ) X5 ( ) E(13)
( ) MATRICULA ( ) A:B
( ) F1GH78 ( ) B*D
( ) AX_DATA ( ) X -Y
( ) VALOR ( ) “NOTA“
( ) AH! ( ) KM/H
( ) NOTA*DO*ALUNO ( ) NOMEDAEMPRESA
( ) ANO ( ) MÉDIA
( ) MÉDIA SALARIAL ( ) AI!
( ) A15B34 ( ) “AULA“
( ) NOME_ALUNO ( ) 1DEPARTAMENTO
8. Sendo SOMA, NUM e X variáveis numéricas (inteiro ou real); NOME, COR

e DIA variáveis literais (caractere); TESTE, COD e TUDO variáveis lógicas,
assinalar os comandos de atribuição considerados inválidos:
( ) NOME <- 5
( ) SOMA <- NUM = 2* X
( ) TESTE <- COD
( ) TUDO <- SOMA
( ) COR <- “PRETO“
( ) X <- X + 1
( ) NUM <- “ABC“
( ) DIA <- “SEGUNDA“
( ) COD <- VERDADEIRO
9. Encontre os erros dos comandos de atribuição a seguir:

Algoritmo “exercício 01”
var
lógico: A
real: B, C
inteiro: D
início
A B + C
D B
C A + D
Fimalgoritmo
Seção 2 Instruções primitivas

Como o próprio nome diz, instruções primitivas são os comandos básicos que
efetuam tarefas essenciais para a operação dos computadores, como entrada e saída
de dados (comunicação com o usuário e com dispositivos periféricos), e movimen-
tação dos mesmos na memória. Esses tipos de instruções estão presentes na maioria
das linguagens de programação.
2.1 Comandos de atribuição

O comando de atribuição ou simplesmente atribuição, é uma das formas para
armazenar uma informação em uma variável. O algoritmo a seguir apresenta exem-
plos de comandos de atribuição:
algoritmo “exemploAtriuicao”
var INICIO
PRECO_UNITÁRIO, TOTAL : real

QTDE : inteiro
PRECO_UNITARIO 10
início
// ------ PROCESSAMENTO ---

QTDE 5
PRECO_UNITÁRIO <- 10
QTDE <- 5
TOTAL <- PRECO_UNITÁRIO * QTDE
TOTAL QTDE * PRECO_UNITARIO
fimAlgoritmo
FIM
- nesse exemplo não será impresso

nenhum valor (o processamento é interno)
2.2 Comandos de saída de dados (escreva)

O comando de saída de dados é o meio pelo qual informações contidas na me-
mória dos computadores são colocadas nos dispositivos de saída, para que os usuá-
rios possam visualizá-las. A seguir temos um exemplo de um algoritmo utilizando o
comando de saída de dados:
algoritmo “exemploSaida”
var INICIO

QTDE : inteiro
PRECO_UNITARIO 10
início
// ------ PROCESSAMENTO ---

QTDE 5
PRECO_UNITÁRIO <- 10
QTDE <- 5
TOTAL QTDE * PRECO_UNITARIO
//------ SAÍDA ---

escreva(TOTAL)
TOTAL
fimAlgoritmo
FIM
2.3 Comando de entrada de dado (leia)

Comando de entrada de dado é o meio pelo qual as informações dos usuários são
transferidas para a memória dos computadores, para que possam ser usadas nos programas.
A seguir, temos um exemplo de um algoritmo utilizando o comando de entrada de dados:
algoritmo “exemploEntradaSaida”
INICIO
var
QTDE : inteiro
PRECO_UNITARIO
início
// ------ ENTRADA -------

QTDE
leia(PRECO_UNITÁRIO)
leia(QTDE)
// ------ PROCESSAMENTO ------- TOTAL QTDE * PRECO_UNITARIO
// ------ SAÍDA -------

escreva(TOTAL) TOTAL
fimAlgoritmo
FIM
1. Analise os algoritmos abaixo e diga o que será impresso na tela ao serem
executados:
Algoritmo Simulação
algoritmo "teste01"
a) var
A , B: inteiro Memória Vídeo
início
A <-10
B <- 20
escreva(B)
B <- 5
Escreva( A, B)
fimalgoritmo
b) algoritmo "teste02"
var
A , B,C: inteiro Memória Vídeo
Início
A <- 30
B <- 20
C <- A + B
escreva(C)
B <- 10
escreva( B, C)
C <- A + B
escreva(A, B, C)
fimalgoritmo
c) algoritmo "teste03"
var
X: inteiro Memória Vídeo
Z, Y: real
início
X <- 30
Y <- 40
Z <- Y – X * 2
Escreva(Z)
X <- 10
Y <- X + Z /2
escreva(X, Y, Z)
fimalgoritmo
2. Identifique ENTRADA(S), PROCESSAMENTO e SAÍDA(S) no algoritmo

abaixo:
algoritmo “exemplo02”
var
PRECO_UNIT, PRECO_TOT : real
QUANT : inteiro
Início
escreva(“Digite o preço unitário: ”)
leia (PRECO_UNIT)
escreva (“Digite a quantidade: ”)

leia(QUANT)
PRECO_TOT PRECO_UNIT * QUANT
escreva(“Preço total: “, PRECO_TOT)

fimalgoritmo
3. O que será atribuído às variáveis A, X e B?

Algoritmo “exemplo03”
logico: A, B
inteiro: X
início
X 8 + 6 * 2
B 5 + 3
A B
fimalgoritmo
4. Dadas as declarações abaixo, assinale os comandos de atribuição inválidos:

var
NUM: inteiro
SOMA, X: real
SIMBOLO, NOME, COR, DIA: caractere
COD, TESTE, TUDO: lógico
( ) SIMBOLO Å 8 ( ) SOMA Å NUM + 3 * X

( ) TESTE Å COR ( ) TUDO Å SOMA
( ) COR Å “VERMELHO”; ( ) XÅX+1
( ) NUM Å “1234” ( ) DIA Å “QUARTA”
Para saber mais

Unidade 3 — Instruções Primitivas
<http://www.inf.unioeste.br/~andre/capitulo3.pdf>.
Apostila da Disciplina de Lógica de Programação
<http://prograd.unifesp.br/images/uni/apostila-logica-110210.pdf>. Acessos em: 7 junho 2014.

É possível criar um algoritmo para calcular a média aritmética (4 notas) e
verificar se esse aluno foi “aprovado” ou “reprovado” usando apenas as
instruções básicas apresentadas nessa unidade?
Seção 3 Tipos de operadores

Operadores são elementos funcionais que atuam sobre operandos e produzem
um determinado resultado. Por exemplo, a expressão 5 + 3 relaciona dois operandos
(os números 5 e 3) por meio do operador (+) que representa a operação de adição.
De acordo com o número de operandos sobre os quais os operadores atuam, estes
podem ser classificados em:
binários, quando atuam sobre dois operandos. Ex.: os operadores das operações
aritméticas básicas (soma, subtração, multiplicação e divisão);
unários, quando atuam sobre um único operando. Ex.: o sinal de (-) na frente
de um número, cuja função é inverter seu sinal.
3.1 Operadores aritméticos

Os operadores aritméticos se relacionam às operações aritméticas básicas, con-
forme a tabela a seguir:
Quadro 2.4 Prioridade dos operadores
Operador Tipo Operação Prioridade

+ Binário Adição 4
- Binário Subtração 4
* Binário Multiplicação 3
/ Binário Divisão 3
MOD Binário Resto da divisão 3
DIV Binário Divisão Inteira 3
** ou ^ Binário Exponenciação 2
+ Unária Manutenção do sinal 1
- Unária Inversão do sinal 1
Durante a execução de uma expressão que envolve vários operadores, é necessário

a existência de prioridades, caso contrário, poderá obter valores que não representam
o resultado esperado. A maioria das linguagens de programação utiliza as seguintes
prioridades de operadores:
1º — Efetuar operações embutidas em parênteses “mais internos”.
2º — Efetuar funções.
3º — Efetuar multiplicação e/ou divisão.
4º — Efetuar adição e/ou subtração.
5º — Operadores relacionais.
3.2 Operadores relacionais

Os operadores relacionais são operadores binários que devolvem os valores ló-
gicos (verdadeiro e falso).
Operador Comparação
> Maior que
< Menor que
>= Maior ou igual
<= Menor ou igual
= Igual
<> Diferente
Os operadores relacionais são utilizados quando se deseja efetuar comparações

entre objetos de mesma natureza, isto é variável do mesmo tipo de dado. O resultado
de uma comparação é sempre um valor lógico.
Por exemplo, digamos que a variável inteira escolha contenha o valor 7. A primeira
das expressões a seguir fornece um valor falso, e a segunda um valor verdadeiro:
escolha <= 5
escolha > 5
3.3 Operadores lógicos

Os operadores lógicos ou booleanos são usados para combinar expressões re-
lacionais. Também devolvem como resultado valores lógicos verdadeiro ou falso. A
tabela a seguir apresenta os tipos de operadores lógicos.
Operação Operador
Negação Não
Conjunção E
Disjunção (não — exclusiva) Ou
Disjunção (exclusiva) Xou
A tabela anterior apresenta os operadores lógicos já ordenados de acordo com

suas prioridades, ou seja, se na mesma expressão for utilizado o operador ou e o
operador não, por exemplo, primeiro irá executar o não e depois o ou.
De uma forma geral, os resultados possíveis para os operadores lógicos estão
representados na tabela abaixo, conhecida como tabela verdade.
A B AeB A ou B Não A A xou B

F F F F V F
F V F V V V
V F F V F V
V V V V F F
Exemplos de expressões utilizando operadores lógicos:

Para A = V, B = F e C = F , as expressões abaixo fornecem os seguintes resultados:
Expressão Resultado
a) Não A Não V = F
b) A e B VeF=F
c) A ou B V ou F = V
d) Não (B ou C) Não (F ou F) = Não F = V
Para saber mais

Conceitos sobre tipos de operadores:
Capítulo 4 — Estruturas de controle — A tomada de decisão (MANZANO, 2008).
Capítulo 5 — Expressões (SALIBA, 1992).
1. Os pares de instruções abaixo produzem o mesmo resultado?
(4 / 2) + (2 / 4) e 4/2+2/4
4 / (2 + 2) / 4 e 4/2+2/4
(4+2)*2-4 e 4+2*2-4
2. Dadas as informações abaixo, informe qual o valor das relações (verda-

deiro ou falso):
a) a = 9.0, b = 2.0, nome = ‘Beatriz’, profissão = ‘advogado’
a + b = 11 ( )
nome <> “Carlos” ( )
profissao = “professor” ( )
b) a = 8 b = 12 nome = “Veronice”, profissão =”professor”
a+5=b-3 ( )
nome <> “ana” ( )
profissao = “dentista” ( )
c) x = 3, y = 4, z = 10, nome = “Carlos”, R = verdadeiro
( x + y > z ) e (nome = “Carlos”) ( )
(R) ou ( y > = x ) ( )
(not R) e ( z div y + 1 = x ) ( )
3. Determine os valores finais de A, B e C após a execução do trecho do

algoritmo abaixo:
Atribuições Simulação
A <-0
B <- 1 Memória Vídeo
C <- A + B
A <- A + 1
B <- A + B + C
4. Sabendo que A=3, B=8 e C=4, informe se as expressões abaixo são verda-
deiras ou falsas.
xpress o erdadeiro also
a) ( +C) > ( ) ( )
b) >= ( + 3) ( ) ( )
) C=( ) ( ) ( )
d) ( + ) >= C ( ) ( )
e) (C+ ) > ( ) ( )
5. Sabendo que A=5, B=4 e C=3 e D=6, informe se as expressões abaixo são
verdadeiras ou falsas.
xpress o erdadeiro also
( > C) e (C >= ) ( ) ( )
( + ) > 1 ou. ( + ) = (C+ ) ( ) ( )
( >=C) e. ( >= C) ( ) ( )
nao ( < ) xo ( = C) ( ) ( )
< xo > ( ) ( )
6. Determine o resultado lógico das expressões abaixo, assinalando se são

verdadeiras ou falsas. Considere os seguintes valores para as variáveis:
X = 8, A=7 , B=5 , C=3 , D=6 , NOME=”MARIA”.
xpress o Verdadeiro falso

( < 1 ) e ( = 3) ( ) ( )
( =5) o ( < 4) o (C> ) ( ) ( )
( =” R ”) e ( > 5) ( ) ( )
( <>” R ”) e ( > ) ( ) ( )
( < ) o ( > C) ( ) ( )
( >= ) e ( >C) ( ) ( )
( <>C) o ( > ) ( ) ( )
( =” R ” ) o (C <> 5) ( ) ( )
( = ) e (C < ) ( ) ( )
( > 3 ) e (C < ) ( ) ( )

Qual a relação entre as variáveis e os tipos de dados?
Qual a restrição para usar os operadores relacionais?
Seção 4 Estrutura sequencial

Na estrutura sequencial os comandos de um algoritmo são executados em uma
sequência preestabelecida. Cada comando é executado somente após o término do
comando anterior.
Pseudocódigo Fluxograma
...
<comando 1> COMANDO 1
<comando 2>
<comando n>
COMANDO 2
...
COMANDO N
4.1 Estrutura sequencial — exemplo (pseudocódigo e

fluxograma)
Exemplo 1: tem por função efetuar a leitura de dois números, calcular a soma e
apresentar o resultado.
Obs: antes de desenvolver o pseudocódigo identifique: INICIO
*Quais são as entradas? NUMERO1 e NUMERO2
*Qual o processamento? Calcular a soma
*Qual é a saída? Apresentar a soma “Entre com o 1º
número: “
algoritmo “SomaNúmeros”
var
NUMERO1, NÚMERO2: inteiro NUMERO1
SOMA: inteiro;
Início “Entre com o 2º
// --------- Entrada --------- número: “
escreva(“Entre com o 1º número: “)
leia(NÚMERO1)
NUMERO2
escreva(“Entre com o 2º número: “)
leia(NÚMERO2)
SOMA <- NUMERO1 + NUMERO2
// -------- Processamento -------

SOMA <- NÚMERO1 + NUMERO2
“A soma é: “,
soma
// -------- Saída -------
escreva(“A soma é: “, SOMA)
FIM
fimalgoritmo
Exemplo 2: tem por função calcular a área e o perímetro de um retângulo.
Dados de entrada:
INICIO
Obter o valor da altura do retângulo.
Obter o valor da largura do retângulo.
“Entre com a
Processamento: altura: “
Calcular a área.
Calcular o perímetro.
ALTURA
Saída:
Mostrar os cálculos realizados.
algoritmo “ÁreaPerímeto” “Entre com a
Var largura “
ÁREA, PERÍMETRO, ALTURA, LARGURA: real
Início
// --------- Entrada -------- LARGURA
escreva(“Entre com a altura: “)
Leia(ALTURA)
AREA <- ALTURA * LARGURA
PERIMETRO <- 2 * ALTURA + 2 * LARGURA
escreva(“Entre com a largura: “)
leia(LARGURA)
“A área é: “,
// --------- Processamento -------- AREA
ÁREA = ALTURA * LARGURA
PERÍMETRO <- 2 * ALTURA + 2 * LARGURA
“O perímetro é: “,
// --------- Saída -------- PERIMETRO
escreva(“A área é: “, AREA)
escreva (“O perímetro é: “, PERÍMETRO)
FIM
fimalgoritmo
Exemplo 3: tem por função determinar a área de um quadrado a partir da leitura

do seu lado.
Dados de entrada: Saída:
INICIO
Obter o valor do lado. Mostrar o valor da área.
Processamento:
“Informe a media
Calcular a área. do lado:”
algoritmo “ÁreaPerímeto”
Var
LADO, ÁREA: real
Início LADO
// --------- Entrada --------
escreva(“Informe a medida do lado:”)
lEIA(LADO) AREA LADO * LADO
// --------- Processamento --------

ÁREA <- LADO * LADO
“A área é:”, AREA
// --------- Saída --------
escreva (“Área =”, ÁREA)
FIM
fimalgoritmo
4.2 Estrutura sequencial — exemplo (simulação —

teste de mesa)
Exemplo 1: Efetuar a leitura de dois valores para as variáveis A e B, e efetuar as
trocas dos valores de forma que a variável A passe a possuir o valor da variável B
e a variável B passe a possuir o valor da variável A. Apresentar os valores trocados.
Algoritmo Simulação
algoritmo "exemplo01"
var
Memória Vídeo
A <- 20 Digite o
A, B, TROCA: inteiro
valor(numérico)
B <- 30
da variável A:
início
TROCA <- 20 20
//========ENTRADA ===========
escreva("Digite o valor(numérico) da A <- 30
Digite o valor
variável A: ")
B <- TROCA (numérico) da
leia(A)
variável A: 30
escreva("Digite o valor(numérico) da
O novo valor de
variável B: ")
A é: 30
leia(B)
O novo valor de
// =====PROCESSAMENTO ========
B é: 20
TROCA <- A
A <- B
B <- TROCA
//==========SAÍDA ============
escreva("O novo valor de A é: ",A)
escreva("O novo valor de B é: ",B)
fimalgoritmo
Exemplo 2: tem por função efetuar a leitura de três números e calcular a média
aritmética.
Pseudocódigo Simulação
algoritmo “MédiaAritmetica”
Var
N1, N2, N3: real
Memória Vídeo
MÉDIA: real Entre com os
Início
// --------- Entrada -------- N1 <- 10 números:
escreva(“Entre com os números: “) N2 <- 20 10
Leia(N1, N2, N3)
N3 <- 30 20
MÉDIA <- (10 + 20 30
// --------- Processamento --------
MÉDIA = (N1 + N2 + N3) / 3 + 30) / 3 A Média é: 20
// --------- Saída --------

escreva(“A Média é: “, MÉDIA)
fimalgoritmo
4.3 Estrutura sequencial — exemplo (resolução)

Exemplo 1: Faça um algoritmo que receba o preço de custo de um produto e
mostre o valor de venda. Sabe-se que o preço de custo receberá um acréscimo de
acordo com um percentual informado pelo usuário.
var
custo, venda, percent: real
início
// ===============ENTRADA ==============
escreva("Digite o custo do produto: ")
leia(custo)
escreva("Digite o percentual para venda: ")

leia(percent)
// ===============PROCESSAMENTO ==============
percent <- (percent/100) * custo
venda <- custo + percent
// ===============SAÍDA ==============
escreval("O valor de venda é: ",venda)
fimalgoritmo
Exemplo 2: O custo ao consumidor de um carro novo é a soma do custo de

fábrica com a percentagem do distribuidor e dos impostos (aplicados, primeiro, os
impostos sobre o custo de fábrica, e depois a percentagem do distribuidor sobre o
resultado). Suponha que a percentagem do distribuidor seja de 28% e os impostos
45%. Escreva um algoritmo que leia o custo de fábrica de um carro e informe o custo
ao consumidor do mesmo.
var
custoFábrica, custoFinal: real
início
// ===============ENTRADA ==============
escreva("Informe o custo de fábrica do veículo: ")
leia(custoFábrica)
// ===============PROCESSAMENTO ==============
custoFinal <- custoFábrica + (0.28 * custoFábrica) + (0.45 *
custoFábrica)
custoFinal <- custoFinal + (0.45 * custoFinal)
// ===============SAÍDA ==============
escreva("O custo para o consumidor final é de: ",custoFinal)
fimalgoritmo
Para saber mais

Conceitos sobre instruções primitivas e estrutura sequencial:
Capítulo 3 — tipos de dados e instruções primitivas (MANZANO, 2008).
Capítulo 6 — Instruções primitivas (SALIBA, 1992).
1. Analise os blocos de código dos algoritmos abaixo e represente o que será
impresso ao serem executados:
a)
A <- 15 Memória Vídeo

B <- 30
escreva( B)
B <- 40
!
escreva (A, B)
b)
A <- 20
C <- A + B
escreva ( C )
B <- 30
escreva ( B, C)
C <- A + B
escreva ( A, B, C)
!
c)
A <- 15
B <- A + 1 Memória Vídeo
A <- B + 2
B <- A + 1
escreva ( A )
A <- B + 1
B <- B - 2
escreva ( A ) !
d)
A <- 40
C <- A + B
escreva (C)
B <- 10
escreva (B, C)
C <- A + B
B <- A - C
A <- (5 + B) * 2
!
escreva (A, B, C)
2. Qual a função do algoritmo abaixo?

Algoritmo “exercício02”
Var
sal : real
início
escreva(“Digite o valor do salário: ”)
leia(sal)
escreva(“O salário com 37% é: ”, sal + (sal * 37 / 100))

fimalgoritmo
3. O algoritmo abaixo deverá ler um salário e calcular 10% de aumento sobre

ele. Para que o algoritmo seja executado corretamente, complete-o com
os comandos que faltam:
Linha 1 - Algoritmo "ReajusteSalarial"
Linha 2 - início
Linha 3 - var
Linha 4 - SALÁRIO, SALÁRIO_NOVO ___________________
Linha 5 - ______________________ (“Digite o salário”)
Linha 6 - ______________________ (SALÁRIO)
Linha 7 - SALÁRIO_NOVO _________________* 1.10
Linha 8 - __________ (“O valor do novo salário é:”, _____________)
Linha 9 - fimalgoritmo
4. Identifique os dados de entrada, processamento e saída no algoritmo abaixo:

Receba código da peça__________________________________
Receba valor da peça___________________________________
Receba Quantidade de peças_____________________________
Calcule o valor total da peça
Quantidade * Valor da peça)____________________________
Mostre o código da peça e seu valor
total__________________________________________________

O que determina se um algoritmo é sequencial?
É possível resolver qualquer tipo de problema usando algoritmos sequenciais?
Fique ligado!
Para representar um algoritmo, são utilizadas diversas técnicas e cabe ao progra-
mador adotar aquela que melhor se adapte a suas necessidades (UNISAL, 2014).
As formas mais conhecidas de algoritmos são: a) narrativa: nessa representação
os algoritmos são expressos diretamente em linguagem natural (em português);
b) fluxograma: o algoritmo é representado em formas geométricas diferentes
que representam ações (instruções, comandos); c) pseudocódigo: é a forma de
representação de algoritmos, também conhecida como português estruturado
ou portugol, é bastante rica em detalhes e assemelha-se bastante à forma em
que os programas são escritos.
Operadores são sinais utilizados nos algoritmos para indicar a realização
de operações que podem ser de três categorias:
Operadores aritméticos: Servem para realizar operações com números
inteiros ou reais (exemplo: 5 + 2, 3 - 1, 3 / 2, 4 * 5).
Operadores relacionais: são operadores binários que devolvem os valores
lógicos (verdadeiro / falso). Estes valores são somente usados quando se
deseja efetuar comparações. Comparações só podem ser feitas entre obje-
tos de mesma natureza, isto é, variareis do mesmo tipo de dado (exemplo:
tendo duas variáveis numéricas (N1, N2), respectivamente, os valores 10
e 12, e é possível comparar se o valor de N1 é MAIOR que o valor de N2.
Operadores lógicos ou booleanos: são usados para combinar expressões
relacionais e resultam nos valores lógicos: verdadeiro ou falso. Exemplo:
tendo uma variável MÉDIA contendo o valor 8 e uma variável FALTAS
contendo o valor 12, é possível criar uma expressão para comparar se a
MÉDIA é maior ou igual a 7 e se as FALTAS menores que 12, para que o
aluno seja “APROVADO”.
As instruções primitivas são comandos básicos que efetuam tarefas essenciais

para a operação dos computadores, como entrada e saída de dados (comuni-
cação com o usuário e com os dispositivos periféricos), e movimentação dos
mesmos na memória. As instruções primitivas abordadas nessa unidade foram:
atribuição, entrada e saída.
A operação de atribuição é uma forma para especificar que a uma variável

será dado um valor. A operação de atribuição será indicada por = e ß.
Exemplo:
NOME “Marcela Reis”
IDADE 25
SALÁRIO 2500,30
Esta é uma operação dita “destrutiva”, pois qualquer valor que a variável
possua antes do processamento da operação de atribuição se perde, sendo
substituído pelo novo valor.
Exemplo:
Algoritmo “atribuição”
var
IDADE: inteiro
NOME: caractere
SALÁRIO: real
início
NOME “Marcela Reis”
IDADE 25
SALÁRIO 2500,30
fimalgoritmo
No algoritmo, é preciso representar a troca de informações que ocorrerá

entre o mundo da máquina e o nosso mundo, para isso, devemos utilizar co-
mandos de entrada e saída.
Exemplo:
Algoritmo “entrada_saida”
var
NOME: caractere
SALÁRIO: real
Início
// ----- SOLICITANDO OS DADOS DE ENTRADA -----
escreva(“Entre com seu nome:”)
leia(NOME)
escreva(“Entre com seu salário:”)

leia(SALÁRIO)
// ------------- APRESENTANDO OS DADOS -----------

escreva(“Seu nome é: “, NOME)
escreva(“Seu salário é: “SALÁRIO)
fimalgoritmo
Os algoritmos representados nessa unidade são denominados “algoritmos

sequenciais”. Na estrutura sequencial, os comandos de um algoritmo são exe-
cutados em uma sequência preestabelecida de forma linear, de cima para baixo.

Os algoritmos podem ser convertidos e executados em outras linguagens de
programação, podendo citar: Pascal, Linguagem C. A seguir é apresentada uma
introdução sobre a linguagem de programação C#.
Linguagem de programação C#
C# (Sharp) é uma linguagem de programação orientada a objetos desen-
volvida pela Microsoft como parte da plataforma .Net (lê-se DOTNET). A sua
sintaxe orientada a objetos foi baseada no C++ mas inclui muitas influências
de outras linguagens de programação, Delphi e Java.
Visual Studio
O Visual Studio é um ambiente de desenvolvimento integrado (IDE) da
Microsoft, ou seja, é um programa para desenvolvimento de software. Pode
ser utilizado para desenvolver aplicações executadas em prompt de comando
(console) e aplicações com interface gráfica para o sistema operacional Win-
dows e para ambiente web. O Visual Studio suporta diferentes linguagens de
programação como as linguagens C, C++,Visual Basic, C#, F#, além de outras,
e possui inúmeros recursos que facilitam o desenvolvimento de aplicações.
Criar e executar um aplicativo de console:
Passos:
1. Inicie o Visual Studio;
2. No menu File, aponte para New e clique em Project;
3. Na Categorias de modelos de painel, expanda Visual C# e, em seguida,
clique em Windows;
4. No modelo de painel, clique em Aplicativo de Console;
5. Digite um nome para seu projeto no nome campo;
6. Clique em OK. O Novo projeto aparece no Solution Explorer.
7. Se Program.cs não estiver aberto no Editor de código, abra-o clicando
com o botão direito em cima do arquivo na Solution Explorer, em se-
guida, clique em Exibir código.
8. Substitua o conteúdo do Program.cs com o código a seguir.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace exemploHello{
class Hello {
static void Main(string[] args){
Console.WriteLine("Hello World!");
Console.WriteLine("Pressione qualquer tecla para sair.");
Console.ReadKey();
}
}
}
Fonte: MSDN (2014).
9. Pressione F5 para executar o projeto. Aparecerá uma janela de Prompt

de comando que contém a linha Hello World!
Entrada e saída
Programas C# geralmente usam os ser-
viços de entrada/saída fornecidos pela bi-
blioteca de tempo de execução do .NET Para saber mais
Framework. A instrução Console.WriteLine
(“Hello World!”); usa o método WriteLine. C# e .Net guia do desenvolvedores,
Este é um dos métodos de saída da classe de Edwin Lima e Eugênio Reis. Rio de
Console na biblioteca de tempo de execu- Janeiro: Campus, 2002.
ção. Ele exibe sua string de parâmetro no
fluxo de saída padrão seguido por uma nova
linha. Outros métodos Console estão dis-
poníveis para operações de saída e entrada
diferente. Se incluir a diretiva using System, Para saber mais
no início do programa, é possível usar dire- Para obter mais informações sobre os
tamente as classes e métodos de System sem métodos de entrada/saída, consulte
qualificá-los totalmente. Por exemplo, você System.IO <http://msdn.microsoft.
pode chamar Console.WriteLine em vez de com/pt-br/library/system.io.aspx>.
System.Console.WriteLine: Acesso em: 07 junho 2014.
Declaração e tipos de variáveis

No C# a declaração de variáveis é obrigatória, assim como a declaração de
seus tipos.
Os tipos de variáveis mais utilizados são:
Tipo de dados Tamanho

int Número Inteiro de 32-bits
continua
continuação
byte Número inteiro de 8-bits

double Número de ponto-flutuante de 64 bits
bool Valor Booleano, verdadeiro ou falso.
string Texto, número ou qualquer carácter.
Exemplo:
using System;
using System.Linq;
using System.Text;
namespace exemploNímero{
class Program{
int Número = 2;
int OutroNúmero = 2;
int MaisUmNúmero = Número + OutroNúmero;
Console.WriteLine(MaisUmNúmero);
}
}
}
Obs.: Note que na primeira linha do

Links código foi utilizado o comando using para
importar o namespace System; com isso
Para saber mais sobre tipos de não será necessário utilizar o System.Con-
dados acesse o endereço: <http:// sole.WriteLine, somente Console.WriteLine,
pt.scribd.com/doc/97707228/ como é mostrado na linha o Console.Wri-
CSharp-Conceitos-Variaveis-Tipos- teLine (MaisUmNúmero).
Operadores-Condicionais-Lacos-
Vetores> (páginas 21 e 22). Acesso Operadores
em: 7 jun. 2014. Um operador é um termo ou símbolo
que pode ser usado com uma ou mais ex-
pressões, chamadas de operandos. Um operador que possui somente um ope-
rando é chamado de operador unário, e um operador com dois operandos, por
sua vez, é chamado de operador binário.
Operador unário (++) Operador binário (*)
Y++; x=10 * 2;
pera ores aritm ticos

O C# suporta os símbolos aritméticos para as operações aritméticas básicas
como adição (+) e subtração (-), ele utiliza o asterisco (*) para multiplicação e
barra para frente (/) para divisão.
Os operadores aritméticos descritos na tabela:
Operador Aritmético Descrição

+ Adição
- Subtração
* Multiplicação
/ Divisão
% Módulo (resto da divisão)
Exemplos:
int a = 20, b = 10, c = 40, d = 10;
Console.WriteLine(a + b); // resultado = 30
Console.WriteLine(a - d); // resultado = 10
Console.WriteLine(b * d); // resultado = 100
Console.WriteLine(d / b); // resultado = 1
Console.WriteLine(a % b); // resultado = 0
pera ores relacionais

Os operadores relacionais comparam dois valores e retornam um valor booleano
(true ou false).
Os operadores relacionais descritos na tabela:
Operador Relacional Descrição

== Igual a
!= Diferente de
> Maior que
< Menor que
>= Maior do que ou igual a
<= Menor do que ou igual a
Exemplos:
int a = 15, b = 10, c = 40, d = 60;

Console.WriteLine(a == d); // resultado false
Console.WriteLine(b != c); // resultado true
Console.WriteLine(a > b); // resultado true
Console.WriteLine(c < d); // resultado true
Console.WriteLine(d <= b); // resultado false
Console.WriteLine(c >= a); // resultado true
pera ores aritm ticos e atri uição re u i a

Esses operadores são usados para compor uma operação aritmética e uma
atribuição, conforme é descrito na tabela a seguir:
Operador Aritmético Descrição

+= mais igual
-= menos igual
*= vezes igual
/= dividido igual
%= módulo igual
No exemplo a seguir, é acrescentado o valor 30 a variável x:
int x = 30;
x += 10; // é a mesma coisa que x = x + 10
Console.WriteLine("Valor do x = " + x); // resultado = 40
x -= 20 // é a mesma coisa que x = x – 20
Console.WriteLine("Valor do x = " + x); // resultado = 20
pera ores l icos
Os operadores lógicos trabalham como operandos booleanos e seu resultado

também será booleano (true ou false). Eles são usados somente em expressões
lógicas, e são descritos na tabela a seguir:
Operador Lógico Descrição

&& AND = E
|| OR = Ou
! NOT = Não
Exemplos:
int a = 10, b = 15, c = 12, d = 25;

Console.WriteLine(a == 10 && d == 15); // resultado false
Console.WriteLine(c < b || d == 20); // resultado true
Console.WriteLine(! (b > a)); // resultado true

1. Faça um algoritmo que escreva a mensagem “Olá, mundo”.
2. Leia dois números inteiros e imprima a soma deles.
3. Faça um programa que calcule e mostre a área de um triângulo. Sabe-se
que: Área = (base * altura) / 2.
4. Faça um algoritmo que leia quatro números informados pelo usuário e que
depois imprima a média ponderada, sabendo que os pesos são respecti-
vamente: 1, 2, 3 e 4:
5. Faça um algoritmo para “Calcular o estoque médio de uma peça”, sendo que
ESTOQUEMEDIO = (QUANTIDADE_MINIMA + QUANTIDADE+MAXIMA) / 2.
6. Elabore um algoritmo que leia o tamanho do lado de um quadrado e informe
a área e o perímetro do quadrado. (Perímetro = 4 * LADO; área = LADO ^ 2).
7. Faça um programa que calcule e mostre a área de um círculo. Sabe-se que:
Área = π * r2.
8. Faça um programa que receba o salário de um funcionário, calcule e mostre
o novo salário, sabendo-se que este sofreu um aumento de 25%.
9. Faça um programa que receba o salário base de um funcionário, calcule
e mostre o seu salário a receber, sabendo-se que o funcionário tem grati-
ficação de R$ 50 e paga imposto de 10% sobre o salário base.
10. Uma revendedora de carros usados paga a seus funcionários vendedores
um salário fixo por mês, mais uma comissão, também fixa, para cada carro
vendido e mais 5% do valor das vendas por ele efetuadas. Escrever um
algoritmo que leia o número de carros por ele vendidos, o valor total de
suas vendas, o salário fixo e o valor que recebe por carro vendido. Calcule
e escreva o salário mensal do vendedor.
11. A conta de água de uma residência é o resultado da soma da tarifa de água
com tarifa de esgoto. Faça um algoritmo que leia a tarifa de água, calcule a
tarifa de esgoto (80% da tarifa de água) e escreva o valor da conta a ser paga.
12. José distribui sua renda mensal da seguinte forma: 10% saúde, 25% edu-
cação, 30% alimentação, 10% vestuário; 5% lazer, 20% outros. Faça um
algoritmo que leia a renda mensal líquida de José, calcule e escreva o valor
aplicado em cada item acima citado.
13. Escreva um algoritmo para ler o número total de eleitores de um município,
o número de votos brancos, nulos e válidos. Calcular e escrever o percen-
tual que cada um representa em relação ao total de eleitores.
14. Elabore um algoritmo que leia o número de horas trabalhadas e o valor do

salário mínimo. Calcule e escreva o salário a receber seguindo as regras
abaixo:
A hora trabalhada vale a metade do salário mínimo.
O salário bruto equivale ao número de horas trabalhadas multiplicado
pelo valor da hora trabalhada.
O imposto equivale a 3% do salário bruto.
O salário a receber equivale ao salário bruto menos o imposto.
15. Uma pessoa paga de impostos anuais, o seguinte:
IPTU: 1% do valor do imóvel.
IPVA: 3% do valor do veículo.
Obs.: Faça um programa que leia o valor do imóvel e do veículo. Calcule
o IPTU e o IPVA, o total pago em impostos e mostre os resultados.
16. Faça um algoritmo que receba o ano de nascimento de uma pessoa e o
ano atual, calcule e mostre:
A idade dessa pessoa.
Quantos anos ela terá em 2028.
17. Faça um algoritmo que receba o custo de um espetáculo teatral e o preço
do convite esse espetáculo. Esse programa deve calcular e mostrar:
A quantidade de convites que devem ser vendidos para que pelo menos
o custo do espetáculo seja alcançado.
A quantidade de convites que devem ser vendidos para que se tenha
um lucro de 23%.
18. Considerando uma eleição de apenas 2 candidatos, elabore um algoritmo
que leia do teclado o número total de eleitores, o número de votos do
primeiro candidato e o número de votos do segundo candidato. Em se-
guida, o algoritmo deverá apresentar o percentual de votos de cada um
dos candidatos e o percentual de votos nulos.
19. Faça o algoritmo que calcule o valor, em reais, correspondente aos dóla-
res que um turista possui no cofre do hotel. O programa deve solicitar os
seguintes dados: Quantidade de dólares guardados no cofre e cotação do
dólar naquele dia.
20. Faça um algoritmo que receba o preço de custo de um produto e mostre o
valor de venda. O preço de custo receberá um acréscimo de acordo com
um percentual informado pelo usuário.
21. Faça um programa que receba o salário-base de um funcionário, calcule
e mostre o seu salário a receber, sabendo-se que esse funcionário tem
gratificação de R$50,00 e paga imposto de 10% sobre o salário-base.
e er ncias
MSDN. Hello World: seu primeiro programa (guia de programação em C#). Disponível em:
<http://msdn.microsoft.com/pt-br/library/k1sx6ed2.aspx>. Acesso em: 31 mar. 2014.
UNISAL. Centro Universitário Salesiano de São Paulo. Algoritmos e fluxogramas: lógica
de programação. Disponível em: <http://galehp.com.br/doc/tecnologia/linguagem_de_
programacao_I/Logica%20_Total.pdf>. Acesso em: 31 mar. 2014.
Leitura complementar
GUIMARÃES, Ângelo de Moura; LAGES, Newton Alberto de Castilho. Algoritmos e
estruturas de dados. Rio de Janeiro: LTC, 1994.
MANZANO, José Augusto N. G.; OLIVEIRA, Jayr Figueiredo de. Algoritmos e lógica para
desenvolvimento de programação de computadores. 21. ed. São Paulo: Érica, 2008.
SALIBA, Walter Luiz Caram. Técnicas de programação: uma abordagem estruturada. São
Paulo: Pearson Makron Books, 1992.
JABOUR. Filippe. Algoritmos computacionais com aplicações em C. Disponível em:
<http://www.jabour.com.br/algoritmosJabour.pdf>. Acesso em: 31 mar. 2014.
MOREIRA. Jander. Construção de algoritmos. Disponível em: <http://livresaber.sead.
ufscar.br:8080/jspui/bitstream/123456789/1008/1/Constru%C3%A7%C3%A3o%20de%20
algoritmos_apostila.pdf>. Acesso em: 31 mar. 2014.
Unidade 3
Estrutura de controle
Veronice de Freitas
Objetivos de aprendizagem: Na criação de algoritmos, ou linguagens

de programação, é necessário utilizar diversos mecanismos para que
consiga resolver um determinado problema. Essa unidade irá contem-
plar vários tipos de estruturas para controle.
Seção 1: Estrutura condicional

A estrutura condicional permite a escolha do grupo
de ações e estruturas a ser executado quando deter-
minadas condições são ou não satisfeitas. A estrutura
condicional pode ser apresentada por meio de uma
estrutura simples, composta, encadeada.
Seção 2: Estrutura caso

Este tipo de estrutura é uma generalização da estru-
tura condicional SE, em que a condição é avaliada e
dois caminhos podem ser seguidos. Na estrutura de
decisão do tipo ESCOLHA pode haver uma ou mais
condições a serem testadas e comandos diferentes
associados a cada uma destas.
Seção 3: Laço enquanto (while)

A estrutura de repetição “enquanto / faça” (tam-
bém chamada de repetição pré-testada ou laço con-
dional) é a mais difundida estrutura de repetição, e
sua estrutura básica é:
enquanto <condição> faca
<bloco de instruções>
Fimenquanto
Seção 4: Repetição com teste no final

A estrutura “repita / até” (também chamada repeti-
ção pós-testada ou laço condicional) é uma variação
da estrutura de repetição enquanto / faça. Nessa
estrutura, a verificação da condição é realizada após
uma execução do bloco. Sua estrutura básica é:
repita
ate <condição>
Seção 5: Repetição incondicional — número

predefinido de repetições
A estrutura de repetição “para / fimpara” (ou repe-
tição com variável de controle também conhecida
como laços contados) é uma estrutura de repetição
que utiliza uma variável de controle para cada ite-
ração do bloco. Sua estrutura básica é:
para VARIAVEL de VALOR INICIAL ate VALOR FINAL passo N faca
Fimpara
Onde: N indica a variação do passo de incremento

da VARIÁVEL (obs.: também poderá ser utilizada
de forma decrementada com o passo negativo se o
valor inicial for maior que o valor final).
Estrutura de controle 91
As estruturas de seleção, também chamadas de estruturas de decisão, executam
testes por meio dos operados relacionais e lógicos, a fim de decidir qual ação (ou
conjunto de ações) deve ser tomada. Essas estruturas são obtidas por meio dos cha-
mados comandos de desvio condicional para tomar decisões.
Até o momento, os algoritmos apresentados utilizavam apenas instruções pri-
mitivas de atribuição, de entrada e saída de dados. Quaisquer conjuntos de dados
fornecidos a este tipo de algoritmo são executados sempre na mesma sequência.
No entanto, na prática, muitas vezes é necessário executar ações diversas em
função dos dados fornecidos ao algoritmo. Além disso, pode ser necessário executar
um mesmo conjunto de instruções um número repetido de vezes. Em resumo, é neces-
sário controlar o fluxo de execução das instruções (a sequência em que as instruções
são executadas em um algoritmo) em função dos dados fornecidos como entrada.
A classificação das estruturas de decisão é realizada de acordo com o número de
condições que devem ser testadas para que se decida qual o caminho a ser seguido,
podendo ser de quatro tipos:
a) Estrutura de decisão simples (se ... então).
b) Estrutura de decisão composta (se ... então ... senão).
c) Estrutura de decisão encadeada (se... então ... senão) com outros testes con-
dicionais encadeados.
d) Estrutura de decisão múltipla do tipo escolha (escolha ... caso ... senão).
A estrutura de repetição — laços (loops) é um mecanismo importante na repre-

sentação de comportamento de programas corresponde à repetição de ações. Em vez
de escrever múltiplas vezes uma mesma sequência de ações, pode-se escrevê-la uma
única vez com o auxílio das estruturas de repetição, nas quais as condições funcio-
nam como o elemento que determina a continuidade ou a interrupção da execução
da sequência de ações especificada.
As estruturas de repetição são úteis quando um trecho de código deve ser repe-
tido várias vezes.
As principais estruturas de repetição são:
enquanto... faça (laço condicional)
repita... Até (laço condicional)
para... de... até... passo... faça (laço contado)
Os LAÇOS CONDICIONAIS são aqueles que não possuem um número pre-

determinado de vezes para que a estrutura de comandos seja executada, porém este
número estará vinculado a uma determinada condição.
Os LAÇOS CONTADOS são aqueles em que de forma prévia já se conhece o
número de vezes que uma determinada sequência de comandos será executada.
Em linguagem de programação, as estruturas de repetição são conhecidas como
laços (loops).
92 E
Seção 1 strutura ond ona

Neste tipo de estrutura, o fluxo de instruções a ser seguido é escolhido em função do
resultado da avaliação de uma ou mais condições. Uma condição é uma expressão lógica.
strutura ond ona s es

Descrevem ações que serão executadas somente quando a expressão lógica for
satisfeita.
Sintaxe:
se <condição> então
<bloco de comandos> comando
fimse
F V
condição
Bloco verdade
Comando
A <condição> é uma expressão que deverá retornar um valor de verdadeiro (V)

ou de falso (F), e caso o resultado dessa expressão seja verdadeiro, será executado
o bloco de comandos que está dentro da estrutura. Caso seja falso, a execução do
programa ignora o bloco de comando e continua na linha seguinte à estrutura de
condição.
O <bloco de comandos> é uma sequência de códigos que será executado somente
quando o resultado da expressão lógica for verdadeiro.
Exemplo 1: tem por função comparar se o valor de X é maior que o valor de Y.
X <- 20
Y <- 10
Se (X > Y) então
escreva(“O valor de X é maior que o valor de Y”)
fimse
Exemplo 2: Condição: verifica se a idade da pessoa é maior ou igual a 18.
Var
idade: inteiro
início
//-------------- ENTRADA ---------------
escreva (“digite a sua idade”)
leia(idade)
//-------------- SAÍDA ---------------

se idade >= 18 então
escreva (“você é maior de idade”)
fimse
fimalgoritmo
Indique a saída dos trechos a seguir:
a) X <- 10 Memória Vídeo

se (X / 5 = 2) então
X <- 0
fimse
escreva (X)
b) X <- 10
Y <- 15 Memória Vídeo
se ((X <= 10) e (Y > 13)) então
X <- 3
fimse
escreva (X)
c) X <- 10
se ((X < 10) e (Y > 13)) então
X <- 3
fimse
escreva (X)
strutura ond ona o osta se então senão

Também chamado de comando de decisão dupla, determinando dois tipos de
ações, uma para quando o resultado da expressão for verdadeiro (após então) e outra
para quando o resultado da expressão for falso (após senão). O comando é formado
pelas palavras reservadas se, então, senão e fimse.
94 E
Sintaxe:
se <condição> então
<bloco de comandos verdade> comando
senão
<bloco de comandos falsidade>
fimse F V
condição
Bloco falsidade Bloco verdade
Comando
Na estrutura se-então-senão, o bloco verdade é executado se a condição for

verdadeira e o bloco falsidade é executado se a condição for falsa.
Exemplo 1: algoritmo verifica se a pessoa possui idade maior ou igual a 18.
algoritmo “exemplo01”
var
idade: inteiro
início
//-------------- ENTRADA ---------------
escreva (“digite a sua idade”)
leia(idade)
//-------------- SAÍDA ---------------

se idade >= 18 então
escreva (“você é maior de idade”)
senão
escreva (_você é menor de idade_)
fimse
fimalgoritmo
Exemplo 2: o algoritmo efetua a leitura de 4 notas de um aluno no intervalo de

1 a 10. Após calcular a média das notas, apresentar a mensagem “Aprovado” se o
aluno tiver obtido média maior ou igual a 6. Caso contrário, apresentar “Reprovado”.
var
n1, n2, n3, n4, media : real
início
//-------------- ENTRADA ---------------
escreva(“Digite o valor da primeira nota de 1 a 10: ”)
leia( n1 )
escreva( “Digite o valor da segunda nota de 1 a 10: ”)

leia ( n2 )
escreva “Digite o valor da terceira nota de 1 a 10: ”)

leia ( n3 )
escreva( “Digite o valor da quarta nota de 1 a 10: ”)

leia ( n4 )
//-------------- PROCESSAMENTO ---------------

média <- (n1 + n2 + n3 + n4) / 4
//-------------- SAÍDA ---------------

se (média >= 6) então
escreva “O aluno foi APROVADO!”
senão
escreva “O aluno foi REPROVADO!”
fimse
fimalgoritmo
1. Indique a saída dos trechos abaixo, considerando
A <- 2 B <- 3 C <- 5 D <- 9
a) se (não (D > 5)) então
X <- (A + B) * D Memória Vídeo
senão
X <- (A – B) / C
fimse
escreva (X)
b) se ((A > 2) e (B < 7)) então
X <- (A + 2) * (B – 2) Memória Vídeo
senão
X <- (A + B) / D * (C + D)
fimse
escreva(X)
c) se ((A = 2) ou (B < 7)) então
X <- (A + 2) * (B – 2) Memória Vídeo
senão
X <- (A + B) / D * (C + D)
fimse
escreva(X)
continua
96 E
continuação
d) se ((A> 2)ou não (B < 7))então
X <- A + B – 2) Memória Vídeo
senão
X <- A – B
Fimse
escreva(X)
e) se (nao (A > 2) ou não (B <7)) então
X <- A + B Memória Vídeo
senão
X <- A / B
Fimse
escreva (X)
f) se (não (A > 3) e não (B < 5)) Memória Vídeo

então
X <- A + D
senão
X <- D / B
fimse
escreva (X)
g) se ((C >= 2) e (B <= 7)) então Memória Vídeo

X <- (A + D) / 2
senão
X <- D * C
fimse
escreva (X)
h) se ((A >= 2) ou (C <= 1)) então Memória Vídeo

X <- (A + D) / 2
senão
X <- D * C
fimse
escreva (X)
2. Qual será o valor final das variáveis A e B depois da execução do seguinte

algoritmo?
Algoritmo “exercicio02” Memória Vídeo

var
A, B: inteiro
início
A <- 1
B <- 2
se A > B então
A <- 5
senão
A <-10
fimse
fimalgoritmo

algoritmo “calcularMédia”
var N1, N2, Média : real Memória Vídeo
início
// ----ENTRADA ----
escreva(“Nota 1:”)
leia(N1)
escreva(“Nota 2:”)
leia(N2)
// ----PROCESSAMENTO ----
Média <- (N1 + N2)/2
// ----SAÍDA ----
se média>=6 então
escreva(“aprovado”)
senão
escreva(“reprovado”)
fimse
fimalgoritmo

O conceito de algoritmo não é de exclusividade da área da computação.
Um algoritmo também não representa, necessariamente, um programa de
computador e sim os passos necessários para realizar uma tarefa ou solu-
cionar um problema, seja de que área for.
Exemplos de algoritmos utilizados no cotidiano:
Fazer um Sanduíche.
Fazer um churrasco.
Como fritar um ovo.
Trocar uma lâmpada.
Ir para o trabalho.
Tomar banho.
Obs.: em que situações poderia fazer uso de estrutura condicional?
strutura ond ona en adeada

O encadeamento ou aninhamento das instruções de seleção se são possíveis e po-
dem conter dentro de seus blocos do então, quando teste condicional for verdadeiro,
ou do senão, quando teste for falso, todas as instruções possíveis na elaboração de
um algoritmo, podendo ser outras instruções de seleção simples ou composta. A esta
possibilidade de uma instrução condicional se estar dentro de outra condicional é
que se denomina Seleção Encadeada.
98 E
Pseudocódigo
se (<condição_1>) então
primeiro bloco de instrução
senão
segundo bloco de instrução
fimse
senao
terceiro bloco de instrução
fimse
instrução n
senão
quarto bloco de instrução
senão
quinto bloco de instrução
fimse
fimse
fimse
Exemplo 1: apresentar se um número informado pelo usuário é positivo, negativo

ou zero.
algoritmo "Exemplo01"
var
número: inteiro
início
Leia (número)
Se numero = 0 então
escreva ("É zero")
senão
Se número > 0 então
escreva ("É positivo")
senão
escreva ("É negativo")
fimse
fimse
fimalgoritmo

É possível definir a estrutura condicional encadeada sem fazer uso do ope-
rador lógico e?
Obs.: analise o próximo exemplo para conceder crédito para os clientes.
Exemplo 2: Um banco concederá um crédito especial aos seus clientes, variável

com o saldo médio no último ano. Faça um algoritmo que leia o saldo médio de um
cliente e calcule o valor do crédito de acordo com a tabela a seguir. Mostre uma
mensagem informando o saldo médio e o valor do crédito.
Saldo médio Percentual

de 0 a 200 nenhum crédito
de 201 a 400 20% do valor do saldo médio
de 401 a 600 30% do valor do saldo médio
acima de 601 40% do valor do saldo médio
algoritmo “SaldoMédio”
Var
Salmédio, Vlrcred: real
Nome : caracter
início
escreva(‘Entre com nome do cliente:’)
leia(Nome)
escreva(‘Entre com saldo médio:’)
leia (Salmédio)
se Salm~edio <=200 então

Vlrcred <- (0,00)
senão
Se Salmedio <=400 então
Vlrcred <- (Salmédio * 20)/100;
senão
se Salmédio <=600 então
Vlrcred <-(Salmédio * 30)/100;
senão
se Salmédio >600 então
Vlrcred <- (Salmédio * 40)/100
fimse
fimse
fimse
fimse
escreva(‘Nome Cliente:’ Cliente)

escreva(‘Saldo médio:’Salmédio)
escreva(‘Valor do Crédito:’Vlrcred)
fimalgoritmo
1. Quais os valores das variáveis A, B, C ao executar o algoritmo a seguir:
algoritmo “TesteCondicional” a) A = 5, B=10, C=10
Var b) A = 5, B=20, C=10
A,B,C : inteiro c) A = 20, B=5, C=10
início
d) A = 10, B=5, C=20
A <- 5
B <- 20
C <- 10 Memória Vídeo
Se (A < B) e (B < C) então
C <- A
Senão
se (B <> C) então
B <- C
Senão
A <- B
Fimse
Fimse
Fimalgoritmo
100 E
2. Qual o resultado das variáveis A, B, C, D e E ao executar o algoritmo a seguir:

algoritmo “TesteLogico” Quais são os valores
var impressos para as variáveis
A, B, C, D, E: real A, B, C, D, E ao executar o
início
algoritmo?
A <- 25
B <- 40
C <- 40 Variáveis Valores
D <- 35
E <- 50 A
se (B > C) e (A < B) então
B <- C - 1 B
E <- A
senão C
se (D < E) ou (B <> C) então
B <- A + 10
D
D <- C E
E <- D / 2
senão
D <- B Obs: dependendo do software
A <- E *4 que for executar o algoritmo é
fimse necessário alterar a variável E
fimse devido ao nome do operador
lógico E.
escreva(A, B, C, D, E)
fimalgoritmo
3. Forneça valores para as variáveis A, B , C e verifique se eles podem ser valo-

res dos lados de um triângulo (“triângulo qualquer”, “triângulo equilátero”
ou “triângulo” isósceles) ou se não são valores válidos (“Não é triângulo”).
Algoritmo “TiposTriângulo”
Var
A, B, C:inteiro
Início
Leia(A)
leia(B)
leia(C)
se (A < B + C) e (B < A + C) e (C < A + B) então

se A = B e B = C então
escreva("Triângulo Equilátero");
senao
se (A = B) ou (A = C) ou (C = B) então
escreva ("Triângulo Isósceles")
senao
escreva("Triângulo Qualquer")
fimse
fimse
senão
escreva("Não é triângulo")
Fimse
Fim algoritmo
4. Dê exemplo de valores para A, B, C para que imprima a mensagem

“Triângulo Equilátero”.
Memória Vídeo

“Triângulo Isósceles”
Memória Vídeo

“Triângulo Qualquer”.
Memória Vídeo
7. Dê exemplo de valores para A, B, C para que imprima a mensagem “Não

é Triângulo”.
Memória Vídeo
Para saber mais

Estruturas Condicionais
<http://www.icmc.usp.br/pessoas/andretta/ensino/aulas/sme0230-1-14/aula3.pdf>.
Aula 5 — Algoritmos — Estruturas de Controle (Estruturas de Seleção)
<http://www.din.uem.br/~teclopes/FCaula5.pdf>.
Lógica de Programação e Estruturas de Dados
<http://rogerioaraujo.files.wordpress.com/2011/11/ebo01_logicaprogramacaoestruturadados_
capitulo01.pdf>. Acessos em: 7 jun. 2014.
Seção 2 Estrutura caso

Certas aplicações envolvem um grande número de testes lógicos, e para tratá-
-los é necessário aninhamento de SE (estrutura condicional encadeada). Existe uma
estrutura que aplicada a certos casos de aninhamento que deixa o algoritmo mais
estruturado. Veja a sintaxe a seguir:
início escolha
inicio escolha
escolha <opção>
Verdadeira
caso <opção 1> opcao 1 Comandos 1
<comandos1> Falsa
caso <opcao2> Verdadeira

opcao 2 Comandos 2
<comandos2>
Falsa
caso <opção n>
Verdadeira
opcao n Comandos 2
<comandosn>
Falsa
outrocaso
Comandos
<comandos_padrão> Padrão
fimescolha
inicio
Observações:
Apenas um Caso será executado. Ao executar o bloco de comandos associado
ao Caso selecionado, o algoritmo sairá da estrutura de Escolha.
O comando Outrocaso é opcional. Se for colocado dentro da estrutura de
escolha, será executado se a condição não atender a nenhum dos testes do
Caso.
2.1 Exemplos de algoritmos — múltipla escolha

Exemplo 1: estrutura de menu de opções:
algoritmo “ExemploMenu”
var
opção:inteiro
início
escreva(“1- Cadastrar”)
escreva(“2- Alterar”)
escreva(“3- Excluir”)
escreva(“4- Imprimir”)
escreva(“5 – 6 – 7 – Em implantação – aguarde !!”)
escreva(“Escolha a opção: “)
Leia(opção)
Escolha opção
caso 1
escreva(“Você escolheu a primeira opção!”)
caso 2
escreva(“Você escolheu a segunda opção!”)
Caso 3
escreva(“Você escolheu a terceira opção!”)
caso 4
escreva(“Você escolheu a quarta opção!”)
caso 5,6,7
escreva(“Você escolheu uma opção que não estava disponível”)
outrocaso
escreva(“Opção inválida”)
fimescolha
fimalgoritmo
Exemplo 2: Este algoritmo funciona como uma calculadora simples, em que algu-
mas operações aritméticas podem ser executadas sobre dois números, dependendo
da operação selecionada pelo usuário (adição, subtração, multiplicação, ou divisão).
Caso o usuário tenha digitado um caractere diferente dos tratados pelo algoritmo, o
valor falso será colocado na variável verifica (pois nenhum caso vai corresponder a
expressão e a instrução dentro do senão será executada).
Algoritmo “Calculadora”
var
num1, num2, result : real
operação : caractere
verifica: lógico
início
escreva(“Digite o primeiro número real: ”)
leia(num1)
escreva(“Digite o segundo número real: ”)

leia(num2)
escreva (“Digite o símbolo da operação a ser realizada: ”)

leia (operação)
verifica <- .VERDADEIRO.
escolha operação
caso '+'
resultado <- num1 + num2
caso '-'
resultado <- num1 – num2
caso '*'
resultado <- num1 * num2
caso '/'
resultado <- num1 / num2
outrocaso
verifica <- .FALSO.
fimescolha
se verifica então
escreva (“O resultado da operação foi ” + resultado)
senao
escreva (Operação invalida!”)
fimse
fimalgoritmo
1. Escreva um algoritmo que receba o código correspondente ao cargo de
um funcionário de uma escola e seu salário atual e mostre o valor do novo
salário, com aumento, conforme tabela a seguir.
Código do Cargo Cargo Aumento
1 Secretário 45%
2 Professor 35%
3 Tesoureiro 25%
4 Coordenador 15%
5 Diretor Não tem aumento
2. Faça um algoritmo que receba o código correspondente ao cargo de um

funcionário e seu salário atual. Depois mostre o cargo, o valor do aumento
e seu novo salário. Os cargos estão na tabela a seguir.
Código Cargo Percentual
1 Escriturário 50
2 Secretário 35
3 Caixa 25
4 Gerente 10
5 Diretor 3
3. Faça um programa que receba dois números e execute as operações listadas

a seguir de acordo com a escolha do usuário.
Escolha do usuário Escolha do usuário
1 Média entre os números digitados
2 Diferença do maior pelo menor
3 Produto entre os números digitados
4 Divisão do primeiro pelo segundo
Para saber mais

Algoritmos e Estrutura de Decisão
<http://www.ifc-camboriu.edu.br/~frozza/2012.1/IA12/IA12-Algoritmos-Aula003-
EstruturasDeDecisao.pdf>. Acesso em: 7 jun. 2014.

Qual a diferença entre usar um estrutura condicional encadeada e uma
estrutura de múltipla escolha? É possível implementar um mesmo algoritmo
usando os dois tipos de estrutura?
Seção 3 a oe ua to hile
A estrutura de repetição (enquanto) é utilizada quando um conjunto de comandos
deve ser executado repetidamente, enquanto uma determinada condição (expressão
lógica) permanecer verdadeira. Dependendo do resultado do teste da condição, o con-
junto de comandos poderá não ser executado nem uma vez (se for falsa no primeiro
teste), ou será executado várias vezes (enquanto for verdadeira). Sua sintaxe geral é:
enquanto condição faca F

Condição
Bloco de comandos
fimenquanto V
Bloco de comandos
Características:
Testa a condição antes da execução do bloco.
Enquanto a condição for verdadeira, o bloco de comandos é executado.
Assim, o bloco de comandos pode ser executado 0 ou mais vezes.
Finaliza a execução do bloco quando a condição se tornar falsa.
3.1 Variáveis contadoras e acumuladoras

Com a utilização de estruturas de repetição para a elaboração de algoritmos,
torna-se necessário o uso de dois tipos de variáveis para a resolução de diversos tipos
de problemas: variáveis contadoras e variáveis acumuladoras.
3.1.1 Variável contadora

Uma variável contadora é uma variável que recebe um valor inicial, geralmente
0 (zero) antes do início de uma estrutura de repetição, e é incrementada no interior
da estrutura de um valor constante, geralmente 1;
Forma geral:
VARIÁVEL <- VARIÁVEL + CONSTANTE
Exemplo 1: Contador para contador de 1 em 1

X <- 5 // X recebe 5
X <- X + 1 // X recebe 5 + 1
Obs: um contador é uma variável (qualquer) que recebe ela mesma mais um va-
lor (uma constante), no caso do exemplo a seguir, a variável X está recebendo o
valor dela mesma mais 1. Normalmente a constante que será somada no contador é
o valor 1, para contar de 1 em 1, mas pode ser qualquer valor, como, por exemplo,
2, se quisermos contar de 2 em 2.
Exemplo 2: contador para contador de 2 em 2.
Y <- 0 // Y recebe 0
Y <- Y + 2 // Y recebe 0 + 2
Observações dos contadores:

1. A variável (do contador) deve possuir um valor inicial conhecido, isto é, ela
deve ser inicializada.
2. Normalmente se inicializa a variável do contador com zero, ou seja, zera-se
a variável antes de utilizá-la.
3. Para zerar uma variável basta atribuir a ela o valor zero: VARIÁVEL <- 0.
4. A constante (que geralmente contém o valor 1) determina o valor do incre-
mento da variável (do contador), ou seja, o que será somado (acrescido) a ela.
Exemplo — algoritmo:
...
cont <- 0 // inicializa o contador
enquanto (CONT <= 10) faca // início da estrutura de repetição
...
cont <- cont + 1 // contador
...
Fimenquanto // final da estrutura de repetição
3.1. Variável acumuladora

Uma variável acumuladora é uma variável que recebe um valor inicial, geralmente
0 (zero), antes do início de uma estrutura de repetição, e é incrementada no interior
da estrutura de um valor variável.
Forma geral:
VARIÁVEL1 <- VARIÁVEL1 + VARIÁVEL2
Exemplo:
SO A <- SO A + N
Obs: um acumulador (somador) é uma variável (qualquer) que recebe ela mesma
mais uma outra variável, no caso do exemplo anterior, a variável SOMA está rece-
bendo o valor dela mesma mais o valor da variável NUM. A variável NUM representa
o valor a ser somado, acumulado na variável SOMA.
Observações dos acumuladores:

1. A variável1 (do acumulador) deve possuir um valor inicial conhecido, isto é,
ela deve ser inicializada. Normalmente, inicializa-se a variável do acumulador
com zero, ou seja, zera-se a variável.
2. Antes de utilizá-la. Para zerar uma variável basta atribuir a ela o valor zero:
SOMA <- 0 (geralmente é inicializada antes da estrutura de repetição).
3. A NUM indica o valor a ser acumulado, somado e armazenado na SOMA.
Exemplo — algoritmo:

soma <- 0 // inicializa o acumulador

...
soma <- soma + cont // acumulador
cont <- cont + 1 // contador (controle da repetição)
...
fimenquanto // final da estrutura de repetição
3. em los seudoc di o simula o

A técnica de simulação é importante para analisar se o algoritmo produz o resul-
tado desejado e também ajuda a desenvolver a lógica para chegar na solução correta.
Exemplo 1: Leia 5 pesos e escreva a média.
Observação: a variável CONT é utilizada como variável de controle para a estru-

tura de repetição o seu valor inicial é 1 e a cada repetição seu valor é incremen-
tado de 1 até que a condição CONT <= 5 se torne FALSA. Ao sair da estrutura de
repetição, é impresso a média dos pesos acumulados na variável SOMA.
.

soma <- 0 // inicializa o acumulador

...
soma <- soma + cont // acumulador
cont <- cont + 1 // contador (controle da repetição)
...
fimenquanto // final da estrutura de repetição
Exemplo: simulação (teste de mesa)

Memória Vídeo
SOMA 0 Entre com o peso : 10
CONT 1 Entre com o peso : 5
// -- primeira repetição -- Entre com o peso : 20
1 <= 5 (VERDADEIRO)
SOMA 0 + 10 (10) Entre com o peso : 30
CONT 1 + 1 (2) Entre com o peso : 10
// -- segunda repetição --
2 <= 5 (VERDADEIRO)
SOMA 10 + 5 (15) A média é: 15
CONT 2 + 1 (3)
// -- terceira repetição --
3 <= 5 (VERDADEIRO)
SOMA 15 + 20 (35)
CONT 3 + 1 (4)
// -- quarta repetição --
4 <= 5 (VERDADEIRO)
SOMA 35 + 30 (65)
CONT 4 + 1 (5)
// -- quinta repetição --
5 <= 5 (VERDADEIRO)
SOMA 65 + 10 (75)
CONT 5 + 1 (6)
6 <= 5(FALSO) = SAI DA ESTRUTURA
Exemplo 2 — Leia vários pesos e escreva a média.
Observação: a variável de controle nessa versão é por meio da variável RESP, que
contém um valor inicial “S” para tornar a condição do ENQUANTO verdadeira
para entrar no laço) o dentro da estrutura de repetição é solicitado para o usuário
se deseja ler mais um peso (caso seja “N” irá sair da estrutura de repetição) e
imprimir a média dos pesos do total de repetição armazenada na variável CONT).
Algoritmo “Exemplo2”
var
PESO, SOMA : real
CONT : inteiro
RESP : caracter
início
SOMA <- 0
CONT <- 0
RESP <- “S”
enquanto (RESP) = “S”) ou (RESP =”s”) faca

escreva(“Entre com o peso : “)
leia (PESO)
SOMA <- SOMA + PESO

CONT <- CONT + 1
Escreva(“Deseja efetuar a leitura de outro peso: (S / N)?”)

leia (RESP)
fimenquanto
escreva (“Média dos Pesos:”, SOMA / CONT)

fimalgoritmo
Exemplo: simulação (teste de mesa)

Memória Vídeo
Soma<-0 Entre com o peso : 10
CONT <- 0
Deseja efetuar a leitura de outro
Resp <- “S”
peso (S / N)? S
// -- primeira repetição --
S = S (VERDADEIRO) Entre com o peso : 5
SOMA <- 0 + 10 (10)
Deseja efetuar a leitura de outro
CONT <- 0 + 1 (1)
peso (S / N)? N
RESP <- “S”
// -- primeira repetição -- Média dos Pesos é: 7.5

S = S (VERDADEIRO)
SOMA <- 10 + 5 (15)
CONT <- 1 + 1 (2)
RESP <- “N” // sai do laço
... Irá repetir até que o usuário
responda que não deseja continuar
3.3 em los en uanto a a seudoc di o

Exemplo 1: faça um algoritmo que leia 10 temperaturas e ao final da execução
imprima quantas temperaturas são POSITIVAS e quantas são NEGATIVAS e a MÉDIA
das temperaturas POSITIVAS.
Observação: faça teste de simulação respondendo os valores : 10, -5, 4, 8, 9, -4,

12, 25, 8, -3 para a temperatura e verifique: qual o total de números positivos e
negativos impressos ao final da execução?
algoritmo "exemplo_temperatura"
var
CONT, TOTAL_N, TOTAL_P: inteiro
TEMPERATURA, SOMA_P: real
início
CONT <- 0 // contador
TOTAL_N <- 0 // total de temperaturas negativas
TOTAL_P <- 0 // total de temperaturas positivas
SOMA_P <- 0 // acumula a soma das temperaturas positivas
Enquanto CONT < 10 faca
leia (TEMPERATURA) // leitura do valor da temperatura
se TEMPERATURA >=0 então

TOTAL_P <- TOTAL_P + 1
SOMA_P <- SOMA_P + TEMPERATURA
senão
TOTAL_P <- TOTAL_N + 1
fimse
CONT <- CONT + 1

fimenquanto
Escreval ("Total de temperaturas positivas = ",TOTAL_P)

Escreval ("Média das temperaturas positivas = ",SOMA_P / TOTAL_P)
Escreval ("Total de temperaturas = ",TOTAL_P)
Fimalgoritmo
Exemplo 2: o algoritmo calcula a média de 30 alunos e a média da turma, infor-

mando a sua situação (reprovado, aprovado ou recuperação).
O algoritmo efetua a leitura das notas 1 e 2 de 30 alunos, calcula a média e im-

prime uma mensagem de acordo a média caculada e também calcula e imprime
a média da turma. Nesse exemplo, é utilizado um contador para controlar a
leitura das notas dos 30 alunos.
algoritmo “ExemploMédia”
var
nome: caractere
nota_1, nota_2, média, SomaG, MédiaG: real
contador: inteiro
início
médiaG <- 0 // inicializa a variável MédiaG
contador <- 1 // inicializa o contador
enquanto (contador<=30) faca
escreva (“Nome do aluno: “)

leia(nome)
escreva (“Primeira nota: “)

leia(nota_1)
escreva(“Segunda nota: “)
leia(nota_2)
// ----- calcula a média -----

média <- (nota_1 + nota_2)/2
//soma todas as médias para no final calcular a média geral

somaG <- SomaG + média
//----- imprime a mensagem de acordo com a média ------

se (média<=3) então
escreva(nome, média, ”Rep.”)
senão
se(média>=6) então
escreva(nome, média, “Apr.”)
senão
escreva(nome, média, “Rec.”)
fimse
fimse
contador <- contador + 1 // contador
fimenquanto
médiaG <- somaG / 30 // calcula a média da turma

escreva(“A média da turma é :”, médiaG)
Algoritmo “exercício02”
Var Memória Vídeo
NUM, SOMA, I : inteiro
início
SOMA <- 0
I <- 1
enquanto i <= 10 faca
leia(num)
SOMA <- SOMA + NUM

I <- I + 1
fimenquanto
escreva (SOMA)
fimalgoritmo

Algoritmo “exercicio04” Memória Vídeo

Var
n, fat, i : inteiro
início
fat <- 1
i <- 1
leia (n)
enquanto i <= n faca

fat <- fat * i
i <- i + 1
fimalgoritmo
escreva (fat)
fimalgoritmo
3. Faça a simulação do algoritmo abaixo de descreva sua função:

algoritmo "Exercício05"
var
nota, notaMaior, soma, conta: real
nome, nomeMaior: caracter
início
conta <- 1
notaMaior <- 0
enquanto (conta < 4) faca

escreva("Informe o nome ", conta, ": ")
leia(nome)
escreva("Informe a nota ", conta, ": ")

leia(nota)
soma <- soma + nota
se (nota > notaMaior) então

notaMaior <- nota
nomeMaior <- nome
fimse
conta <- conta + 1

fimenquanto
escreva(nomeMaior, " teve a maior nota!")

escreva("A média da turma foi: ", soma / 3)
fimalgoritmo
Para saber mais

Acesse <http://www.esj.eti.br/INED/ALP/Exercicios/ALP_Exercicios_04_Respostas.pdf>. Acesso
em: 7 jun. 2014.

O teste condicional da estrutura ENQUANTO <condição> FAÇA pode ser
FALSO logo no primeiro teste? O que irá acontecer com as instruções internas?
Seção 4 e eti o com teste no inal

Essa estrutura de repetição é utilizada quando não se sabe o número de vezes em
que um trecho do algoritmo deve ser repetido, embora também possa ser utilizada
quando sabe esse número. A sintaxe geral é:
REPITA
ação 1 Bloco de comandos

ação 2
...
ação n F
Condição
ATÉ condição
V
Características:
Testa a condição após a execução do bloco.
A sequência ação 1; ação 2;...; ação n, será realizada uma vez, sendo em
seguida verificada a condição associada à cláusula ATÉ. Se a condição for
falsa, o processo se repete, reiniciando pela ação 1. Se a condição for
verdadeira, a repetição é cancelada;
Repete as instruções enquanto a condição for falsa.
Para a execução do bloco quando a condição se tornar verdadeira
(denominada de condição de parada). o bloco de comandos é executado
pelo menos uma vez.
A diferença entre a estrutura ENQUANTO e a estrutura REPITA é que na estru-

tura REPITA os comandos serão repetidos pelo menos uma vez, já que a condição
se encontra no final.
.1 em lo re ita at seudoc di o simula o

Exemplo 1: repita os comandos até a condição se tornar verdadeira.
Pseudocódigo Valores – obtidos durante a execução

X <-1
repita X <- 1 3 6
Y <- 5 5 7
X <- X + 2 7 8
Y <- Y + 1 // --- primeira vez --- 9 9
X <- 1 + 2(3)
Escreva(X,Y) Y <- 6 + 1 (6)
X >= Y (falso) – repete
ate X >= Y
// --- segunda vez ---
X <- 3 + 2(5)
Y <- 6 + 1 (7)
X >= Y (falso) – repete
// --- terceira vez ---

X <- 5 + 2(7)
Y <- 7 + 1(8)
X >= Y (falso) - repete
// --- quarta vez ---

X <- 7 + 2 (9)
Y <- 8 + 1(9)
X >= Y (verdadeiro) - sai
. em lo seudoc di o
1. Faça um algoritmo com números (positivos) até que o usuário informe o valor
o valor ZERO e obtenha o MAIOR valor.
Observação: inicia a variável MAIOR com o valor ZERO e durante a execução

do algoritmo o número informado é comparado com a variável MAIORo se o
número informado for maior que o valor armazenado na variável MAIOR, seu
valor será substituído pelo número (no final da execução a variável MAIOR irá
conter o número com maior valor).
algoritmo "maiorValor"
var
maior: inteiro
N: inteiro
RESP: caracter
início
MAIOR <- 0 // valor inicial da variável MAIOR
repita
//validação para entrar com nº maior ou igual a zero
repita
escreva("Entre com um número: ")
leia(N)
ate N >= 0
//compara o valor digitado com a variável MAIOR

se N > MAIOR então
MAIOR <- N
fimse
escreva("deseja entrar com outro número (S/N):")

leia(RESP)
ate RESP = "N"
escreva("O maior valor é : ", MAIOR)

fimalgoritmo
1. Analise e teste o código de programa abaixo e identifique o problema desse
código (faça a correção do algoritmo).
algoritmo "exercício_01"
var
contador: inteiro
início
escreva("Digite um número menor que dez: ")

leia(contador)
repita
escreva("Contador: ", contador)
ate contador > 10
fimalgoritmo
2. Qual a função do código a seguir?

algoritmo "exercício_02"
var
opção: inteiro
somador: inteiro
início
somador <- 0
repita
escreva("Digite um número qualquer ou zero para sair: ")
leia(opção)
somador <- somador + opção
escreva("Somador: ", somador)
ate opção = 0
fimalgoritmo
3. Qual a função do código a seguir?

algoritmo "exemplo_03"
var
R: real
X, Y: inteiro
opcao: caracter
início
repita
escreva("Digite o primeiro valor: ")
leia(X)
escreva("Digite o segundo valor: ")

leia(Y)
escreva("Digite um operador (+, -, * ou /) ou s para sair: ")

leia(opção)
escolha opção
caso "+"
R <- X + Y
escreva(X, " +", Y, " =", R)
caso "-"
R <- X - Y
escreva(X, " -", Y, " =", R)
caso "*"
R <- X * Y
escreva(X, " *", Y, " =", R)
caso "/"
R <- X / Y
escreva(X, " /", Y, " =", R)
fimescolha
ate (opção = "s") ou (opção = "S")
fimalgoritmo
4. Faça o fluxograma do algoritmo abaixo:

Algoritmo “exercício_04”
var
X: inteiro
início
repita
escreva(“Digite um valor”)
leia (x)
Se (x > 0) então
Escreva (“X > 0”)
Senão
Se (x < 0) Então
Escreva (“X < 0”)
ate (x = 0)
escreva (“X = 0”)

fimalgoritmo
Para saber mais

Estrutura de repetição
<http://www.veniciopaulo.com/Aula5.pdf>. Acesso em: 7 jun. 2014.

Qual a principal diferença entre as estruturas de repetição ENQUANTO /
FAÇA e REPITA / ATÉ?
Seção 5 e eti o incondicional

n mero rede inido de re eti es
Essa estrutura de repetição é utilizada quando se sabe o número de vezes em que
um trecho do algoritmo deve ser repetido.
A estrutura de repetição para-até-faça é um pouco diferente das outras duas
(repita-até e enquanto-faça), pois possui uma variável de controle, ou seja, com esta
estrutura é possível executar um conjunto de instruções um número determinado de
vezes, ou seja, por meio da variável de controle, define-se a quantidade de repetições
que o laço irá realizar. A sintaxe geral é:
Para variável de controle = valor inicial até valor final faça

Bloco de comandos
Fim para
Repete o bloco de comandos:

Incrementa automaticamente a variável de controle cada vez que o bloco
é executado (incremento “default” de 1 até alcançar o valor final)
Se o valor final definido for menor que o valor inicial, o laço de repetição
não é executado nenhuma vez.
A variável de controle deve ser do tipo primitivo inteiro.
A variável usada como controle da estrutura não deve ser modificada
A repetição comeca de um valor_inicial (numérico) e se encerra quando
supera o valor final.
5.1 Exemplos — para / fimpara (pseudocódigo /

simulação)
Exemplo 1: tem por função efetuar a leitura das idades de 5 pessoas e contar a
quantidade de adultos (idade >= 18).
Algoritmo “Conta_Adultos”
Var
IDADE, QTDE, X : Inteiro Memória Vídeo
QTDE <- 0 Idade? 25
início X <- 1 Idade? 15
25 >= 18 (verdadeiro)
QTDE <- 0 QTDE <- 0 + 1(0) Idade? 40
X <- 2 Idade? 30
Para X de 1 Ate 5 Faca
15 >= 18 (falso)
Idade? 14
Escreva(“Idade ?”)
X <- 3
Leia (IDADE)
40 >= 18 (verdadeiro)
QTDE <- 1 + 1(2) Total de
se IDADE >=18 Então adultos: 3
QTDE QTDE + 1 X <- 4
Fimse 30 >= 18 (verdadeiro)
QTDE <- 2 + 1(3)
Fimpara
X <- 5
Escreva (‘Total de Adultos 14 >= 18 (falso)
: ‘,QTDE)
X <- 6 (sai do laço)
Fimalgoritmo
Exemplo 2: efetua a leitura de um número e imprime a tabuada do mesmo.
Pseudocódigo
Algoritmo “tabuada”
Var
I, NUM : Inteiro
início
escreva(“Entre com o número da tabuada? “)
leia(NUM)
para I de 1 ate 10 passo 1 faca

escreva(NUM, “ X “, I , “ = “, NUM * I)
fimpara
fimalgoritmo
Simulação (TESTE DE MESA)
Memória Vídeo
NUM <- 5 Entre com o número da
tabuada? 5
I <- 1 Valor de 5 x 1 = 5
I <- 2 NUM 5 x 2 = 10 NUM * I
I <- 3 5 x 3 = 15
I <- 4 5 x 4 = 20
I <- 5 5 x 5 = 25
I <- 6 5 x 6 = 30
I <- 7 5 x 7 = 35
VALORES
I <- 8 5 x 8 = 40
DE I
I <- 9 5 x 9 = 45
I <- 10 5 x 10 = 50
Exemplo 3: efetua a leitura de um número e calcula o fatorial.
Pseudocódigo
Algoritmo “fatorial”
Var
I, FAT, NUM : Inteiro
início
escreva(“Entre com o número para calcular o fatorial? “)
leia(NUM)
FAT <- 1
para I de 1 ate NUM passo 1 faca
FAT <- FAT * NUM
Fimpara
Escreva(“O fatorial de “, NUM, “ é : “, FAT)

fimalgoritmo
Simulação (TESTE DE MESA)

Obs.: o algoritmo utiliza o tipo inteiro para a variável FAT — o valor do fatorial calculado
está limitado ao tamanho suportado pelo tipo inteiro (dependendo da linguagem poderá
utilizar outro tipo de dados por exemplo: long int (linguagem c).
Memória Vídeo
NUM <- 6 Entre com o número para calcular o
fatorial? 6
FAT <- 1
I <- 1
FAT <- 1 * 1 (1)
I <- 2
FAT <- 1 * 2 (2)
I <- 3
FAT <- 2 * 3 (6)
I <- 4
FAT <- 6 * 4 (24)
I <- 5
FAT <- 24 * 5 (120)
I <- 6
FAT <- 120 * 6 (720)
O fatorial de 6 é 720
5. Exemplo — para / para (pseudocódigo)

Nessa versão do algoritmo, deverá efetuar a leitura de 30 temperaturas e imprimir:
a) Quantidade de temperaturas positivas;
b) Média das temperaturas positivas;
c) Quantidade de temperaturas negativas.
algoritmo "Temperatura_v2"
var
CONT, CONT_P, CONT_N: inteiro
TEMPERATURA, SOMA_P, SOMA_G: real
Início
// ------ inicializa as variáveis ------------
CONT_N <- 0 // contar as temperaturas negativas
CONT_P <- 0 // contar as temperaturas positivas
SOMA_P <- 0 // somar as temperaturas positivas para
// calcular a média das temperaturas positivas
//-------- LEITURA DAS 30 TEMPERATURAS -------

para CONT de 1 ate 30 passo 1 faca
Escreval("Entre com a temperatura: ")
Leia(TEMPERATURA)
se TEMPERATURA >= 0 então

CONT_P <- CONT_P + 1
SOMA_P <- SOMA_P + TEMPERATURA
senão
CONT_N <- CONT_N + 1
Fimse
Fimpara
Escreval("Qtde de temperaturas positivas: ", CONT_P)

Escreval("Média das temp. positivas: ", SOMA_P / CONT_P)
Escreval("Qtde de temperaturas negativas: ", CONT_N)
fimalgoritmo
1. Qual a função do algoritmo baixo?
algoritmo “exercício01”
Var
SOMA, IMPAR: inteiro Memória Vídeo
início
para IMPAR de 1 ate 18 passo 2 faca
SOMA <- SOMA + IMPAR
Fimpara
escreva(“a soma é:”, SOMA)

fimalgoritmo

var
r, n1, cont: inteiro
início
escreva(“Entre com um número de 1 até 20 : “
leia(n1)
Para cont de 1 ate 10 faca

r cont * n1;
escreva (n1,“ x ”,cont,“ = ”,r)
fimpara
fimalgoritmo
3. O algoritmo abaixo tem por função calcular a área de um retângulo. Inclua

a estrutura de repetição para / fimpara para permitir que o usuário calcule
a área de 10 retângulos.
var
Base, Altura, Área: real
início
//Obtendo os dados do usuário
Escreva('Digite o valor da base do retângulo: ')
Leia(Base)
Escreva('Digite o valor da altura do retângulo: ')

Leia(Altura)
//Calculando a área
Área <- Base * altura
Escreva('A área é: ',Área)

FimAlgoritmo
var
L: Inteiro
NOME: caracter
início
escreva(“entre com um nome :”)
leia(NOME)
Para cont de 1 ate 10 faca

escreva(NOME)
fimpara
FimAlgoritmo
Para saber mais

Estruturas de Repetição
<http://www.esj.eti.br/INED/ALP/Exercicios/ALP_Exercicios_04_Respostas.pdf>. Acesso em: 7 jun. 2014.

Um problema que faz uso da estrutura de repetição PARA / FIMPARA pode ser
reescrito usando as estruturas de repetição ENQUANTO / FAÇA ou REPITA / ATÉ?
Fique ligado!
Estruturas utilizadas para reger o fluxo de execução de um algoritmo: Estrutura
Sequencial; Estrutura de Seleção; Estrutura de Repetição. A Tabela 3.1 representa
os três tipos de estrutura.
Tabela 3.1 Tipos de estrutura
ESTRUTURA EXEMPLO
Estrutura sequencial: Algoritmo “média_aluno”
Cada comando é executado varnota1,nota2,nota3,media: real
sequencialmente até término do início
algoritmo. leia (nota1,nota2,nota3)
média (nota1+nota2+nota3)/3
fimalgoritmo
Estrutura Condicional: algoritmo “média_aluno”
var
Permite a seleção de um grupo nota1,nota2,nota3,média: real
de ações (bloco) a ser executado início
quando determinadas condições leia (nota1,nota2,nota3)
forem satisfeitas. média (nota1+nota2+nota3)/3
se média >= 7 então
escreva (“Aprovado”)
senão
escreva (“Reprovado”)
fimse
fimalgoritmo
Estrutura de Repetição: Algoritmo “média_turma”
var
Execução de uma sequencia de
nota1,nota2,nota3,média,média_t: real
ações repetidas vezes. cont: inteiro
início
média 0
média_t 0
para cont de 1 ate 10 passo 1 faca

leia (nota1,nota2,nota3)
média (nota1+nota2+nota3)/3
se média >= 7 então
escreva (“Aprovado”)
senão
escreva (“Reprovado”)
fimse
fimpara
escreva(“Media da turma:”, média_t / 10);
Fimalgoritmo
Na Tabela 3.1, o primeiro algoritmo representa a estrutura sequencial que

efetua a leitura de três notas, calcula e apresenta a média do aluno. No segundo
exemplo, faz uso da estrutura condicional para apresentar uma mensagem “apro-
vado” ou “reprovado”, dependendo do valor da média. No terceiro exemplo,
o algoritmo é alterado para repetir o cálculo da média para uma turma de 10
alunos e informar a média da turma.
Durante a programação, pode necessitar incluir outras instruções para
melhorar a integridade do algoritmo. Imagine se o usuário fornecer uma nota
para o aluno que não esteja no intervalo permitido (de 0 até 10). Nesse caso,
seria necessário validar o valor informado para a nota usando outra estrutura
de repetição interna.
Existem situações em que os caminhos para a tomada de uma decisão aca-
bam formando uma espécie de árvore com diversas ramificações, em que cada
caminho é um conjunto de ações. Nesses casos, podemos recorrer à utilização
de várias estruturas se-então-senão embutidas umas dentro das outras, comu-
mente chamadas de ninhos. Como exemplificado na Tabela 3.2, tem que ficar
atento para o fechamento adequado dessas estruturas.
Tabela 3.2: encadeando diversas estruturas
O if aninhado é simplesmente um if dentro da declaração de um outro if

externo. É necessário saber exatamente a qual if um determinado else está li-
gado, para não ocasionar erro na lógica do programa (CACHO; COELHO, 2013).

Nessa seção, os algoritmos são representados na linguagem de programação C#.
Estrutura de seleção em C#
Estruturas condicionais são comuns e necessárias em todos os programas.
Em C# também é possível utilizar estrutura condicional simples (if), composta
(if/else), estrutura condicional encadeada e também uso da estrutura de múltipla
escolha (switch). Essa seção aborda a sintaxe da declaração if...else e também
explora outras construções condicionais presentes no C#.
Estrutura condicional — if/else
A estrutura utilizada no C# é semelhante com a estrutura representada nos
algoritmos condicionais.
Sintaxe:
VisuAlg C#
se (<condição>) então if(<condição>){
... ...
senão //Opcional }
... else //Opcional
fimse {
...
}
Exemplo 1: condicional simples.

using System;
using System.Linq;
using System.Text;
namespace Exemplo_if_01{
class Program{
int A = 5;
int B = 2;
if(A > B){

Console.WriteLine("O valor de A é Maior.");
}
}
}
}
Exemplo 2: condicional composta.
using System;
using System.Linq;
using System.Text;
namespace Exemplo_if_02{
class Program{

int A = 4;
int B = 6;
if (A > B)
{
Console.WriteLine("O valor de A é Maior.");
}
else
{
Console.WriteLine("O valor de B é Maior.");
}
}
}
}
Obs.: Se dentro de um if/else tiver somente uma linha, o uso das { } é opcional.
if-Inline
No C# também existe o “if-Inline” que é composto por três operandos se-
parados pelos sinais ? e : e tem o objetivo de atribuir o valor a uma variável de
acordo com o resultado de um teste lógico.
Sintaxe:
teste lógico ? valor se verdadeiro : valor se falso;
Onde:
Teste lógico é qualquer valor ou expressão, que pode ser verdadeiro ou falso.
Valor se verdadeiro é atribuído ao valor true;
Valor se falso é atribuído ao valor false.
Exemplo 1a: exemplo usando a condicional composta.
var idade = 26;
if (idade >= 16)

Console.WriteLine("Pode votar!");
else
Console.WriteLine("Não pode votar!");
}
Exemplo 1b: exemplo usando a IF-INLINE.
static void Main(string[] args{

var idade = 26;
Console.WriteLine(idade >= 16 ? "Pode votar!" : "Não pode votar!");

}
Switch/case
A instrução switch permite a execução condicional de instruções de acordo
com os valores de um argumento teste, o qual pode ser uma variável, uma ex-
pressão numérica, uma string ou funções.
Sintaxe:
switch(VARIAVEL){
case VALOR:
//Faz algo se VARIAVEL for igual ao VALOR
break;
default: //(OPCIONAL)
//Faz algo se VARIAVEl não for igual a nenhum CASE
break;
}
VisuALG C#
var int x = 10;
x: inteiro switch(x) {
início case 1:
x <- 10 Console.Write(“Um”);
escolha (x) break;
caso 1: case 2:
escreva(“Um”) Console.Write(“Dois”);
caso 2: break;
escreva(“Dois”) default:
outrocaso: Console.Write(“Desconhecido”);
escreva(“Desconhecido”) break;
fimescolha }
fimalgoritmo
O funcionamento ocorre da seguinte forma: a expressão é obtida no switch

e para cada Case existe uma condição a ser validada. Caso o Case seja verda-
deiro, então a linha ou o bloco de código é executado. Se nenhum dos Cases for
válido, então default é executado. O default é opcional e você pode ter quantos
Cases for necessário.
Observações:
No switch você pode ter quantos cases você quiser.
A cada Case é preciso declarar o break, senão o programa continua ava-
liando todos os Cases.
Exemplo:
using System;
using System.Linq;
using System.Text;
namespace Exemplo_switch{
class Program{
int Numero = 2;
switch(Numero){
case 1:
Console.WriteLine("Numero é igual a 1");
break;
case 2:
break;
case 3:
break;
default:
Console.Write(“Opção inválida”);
break;
}
}
}
}
Para saber mais

Estruturas Condicionais no C#
<http://www.linhadecodigo.com.br/artigo/2286/estruturas-condicionais-no-csharp.aspx>.
Linguagem de Programação I (linguagem C#)
<http://www.alcidesmaya.com.br/apostilas/linguagem_c.pdf>.
Estrutura de repetição C#
As estruturas de repetição são muito úteis e empregadas quando se deseja
executar uma, ou um bloco, de instruções diversas vezes.
Estruturas de repetição do C#:
a) while
b) do... while
c) for
d) foreach
Estrutura de repetição — while

A estrutura while é executada sempre associada a uma condição, ou seja, a
cada passagem pelo looping a condição é avaliada.
A condição expressa na estrutura while é uma expressão booliana, ou seja,
sempre retorna falso ou verdadeiro e as instruções dentro do bloco de código
só serão executadas enquanto essa expressão retornar verdadeiro.
Sintaxe:
while (CONDIÇÃO){
//Código
}
Exemplo:
class Program{
int contador = 0;
while (contador < 5){
Console.WriteLine("Anderson Macedo");
contador++;
}
Console.ReadKey();
}
}
No exemplo acima, tem uma variável chamada contador com seu valor ini-
cial 0. Na CONDIÇÃO do bloco while é testado se a variável contador é menor
que 5, caso verdadeiro, é apresentado na tela o nome “Eduardo dos Santos”
e incrementado em 1 na variável contador. Esse processo se repete até que a
CONDIÇÃO do while seja falsa.
Estrutura de repetição: do while
O comando do/while tem o mesmo funcionamento que o comando while,
tendo como diferença que a condição da estrutura é testada no final e não no
início como acontece no while.
No while, existe a possibilidade do código não ser executado nenhuma vez,
pois está vinculado ao resultado da condição que é testada no início do bloco.
No do/while, o código escrito dentro da estrutura será executado pelo menos
uma vez, isso porque a verificação é realizada apenas no final da estrutura.
Sintaxe:
do
{
// Código
}
while (CONDIÇÃO);
Exemplo:
Código Teste de Mesa
using System;
class ExemploWhile{ Memória Vídeo
public static void Main(){ cont=0 Numero: 1
int cont = 0; cont 0 < 5 (v) Numero: 2
while (cont <= 5){ cont <- 0 + 1 Numero: 3
console.write(“Numero: “, numero); (1) Numero: 4
cont++; Numero: 5
} cont 1 <= 5 (v)
Console.WriteLine(“”); cont <- 1 + 1
} (2)
}
cont 2 <= 5 (v)
cont <- 2 + 1
(3)
cont 3 <= 5 (v)

cont <- 3 + 1
(4)
cont 4 <= 5 (v)

cont <- 3 + 1
(4)
cont 5 <= 5 (v)

cont <- 5 + 1
(5)
cont 6 <= 5 (f)

(sai do laço)
Estrutura de repetição: for

A estrutura for é constituída de uma variável de inicialização, uma condição
e o incremento. O laço for trabalha checando uma condição para executar um
bloco de código até que essa condição seja verdadeira.
Sintaxe:
for (int i = 0; i <= 5; i++)
{
//Código Incremento
}
Onde:
int i = 0: (inicialização) o é declarada uma variável do tipo inteiro (int), onde
também é definido o seu valor inicial, que nesse exemplo foi o valor 0 (zero).
i <= 5: (condição) o é definido a condição.
i++: (incremento) o um incremento nada mais é do que adicionar 1 a uma
variável, ou seja, se uma variável vale 0 (zero) e passa por um incremento, vale
1 e, se passa mais uma vez, vale 2, e assim por diante.
Exemplo 1: incremento de 1.
for (i = 1; i <= 10; i++){
Console.WriteLine("{0}", i);
}
Exemplo 2: decremento de 2
for (i = 10; i >= 0; -=2){

Console.WriteLine("{0}", i);
}
Estrutura: foreach
A estrutura foreach é utilizada para percorrer coleções ou arrays. Sua estru-
tura é formada pelo tipo de dado, o nome da variável e a lista a ser percorrida.
O exemplo a seguir faz uso de array, que será o assunto da próxima unidade.
Sintaxe:
foreach(<tipo de dado> <nome> in <lista>)
{
//Código
}
Exemplo:
class Program{
// array de strings = declaração e inicialização do array
string[] nomes = { "Maria", "Ana", "Rita", "Pedro","Carlos"};
foreach (string pessoa in nomes) {

Console.WriteLine(pessoa);
}
Console.ReadKey();
}
}

Atividades — estrutura condicional
1. Faça um algoritmo para ler: a descrição do produto (nome), a quantida-
de adquirida e o preço unitário. Calcular e escrever o total (total = quan-
tidade adquirida * preço unitário), o desconto e o total a pagar (total a
pagar = total — desconto), sabendo que:
Se quantidade <= 5 o desconto será de 2%.
Se quantidade > 5 e quantidade <=10 o desconto será de 3%.
Se quantidade > 10 o desconto será de 5%.
2. Um posto está vendendo combustíveis com a seguinte tabela de descontos:
até 20 litros, desconto de 3% por litro
Álcool
acima de 20 litros, desconto de 5% por litro
até 20 litros, desconto de 4% por litro
Gasolina
acima de 20 litros, desconto de 6% por litro
Escreva um algoritmo que leia o número de litros vendidos e o tipo de

combustível (codificado da seguinte forma: A-álcool, G-gasolina), calcule
e imprima o valor a ser pago pelo cliente sabendo-se que o preço do litro
da gasolina é R$ 3,30 e o preço do litro do álcool é R$ 2,90.
Observação: embora seja possível desenvolver as atividades a seguir usando
qualquer uma das estruturas de repetição apresentadas nessa unidade, os
exercícios foram agrupados para usar os três tipos de estruturas. Desenvolva
inicialmente usando a estrutura sugerida e depois tente adaptar para as
outras estruturas de repetição.
Atividades — estrutura de repetição — ENQUANTO / FAÇA

3. Faça um algoritmo que imprima os números de 1 até 10.
Exemplo de saída: 1,2,3,4,5,6,7,8,9,10
4. Faça um algoritmo que imprima os números pares de 20 até 30.
Exemplo de saída: 20,22,24,26,28,30
5. Faça um programa que receba vários números positivos ou negativos,
terminados por zero. O programa deve fornecer como saída a soma dos
números positivos. Exemplo:
Entre com um número: 26

Entre com um número: -5
Entre com um número: 0 (sai do laço)
6. Ler, um número não determinado de vezes, um valor do teclado e escrever

o valor da soma de todos os números digitados até o momento, até que
seja digitado um número negativo. Exemplo:

Entre com um número: -3
A soma é: 30
Obs: não considere o valor negativo na soma.
Observação: analise as estruturas de repetição a seguir antes de desenvolver

as atividades.
Visualg C#
Repita do
// bloco de comandos // bloco de comandos
Ate condição (verdadeira) while condição (verdadeira)
Repete o bloco de comandos até que a Repete o bloco de comandos enquanto
condição seja verdadeira. a condição for verdadeira.
Atividades — estrutura de repetição — REPITA/ATÉ

7. Uma empresa decidiu fazer um levantamento em relação aos candida-
tos que se apresentarem para preenchimento de vagas no seu quadro de
funcionários. Supondo que você seja o programador dessa empresa, faça
um programa que leia, para cada candidato, a idade, o sexo (M ou F) e a
experiência no serviço (S ou N). Para encerrar a entrada de dados, digite
zero para a idade. Calcule e escreva:
Número de candidatos do sexo feminino.
Número de candidatos do sexo masculino.
A idade média dos homens que já têm experiência no serviço.
A porcentagem dos homens com mais de 45 anos entre o total dos
homens.
Número de mulheres com idade inferior a 35 anos e com experiência no
serviço.
A menor idade entre as mulheres que já têm experiência no serviço.
Obs: para continuar o levantamento, solicite ao usuário se deseja continuar
(S — SIM ou N — NÃO).
Atividades — estrutura de repetição — PARA/FAÇA

8. Faça um algoritmo para imprimir 10 vezes o nome: Disciplina de Introdu-
ção à Programação.
9. Faça um algoritmo que apresente o total da soma dos cem primeiros números
inteiros ( 1 + 2 + 3 + 4 + 5 + 6 + 7 + ... 97 + 98 + 99 + 100).
10. Leia 5 idades e calcule a média entre as idades.
11. Escreva um programa que receba a idade de 10 pessoas, calcule e imprima
a quantidade de pessoas maiores de idade (idade >= 18 anos).
12. Dados: Sexo e idade dos alunos. Construa um algoritmo para verificar em
uma classe com 50 alunos quantos são do sexo feminino e masculino e
quantos da classe toda são maiores que 18 anos. Ao final, apresente no
vídeo os totais.
13. Faça um algoritmo que calcule o fatorial de um número informado pelo usuário.
14. Faça um programa para ler o código, número de horas trabalhadas e nú-
mero de dependentes de cada funcionário. Após a leitura, escreva qual o
código, os valores descontados para cada tipo de imposto e finalmente o
salário líquido de cada um dos funcionários.
Tem-se um conjunto de dados contendo a altura e o sexo (M ou F) de 15
pessoas. Faça um Programa que calcule e escreva:
A maior e a menor altura do grupo;
A média de altura das mulheres;
Número de homens
Referência
CACHO, Nélio Alessandro Azevedo; COELHO, Keivilany Janielle de Lima. Lógica de
programação e algoritmos. Disponível em: <http://www.metropoledigital.ufrn.br/aulas/
disciplinas/logica/aula_10.html>. Acesso em: 15 jul. 2013.
Unidade 4
Estrutura de
dados homogênea
e heterogênea
Veronice de Freitas
Objetivos de aprendizagem: Geralmente, os algoritmos são elabo-

rados para manipulação de dados. Quando estes dados estão organi-
zados (dispostos) de forma coerente, caracterizam uma forma, uma
estrutura de dados. A organização dos dados é chamada de estrutura
composta de dados que se divide em duas formas fundamentais: ho-
mogêneas (vetores e matrizes) e heterogêneas (registros).
Seção 1: Matrizes de uma dimensão ou vetores

Vetores (array unidimensional) são variáveis compos-
tas que podem armazenar um conjunto de valores.
Esse tipo de estrutura permite criar uma variável com
n posições, recebendo dados do mesmo tipo. Cada
elemento é referenciado pelo nome do vetor e sua
posição, dessa forma é possível armazenar e recuperar
os elementos do vetor.
Seção 2: Estrutura de dados homogênea (matrizes)

Estruturas de dados homogêneas bidimensionais,
também conhecidas como matrizes, são referencia-
das por dois índices: um para indicar a linha e outro
para indicar a coluna da matriz onde se encontra o
dado. A mais comum é a matriz bidimensional, por
se relacionar diretamente com a utilização de tabelas.
As matrizes com mais de duas dimensões também

podem ser utilizadas com facilidade após ter domínio
na utilização de uma matriz bidimensional.
Seção 3: Estrutura de dados heterogênea (registros)

É uma estrutura composta por um conjunto de
variáveis de tipos diferentes que estão logicamente
relacionados (por exemplo: informações de um
cliente) e que podem ser referenciados por um
mesmo nome (identificador do tipo registro).
Estrutura de dados homogênea e heterogênea 139
nr a e
As estruturas de dados homogêneas permitem agrupar diversas informações dentro
de uma mesma variável. Este agrupamento ocorre obedecendo sempre ao mesmo tipo
de dado, e por esta razão que estas estruturas são chamadas homogêneas.
A utilização deste tipo de estrutura de dados recebe diversos nomes, como: variá-
veis indexadas, variáveis compostas, arranjos, vetores, matrizes, tabelas em memória
ou arrays. Os nomes mais usados e que utilizaremos para estruturas homogêneas
são: matrizes (genérico) e vetores (matriz de uma linha e várias colunas). Quando
possuem um único índice, é chamada de vetor, tendo dois ou mais, chama-se matriz.
A estrutura contém:
Valor numérico inteiro e positivo que corresponde ao endereço de alocação de

Índice
uma unidade do vetor e da matriz
Conteúdo armazenado em um determinado endereço. Pode ser de um único tipo
Elemento
de dado (inteiro, real, caractere ou lógico).
Dimensão Número de índices da estrutura, ou seja, o seu tamanho.
Vetor (uma dimensão) Matriz (duas dimensões)
Índice Conteúdo Índice: coluna 1 2 3

1 5 linha
2 10 1 3 4 2
3 8 2 9 6 10
4 15 3 8 5 12
5 21 4 15 5 4
5 21 17 22
Conteúdo
Na representação anterior foi exemplificada a estrutura de dados homogênea

(vetor e matriz), em que todos os elementos pertencem ao mesmo tipo de dados. Em
alguns casos é necessário armazenar estruturas que contém diferentes tipos de dados
(como por exemplo: informações de um funcionário).
Uma estrutura de dados é chamada de heterogênea quando envolve a utilização de
mais de um tipo básico de dado (inteiro ou caractere, por exemplo) para representar
uma estrutura de dados. Normalmente, este tipo de dado é chamado de registro. Um
exemplo de uma estrutura de registro é apresentado na Figura 4.1.
Figura 4.1 Reg_funcionário
Roberto da Silva
15 05 1970
Vendas
2500,00
O registro do funcionário contém vários tipos de dados: NOME, DIA, MÊS e ANO
DE NASCIMENTO, DEPARTAMENTO, SALÁRIO.
Exemplo – Registro:
// -------------- TIPO DE DADOS -----------

Tipo
dt = registro
ano: inteiro
mês: inteiro
dia: inteiro
fim
REG_FUNCIONARIO = registro
NOME :caractere
DATA_NASC :dt
DEPARTAMENTO :caractere
SALÁRIO:real
Fim
// -------------- VARIÁVEIS -----------

Var
// variável para armazenar um funcionário
FUNCIONÁRIO : REG_FUNCIONÁRIO
Registros e vetores podem ser compostos a fim de resolver problemas mais com-
plexos. Considerando que um vetor é um conjunto de elementos do mesmo tipo, é
natural que, quando precisarmos agrupar vários registros (por exemplo, várias Fichas
Cadastro), utilizaremos vetores (conjuntos) de registros.
Var
// CADASTRO SERÁ UM VETOR – REGISTRO REG_FUNCIONÁRIO
CADASTRO : conjunto [1..20] de REGFUNCIONÁRIO
DATA_NASC
NOME DIA MÊS ANO DEPARTAMENTO SALÁRIO
1
Roberto da Silva 15 05 1970 Vendas 2500

!
2
3 REG_FUNCIONARIO
4
... ...
... ... VETOR VET_FUNC = para
20 armazenar 20 registros
Para leitura dados do vetor de registro:
para X de 1 até 20 faça

leia(CADASTRO[X].NOME)
leia(CADASTRO[X].DATA_NASC.DIA)
leia(CADASTRO[X].DATA_NASC.MÊS)
leia(CADASTRO[X].DATA_NASC.ANO)
leia(CADASTRO[X].DEPARTAMENTO)
leia(CADASTRO[X].SALÁRIO)
fim para
Para impressão dados do vetor de registro:
para X de 1 até 20 faça

escreva(CADASTRO[X].NOME)
escreva (CADASTRO[X].DATA_NASC.DIA)
escreva (CADASTRO[X].DATA_NASC.MÊS)
escreva (CADASTRO[X].DATA_NASC.ANO)
escreva (CADASTRO[X].DEPARTAMENTO)
escreva (CADASTRO[X].SALÁRIO)
fim para
Seção 1 a ri e e a i en
e re
Vetor também é conhecido como variável composta unidimensional. Isto quer
dizer que se trata de um conjunto de variáveis de mesmo tipo, que possuem o mesmo
identificador (nome) e são alocadas sequencialmente na memória. Como as variáveis
têm o mesmo nome, o que as distingue é um índice que referencia sua localização
dentro da estrutura.
e ara e a ri ni i enci na
A sintaxe do comando de definição de vetores é:
<nome_variável>: vetor [posInicial..posFinal] de <tipo>
Exemplo:
VET : vetor [1..10] de inteiros

IDADE : vetor [1..5] de inteiros
VALOR : vetor [1..20] de real
SALÁRIO: vetor[1..20] de real
NOME: vetor [1..100] de caractere
Do mesmo modo que acontece com variáveis simples, também é possível operar
com variáveis indexadas (matrizes). O acesso individual a cada componente de um
vetor é realizado pela especificação de sua posição na mesma por meio do seu índice.
Na declaração VET: vetor [1.10] de inteiros, foi definido uma variável VET capaz de
armazenar 10 números inteiros. Para acessar um elemento deste vetor deve-se fornecer
o nome do mesmo e o índice do componente desejado do vetor (um número de 1 a
10). O exemplo a seguir apresenta o vetor VET com a representação dos 10 valores.
VET 10 9 80 75 80 89 41 35 87 55
INDICE 1 2 3 4 5 6 7 8 9 10
Por exemplo, vet [1] indica o primeiro elemento do vetor, vet [2] indica o segundo
elemento do vetor e vet [10] indica o décimo elemento do vetor.
ri i e a a ri i e r
No caso de vetores (variáveis indexadas), além do nome da variável deve-se neces-
sariamente fornecer também o índice do componente do vetor onde será armazenado
o resultado da avaliação da expressão.
Exemplo:
VET[1] <- 10
VET[2] <- 80
VET[5] <- 20
VET[8]<- 30
VET[10]<- 40
Com as atribuições anteriores o vetor VET passará a ter os valores a seguir:
VET 10 80 80 75 20 89 41 30 87 40
INDICE 1 2 3 4 5 6 7 8 9 10
Para acessar cada valor correspondente ao vetor VET, no exemplo acima, deve-se
utilizar um índice, cujo valor varia de 1 até o tamanho do vetor.
ei ra e a e a a ri i e r
A leitura de um vetor é realizada passo a passo, um de seus componentes por vez,
usando a mesma sintaxe da instrução primitiva da entrada de dados, onde, além do
nome da variável, deve ser explicitada a posição do componente lido:
leia (<nome_da_variável> [ <índice> ] )

Exemplo: leitura do vetor
algoritmo "exemplo_leitura1"
var
números : vetor [1..5] de inteiro
i : inteiro
início
para i <- 1 ate 5 faca
escreval ("Insira o ", i, "º elemento do vetor: ")
leia (números[i])
fimpara
fimalgoritmo
Simulação:
MEMÓRIA TELA
I=1 Insira o 1º elemento do vetor: 35
números 35
1 2 3 4 5
números 35 40
1 2 3 4 5
números 35 40 25
1 2 3 4 5
números 35 40 25 8
1 2 3 4 5
números 35 40 25 8 35
1 2 3 4 5
cri a e a e a a ri i e r
A escrita de um vetor obedece à mesma sintaxe da instrução primitiva de saída
de dados; vale lembrar que, além do nome do vetor, deve-se também especificar o
índice e o componente a ser escrito.
escreva ( <nome_da_variável> [ <índice> ] )

O algoritmo a seguir exemplifica a operação de leitura e escrita de um vetor.

Exemplo: leitura e escrita (impressão) do vetor.
algoritmo "exemplo_leitura_de_vetor"
var
i : inteiro
início
// -------------- LEITURA ------------------
escreva("Insira o ", i, "elemento do vetor: ")
leia (números[i])
fimpara
// --------- IMPRESSÃO (ESCRITA)-------------

escreva("elemento do vetor: ", números[i])
fimpara
fimalgoritmo
e ea ri
Exemplo 1: leitura de um vetor de 7 posições.
Algoritmo “Vetor”
Var
V : vetor [1..7] de inteiro
CONT : inteiro
início
Para CONT de 1 ate 7 passo 1 faca
Escreva(“Elemento”, Cont, “:”)
Leia(V[CONT])
Fimpara
fimalgoritmo
Simulação:
MEMÓRIA VÍDEO
CONT = 1 Elemento 1: 24
V 24
1 2 3 4 5 6 7
V 24 16
1 2 3 4 5 6 7
V 24 16 5
1 2 3 4 5 6 7
V 24 16 5 42
1 2 3 4 5 6 7
V 24 16 5 42 18
1 2 3 4 5 6 7
V 24 16 5 42 18 1
1 2 3 4 5 6 7
V 24 16 5 42 18 1 3
1 2 3 4 5 6 7
Exemplo 2: algoritmo que efetua a leitura de 5 elementos de um vetor e calcule

a soma dos mesmos.
algoritmo "exemplo_leitura2"
var
soma, i : inteiro
início
soma <- 0
para i <- 1 ate 5 passo 1 faca
escreva ("Insira o ", i, "elemento do vetor: ")
leia (números[i])
soma <- soma + números[i]
fimpara
escreva("A soma dos elementos é: ", soma)

fimalgoritmo
Simulação:
MEMÓRIA VÍDEO
soma = 0
I=1 soma = 0 + 35 (35) Insira o 1º

números 35 elemento do
1 2 3 4 5 vetor: 35
I=2 soma = 35 + 40 (75) Insira o 2º
números 35 40 elemento do
1 2 3 4 5 vetor: 40
I=3 soma = 75 + 25 (100) Insira o 3º
números 35 40 25 elemento do
1 2 3 4 5 vetor: 25
I=4 soma = 100 + 8 (108) Insira o 4º
números 35 40 25 8 elemento do
1 2 3 4 5 vetor: 8
I=5 soma = 108 + 30(138) Insira o 5º
números 35 40 25 8 30 elemento do
1 2 3 4 5 vetor: 30
A soma dos
elementos é: 138
Exemplo 3: O algoritmo efetua a leitura da média final de cinco alunos e imprime

a mensagem “aprovado” para alunos com a média final maior ou igual a sete e re-
provado para média final menor que sete. O algoritmo também acumula a soma de
todas as médias para calcular a média da turma.
Algoritmo “MédiaTurma”
var
médias: vetor[1..10] de real
i: inteiro;
soma, média_turma: real
Inicio
soma <- 0
média_turma <- 0
// --------- Entrada de dados no vetor -----
para i de 1 ate 5 passo 1 faca
escreva(“Informe a média do aluno ”, i, “:”)

leia médias[i]
//-- verifica se o aluno foi aprovado ou reprovado --

se meia[i] >= 7 então
escreva(“aprovado”)
senão
escreva(“reprovado”)
fimse
// soma a média de todos os alunos

soma <- soma + medias[i]
fimpara
media_turma <- soma/5
escreva(“A media da turma é: “, média_turma)

Fim algoritmo
Obs.: exemplo de valores para o vetor médias.
médias 9.5 8.3 9.9 6.0 7.1

1 2 3 4 5
Simulação:
Memória Vídeo
Soma=0
média_turma = 0
I = 1 médias 9.5 Informe a
Soma=0 + 9.5(9.5) 1 2 3 4 5 média do
média_turma = 0 aluno 1: 9.5
I = 2 médias 9.5 8.3 Informe a
Soma=9.5 + 8.3(17.8) 1 2 3 4 5 média do
I = 3 médias 9.5 8.3 9.9 Informe a
Soma=17.8 + 9.9(27.7) 1 2 3 4 5 média do
I = 4 médias 9.5 8.3 9.9 6.0 Informe a
Soma=27.7 + 6.0(33.7) 1 2 3 4 5 média do
I = 5 médias 9.5 8.3 9.9 6.0 7.1 Informe a
Soma=33.7 + 7.1(40.8) 1 2 3 4 5 média do
I = 5 (sai do laço) A média da
Soma= 40.8 turma é: 8.16
média_turma=40.8/5
1. Qual o resultado da MEMÓRIA e do VÍDEO ao executar o algoritmo abaixo?
Informe os valores: 10,5, 8, 20, 35 para efetuar a simulação (complete o teste).
Pseudocódigo Teste de mesa
algoritmo "EXEMPLO01"
var Obs: complete o teste informando os
NÚMEROS: vetor [1..5] de inteiro demais valores.
I : inteiro
Início Memória Vídeo
para I de 1 ate 5 faca I 1
leia(NÚMEROS[i]) ? 10
NÚMEROS[1] 10
fimpara
fimalgoritmo
2. Qual o resultado da MEMÓRIA e do VÍDEO ao executar o algoritmo abaixo?

Pseudocódigo
algoritmo "EXERCÍCIO02"
var
SALÁRIO : vetor [1..10] de REAL
SOMA, cont : inteiro
início
SOMA <- 0
para cont <- 1 ate 10 faca
escreva("Insira o ", cont, "elemento do vetor: ")

leia (SALÁRIO [cont])
SOMA <- SOMA + SALÁRIO[cont]

fimpara
escreva("A soma é dos elementos é : ", SOMA)

fimalgoritmo
3. Considerando o vetor V abaixo:

V 15 12 9 10 8 7 41 22 12 8
1 2 3 4 5 6 7 8 9 10
Quais seriam os valores impressos considerando os valores das variáveis

para acesso aos índices que tivessem os valores X=2 e Y=4? Escreva o valor
correspondente para cada exemplo:
a) escreva ( V[X + 1] ) e) escreva ( V[X + Y] ) i) escreva ( V[X + 1 + Y * 2]
b) escreva ( V[X + 2] ) f) escreva ( V[X - Y] ) j) escreva ( V[X + Y] )
c) escreva ( V[Y + 5] ) g) escreva ( V[X * 3] ) k) escreva ( V[6 - V[10] ])
d) escreva ( V[Y + 2] ) h) escreva ( V[ V[3] ] )
4. Considere o algoritmo a seguir:

algoritmo "EXERCÍCIO04"
var
VET1 : vetor [1..20] de inteiro a) Represente os valores gerados
VET2 : vetor [1..20] de inteiro para os vetores VET1 e VET2.
VET3 : vetor [1..20] de inteiro b) Qual será o valor armazenado
I: inteiro em:
Início Vet3[3]
para i de 1 ate 20 passo 1 faca Vet3[6]
VET1[i] <- i Vet3[9]
VET2[i] <- 20 – i Vet3[12]
fim para
Vet3[15]
para i de 1 ate 20 passo 1 faca
VET3[i] <- VET1[i] + VET2[i]
Escreva(VET3[i])
Fimpara
fimalgoritmo
5. Analise o programa abaixo e descreva sua função e preencha o texto da lacuna:

Algoritmo "matriz"
var
n: vetor [1..5] de inteiro
i,cont : inteiro
média : real
início
média <- 0
Para i de 1 ate 5 passo 1 faca
leia(n[i])
média <- media + n[i]
fimpara
média <- média/5
escreva(media) LACUNA
cont <- 0
Para i de 1 ate 5 passo 1 faca
se (n[i] > média) então
cont <- cont + 1
fimse
fimpara
escreval("______________________: ", cont)

fimalgoritmo
6. Altere o programa a seguir para que o mesmo faça a soma dos 10 números
lidos e ao final apresente a soma obtida.
Algoritmo "VetoresSoma"
Var
números: vetor[1..10] de inteiro
I: inteiro
Início
// ------ LEITURA 10 NÚMEROS -------------
escreva("Valor: ")
leia(números[I])
fimpara
// -------- IMPRESSÃO 10 NÚMEROS----------

escreva(números[I])
fimpara
fimalgoritmo
Para saber mais

EDUCANDUS – Apostila de Algoritmos
<http://www.educandusweb.com.br/ewce/portal/formularios/apoio/arquivos/apoio966_apostila_
algoritmos_educandus_final.pdf>. Acesso em: 7 jun. 2014.

Nesse tipo de estrutura, os dados são chamados homogêneos o por qual
motivo é utilizado esse termo para esse tipo de estrutura?
Seção 2 Estrutura de dados homogênea

(matrizes)
São conhecidas como estruturas de dados homogêneas multidimensionais. Em
determinados problemas são utilizados estruturas de matrizes com mais de duas
dimensões. O mais comum é a matriz de duas dimensões por se relacionar com a
utilização de tabelas.
Uma matriz bidimensional é composta por linhas e colunas. As linhas podem ser
consideradas como a primeira dimensão e as colunas a segunda dimensão. É preciso
definir o tamanho de cada uma dessas dimensões, ou seja, o número de linhas e o
número de colunas que esta matriz deverá possuir. O exemplo a seguir representa
uma matriz bidimensional 4 x 4 (4 linhas e 4 colunas), nela é possível referenciar
cada elemento através de seu índice, por exemplo: a posição 1,3 contém o valor 24,
a posição 2,2 contém o valor 4.
Matriz Mat
1 2 3 4
1 18 15 24 9
2 7 4 3 10 Índice das
3 12 37 1 6 colunas
Índice das
linhas 4 5 13 21 42
As posições da matriz são formadas por:
Mat[1,1] contém 18 Mat[2,1] contém 15 Mat[3,1] contém 24 Mat[4,1] contém 9

Uma matriz é uma coleção de dados de um mesmo tipo, referenciada por um

nome comum. Um elemento específico de uma matriz é acessado através de um
índice. Todos os elementos ocupam posições contíguas na memória.
2.1 Representação dos índices de uma matriz

bidimencional
Um algoritmo muito utilizado para gerar o índice de determinada matriz (exemplo:
4 linhas x 4 colunas) é apresentado a seguir:
Algoritmo “teste“
Var Memória Vídeo
L,C: inteiro L C
Início 1 1 1 - 1
// --------- IMPRESSÃO ----------- 1 2 1 - 2
para L de 1 ate 4 passo 1 faca 1 3 1 - 3
para C de 1 ate 4 passo 1 faca 1 4 1 - 4
escreval(L , " - " , C) 5(SAI)
fimpara 2 1 2 - 1
fimpara 2 2 2 - 2
Fimalgoritmo
2 3 2 - 3
2 4 2 - 4
Valores impressos no vídeo podem representar os índices
5(SAI)
da matriz 4 x 4 exemplificada abaixo:
1,1 2,1 3,1 4,1 3 1 3 - 1

1,2 2,2 3,2 4,2 3 2 3 - 2
3 3 3 - 3
1,3 2,3 3,3 4,3
1,4 2,4 3,4 4,4 3 4 3 - 4
5(SAI)
4 1 4 - 1
4 2 4 - 2
4 3 4 - 3
4 4 4 - 4
5(SAI)
5 SAI
2.2 elaração de matriz bidimencional

A sintaxe do comando de definição de matrizes de duas dimensões é a seguinte:
<nome_variável>: vetor [li..lf, ci..cf] de <tipo>
Onde:
li e lf representam respectivamente o índice inicial e final das linhas;
ci e cf representam respectivamente o índice inicial e final das colunas.
Exemplos:

2EVVLQWD[HXVDGDQRYLVXDOJ

MAT1: vetor [1:3 , 1:3] de inteiro

2EVVLQWD[HXVDGDQRYLVXDOJ

MAT2: vetor [1:4 , 1:5] de inteiro

2. tribuição de uma matriz de duas dimens es

Na atribuição de matrizes, da mesma forma que nos vetores, além do nome da
variável deve-se necessariamente fornecer também o índice do componente da ma-
triz. No caso de ter duas dimensões, o primeiro número se refere à linha e o segundo
número se refere à coluna da matriz em que se encontra a informação.
Algoritmo “exemplo_atribuiçãoo”
var
mat : vetor [1..2,1..3] de real
média, soma : real
início Representação da matriz
início
mat[1,1] <- 9.0 Colunas
mat[1,2] <- 8.0
mat[1,3] <- 7.0
1 2 3
mat[2,1] <- 6.5 1 9.0 8.0 7.0
Linhas
mat[2,2] <- 9.0 2 6.5 9.0 8.5
mat[2,3] <- 8.5
soma <- mat[1,1] + mat[1,2] + mat[1,3]

média <- soma / 3
escreval (“ A média dos elementos da 1º linha é: ”, média)
soma <- mat[2,1] + mat[2,2] + mat[2,3]

média <- soma / 3
escreval (“ A média dos elementos da 2º linha é: ”, média)
fimalgoritmo
2. eitura de dados de uma matriz de duas dimens es

Da mesma forma que se realiza a leitura dos dados primitivos, também é possível
efetuar a leitura de uma matriz. O que difere na leitura é a posição de seus índices.
Sintaxe:
leia( <nome_da_variável> [ <índice_1>, ... , índice_n> ])
Exemplo: leitura de uma matriz de duas linhas por três colunas.
Algoritmo “leitura_matriz”
var
mat : vetor[1..2, 1..3] de inteiro
i, j : inteiro
início
// ------ leitura da matriz de 2 linhas por 3 colunas -----
para i de 1 ate 2 faca // estrutura para indexar as linhas
para J de 1 ate 3 faca // estrutura para indexar as colunas
escreva(“Digite o valor do elemento “, i , “-”, “:”)

leia(mat[i,j] // leitura do elemento i,j
fimpara
fimpara
fimalgoritmo
A tabela a seguir representa a leitura e armazenamento da matriz de duas linhas

por três colunas.
Memória Vídeo
i J mat
1 2 mat[1,1] <- 9.0 Digite o valor do
elemento 1 – 1 : 9
4(sai - laço)
elemento 2 – 1 : 6.5
elemento 2 – 3 : 8.5
4(sai - laço)
3(sai -
laço)
2. presentando dados de uma matriz de duas

dimens es
Na apresentação dos dados da matriz também é necessária a especificação de seus
índices.
Sintaxe:
Escreva( <nome_da_variável> [ <índice_1>, ... , índice_n> ])
Exemplo 1: exemplo de leitura e impressão de uma matriz de duas linhas por

três colunas.
Algoritmo “leitura_escrita_matriz”
var
mat : vetor[1..2, 1..3] de inteiro
i, j : inteiro
início
// ------ leitura da matriz de 2 linhas por 3 colunas -----
escreva(“Digite o valor do elemento “, i , “-”, “:”)
leia(mat[i,j] // leitura do elemento i,j
fimpara
fimpara
// ------ impressão da matriz de 2 linhas por 3 colunas -----
escreva(“Valor: “,mat[i,j]) // impressão
fimpara
fimpara
fimalgoritmo
Exemplo 2: o algoritmo efetua a leitura e impressão de duas matrizes MatA e

MatB. A matriz MatA com 2 linhas e 2 colunas e a Matriz MatB com 3 linhas e 2
colunas (as tabelas a seguir exemplifica valores que poderão ser informados para as
matrizes MatA e MatB).
Exemplo: MatA Exemplo: MatB

5 3 4 2
2 9 3 1
8 6
Algoritmo “exemplo”
var
MatA: vetor[1..2,1..2] de inteiro
MatB: vetor[1..3,1..2] de inteiro
I,J: inteiro
Início
// ------- leitura da matriz MatA --------
Escreva(“preenchendo a matriz a”)
Para I de 1 ate 2 faca
Para J de 1 ate 2 faca
Leia(MatA[I, J])
Fimpara
Fimpara
// ----impressão da matriz MatA ----
Escreva(“Imprimindo a matriz a”)
escreva(MatA[I, J])
Fimpara
Fimpara
// ------- leitura da matriz MatB --------
Escreva(“preenchendo a matriz B”)
Leia(MatA[I, J])
Fimpara
Fimpara
// ----impressão da matriz MatB ----
Escreva(“Imprimindo a matriz B”)
escreva(MatA[I, J])
Fimpara
Fimpara
Fimalgoritmo
2. .1 E emplos matrizes
Exemplo 1: o algoritmo lê uma matriz 3 X 3 do tipo inteiro e imprime somente
os números ímpares.
1 2 3 Resultado
1 3 8 5 3, 5, 9, 3, 5, 3
2 9 2 3
3 5 3 4
Algoritmo "matriz"
var Memória Vídeo
MAT: vetor [1..3, 1..3] de inteiro Leitura da matriz ?3
I, J: integer I 1 ?8
início J 1 ?5
// --LEITURA ---- MAT [1,1] 3 ?9
para I de 1 ate 3 faca I 1 ?2
para J de 1 ate 3 faca J 2 ?3
leia(MAT[I, J]) MAT[1,2] 8 ?5
I 1 ?3
fimpara
J 3 ?4
fimpara MAT[1,3] 5 //
J 4 (sai do laço impressão
// --IMPRESSÃO ---- interno) dos
para I de 1 ate 3 faca valores
para J de 1 ate 3 faca // repete o processo impares
//compara se o resto da divisão para linha 2 3
//de cada valor da matriz por 2 é I 2 5
//igual a 1 (se for o número é J 1 8
//impar) MAT[2,1] 9 3
... 5
se MAT[I,J] MOD 2 = 1 então
3
escreva(MAT[I, J]) // repete o processo
fimse para linha 3
I 3
fimpara J 1
fimpara MAT[3,1] 5
fimalgoritmo ...
Exemplos do operador MOD (utilizado para obter o resto da divisão)

MOD retorna o resto da divisão entre dois números inteiros
DIV retorna o valor inteiro que resulta da divisão entre 2 números inteiros
Exemplo:
5 DIV 2 = 2
5 2 5 MOD 2 = 1
MOD 1 2 DIV
Exemplo 2: o algoritmo lê uma matriz 3 X 3 do tipo inteiro e imprime somente

os elementos da diagonal principal.
1 2 3 Resultado
1 3 8 5 3 2 4
2 9 2 3
3 5 3 4

Algoritmo "matriz"
var Memória Vídeo
MAT: vetor [1..3, 1..3] de inteiro Leitura da matriz ?3
I, J: integer I 1 ?8
inicio J 1 ?5
// --LEITURA ---- MAT [1,1] 3 ?9
para I de 1 ate 5 faca I 1 ?2
para J de 1 ate 5 faca J 2 ?3
leia(MAT[I, J]) MAT[1,2~ 8 ?5
fimpara I 1 ?3
fimpara J 3 ?4
MAT[1,3] 5 // impressão dos
// --IMPRESSAO ---- J 4 (sai do laço valores da
para I de 1 ate 5 faca interno) diagonal
para J de 1 ate 5 faca principal
// repete o processo para 3
//se for diagonal principal linha 2 2
se I = J entao I 2 4
escreva(MAT[I, J])
J 1
fimse
MAT[2,1] 9
...
fimpara
fimpara
fimalgoritmo
Exemplo 3: o algoritmo lê uma matriz 5 X 5 do tipo inteiro e soma cada linha

da matriz.
Obs.: dependendo da linguagem de

programação é possível criar uma fórmula
para leitura da matriz em forma de tabela.
Obs.: o vetor foi impresso após a última
coluna da matriz.

Algoritmo "matrizVetor"
VAR Memória Vídeo
MAT:vetor [1..5, 1..5] de inteiro I 1 ?2
VET:vetor [1..5] de inteiro J 1 // MAT[1,1] 3 ?5
I, J, S: integer J 2 // MAT[1,2] 5 ?4
início J 3 // MAT[1,3] 4 ?6
// ---leitura da matriz --- J 4 // MAT[1,4] 6 ?7
para I de 1 ate 5 faca J 5 // MAT[1,5] 7 ...
para J de 1 ate 5 faca
leia(MAT[I, J]) Continua até efetuar a --- vetor / soma ---
fimpara leitura das 5 linhas
fimpara 24
---- soma ---- 15
// -- soma as linhas -- I 1 31
para I de 1 ate 5 faca S 0 62
s := 0; 40
para J de 1 ate 5 faca J 1
S := S + MAT[I,J]
S 0 + 2 (2)
fimpara
J 2
VET[I] := S
S 2 + 5 (7)
fimpara
J 3
S 7 + 4 (11)
// ---- impressão do vetor ----
para I ate 1 ate 5 faca
J 4
escreva(VET[I])
fimpara S 11 + 6 (17)
fimalgoritmo J 5
S 17 + 7 (24)
J 6 (sai do laço de J)
para somar a segunda
linha.
Exemplo 4: no exemplo a seguir é utilizado uma matriz de três linhas e duas colu-
nas para armazenar os nomes e endereços de três pessoas (os nomes são armazenados
na primeira coluna da matriz e os endereços na segunda coluna).
Exemplo: índices da matriz dados

1,1 2,1
1,2 2,2
1,3 2,3
Exemplo: valores da matriz dados

José Luis dos Santos Rua Santa Caratina, 35
Marcos da Silva Rua Goiás, 745
Carlos Henrique Pereira Rua Manaus, 255
Var
Dados: vetor[1..3, 1..2] de caractere
I : inteiro
Início
// ---- leitura da matriz dados ----
Para I de 1 ate 3 passo 1 faca
Escreva(“Digite o nome da “, i, “ª pessoa”)

Leia(Dados[I, 1)
Escreva(“Digite a rua da “, i, “ª pessoa”)

Leia(Dados[I, 2)
fimpara
// ---- imprimindo a matriz dados ----

Para I de 1 ate 3 passo 1 faca
Escreva(“Dados da “, I, ”ª pessoa”)
Escreva(“Nome: “, Dados[I,1])
Escreva(“Endereço: “, Dados[I,2])
Fimpara
fimalgoritmo
1. Considere a matriz M a seguir:
Colunas
1 2 3 4 6
1 2 8 3 7 4
Linhas 2 5 2 1 9 16
3 2 12 7 8 10
4 4 5 3 8 5
5 14 11 5 3 6
E as variáveis X=2 e Y=3. Escreva o valor correspondente à solicitação (se

os valores de indicação de linha forem maiores que 5 (fora da faixa) e o
valor da coluna forma maior que 6 (fora da faixa):
a) M[X, Y]
b) M[Y, X]
c) M[X + 1, Y – 1]
d) M[X + 1, Y – 1 * 2] // analise primeiro o resultado da multiplicação
e) M[Y – X, Y + X]
f) M[Y + 1, X]
2. Considerando os valores da matriz M representada:

1 2 3 4 6
1 2 8 3 7 4
2 5 2 1 9 16
3 2 12 7 8 10
4 4 5 3 8 5
5 14 11 5 3 6
a) Identifique quais são os valores que estão na diagonal principal.

b) Identifique quais são os valores que estão na diagonal secundária.
3. Desenhe a matriz resultante do algoritmo abaixo (obs: valor atribuído para
a mesma posição irá substituir o valor anteiror):
Algoritmo “matriz”
Var
matriz: vetor [1..3, 1..3] de caractere;
início
mat[1,2] <- 'F';
mat[2,3] <- 'E';
mat[3,1] <- 'L';
mat[3,2] <- 'I';
mat[2,3] <- 'P';
mat[3,3] <- 'E';
fimalgoritmo
4. Quais são os valores impressos pelo algoritmo abaixo?

Matriz MAT
5 4 3
8 7 8
9 3 6
Algoritmo "MatrizSoma"
Var
MAT : vetor[1..3, 1..3] de inteiro
L,C: inteiro
Início
// --------- LEITURA -----------
para L de 1 ate 3 passo 1 faca
para C de 1 ate 3 passo 1 faca
escreval(“digite uma valor”)
leia(MAT[L,C])
fimpara
fimpara
// --------- IMPRESSAO -----------

para L de 1 ate 3 passo 1 faca
para C de 1 ate 3 passo 1 faca
se L = C entao
escreval(MAT[L,C])
fimse
fimpara
fimpara
fimalgoritmo
Para saber mais

Mais informações e exercícios poderão ser encontrados em:
ASCENCIO, Ana F. G.; CAMPOS, Edilene A. V. de. Fundamentos da programação de com-
putadores: Algoritmos, Pascal e C/C++. São Paulo: Pearson, 2002. p. 131-201. (Vetores e
Matrizes)
ASCENCIO, Ana F. G.; CAMPOS, Edilene A. V. de. Fundamentos da programação de com-
putadores: Algoritmos, Pascal, C/C++ e Java. 2. ed. São Paulo: Pearson, 2007. p. 145-229.
(Vetores e Matrizes)

É possível representar dados em uma matriz com mais de duas dimensões.
Para qual finalidade poderia ser utilizado esse tipo de matriz?
2.6 Estrutura homogênea em C#

Trabalhar com vetores em C# é a maioria das linguagens de programação. Na
sintaxe para a declaração de um array, coloca-se o tipo desejado e em seguida os
colchetes abrindo e fechando o nome da variável e a alocação de tamanho do vetor.
O exemplo a seguir declara um array de string unidimensional com 5 posições.
using System;
class Teste
{
public static void Main()
{
string[] vetNome = New string[5];
//atribuição
vetNome[0] = “Maria”;
vetNome[1] = “Pedro”;
vetNome[2] = “Marcio”;
vetNome[3] = “Carlos”;
vetNome[4] = “Roberto”;
// ------------- impressão ------------------

for(int x=0; x <= 4; x++)
{
Console.WriteLine(“Nome = ” + vetNome[x]);
}
}
}
É possível inicializar uma matriz na declaração, neste caso, não é necessário

especificar a quantidade de elementos, pois ela já é fornecida automaticamente à
medida que os elementos são inseridos na matriz (MSDN, 2013a). Por exemplo:
int[] Idades = new int[] {25,36,25,40,28,12 }; // inteiro
string[] Animais = {"Cachorro", "Gato", "Cavalo", "Gato"}; // caracter
Também é possível declarar uma variável de matriz sem inicialização (MSDN,

2013a). Nesse caso, deve usar o new operador quando você atribui uma matriz para
essa variável Por exemplo:
Arrays podem ter mais de uma dimensão. Por exemplo, a declaração a seguir cria
uma matriz bidimensional de cinco linhas e cinco colunas:
int[,] MAT = new int[5, 5];
Exemplo de leitura da matriz 5 x 5 do tipo inteiro:
using System;
class Teste{
public static void Main(){
int[,] MAT = new int[5,5];
for (int i = 0; i < 5; i++ ){

for (int j = 0; j < 5; j++){
Console.WriteLine(String.Format("Valor..: " + i + j));
MAT[i, j] = int.Parse(Console.ReadLine());
} // for j
} // for i
}
}
Além dos arrays multidimensionais é possível criar arrays de arrays. Trata-se de arrays
com múltiplas dimensões de tamanho variável.
Exemplo:
Int[][] VALORES = new int[4][];

Vals[0] = new int[2];
Rodrigues (2013) exemplifica o uso de “jagged arrays”. Supondo que temos um

array que armazena as turmas de uma escola e, para cada turma, um número diferente
de alunos dos quais necessita armazenar o código. É possível usar uma matriz on-
de as linhas representariam a turma e as colunas representariam os alunos, porém,
nesse caso estaria utilizando um número fixo de alunos, igual para todas as turmas, o
que não atende a nossa necessidade. Aqui entram os jagged arrays, podemos ter um
array que comporte a quantidade de turmas (um número conhecido) e cada elemento
é um vetor, cujo comprimento varia e podemos definir individualmente. Por exemplo:
int [][] TURMA = new int[3][];

Nums[0] = new int[] {1000,1001,1002};
Nums[1] = new int[] {2000,2010,2015,2016,2021,2025};
Nums[2] = new int[] {3000,3002,3003,3004,3006,3007,3015,3016};
Os exemplos a seguir criam simples-dimensionais, multidimensionais e matrizes

irregulares (MSDN, 2013b):
class TestArraysClass
{
static void Main()
{
// Declarar uma matriz unidimensional
int[] array1 = new int[5];
// Declarar e define os valores dos elementos da matriz

int[] array2 = new int[] { 1, 3, 5, 7, 9 };
// sintaxe alternative
int[] array3 = { 1, 2, 3, 4, 5, 6 };
// Declarar uma matriz bidimensional

int[,] multiDimensionalArray1 = new int[2, 3];
// Declarar e define os valores dos elementos da matriz

int[,] multiDimensionalArray2 = { { 1, 2, 3 }, { 4, 5, 6 } };
// Declara uma matriz jagged

int[][] jaggedArray = new int[6][];
//Define os valores da primeira posição da matriz jaggedArray

//vetor de 4 elementos
jaggedArray[0] = new int[4] { 1, 2, 3, 4 };
}
}&
Quando se faz uso de array, é necessário saber seu tamanho, copiar parte dos
elementos, classificar seus valores. Diante dessa necessidade, as linguagens de
programação dispõem de instruções para auxiliar na programação. Seguem alguns
métodos oferecidos pela classe System.Array (MEDEIROS, 2013):
GetLength: retorna o número de elementos da dimensão específica do array.
Length: Retorna o total de elementos do array.
Sort: Ordena os elementos de um array.
CopyTo: Copia os elementos de um array para outro.
Clone: Cria um novo array que é uma copia superficial do array de origem.
Rank: Retorna o número de dimensões do array.
Para saber mais

Trabalhando com Arrays
<http://www.devmedia.com.br/trabalhando-com-arrays/5212>.
Arrays em C# — Teoria e prática
<http://www.linhadecodigo.com.br/artigo/3444/arrays-em-csharp-teoria-e-pratica.aspx>.
Guia de Programação C#
<http://msdn.microsoft.com/pt-br/library/67ef8sbd(v=vs.90).aspx>. Acesso em: 7 jun. 2014.
Outros exemplos:
Exemplo 1: o programa efetua a leitura de 10 salários, calcula a média e imprime
os salários que estão abaixo da média.
int[] salários = new int[10];
decimal soma = 0, meédia = 0;
for (int i = 0; i < 10; i++){

Console.WriteLine(String.Format("Informe o salário {0}:", i));
Salários[i] = int.Parse(Console.ReadLine());
soma += salários[i];
}
média = soma / 10;
for (int i = 0; i < 10; i++)

{
if(salários[i] < média)
Console.WriteLine(String.Format("O elemento de índice {0}, cujo valor
é {1}, está abaixo da média." + i + salários[i]));
}
Exemplo 2: o programa efetua a leitura e a impressão de 20 temperaturas.

int[] temperatura = new int[20];
// ------------leitura das temperaturas -------

for (int i = 0; i < 20; i++){
Console.Write("Digite a temperatura {0}: ",i);
temperatura[i] = Int32.Parse(Console.ReadLine());
}
// -------------- impressão do vetor ---------

for (int i = 0; i < 20; i++){
Console.Write(temperatura[i]);
}
}
Exemplo 3: vetores para armazenar dados de 10 alunos.

string[] nome;
int[] idade = new int[10];
char[] sexo = new char[10];
// ------------ leitura dos vetores -----------

for (int i = 0; i < 10; i++){
Console.Write("Digite o seu nome: ");
nome[i] = Console.ReadLine();
Console.Write("Digite a sua idade: ");

idade[i] = Int32.Parse(Console.ReadLine());
Console.Write("Digite o seu sexo: ");
sexo[i] = char.Parse(Console.ReadLine());
}
// ------------ impressão dos vetores -----------

for (int i = 0; i < 10; i++){
Console.Write("O seu nome é: {0} ", nome[i]);
Console.Write("O seu idade é: {0} ", idade[i]);
Console.Write("O seu sexo é: {0} ", sexo[i]);
}
}
Exemplo 4: foreach().
string[] nome;
int[] idade = new int[10];
char[] sexo = new char[10];
// ------------ leitura dos vetores -----------

for (int i = 0; i < 10; i++){
Console.Write("Digite o seu nome: ");
nome[i] = Console.ReadLine();
Console.Write("Digite a sua idade: ");

idade[i] = Int32.Parse(Console.ReadLine());
Console.Write("Digite o seu sexo: ");
sexo[i] = char.Parse(Console.ReadLine());
}
// ------------ impressão dos vetores -----------

for (int i = 0; i < 10; i++){
Console.Write("O seu nome é: {0} ", nome[i]);
Console.Write("O seu idade é: {0} ", idade[i]);
Console.Write("O seu sexo é: {0} ", sexo[i]);
}
}
Exemplo 5: array jagged.

Console.WriteLine("Informe o número de turmas: ");
int num_turmas = int.Parse(Console.ReadLine());
string[][] turmas = new string[num_turmas][];
for (int i = 0; i < num_turmas; i++ )

{
Console.WriteLine("Informe a quantidade de alunos da turma {0}:", i);
int num_alunos = int.Parse(Console.ReadLine());
turmas[i] = new string[num_alunos];

for (int j = 0; j < num_alunos;j++ )
{
Console.WriteLine("Informe o nome do aluno {0}:", j);
turmas[i][j] = Console.ReadLine();
}
}
Para saber mais

Guia de Programação C#
<http://msdn.microsoft.com/pt-br/library/67ef8sbd(v=vs.90).aspx>.
C# Multidimensional Array
<http://www.dotnetperls.com/multidimensional-array>.
C# Essencial
<https://woc.ipca.pt/est/course/INFSAUD/2008-2009/Csharp_Tutorial_All.pdf>.
C# 2D Array
<http://www.dotnetperls.com/2d-array>. Acessos em: 7 jun. 2014.
Essa seção teve como objetivo fazer uma abordagem geral sobre arrays usando
C#, finalizando com alguns exemplos práticos de utilização.
1. Dados os seguintes campos de um registro: nome, telefone, dia e mês de
aniversário, desenvolver um algoritmo que mostre em um dado mês do
ano, quem são as pessoas que fazem aniversário, exibir também o dia.
Considere um conjunto de 40 pessoas.
2. Uma pessoa cadastrou um conjunto de 15 registros contendo o nome da
loja, telefone e preço de um eletrodoméstico. Desenvolver um algoritmo
que permita exibir qual foi a média dos preços cadastrados e uma relação
contendo o nome e o telefone das lojas cujo preço estava abaixo da média.
3. O registro dos alunos é realizado através dos seguintes dados:

Nome do aluno.
Nota obtida ao longo do semestre.
Nota obtida na avaliação especial.
Construir um programa que permita o registro de dois alunos. Em seguida
exibir na tela os seguintes dados de cada aluno:
Nome do aluno.
Nota obtida ao longo do semestre.
Nota obtida na avaliação especial.
Nota final, sabendo que a nota final corresponde à média entre as outras
duas notas.
Média das notas finais obtidas pelos dois alunos.
Seção 3 Estrutura e a os heterogêneas

reg stros
Uma variável composta heterogênea ou registro é uma estrutura onde podemos
armazenar valores de tipos diferentes sob uma mesma entidade lógica. Cada um
desses possíveis valores é armazenado em um compartimento do registro denomi-
nado campo do registro, ou simplesmente campo. Um registro é composto pelo seu
identificador e pelos seus campos.
Exemplo: ficha de um cadastro de cliente
Código: int Ficha
Código: _____
Nome: string
Nome: ______
Endereço: string Endereço: ___ Registro
Campo
Telefone: string Telefone: ___
Salário: _____
Salário: float Idade: ______
Idade: int
Suponha que queremos trabalhar com um agrupamento de valores que represen-
tam uma determinada mercadoria de uma loja, cujas informações relevantes são o
código do produto e seu valor. Na linguagem C, podemos declarar um registro com
identificador produto da seguinte forma:
struct{
int código;
string nome;
string endereço;
string telefone;
float salário;
int idade;
}vendedor;
A Figura 4.2 a seguir mostra a disposição do registro vendedor e de seus campos

na memória do computador.
Figura 4.2 Exemplo registro / Vendedor
Informações do registro
vendedor Nome do registro
Memória 1 José Rua Para, (43)33253345 2500 35

33
código nome endereço telefone salário idade
Campos do registro
A declaração de um registro sempre inicia com a palavra reservada struct. Em se-

guida, um bloco de declarações é iniciado com o símbolo “{”, depois, são declarados
os campos do registro, linha após linha. Cada linha deve conter o tipo e o identifica-
dor do campo do registro. Finalizando, então, as declarações dos campos do registro
com o símbolo “}” e, logo depois, é informado o nome do identificador. A variável
do tipo registro com identificador vendedor declarada acima contém seis campos.
É possível declarar outras variáveis do tipo registro com os mesmos campos da
variável vendedor da seguinte forma:
struct{
int código; Outras variáveis do
string nome; tipo registro
string endereço;
string telefone;
float salário;
int idade;
}vendedor, professor, medico;
Diferentemente da atribuição de um valor a uma variável ou a um compartimento

de uma variável composta homogênea, a atribuição de um valor a um campo de uma
variável do tipo registro é realizada através do acesso a esse campo, especificando
o identificador do registro, um ponto e o identificador do campo.
Por exemplo, para atribuir os valores 1, “José”, “Rua Pará, 33”, “(43)33253345”,
2500 e 35 aos campos código, nome, endereço, telefone, salário, idade, respecti-
vamente, da variável do tipo registro vendedor declarada anteriormente, devemos
fazer como abaixo:
vendedor. código = 1;
vendedor.nome=“José”,
vendedor. endereço=“Rua Pará, 33”, Exemplo de atribuição no
vendedor.telefone=“(43)33253345”, registro - vendedor
vendedor. salário=2500;
vendedor.idade=35;
Observe acima que, quando referenciamos um campo de uma variável do tipo

registro, não são permitidos espaços entre o identificador do registro, o ponto e o
identificador do campo.
Também é possível usar o valor de um campo de um registro em quaisquer ex-
pressões. Por exemplo, a expressão relacional abaixo é correta:
se (vendedor. salário > 3000)

Printf(“Esse mês seu salário foi excelente!\n”;
Declarações de registros diferentes podem conter campos com mesmo identifi-

cador. Por exemplo:
struct { struct {
int código; int código; Os dois registros
string nome; string nome;
char tipo; string endereço; possuem campos código
int qtdmin; int nundependentes; e nome
float preco; float salário;
}produto; }funcionário;
São declarações válidas na linguagem C. O acesso aos campos dessas variáveis se

diferencia justamente pelo identificador dos registros. Isto é, a partir das declarações
dos registros produto e funcionário, as atribuições abaixo estão corretas:
produto.código=55;
funcionário.código = 323; Exemplo de atribuição de informação nos
produto.nome = “Arroz”; campos do registro coleta e registro
funcionário.nome = “Carlos”; certidão
etores e reg stros

Podemos declarar variáveis compostas homogêneas a partir de qualquer tipo bá-
sico ou ainda de um tipo definido pelo(a) programador(a). Ou seja, podemos decla-
rar, por exemplo, um vetor do tipo inteiro, uma matriz do tipo ponto flutuante, uma
variável composta homogênea de k dimensões do tipo caracter e etc. Por exemplo,
podemos declarar um vetor com identificador produto como mostrado a seguir:
struct {
int código;
string nome; Vetor produto (10 compartimentos de
char tipo; memória com a estrutura do registro)
int qtdmin;
float preço;
}produto[10];
Exemplo 1: algoritmo.
tipo
RegConta=retistro
NumCliente :inteiro;
NomeCliente :caracter[35];
TipoCliente :caracter[1];
SaldoCliente:real;
fim;
var
Cliente : RegConta;
// ------------Entrada ------------
leia(Cliente.NumCliente);
leia(Cliente.NomeCliente);
leia(Cliente.TipoCliente);
leia(Cliente.SaldoCliente);
// ------------ Saida------------
escreva(Cliente.NumCliente);
escreva(Cliente.NomeCliente);
escreva(Cliente.TipoCliente);
escreva(Cliente.SaldoCliente);
Exemplo 2: algoritmo.
tipo
RegEnder = registro
Rua : caracter[35];
Número : inteiro;
fim;
RegConta = registro
NumCliente :integer;
NomeCliente :caracter[35];
Endereço :RegEnder;
TipoCliente :caracter[1];
{1 – especial, 2 – normal}
SaldoCliente:real;
fim;
var
Cadastro : conjunto [1..20] de RegConta;
Cont :Inteiro;
// ------------- Entrada (leitura) --------------------

Para Cont de 1 até 20 faça
Cadastro[Cont].NumCliente Cont;
Escreva('Número:', Cadastro[cont].NumCliente);
Escreva('Nome:');
Leia(Cadastro[Cont].Nomecliente);
Escreva('Rua:');
Leia(Cadastro[Cont].Endereçoo.rua);
Escreva('Número:');
Leia(Cadastro[Cont].Endereco.Número);
Repita
Escreva('Tipo cliente:');
Leia(Cadastro[Cont].Tipocliente);
Se (Cadastro[Cont].Tipocliente <> '1' .e.

Cadastro[Cont].Tipocliente <> '2')
Escreva(“Tipo inválido”);
Fim se;
Até (Cadastro[Cont].Tipocliente = '1' .ou.

Cadastro[Cont].Tipocliente = '2')
Escreva('Saldo:');
Leia(Cadastro[Cont].SaldoCliente);
fim para;
Exemplo 3:
#include <stdio.h>
#include <conio.h>
typedef struct{ typedef permite criar novos tipos

char NOME[30];
float NOTA1;
float NOTA2;
float NOTA3;
float NOTA4;
Cria uma variável com nome CAD_ALUNO
} CAD_ALUNO;
contendo a estrutura definida no typedef
void main (void){
CAD_ALUNO ALUNO;
double média;
printf("Entre com as informações do aluno: ");
scanf("%s",&ALUNO.NOME);
scanf("%f",&ALUNO.NOTA1); Leitura apenas de dados de um
aluno
scanf("%f",&ALUNO.NOTA2);
média = (ALUNO.NOTA1 + ALUNO.NOTA2 + ALUNO.NOTA3 + ALUNO.NOTA4)/4;
printf("A média do aluno eh: %f", media);
getch();
}
Exemplo 4: vetor para notas – linguagem C.
#include <stdio.h>
#include <conio.h>
typedef struct{
char NOME[30];
float NOTA[4];
} CAD_ALUNO;
void main (void){

CAD_ALUNO ALUNO;
double média, soma=0;
int I;
printf("Entre com as informações do aluno: ");

scanf("%s",&ALUNO.NOME);
printf("Entre com as notas do aluno: ");

for(I=0; I<4; I++){
scanf("%f",&ALUNO.NOTA[I]);
}
for(I=0; I<4; I++){

soma = soma + ALUNO.NOTA[I];
}
média = soma / 4;
printf("A média do aluno eh: %f", média);
getch();
}
Exemplo 03: vetor para armazenar o registro de oito alunos.
#include <stdio.h>
#include <conio.h>
typedef struct{ Cria o tipo CAD_ALUNO

char NOME[30];
float NOTA[4];
} CAD_ALUNO;
Cria o vetor ALUNO com a estrutura do tipo
void main (void){ CAD_ALUNO
CAD_ALUNO ALUNO[8];
double média[8], soma=0;
int I,J;
// -----leitura de nome e notas de 8 alunos -----

for(I=0; I < 8; I++){
printf("Entre com o nome do aluno: ");
scanf("%s",&ALUNO[I].NOME);
printf("Entre com as notas do aluno: ");
// ------------ leitura das notas -----------
for(J=0; J < 4; J++){
scanf("%f",&ALUNO[I].NOTA[J]);
}
}
// soma as notas, calcula a média de 8 alunos e armazena no vetor média

for(I=0; I < 8; I++){
soma = 0;
for(J=0; J < 4; J++){

soma = soma + ALUNO[I].NOTA[J];
}
média[I] = soma / 4;
}
// -------------- imprime os alunos com suas médias --------------

for(I=0; I < 8; I++){
printf("\n\nMédia do aluno: %s", ALUNO[I].NOME );
printf(" : %f",média[I]);
}
getch();
}// final - main()
1. Criar um algoritmo que leia o nome de um cliente, código e o total em
débito deste cliente. Mostre os dados lidos.
2. Analise a estrutura a seguir:
a) Crie um vetor para armazenar as informações dessa tabela.
b) Cadastre os produtos.
c) Imprima os produtos.
Código Produto Preço (R$)

A Refrigerante 0,60
B Casquinha simples 1,00
C Casquinha dupla 1,20
D Sundae 1,50
E Banana split 2,00
3. Uma pessoa cadastrou um conjunto de 15 registros contendo o nome da

loja, telefone e preço de um eletrodoméstico. Desenvolver um algoritmo
que permita exibir qual foi a média dos preços cadastrados e uma relação
contendo o nome e o telefone das lojas cujo preço estava a seguir da média.

As estruturas de dados heterogênea visa atender qual(is) necessidade(s) da
programação?
Para saber mais

Registro –— Comando TYPE e RECORD
<http://osorio.wait4.org/oldsite/prog1/prog1-a10.pdf>.
Unidade 5 — Estrutura de dados –— Variáveis Compostas Homogêneas
<http://www.inf.unioeste.br/~andre/capitulo5.pdf>. Acessos em: 7 jun. 2014.
Fique ligado!
As variáveis compostas homogêneas são estruturas de dados que se caracterizam
por um conjunto de variáveis do mesmo tipo. Elas podem ser unidimensionais
ou multidimensionais. Essas estruturas são ditas “homogêneas” porque os valores
que serão armazenados são de um mesmo tipo de dado.
Os índices são as posições que garantem independência a cada um dos
valores armazenados na estrutura. Por meio destes índices, também chama-
dos de posições seus valores (conteúdos), podem ser manipulados de forma
independente.
Exemplos: vetor o SALÁRIO (unidimensional) o matriz NOTAS (bidimensional).
Quatro colunas
SALÁRIO NOTAS
que
1 1000 1 2 3 4 Correspondem
as notas dos
2 1500 1 5 10 8 7 quatro
bimestres
3 500 2 6 7 9 10
4 3000 3 7 9 10 10
5 1200 4 9 8 5 9
5 8 10 9 10
Exemplos:
// primeiro elemento Exemplos:
Escreva (SALÁRIO[1]) // primeiro e segundo elemento da primeira coluna
Escreva (“Matemática – bimestre 01: “, NOTAS[1,1] )
// terceiro elemento Escreva (“Matemática – bimestre 02: “, NOTAS[2,1] )
Escreva (SALÁRIO[3])
// primeiro e segundo elemento da segunda coluna
Escreva (“Ciências – bimestre 01: “, NOTAS[2,1] )
...
O acesso às estruturas heterogêneas pode mudar dependendo da linguagem

de programação. Dependendo da linguagem, os índices do array pode começar
em 1 e em outras com 0. Isso é o que geralmente difere as linguagens. Nas
linguagens em que começam os arrays com o índice 0, o último elemento do
array recebe o índice (<tamanho do array> – 1).
Exemplos: vetor o SALÁRIO (unidimensional) o matriz NOTAS (bidimensional).
SALÁRIO NOTAS
Quatro colunas
0 1000 0 1 2 3 que
Correspondem
1 1500 0 5 10 8 7 as notas dos
quatro
2 500 1 6 7 9 10
bimestres
3 3000 2 7 9 10 10
4 1200 3 9 8 5 9
4 8 10 9 10
Exemplos:
Exemplos:
// primeiro elemento
Escreva (SALÁRIO[0]) // primeiro e segundo elemento da primeira coluna
Escreva (“Matemática – bimestre 01: “, NOTAS[0,0] )
// terceiro elemento Escreva (“Matemática – bimestre 02: “, NOTAS[1,0] )
Escreva (SALÁRIO[2])
// primeiro e segundo elemento da segunda coluna
......
A matriz mais comum é a de duas dimensões (linha e coluna), por se relacio-

nar diretamente com a utilização de tabelas. No entanto, pode ser necessário,
em algum momento, matrizes de 3 ou mais dimensões.
Exemplos: C# (MSDN, 2013c).

Programação modular
Programação modular é um paradigma de programação no qual o desenvol-
vimento das rotinas de programação é feito por meio de módulos, que são
interligados entre si através de uma interface comum.
Vantagens:
Permitem o reaproveitamento de código já construído.
Evitam que um trecho de código que seja repetido várias vezes dentro de
um mesmo programa.
Facilitam a leitura do programa-fonte.
Decompõem o programa em partes (blocos) que possam ser logicamente
compreendidos de forma isolada.
É possível encontrar subprogramas de dois tipos: as funções e os procedi-

mentos. Qualquer um deles é uma peça importante para o desenvolvimento de
programas de computador, especialmente quando esses programas se destinam
à resolução de problemas complexos.
Procedimento
Um procedimento (procedure), também chamado de sub-rotina, é um
conjunto de instruções que realiza uma determinada tarefa. É identificado por
um nome, por meio do qual é referenciado em qualquer parte do programa
que o chamou. Quando um procedimento é chamado por um programa, ele é
executado e, quando termina, o controle do processamento retorna automa-
ticamente para a primeira linha de instrução após a linha que fez a chamada
do procedimento.
A sintaxe em português estruturado é:
PROCEDIMENTO <identificador> (lista de parâmetros)

VAR
<declaração das variáveis locais do procedimento>
INÍCIO
<código do procedimento>
FIMPROCEDIMENTO
Algoritmo "CalculaMédia"
Var
N1, N2, M: Real
// ------- função para calcular a média -----------

Função Calcula_Média (Nota1, Nota2: Real): Real
Var
Média : Real
Início
Média <- (Nota1 + Nota2)/2
Retorne Média
FimFunção
//------------- programa principal --------------

Início
Escreva ("Digite a Nota 1:")
Leia (N1)
Escreva ("Digite a Nota 2:")
Leia (N2)
M <- Calcula_Média (N1, N2)
Escreva ("A média é: ", M)

FimAlgoritmo
Funções
Uma função também é um bloco de programa como são os procedimentos,
contendo início e fim e sendo identificado por um nome por meio do qual tam-
bém será referenciada em qualquer parte do programa principal. Uma sub-rotina
de função é, na verdade, muito parecida com uma sub-rotina de procedimento.
A sintaxe em português estruturado será também idêntica ao exemplo anterior.
Observe, a seguir, o código em português estruturado de uma função.
FUNCAO <identificador> (<parâmetros>):<tipo>

VAR
<declaração das variáveis locais>
INÍCIO
<lista dos comandos>
RETORNE <variável p/ retorno>
Exemplo: função para calcular o fatorial.
ALGORITMO "FATORIAL"
VAR
NUM:inteiro
// -------------- FUNÇÃO TIPO_TRIÂNGULO -------------

FUNÇÃO FATORIAL(N: inteiro): inteiro
VAR
FAT, CONT : inteiro
INICIO
FAT <- 1
para CONT <- 1 ate N faca

FAT <- FAT * CONT
fimpara
retorne FAT
FIMFUNÇÃO
// -------------- PROGRAMA PRINCIPAL -------------

INÍCIO
escreval("Entre com o número que deseja calcular o fatorial:")
leia(NUM)
escreval(FATORIAL(NUM)) // chamada da função
Fimalgoritmo
Exemplo: calculadora com C#.
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace calculadora
{
class Program{
static int Somar(int a, int b){

int soma = a + b;
return soma;
}
static int Subtrair(int a, int b){

int subtrai = a - b;
return subtrai;
}
static int Multiplicar(int a, int b){

int mult = a * b;
return mult;
}
// Obs: nesse exemplo não foi previsto o erro de divisão por zero
static int Dividir(int a, int b){
int divide = a / b;
return divide;
}
int a, b;
Console.Write("Entre com o primeiro valor: ");
a = int.Parse(Console.ReadLine());
Console.Write("Entre com o segundo valor: ");

b = int.Parse(Console.ReadLine());
Console.Write("1 - Somar \n");

Console.Write("2 - Subtrair \n");
Console.Write("3 - Multiplicar \n");
Console.Write("4 - Dividir \n");
Console.Write("Entre com uma opção: ");
switch (Console.Read()) {
case '1': Console.Write("Soma = " + Somar(a,b));
break;
case '2': Console.Write("Subtração = " + Subtrair(a,b));

break;
case '3': Console.Write("Multiplicação = "+ Multiplicar(a,b));

break;
case '4': Console.Write("Divisão = " + Dividir(a,b));

break;
}
Console.ReadKey();
}
}
}
Na orientação a objetos, os subprogramas são chamados de métodos, onde

procedimentos são métodos que tem o tipo de retorno void e funções são mé-
todos que tem um tipo de retorno diferente de void.
Escopo
O escopo de uma variável define a área do programa onde esta variável
pode ser referenciada, podendo ser:
Variáveis Globais: são as variáveis declaradas no programa que são co-
nhecidas em todo programa e inclusive nos subprogramas contidos nele.
Exceto naqueles módulos onde for declarada outra variável com o mesmo
nome.
Variáveis Locais: são as variáveis declaradas em um subprograma, que são
conhecidas em todo o subprograma, mas não no programa que contém o
subprograma. Caso um subprograma contenha a definição de outro sub-
programa, as variáveis declaradas no programa e no subprograma serão
visíveis no subprograma, mas o contrário não é verdadeiro. No escopo
do programa, não podemos chamar o subsubprograma, assim como não
podemos acessar as variáveis do subprograma.

Vetores
1. Faça um programa que leia um conjunto de 50 elementos inteiros e os

imprima em ordem contrária da que foi lida (DICA: use um vetor).
Ex. conjunto lido:
VET 55 80 45 38 13 24 ... 12
1 2 3 4 5 6 7 8
2. Faça um programa que calcule e escreva o somatório dos valores arma-

zenados numa variável unidimensional A de 100 elementos numéricos a
serem lidos do teclado.
VET 55 80 45 38 13 24 ... 12
1 2 3 4 5 6 7 8
Exemplo:
SOMA = 55 + 80 + 45 + 38 + 13 + 24 ... + 12 = 75.5
3. Faça um algoritmo que leia o vetor A e calcule o fatorial de cada valor

de A e armazene em outro vetor B de tamanho 10 de inteiros. Ao final,
imprima o vetor B.
A 4 1 0 3 ...
B 24 1 1 6 ...
4. Faça um programa que leia um vetor A de 15 valores do tipo inteiro e
calcule o somatório de cada valor de A e armazene no vetor B. Ao final,
imprima o vetor B.
A 4 1 0 5 ...
B 10 1 0 15 ...
5. Faça um programa que leia um vetor A de 15 valores do tipo inteiro e
calcule o somatório de cada valor de A e armazene no vetor B. Ao final,
imprima o vetor B.
6. Faça um programa que leia e mostre um vetor de 20 números. A seguir,
conte quantos valores pares existem no vetor.
a) Ler um vetor de 14 elementos e armazenar no vetor V.
b) Ler o vetor DADOS contendo 5 elementos.
c) Para cada elemento do vetor dado, deve-se verificar se o mesmo existe no
vetor V. Caso existir, ao encontrar o primeiro elemento, deve-se armazenar
sua posição no vetor POSIÇÕES e cancelar a busca do elemento encontrado.
(Note que o elemento 3 que está na posição um do vetor DADOS não existe
no vetor V. Neste caso, a posição 1 do vetor POSIÇÕES irá conter zero);
d) Ao final do programa deve mostrar os três vetores.
Observação: o programa deverá conter a lógica completa
Exemplo:
1 2 3 4 5 6 7 8 9 10 11 12 13 14
V 2 6 8 8 9 9 15 21 56 101 125 125 125 200
Dados 3 8 10 21 125
Posições 0 3 0 8 12
Matrizes
1. Faça um programa para ler uma MATRIZ 5 x 5 e em seguida invertê-la em

relação a sua diagonal principal.
a) Leitura da matriz
b) Inverter a matriz
c) Imprimir a mariz invertida
Exemplo: MATRIZ A Exemplo: MATRIZ A após a execução do algorítimo.
1 2 3 4 5 1 6 11 16 21
6 7 8 9 10 2 7 12 17 22
11 12 13 14 15 3 8 13 18 23
16 17 18 19 20 4 9 14 19 24
21 22 23 24 25 5 10 15 20 25
2. Faça um programa para transpor as matrizes abaixo.

1 2
1 2 3 1 1 4
Matriz A 1 1 2 3
2 4 5 6 = 2 2 5
3 3 6
3. Faça um programa para ler a matriz A abaixo e criar um vetor B contendo

a soma das colunas da matriz A.
1 2 3 4 5
1 1 0 2 -1 3
A
2 4 3 2 1 0
3 1 -2 3 4 5
4 8 5 1 3 2
1 14
2 6
B 3 8
4 7
5 10
4. Faça um programa para ler uma matriz M(5 X 5) e gere três vetores (A, B e C),
onde o vetor:
a) Irá armazenar os elementos acima da diagonal principal.
b) Irá armazenar os elementos da diagonal principal.
c) Irá armazenar os elementos abaixo da diagonal principal.
1 2 3 4 5 Vetor A 2 3 4 5 8 9 10 14 15 20
6 7 8 9 10 Vetor B 1 7 13 19 25
11 12 13 14 15 Vetor C 6 11 12 16 17 18 21 22 23 24
16 17 18 19 20
21 22 23 24 25
5. Faça um programa que leia uma matriz M(5 X 10) e realize a seguinte ope-
ração: procure pelo Dado em cada linha da matriz M e, para cada linha,
armazene no Vetor Freq a quantidades de vezes que o dado foi encontrado

na respectiva linha. Observe que cada linha da matriz esta ordenada.
1 2 3 4 5 6 7 8 9 10
1 2 6 8 8 10 11 15 21 56 101
2 3 4 5 6 7 9 10 11 13 16
M 3 1 4 6 7 8 8 8 23 56 34
4 0 2 3 4 5 6 7 8 9 10
5 1 3 7 21 34 78 234 456 789 987
Dado 8
1 2 3 4 5
Freq 2 0 3 1 0
Registros
1. Crie um algoritmo para ler o código, o sexo (M — masculino; F — feminino)

e o número de horas/aula ministradas pelos professores de uma escola du-
rante um mês. Sabe-se que um professor ganha R$ 20,50 hora/aula e que
a escola possui 10 professores. Após a leitura, o programa deverá mostrar:
Uma listagem contendo o código, o salário bruto, o desconto e o salário
líquido de todos os professores.
A média aritmética dos salários brutos dos professores do sexo feminino.
A média aritmética dos salários brutos dos professores do sexo feminino.
Os descontos devem ser assim calculados:
Sexo Até 70 horas/aula no mês Mais que 70 horas/aula no mês
Masculino 10% 8%
Feminino 7% 5%
Referências
MEDEIROS. Higor. Trabalhando com arrays. Disponível em: <http://www.devmedia.com.
br/trabalhando-com-arrays/5212>. Acesso em: 21 jul. 2013.
MSDN. Arrays de único dimensional (guia de programação translation from VPE for
Csharp). Disponível em: <http://msdn.microsoft.com/pt-br/library/0a7fscd0(v=vs.90).aspx>.
Acesso em: 21 jul. 2013a.
MSDN. Matrizes (Guia de programação do C#). Disponível em: <http://msdn.microsoft.
com/pt-br/library/9b9dty7d(v=vs.90).aspx>. Acesso em: 21 jul. 2013b.
MSDN. Multidimensional arrays (C# Programming Guide). Disponível em: <http://msdn.
microsoft.com/en-us/library/2yd9wwz4.aspx>. Acesso em: 21 jul. 2013c.
RODRIGUES, Joel. Arrays em C# — teoria e prática. Disponível em: <http://www.linhadecodigo.
com.br/artigo/3444/arrays-em-csharp-teoria-e-pratica.aspx.>. Acesso em: 21 jul. 2013.
Anotações
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________
__________________________________________________________________

Técnicas de Programação - IFPB

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

Técnicas de Programação - IFPB

Enviado por

Direitos autorais:

Formatos disponíveis

7e&1,&$6B'(B352*5$0$d®2BBBSGISDJH#3UHIOLJKW$XJXVW3*

Anderson Emídio de Macedo Gonçalves

© 2014 by Editora e Distribuidora Educacional S.A.

Diretor editorial e de conteúdo: Roger Trimer

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

1. Lógica. 2. Estrutura. I. Gonçalves, Anderson Emídio

Unidade 1 — Lógica proposicional ................................1

Unidade 2 — Introdução a algoritmos .........................43

Seção 2 Instruções primitivas ..........................................................62

Unidade 3 — Estrutura de controle..............................89

Unidade 4 — Estrutura de dados homogênea

Um algoritmo é uma sequencia de instruções finita e ordenada de forma lógica

viii TÉCNICAS DE PROGRAMAÇÃO

Na metodologia adotada, busca-se, por meio da narrativa do livro, introduzir o lei-

Objetivos de aprendizagem: A lógica matemática (ou lógica simbó-

Seção 3: Construção da tabela verdade

Seção 4: Equivalências proposicionais

Na linguagem natural nos acostumamos com vários tipos de proposições ou

1.1 Classificação de proposições lógicas

1.1.1 Proposições simples ou atômicas

1.1.2 Proposições compostas ou moleculares

São designadas pelas letras latinas maiúsculas P, Q, R, S..., chamadas de letras

Também são chamadas de fórmulas proposicionais ou fórmulas.

Em geral, de acordo com Pinho (1999), as proposições simples são constituídas

1.2 Tabela verdade

Quadro 1.1 Avaliando as proposições

Todo chumbo é metal (V)

Quadro 1.2 Tabela das possíveis combinações das proposições

Fonte: Do autor (2014).

Na Seção 3, é exemplificado o processo para construir a tabela verdade.

1.3 Exemplos de proposições

Uma proposição é uma sentença declarativa que admite um e somente um

Observe alguns exemplos de proposições:

d) Quem está batendo à porta?

Para saber mais

Questões para reflexão

Quadro 1.3 Conectivos e símbolos

Operação Conectivo Símbolo Exemplo

Quando a precedência não estiver explicitada através de parênteses, a seguinte

Quadro 1.4 Precedência / Exemplos

Operador Precedência Exemplos Interpretação

Exemplo: A expressão p  q r significa p (q  r) e não (p q) r.

Quadro 1.5 Negação (~) e sua tabela da verdade

p: João não foi ao cinema.

p: Matemática discreta é fundamental para Ciência da Computação.

Quadro 1.6 Conjunção () e sua tabela da verdade

Quadro 1.7 Disjunção () e sua tabela da verdade

2.4 Disjunção exclusiva

Quadro 1.8 Disjunção exclusiva (v) e sua tabela da verdade

Exemplo: “O novo aluno nasceu no Brasil ou na Argentina”. Note que a sentença

2.5 Implicação ou condicional

Quadro 1.9 Tabela verdade: Condicional (o)

Exemplo 7: “Se ele for eleito, aumentará o salário mínimo”.

2.6 Implicacação bicondicional

Quadro 1.10 Tabela verdade: bicondicional (l)

Exemplo: “Você pode entrar na faculdade se e somente se for aprovado no

Quadro 1.11 Exemplos

Fórmula Fatos Interpretação Valor lógico

Para saber mais

c) Não é verdade que Marcos é baixo ou elegante.

10. Sejam as proposições p e q, traduzir para a linguagem corrente as seguintes

Questões para reflexão

Seção 3 Construção da tabela verdade

Exemplo: criando a tabela para duas; três e quatro proposições.

7e&1,&$6B'(B3525$0$d®2BBBSGISDJH#3UHIOLJKW$XJXVW3

Exemplo: A expressão p q r significa p (q r) e não (p q) r.

Quadro 1.6 Conjunção () e sua tabela da verdade

Quadro 1.7 Disjunção () e sua tabela da verdade

Exemplo 1: P(p, q) = ~(p ~q)

Assim, pelo teorema tem-se que (p ~ q o c) (p o q).

p q pq ~(p q) p ~(p q)

b) P(p, q) = ~p (p ~q)

b) P(p, q) = p q op

p q r pq pqor qor po(q o r) (p q o r) l (p o (q o r))