Algoritmos em portugol

Programação de Computadores I Prof. Erlon Pinheiro
1/77

Programação de Computadores I Prof. Erlon Pinheiro
2/77
UNIDADE I – Introdução à Lógica de Programação

O que vamos ver:

Noções de Lógica
Algoritmizando a Lógica
Conceitos e Exemplos de Algoritmos
Noções de Fluxos de Controle
Algoritmos
Exercícios de Fixação

1.
Noções de Lógica

O uso corriqueiro da palavra lógica está normalmente relacionado à coerência e
racionalidade. Freqüentemente associa-se lógica apenas à matemática, deixando-se de
perceber sua aplicabilidade e relação com as demais ciências.

Lógica é a “arte de bem pensar”, que é a “ciência das formas do pensamento”. Visto
que a forma mais complexa do pensamento é o raciocínio, a lógica estuda a “correção
do pensamento”.

Podemos também dizer que a lógica tem em vista a “ordem da razão”. Isto dá entender
que a nossa razão pode funcionar desordenadamente. Por isso a lógica estuda e ensina
a colocar “ordem no pensamento”. Exemplos:

Todo mamífero é um animal.
Todo cavalo é um mamífero.
Portanto, todo cavalo é um animal.

Espírito Santo é um estado do Brasil.
Capixabas são as pessoas nascidas no Espírito Santo
Logo, todos os capixabas são Brasileiros.

Programação de Computadores I Prof. Erlon Pinheiro
3/77
2. EXISTE LÓGICA NO DIA-A-DIA ?

Sempre que pensamos, a lógica ou a ilógica necessariamente nos acompanha. Quando
falamos ou escrevemos estamos expressando nosso pensamento, logo, precisamos usar
de lógica nessas atividades.

Exemplos:
A gaveta está fechada.
A caneta está dentro da gaveta.
Precisamos primeiro abrir a gaveta para depois pegar a caneta.

Anacleto é mais velho que Felisberto.
Felisberto é mais velho que Marivaldo.
Portanto, Anacleto é mais velho que Marivaldo.

3. MAS E A LÓGICA DE PROGRAMAÇÃO?

Significa o uso correto das leis de pensamento, da “ordem da razão” e de processos de
raciocínio e simbolização formais na programação de computadores, objetivando
racionalidade e o desenvolvimento de técnicas que cooperam para a produção de
soluções logicamente válidas e coerentes, que resolvam com qualidade os problemas
que se deseja programar.

O raciocínio é algo abstrato, intangível. Os seres humanos têm a capacidade de
expressá-los através da palavra falada ou escrita (idioma). Um mesmo raciocínio pode
ser expresso em qualquer um dos inúmeros idiomas existentes, mas continuará
representando o mesmo raciocínio, usando apenas uma outra convenção.

Algo similar ocorre com a Lógica de Programação, que pode ser concebida pela mente
treinada e pode ser representada em qualquer uma das inúmeras linguagens de
programação existentes. Para escapar dessa torre de Babel (detalhes das diversas
linguagens de programação), e ao mesmo tempo, representar mais fielmente o
raciocínio da Lógica de Programação, utilizamos os Algoritmos.

Programação de Computadores I Prof. Erlon Pinheiro
4/77
4. O QUE É UM ALGORITMO?

Um algoritmo pode ser definido como uma seqüência de passos que visam atingir um
objetivo bem definido.

Na medida em que precisamos especificar uma seqüência de passos, precisamos utilizar
ordem, ou seja, “pensar com ordem”, portanto precisamos utilizar lógica.

Exemplo de Algoritmo: receita de bolo.

5. ALGORITMIZANDO A LÓGICA

Por que é Importante Construir um Algoritmo?

Um algoritmo tem por objetivo representar mais fielmente o raciocínio envolvido na
Lógica de Programação e, dessa forma, permite-nos abstrair de uma série de detalhes
computacionais, que podem ser acrescentados mais tarde.

Outra importância da construção dos algoritmos é que, uma vez concebida uma solução
algorítmica para um problema, esta pode ser traduzida para qualquer linguagem de
programação. Costumamos denominar esse processo de codificação.

Vamos a um Exemplo?

A troca de uma lâmpada.

Algoritmo 1.1
• pegar uma escada;
• posicionar a escada embaixo da lâmpada;
• buscar uma lâmpada nova;
• subir na escada;
• retirar a lâmpada velha;
• colocar a lâmpada nova.

Involuntariamente, já seguimos uma determinada seqüência de ações que
representadas nesse algoritmo, fazem com que ela seja seguida naturalmente por
qualquer pessoa, estabelecendo um padrão de comportamento, pois qualquer pessoa
agiria da mesma maneira.

A seqüenciação é uma convenção com o objetivo de reger o fluxo de execução do
algoritmo, determinando qual a primeira ação a ser executada e qual ação vem a seguir.
Nesse caso, a seqüência é linear, de cima para baixo.

Programação de Computadores I Prof. Erlon Pinheiro
5/77
O algoritmo tem um objetivo bem definido: trocar uma lâmpada. Porém, e se a lâmpada
não estivesse queimada?

A execução das ações conduziria a uma troca, independentemente de a lâmpada estar
ou não queimada, porque não foi prevista essa possibilidade em sua construção. A
solução seria acrescentar um teste, a fim de verificar se a lâmpada está ou não
queimada.

Algoritmo 1.2
• pegar uma escada;
• posicionar a escada embaixo da lâmpada;
• buscar uma lâmpada nova;
• acionar o interruptor;
• se a lâmpada não acender, então
• subir na escada;
• retirar a lâmpada velha;
• colocar a lâmpada nova.
Agora estamos ligando algumas ações à condição lâmpada não acender, ou seja, se esta
condição for verdadeira (lâmpada queimada) efetuaremos a troca da lâmpada, seguindo
as próximas ações:
• subir na escada;
• retirar a lâmpada velha;
• colocar a lâmpada nova.
Se a condição lâmpada não acender for falsa (a lâmpada está funcionando), as ações
relativas à troca da lâmpada não serão executadas, e a lâmpada (que está em bom
estado) não será trocada.

O algoritmo está correto, visto que atinge seu objetivo, porém, pode ser melhorado,
uma vez que buscamos uma escada e uma lâmpada sem saber se serão necessárias.

Algoritmo 1.3
• acionar o interruptor;
• se a lâmpada não acender, então
• pegar uma escada;
• posicionar a escada embaixo da lâmpada;
• buscar uma lâmpada nova;
• subir na escada;
• retirar a lâmpada velha;
• colocar a lâmpada nova.

Programação de Computadores I Prof. Erlon Pinheiro
6/77
A solução apresentada está aparentemente adequada, porém, não prevê a possibilidade
de a lâmpada nova não funcionar e, portanto, não atingir o objetivo nesta situação
específica. Podemos fazer um refinamento, uma melhoria no algoritmo, de tal modo
que se troque a lâmpada diversas vezes, se necessário, até que funcione.

Algoritmo 1.4
• acionar o interruptor;
• se a lâmpada não acender, então
• pegar uma escada;
• posicionar a escada embaixo da lâmpada;
• buscar uma lâmpada nova;
• subir na escada;
• retirar a lâmpada velha;
• colocar a lâmpada nova.
• se a lâmpada não acender, então
• retirar a lâmpada queimada;
• colocar outra lâmpada nova;
• se a lâmpada não acender, então
• retirar a lâmpada queimada;
• colocar outra lâmpada nova;
.
.
.
• Até quando ???

Notamos que o Algoritmo 1.4 não está terminado, faltou especificar até quando será
feito o teste da lâmpada. As ações cessarão quando conseguirmos colocar uma lâmpada
que acenda; caso contrário, ficaremos testando indefinidamente.

Programação de Computadores I Prof. Erlon Pinheiro
7/77
Podemos, então, expressar uma repetição de ação sem repetir o texto que representa a
ação, assim como determinar um limite para tal repetição, com o objetivo de garantir
uma condição de parada, ou seja, que seja cessada a atividade de testar a lâmpada nova
quando esta já estiver acesa. Uma solução seria:

Algoritmo 1.5
• acionar o interruptor;
• se a lâmpada não acender, então
• pegar uma escada;
• posicionar a escada embaixo da lâmpada;
• buscar uma lâmpada nova;
• subir na escada;
• retirar a lâmpada velha;
• colocar a lâmpada nova.
• enquanto a lâmpada não acender, faça
• retirar a lâmpada queimada;
• colocar outra lâmpada nova;

A condição lâmpada não acender permaneceu, e estabelecemos um fluxo repetitivo que
será finalizado assim que a condição de parada for falsa, ou seja, assim que a lâmpada
acender. Percebemos que o número de repetições é indefinido, porém, é finito até
alcançar o objetivo: trocar a lâmpada queimada por uma que funcione.

Programação de Computadores I Prof. Erlon Pinheiro
8/77
Até agora estamos efetuando a troca de uma única lâmpada, na verdade, estamos
testando um soquete (acionado por um interruptor), trocando tantas lâmpadas quantas
forem necessárias para assegurar que o conjunto funcione. O que faríamos se
tivéssemos mais soquetes a testar, por exemplo, 10 soquetes ?

Algoritmo 1.6
• acionar o interruptor do primeiro soquete;
• se a lâmpada não acender, então
• pegar uma escada;
• posicionar a escada embaixo da lâmpada;
• buscar uma lâmpada nova;
• subir na escada;
• retirar a lâmpada velha;
• colocar a lâmpada nova.
• enquanto a lâmpada não acender, faça
• retirar a lâmpada queimada;
• colocar outra lâmpada nova;
• acionar o interruptor do segundo soquete;
• se a lâmpada não acender, então
• pegar uma escada;
• posicionar a escada embaixo da lâmpada;
.
.
• acionar o interruptor do terceiro soquete;
• se a lâmpada não acender, então
.
.
• acionar o interruptor do décimo soquete;
.
.

Programação de Computadores I Prof. Erlon Pinheiro
9/77
Observamos que o Algoritmo 1.6 é apenas um conjunto de 10 repetições do Algoritmo
1.5, uma vez para cada soquete, havendo a repetição de um mesmo conjunto de ações
por um número definido de vezes: 10. Como o conjunto de ações tem uma forma
repetida, poderíamos alterar o fluxo seqüencial de execução de modo a fazer com que
este voltasse a executar o conjunto de ações relativas a um único soquete (Algoritmo
1.5) tantas vezes quantas fossem desejadas. Uma solução para 10 soquetes seria:

Algoritmo 1.7
• ir até o interruptor do primeiro soquete.
• enquanto a quantidade de soquetes testados for menor ou igual que dez,
faça
• acionar o interruptor do soquete;
• se a lâmpada não acender, então
• pegar uma escada;
• posicionar a escada embaixo da lâmpada;
• buscar uma lâmpada nova;
• subir na escada;
• retirar a lâmpada velha;
• colocar a lâmpada nova.
• enquanto a lâmpada não acender, faça
• retirar a lâmpada queimada;
• colocar outra lâmpada nova;
• ir até o interruptor do próximo soquete;

Quando a condição ( quantidade de soquetes testados for menor ou igual a dez ) for
verdadeira, as ações responsáveis pela troca ou não de um único soquete serão
executadas. caso a condição de parada seja falsa, ou seja, todos os dez soquetes já
tiverem sido trocados, nada mais será executado.

Programação de Computadores I Prof. Erlon Pinheiro
10/77
6. DE QUE MANEIRA REPRESENTAMOS O ALGORITMO?

Convém enfatizar mais uma vez que um algoritmo é uma linha de raciocínio, que pode
ser descrito de diversas maneiras, de forma gráfica ou textual.

Os algoritmos representados até o momento estavam em forma textual, usando
português coloquial.

As formas gráficas são mais puras por serem mais fiéis ao raciocínio original,
substituindo um grande número de palavras por convenções de desenhos. Para fins de
ilustração mostraremos como ficaria o Algoritmo 1.7 representado graficamente em um
fluxograma tradicional (algoritmo 1.8) e em um Chapin (Algoritmo 1.9).
Algoritmo 1.8

Programação de Computadores I Prof. Erlon Pinheiro
11/77

Algoritmo 1.9

Programação de Computadores I Prof. Erlon Pinheiro
12/77
7. EXERCÍCIOS DE FIXAÇÃO

1 - Um homem precisa atravessar um rio com um barco que possui capacidade de
transportar apenas ele mesmo e mais uma de suas três cargas, que são: um lobo, um
bode e um maço de alfafas. O que o homem deve fazer para conseguir atravessar o rio
sem perder suas cargas?
informações:
um barco
um homem
um lobo
um bode
um maço de alfafa
ação:
atravessar o rio sem perder as cargas
resultado:
todas as cargas na outra margem do rio.

2 - Elabore um algoritmo que mova três discos de uma Torre de Hanói, que consiste em
três hastes (a-b-c), uma das quais serve de suporte para três discos de tamanhos
diferentes (1-2-3), os menores sobre os maiores. Pode-se mover um disco de cada vez
para qualquer haste, contanto que nunca seja colocado um disco maior sobre um
menor. O objetivo é transferir os três discos para outra haste.

informações:
3 discos
3 hastes

ações:
movimentar um disco de cada vez de forma que fiquem ordenado

resultado:
discos transferidos e ordenados para outra haste

Programação de Computadores I Prof. Erlon Pinheiro
13/77
3. Três jesuítas e três canibais precisam atravessar um rio; para tal, dispõem de um
barco com capacidade para duas pessoas. Por medidas de segurança não se permite que
em alguma margem a quantidade de jesuítas seja inferior à de canibais. Qual a
seqüência de passos que permitiria a travessia com segurança?

informações:

3 jesuítas
3 canibais
1 barco com capacidade para 2 pessoas

ações:
atravessar o rio com segurança

resultado:
3 jesuítas e 3 canibais na outra margem do rio (B)

Programação de Computadores I Prof. Erlon Pinheiro
14/77
UNIDADE II  - Tópicos Preliminares

O que vamos ver:

Tipos de Dados Básicos
Constantes e Variáveis

1. TIPOS DE DADOS BÁSICOS

Informação é a matéria-prima que faz com que seja necessária a existência dos
computadores, pois eles são capazes de manipular  e armazenar um grande volume de
dados com alto desempenho, liberando o homem para outras tarefas onde o seu
conhecimento é indispensável.

Aproximando-se da maneira pela qual o computador manipula as informações, vamos
dividi-las em três tipos primitivos, que serão os tipos básicos que usaremos na
construção de algoritmos.

• Numérico

Os dados numéricos dividem-se em dois grupos: inteiros e reais.

Os números inteiros podem ser positivos ou negativos e NÃO possuem parte decimal.

Exemplos:
Vejamos algumas proposições declarativas comuns, em que é usado o tipo inteiro:

a) Ele tem 15 irmãos.
b) A escada possui 8 degraus.
c) Meu vizinho comprou 2 carros novos

Enfatizando o conceito de dado, vale observar, por exemplo, o item: 8 é um dado do tipo
inteiro e a informação é associar que 8 é o número de degraus da escada.

• Real
Os números reais podem ser positivos ou negativos e possuem parte decimal.

Exemplos:
a) Ela tem 1.73 metro de altura.
b) Meu saldo bancário é de 215.20.
c) No momento estou pesando 82.5 kg.
Observação: Nas linguagens de programação a separação entre a parte inteira e a parte
decimal de um número é feita pelo ponto (.), e a simples presença do ponto já significa
que é um número real.

Programação de Computadores I Prof. Erlon Pinheiro
15/77
• Literal ou Caractere

São dados formados por caracteres (um ou mais). Esses caracteres podem ser as letras
maiúsculas, as letras minúsculas, os números e os caracteres especiais (&, #, @, ?, +).

Exemplos:
a) Escolha o sexo: ‘M’ ou ‘F’.
b) Constava na prova: “Use somente a caneta!”;
c) Parque municipal estava repleto de placas: “Não pise na grama”.
d) Nome do vencedor é “Felisberto Laranjeira”.

Observação: Os dados do tipo literal na linguagem C são sempre representados entre
aspas simples quando temos um único caractere ou aspas duplas quando temos mais de
um caractere.

2. CONSTANTES

Entendemos que um dado é constante quando não sofre variação no decorrer do tempo,
ou seja, seu valor é constante desde o início até o fim da execução do algoritmo, assim
como é constante para execuções diferentes no tempo. O uso de constantes é igual na
matemática, por exemplo: o uso da constante pi no cálculo da área de um círculo (área =
π * r
2
, onde π = 3.14159).

3. VARIÁVEL

Um dado é classificado como variável quando tem a possibilidade de ser alterado em
algum instante no decorrer do tempo, ou seja, durante a execução do programa em que
é utilizado, o valor do dado sofre alteração ou o dado é dependente da execução em
certo momento ou circunstância.

Exemplos:
A cotação do dólar, o peso de uma pessoa, o índice da inflação.

Quando fazemos um programa, este normalmente recebe dados, os quais precisam ser
armazenados no computador para que possam ser utilizados no processamento; esse
armazenamento é feito na memória.

Um exemplo para ilustrar a diferença entre valores constantes e variáveis seria a
construção de um programa para calcular o valor da área de uma circunferência.

Area = πr
2

Area O 3.14159 * (raio*raio)

Programação de Computadores I Prof. Erlon Pinheiro
16/77
4. DECLARAÇÃO DE VARIÁVEIS

No ambiente computacional, as informações variáveis são guardadas em dispositivos
eletrônicos chamados de “memória”. Podemos imaginar essa “memória” como sendo
um armário repleto de gavetas, no qual as gavetas seriam os locais físicos responsáveis
por armazenar objetos; os objetos (que podem ser substituídos) seriam  os dados e as
gavetas, as variáveis.

Visto que na memória (armário) existem inúmeras variáveis (gavetas), precisamos
diferenciá-las, o que é feito por meio de identificadores (etiquetas ou rótulos). Cada
variável (gaveta), no entanto, pode guardar apenas um dado (objeto) de cada vez, sendo
sempre de mesmo tipo primitivo (material).

Portanto, precisamos definir nomes para determinadas gavetas especificando qual o
material dos objetos que lá podem ser armazenados; em outras palavras, declarar as
variáveis que serão usadas para identificar os dados.

5. FORMAÇÃO DE IDENTIFICADORES
Os identificadores são os nomes das variáveis utilizadas nos algoritmos.

As regras básicas para a formação dos identificadores são:

• Podem possuir qualquer tamanho. Entretanto, apenas os 32 primeiros caracteres
são utilizados pelo compilador C.
• Os caracteres que você pode utilizar na formação dos identificadores são: os
números, as letras maiúsculas, as letras minúsculas e o caractere sublinhado (_);
• Compilador C faz diferença entre letras maiúsculas e minúsculas; portanto, o
identificador NUM é exatamente diferente dos identificadores num, Num (aliás,
em C todos esses identificadores seriam diferentes);
• O primeiro caractere deve ser sempre uma letra;
• Não são permitidos espaços em branco e caracteres especiais (@, $, +, -, %, !);
• Não podemos usar as palavras reservadas nos identificadores.

Obs.: Palavras reservadas da linguagem C não podem ser identificadores de variáveis:
   auto, break, case, char, const, continue, default, do, double, else, enum, extern, float,
for, goto, if, int, long, register, return, short, signed, sizeof, static, struct, switch, typedef,
union, unsigned, void, volatile, while.

Exemplos de identificadores válidos:
A
a
nota
NOTA
X5
A32

Programação de Computadores I Prof. Erlon Pinheiro
17/77
NOTA1
MATRICULA
nota_1
dia
IDADE

Exemplos de identificadores inválidos:
5b
e@12
x-y
prova   2n
nota(2)
else
int

6. DECLARAÇÃO DE VARIÁVEIS As declarações de variáveis são obrigatórias para validar os identificadores. Todas as
variáveis devem ser incluídas em uma única declaração da forma:
tipo  lista de variáveis;
tipo  lista de variáveis;

Onde tipo representa o conjunto de valores que podemos atribuir a essas variáveis e as
listas de variáveis são os identificadores das variáveis do mesmo tipo separados por
vírgulas.

7. TIPOS DE VARIÁVEIS
Exemplos das declarações de variáveis:

real  salario, nota_1;
inteiro  matricula, contador;
caractere  nome;

8. COMENTÁRIOS

Os comentários não são interpretados pelo compilador, servem apenas para esclarecer
o programador, são excelentes instrumentos de documentação e devem sempre estar
entre /* ......... */. Ou ainda pode-se usar // para comentar o resto da linha.

Exemplos de comentários:
inteiro  num;  // variável inteira para guardar o nº de alunos
real  nota_1, nota_2; /* Variáveis reais que serão utilizadas para armazenar as duas
notas do aluno. */

Programação de Computadores I Prof. Erlon Pinheiro
18/77
9. Operações aritméticas:

Os operadores aritméticos a serem utilizados:

+ Adição
- Subtração
* Multiplicação
/ Divisão inteira e divisão real
% Resto da divisão

Exemplo: Considere X e Y variáveis do tipo inteiro e com valores 7 e 3
respectivamente.

X + Y  => 10 X /  Y   => 2
X -  Y  => 4 Y /   X   => 0
Y -  X  => - 4 Y % X => 3
X *  Y  => 21 X % Y => 1
X / 2.0 = 3.5 Y / 3.0 => 1.0

Exemplo:
X + Y – Z   =>  (X + Y) – Z
X *  Y %  Z   =>  (X * Y)  % Z

q A ordem da precedência dentro de uma expressão aritmética pode ser alterada
fazendo-se uso de parênteses. Caso tenha dúvidas quanto à ordem de precedência de
uma expressão, utilize sempre parênteses para especificar claramente a ordem da
avaliação desejada.

Exemplo:

A + B * C => A + (B * C)
Para forçar a precedência usamos os parênteses =>  (A + B) * C
10. Potenciação e Radiciação
Usaremos inicialmente duas funções matemáticas predefinidas para calcular a
potenciação e a radiciação.

Operador Função Significado Exemplo
pot(x,y) Potenciação x elevado a y pot(2,3)==2
3
== 8.0

rad(x) Radiciação Raiz quadrada de x   rad(9)==3.0

Prioridades

Na resolução das expressões aritméticas, as operações guardam uma hierarquia
entre si.

Programação de Computadores I Prof. Erlon Pinheiro
19/77

Prioridade Operadores
1ª   parênteses mais internos
2ª   pot    rad
3ª   *   /   % (mod em portugol)
4ª   +   -

Em caso de empate (operadores de mesma prioridade), devemos resolver da
esquerda para a direita, conforme a seqüência existente na expressão aritmética.
Para alterar a prioridade da tabela, utilizamos parênteses mais internos.

Exercício: Supondo que A, B e C são variáveis de tipo inteiro, com valores
iguais a 5, 10 e – 8, respectivamente, uma variável real D, com valor de 1.5,
resolva passo a passo (obedecendo a ordem de prioridade) as expressões
aritméticas abaixo e determine quais são os resultados.
a) 2 * A % 3 – C
b) rad( - 2 * C) / 4
c) ((20 / 3) / 3) + pot(2, 8) / 2
d) (30 % 4 * pot(3,3) ) * -1
e) pot( - C, 2 ) + ( D * 10 )/A
f) rad ( pot ( A,  B/A) ) + C * D
Respostas: (a) 9 (b) 1.0   (c) 130.0    (d) – 54.0 ( e)
67.0 (f) - 7.0

11.  Sinal de atribuição
O conteúdo de uma variável pode ser alterado a qualquer momento. Portanto para
atribuir valores a variáveis devemos usar o sinal de  O  (“=” em C) .
Exemplos:
Portugol
A OOOO 2;
B OOOO 3;
C OOOO A + B;
C
A = 2;
B = 3;
C = A + B;

Exercício: Encontre os erros dos seguintes comandos de atribuição:

Programação de Computadores I Prof. Erlon Pinheiro
20/77
inteiro A,D;
real B, C;

A OOOO 0;
A OOOO A + 1;
D OOOO B;
C + 1 OOOO B + C;
C OOOO 3.5;
D OOOO  2*C +6*6*2 - 3 * 4;

12. Operações relacionais (Seguem a ordem de precedência
posicional):
== Igual
> Maior
< Menor
>= Maior ou igual
<= Menor ou igual
!= Diferente

Exemplo: Considere I1 e I2 variáveis do tipo inteiro, R do tipo real com valores 10,
20, 4.5 respectivamente;

I1 > I2        é  FALSO I1 > R        é VERDADEIRO
I1 == 10      é  VERDADEIRO I1 < I2      é VERDADEIRO
I2 != 20      é  FALSO I2 == 20 é VERDADEIRO

13. Operadores Lógicos:
não (!) Negação lógica
e (&&) Interseção lógica
ou (||) União lógica

Exemplo: Considere as variáveis: inteiro a = 3; real: x = 1.5:

Expressão Valor Lógico
((a/2 = = x) &&  (a>2)) Falso
((a != x) || (a/x < 2)) Verdadeiro
! (a/3 <= x) Falso
((a < 2*x) || ( x < a/2)) Falso

q Note que o valo r lógico de uma expressão lógica e (&&) é verdadeira somente
se ambas as partes forem verdadeiras. Caso contrário, o valor lógico será falso.
Por outro lado, o valor lógico de uma expressão lógica ou (||) é falso somente se
ambas as partes forem falsas. Caso contrário, o valor lógico será verdadeiro.

Programação de Computadores I Prof. Erlon Pinheiro
21/77
Exercício: Determine os resultados obtidos na avaliação das expressões
lógicas seguintes, sabendo que A, B, C contêm, respectivamente,  2, 7 e 3.5:
a) (B == (A * C) ) &&  (C == 2)
b) (B > A) || (B == 4)
c) ((B % A) >= C) || ( ! ( A <= C))
d) ( ! (2 == A)) || ( 3 >= C)
e) ((B / A ) == C ) || ((B /  A ) != C)

Construção de tabela-verdade
Os operadores lógicos são usados para dar suporte às operações lógicas básicas de E
(&&), OU (||) e NÃO (!), de acordo com a tabela-verdade. A tabela usa V para verdadeiro
e F para falso. E1 e E2 são expressões lógicas quaisquer.
E1 E2 !E1 E1 && E2 E1 || E2
V V F V V
V F F F V
F V V F V
F F V F F
O número de linhas de uma tabela verdade é sempre 2
n
onde n é o número de
expressões lógicas presente na sentença. A forma de preenchimento sempre se dará
por colunas e começa preenchendo a primeira coluna com metade V e a outra
metade F, a segunda coluna será preenchida com a metade da metade e assim por
diante. (como no exemplo anterior)
Exercício Proposto: Para cada uma das sentenças lógicas construa a respectiva
tabela-verdade:
a) E1 && !(E2 || E2)
b) !( !E1 || !(E2 && ! E3))
c) (E1 && E2) || !E3
d) !(!(!(E1 || !E2))) && !(E3||!E1)
e) !(!(!E1 || !E2)) && !(E3||!E1)
f) !(!(E1 && E2)) && !(!E3 && !E1)
g) (E1 || !E3) && (!E2 && !(E1 || E3))

Programação de Computadores I Prof. Erlon Pinheiro
22/77
14. Comandos de entrada e saída
leia u Comando de entrada que permite a leitura de variáveis de entrada.
EXEMPLO:  leia(MATRICULA);
  leia( NOME, NOTA_1, NOTA_2);
escreva uuuu Comando de saída que exibe uma informação na tela do monitor.
EXEMPLO:  escreva( “BOM DIA  “, NOME);
  escreva( “VOCÊ PESA   “, PESO, “  KG”);

15. Bloco do programa principal
O bloco do programa principal geralmente começa com a declaração das
constantes e variáveis que o algoritmo utilizará. Em seguida, especifica as ações a
serem executadas sobre os objetos definidos (variáveis e/ou constantes). Ele é
iniciado pela palavra início seguida pela seqüência de comandos e finalizada pela
palavra fim  seguida de um ponto.
início
    <Bloco de comandos>
fim.

Exercício:  Utilizando o seguinte trecho de algoritmo, explique o que está
acontecendo em cada linha e qual é o resultado de cada ação executada.
início
    inteiro  X, Y ;
    real  Z;

    Z  OOOO 1;
    escreva(“Digite um valor inteiro: “);
    leia(X);
escreva(X, “ ELEVADO AO CUBO = “, X*X*X);
    escreva(“Digite outro valor inteiro: “);
leia(Y);
escreva(“A soma e: “, X+Y);
Z OOOO Z + 1;
     X OOOO (Y + X) % 2;
escreva(“O valor final da expressao e: “, X);
  ....
fim.

Exercícios de Fixação II

1 - Determine qual é o tipo básico de dados da informação destacado nas sentenças a
seguir:

a) A placa  “Pare !” tinha 2 furos de bala.

Programação de Computadores I Prof. Erlon Pinheiro
23/77
b) Josefina subiu 5 degraus para pegar uma maçã “boa”.
c) Alberta levou 3.5 horas para chegar ao hospital onde concebeu uma "garota” .
d) Astrogilda pintou em sua camisa: “Preserve o meio ambiente”, e ficou devendo
100.59 ao vendedor de tintas.
e) Felisberto recebeu sua 18
a
. medalha por ter alcançado a marca de 57.3 segundos nos
100 metros rasos.

2 – Assinale os identificadores válidos:
a) if b) U2 c) AH! d) ‘ALUNO’ e) #55
f) KM/L g) UYT h) ASBRUBAL i) AB*C j) O&O
k) P{O} l) B52 m) Rua n) CEP o) dia_mês

3 – Supondo que as variáveis Nota_A, Nome_A, NMat sejam utilizadas para armazenar a
nota do aluno, o nome do aluno e o número da matrícula, declare-as corretamente,
associando o tipo básico adequado ao dado que será armazenado.

4 – Encontre os erros da seguinte declaração de variáveis:

   inteiro  endereco     n_filhos;
caractere  idade,  X, C;
real  XPTO,  C,  peso,  R$;

5 - Identifique o tipo dos dados:
(a) inteiro;
(b) real;
(c) caractere;

(   ) “MARIA” (   ) 45.0 (   ) 1234 (   ) 0.0
(   ) ‘a’ (   ) ‘*’ (   ) -234 (   ) ‘1’
(   ) -0.342 (   ) 35.23 (   ) ‘3’ (   ) -18.589
(   ) ”       “    (   ) -354.0 (   ) -15.2    (   ) ”José”
(   ) 0 (   ) 897 (   ) -23

6 - Identifique o tipo dos dados:
(d) inteiro;
(e) real;
(f) caractere.
(   ) “lote” (   ) 45.0 (   ) 1234 (   ) 0.0
(   ) ’a’ (   ) ‘*’ (   ) -234 (   ) ’1’
(   ) -0.342 (   ) 35.23 (   ) ’3’ (   ) -18.589
(   ) ’  ‘    (   ) -354.0 (   ) -15.2 (   ) ”Maria”
(   ) 0 (   ) 897 (   ) -23

7 - Faça a declaração de 2 variáveis do tipo inteiro, 3 variáveis do tipo real e 2
variáveis do tipo caractere.

Programação de Computadores I Prof. Erlon Pinheiro
24/77
8 - Indique qual o resultado das expressões aritméticas abaixo:
Sendo: x = 6.0 y = 2 z = 4.0 a = 8 b = 7.5
c = 7.7 d = 12 p = 4 q = 3 r = 10 s = 7.7
a) x + y – z * a
b) d / y
c) d % y
d) y / d
e) ((z / a) + b * a) – d
f) 100 * (q / p) + r

9 - De acordo com as informações abaixo, informe qual o valor das relações  ( V -
Verdadeira ou F - falsa):
a) a O 2.0, b O 9.0, nome O “ana” , profissao O “advogado”
a + 1 >=  b*a (   )
nome != “ana” (   )
profissao == “médico” (   )
b) a O 6.0 , b O 121.0 , nome O “pedro”, profissao O “médico”
a + 1 >=  b – 5 (   )
nome != “ana” (   )
profissao == “médico” (   )
c) x O 3 , y O 4 , z O 16 , nome O “maria” :
(( x +y > z ) && (nome == “maria”)) (   )
(( x *y > z ) || ( y > = x )) (   )
(!( x - y > z ) && ( z / y + 1 == x )) (   )
((nome == “josé”)  && ( x + y + z <  ( y*y ))) (   )

10 - Dadas as declarações:
  inteiro NUM;
real SOMA, X;
caractere SIMBOLO;

Assinale os comandos de atribuição inválidos:
(   ) SIMBOLO ← 5; (  ) SOMA ← NUM+2*X;
(   )  X*X ←  SOMA; (   ) TUDO ← SOMA;
(   ) X ← X+1; (   ) NUM O 5*SOMA+2;
(   ) NUM ←”*ABC*”;

11 - Marque os identificadores como válidos ou inválidos (explicando a resposta
quando o identificador for inválido):
(a)    identificador válido;
(b)      identificador inválido;
(   ) ano
(   ) media_salario
(   ) ai!
(   ) A15B34

Programação de Computadores I Prof. Erlon Pinheiro
25/77
(   ) “aula”
(   ) 3/1

12 – Faça o rastreamento (tela e memória) do seguinte bloco de comandos:
Início
    real  nota1, nota2, media;
    escreva(“Digite as duas notas: “);
    leia(nota1,nota2);
    media OOOO (nota1  +  nota2 ) / 2;
escreva(“Media =  “, media);
fim.

13 – Encontre os erros no bloco de comandos abaixo:
início
    inteiro  X, Y ;
    real  Z;

    Z  OOOO 1.5;
    escreva(“Digite um valor inteiro: “);
    leia(X;
escreva(X, “ ELEVADO AO CUBO = “, X*X*X);
    escreva(“Digite outro valor inteiro: “)
leia(Y);
escreva(“A soma e: , X+Y);
Z  + 3 OOOO Z + 1;
     X OOOO (Y + X) / 5.0;
escreva(“O valor final da expressao e: “    X);
fim

Programação de Computadores I Prof. Erlon Pinheiro
26/77
Unidade III - ESTRUTURA DE ALGORITMOS EM PORTUGOL

1.
Introdução
Usaremos um exemplo simples para compreendermos como a formalização
em uma linguagem artificial é importante.

Exemplo Inicial

Suponha que o algoritmo leia dois números que o usuário do computador digitará no
teclado, some-os e mostre o resultado na tela do computador.
1
a
solução: (Narrativa informal)
1. Leia do teclado dois valores
2. Some os dois valores
3. Mostre o resultado da soma na tela

2
a
solução: (Narrativa um pouco mais formal seria)
1. Leia o valor do teclado e armazene na memória A;
2. Leia o valor do teclado e armazene na memória B;
3. Some os valores da memória A e B e coloque o resultado na
     memória SOMA;
4. Mostre na tela o valor da memória SOMA.

Nesta solução vemos o uso de 3 memórias: A, B e SOMA. Aqui o conceito de memória é
semelhante ao das memórias existentes nas calculadoras. Elas servem para acumular o
resultado de cálculos intermediários.

Uma solução ainda mais formal seria:
3
a
solução: (Portugol que será utilizado na disciplina)
algoritmo mostra_soma;
     início
    inteiro  a, b, soma;

         escreva(“Digite o primeiro número: “);
         leia (a);
         escreva(“Digite o segundo número: “);
         leia (b);
         soma ← a + b;
         escreva(“A soma é “, soma);
     fim.
{ Observe a identação }
Aqui as palavras início e fim foram usadas para delimitar o bloco de comandos.

2. Estrutura de um algoritmo em Portugol

Programação de Computadores I Prof. Erlon Pinheiro
27/77
algoritmo     <identificador>;
ínicio
const <tipo>  <identificador> O <dado>;
        <tipo>  <identificador>;

    <comando1>;
    ...
    <comandon>;
fim.

Segue um Algoritmo que lê as 4 notas bimestrais de um aluno. Em seguida o Algoritmo
calcula e escreve a média obtida.
Resolução:
algoritmo         media_final;
início
     real  nota1, nota2, nota3, nota4, media;

escreva (“DIGITE SUAS QUATRO NOTAS:   “);
leia (nota1, nota2, nota3, nota4);
media O (nota1 + nota2 + nota3 + nota4) / 4;
escreva (“ SUA MÉDIA É: “, media);
fim.

algoritmo media_final_v2;
início
     real  nota1, nota2, nota3, nota4, soma, media;

escreva (“DIGITE SUAS QUATRO NOTAS:   “);
leia (nota1, nota2, nota3, nota4);
soma O nota1 + nota2 + nota3 + nota4;
media O soma / 4;
escreva (“ SUA MÉDIA É: “, media);
fim.

Exercícios Resolvidos:

1) Faça um algoritmo em Portugol que leia os valores inteiros para largura,
comprimento e altura de um paralelepípedo retângulo  e calcule o seu volume.

RESOLUÇÃO:

algoritmo      volume_paralelepipedo;
início
    inteiro largura, comprimento, altura;
    escreva(“Digite os valores para largura, comprimento e  altura:    “);

Programação de Computadores I Prof. Erlon Pinheiro
28/77
    leia(largura, comprimento, altura);
escreva(“Volume =   “, largura*comprimento*altura,”   cm3”):
fim.

Se   largura == 10; comprimento = = 3;   altura = = 2; o resultado do programa acima
ficaria assim no vídeo:

Digite os valores para largura, comprimento e altura: 10  3  2 <enter>.
Volume = 60 cm3
Versão 2 do algoritmo anterior:
algoritmo volume_paralelepipedo;
início
    inteiro  largura, comprimento, altura, volume_p;
    escreva(“Digite os valores para largura, comprimento e  altura:    “);
    leia(largura, comprimento, altura);
     volume_p O largura*comprimento*altura;
escreva(“Volume =   “, volume_p,”   cm3”);
fim.

2) Faça um Algoritmo que lê o raio de uma circunferência e calcula sua área.
Resolução:

algoritmo  area_circunferencia;
início
const  real pi = 3.1416;
real  raio, area;
     //Entrada de dados
    escreva(“Digite o valor do raio: “);
leia (raio);
//Processamento de dados
area O pi * (raio*raio); // ou area O pi * (pot(raio,2));
// Saída de dados
escreva (“Area =  “, area) ;
fim.
3) Faça um algoritmo em Portugol que leia dois valores inteiros para as variáveis A
e B e efetuar as operações de adição, subtração, multiplicação e divisão de A por B,
apresentando ao final os resultados obtidos.
Resolução:

Programação de Computadores I Prof. Erlon Pinheiro
29/77
algoritmo operações;
inicio
inteiro a, b, soma, sub, mult, divi;
//Entrada de dados
escreva(“Digite dois valores inteiros: “);
leia(a, b);
//Processamento de dados
soma O a+b;
sub O a - b;
mult O a * b;
divi O a/b;
//Saída de dados
escreva(a, “ + “, b, “ = “, soma);
escreva(a, “ - “, b, “ = “, sub);
escreva(a, “ * “, b, “ = “, mult);
escreva(a, “ / “, b, “ = “, divi);
fim.

4) Efetuar a leitura de um número inteiro e apresentar o resultado do quadrado deste
número.
Resolução:
algoritmo calcula_quadrado.;
inicio
inteiro num;

//Entrada de dados
escreva(“Digite um valor inteiro: “);
leia(num);

//Processamento e saída de dados
escreva( num, “ ao quadrado e “, num*num);

Programação de Computadores I Prof. Erlon Pinheiro
30/77
fim.

algoritmo    calcula_quadrado_v2;
inicio
inteiro num, quad;

//Entrada de dados
escreva(“Digite um valor inteiro: “);
leia(num);

//Processamento de dados
quad O num*num;

//Saída de dados
escreva( num, “ ao quadrado e “, quad);
fim.

algoritmo    calcula_quadrado_v3;
inicio
inteiro num;
real quad;
//Entrada de dados
escreva(“Digite um valor inteiro: “);
leia(num);

//Processamento de dados
quad O pot(num, 2);

//Saída de dados
escreva( num, “ ao quadrado e “, quad);
fim.

Programação de Computadores I Prof. Erlon Pinheiro
31/77

5) Ler uma temperatura em graus Fahrenheit e apresentá-la convertida em graus
Célsius. A fórmula de conversão é: C O (F – 32) * (5 / 9.0), onde F é a temperatura em
Fahrenheit e C é a temperatura em Célsius.
Resolução:
algoritmo converte_temperatura;
inicio
real celsius, f;
//Entrada de dados
escreva(“Digite a temperatura em Fahrenheit: “);
leia(f);
//Processamento de dados
celsius O (f – 32)*(5/9.0);
//Saída de dados
escreva(“A temperatura em Celsius e “, celsius);
fim.

6) Calcular e apresentar o volume de uma lata de óleo, utilizando a fórmula: VOLUME
O 3.14159 * R * R * ALTURA.
Resolução:
algoritmo volume_lata_oleo;
inicio
const real PI O 3.14159;
real volume, raio, altura;
//Entrada de dados
escreva(“Digite o valor do raio e da altura em cm: “);
leia(raio, altura);
//Processamento de dados
volume O PI * pot(raio,2) * altura;
//saída de dados
escreva(“O volume da lata de óleo é “, volume, “ cm3”);

Programação de Computadores I Prof. Erlon Pinheiro
32/77
fim.

Exercícios de Fixação III

1 - Ler dois valores inteiros para as variáveis A e B e efetuar as operações de adição,
subtração, multiplicação e divisão de A por B, apresentando ao final os resultados
obtidos.

2 - Efetuar a leitura de um número inteiro e apresentar o resultado do quadrado deste
número.

3 - Ler uma temperatura em graus Fahrenheit e apresentá-la convertida em graus
Célsius. A fórmula de conversão é: C O (F – 32) * (5 / 9.0), onde F é a temperatura em
Fahrenheit e C é a temperatura em Célsius.

4 - Calcular e apresentar o volume de uma lata de óleo, utilizando a fórmula: VOLUME
O 3.14159 * R * R * ALTURA.

5 - Faça um algoritmo que receba dois números inteiros, calcule e imprima:
soma dos dois números;
subtração do primeiro pelo segundo;
subtração do segundo pelo primeiro;
multiplicação dos dois números;
divisão real do primeiro pelo segundo;
divisão real do segundo pelo primeiro;
quociente inteiro da divisão do primeiro pelo segundo;
quociente inteiro da divisão do segundo pelo primeiro;
resto da divisão do primeiro pelo segundo;
resto da divisão do segundo pelo primeiro.

6 - Ler dois valores para as variáveis A e B, efetuar a troca de valores de forma que a
variável A passe a possuir o valor da variável B e que a variável B passe a possuir o valor
da variável A. Apresentar os valores trocados.

7 – Faça um algoritmo que efetue o cálculo do valor de uma prestação em atraso,
utilizando a fórmula: PRESTACAO O VALOR + (VALOR * (TAXA/100) * TEMPO), onde a
TAXA é um valor constante de 2 e o TEMPO é dado em dias.
Resolução:
algoritmo   valor_prestacao;
inicio
const real taxa O 2.0;
inteiro tempo;
real prestação, valor;

//Entrada de dados

Programação de Computadores I Prof. Erlon Pinheiro
33/77
escreva(“Digite  o valor da prestação: “);
leia(valor);
escreva(“Digite o tempo de atraso em dias: “);
leia(tempo);
//Processamento de dados
prestação O (valor * (taxa/100)*tempo)+valor;
//saída de dados
escreva(“O valor final da prestação é: “, prestação);
     fim.

8 - Uma loja de animais precisa de um programa para calcular os custos de criação de
coelhos. O custo é calculado com a fórmula CUSTO O (NR_COELHOS * 0.70) / 18 + 10.  O
programa deve ler um valor para a variável NR_COELHOS e apresentar o valor da
variável CUSTO.

9 - Faça um algoritmo que receba duas notas de um aluno e seus respectivos pesos,
calcule e imprima a média ponderada dessas  notas.
Resolução:
algoritmo media_ponderada;
inicio
real  nota1, nota2, media_p;
inteiro peso1, peso2;

   //Entrada de dados
escreva(“Digite as duas notas: “);
leia(nota1, nota2);
escreva(“Digite os pesos: “);
leia(peso1, peso2);

//Processamento de dados
media_p O (nota1*peso1 + nota2*peso2)/(peso1+peso2);

//Saída de dados
escreva(“A media ponderada e “, media_p);
fim.

Rastreamento

Memória Tela

nota1: 7.0
     nota2:  8.0
     media_p: 7.6666
peso1: 1
    peso2:  2

Digite as duas notas: 7  8  <Enter>
Digite os pesos: 1  2  <Enter>
A media ponderada e 7.6666

Programação de Computadores I Prof. Erlon Pinheiro
34/77

10 - Faça um algoritmo que receba o valor de um depósito e o valor da taxa de juros.
Calcule e imprima o valor do rendimento e o valor total depois do rendimento.
Resolução:

algoritmo   aplicacao_financeira;
inicio
real  deposito, taxa, rend, valor_final;

//Entrada de dados
escreva(“Digite o valor do deposito: “);
leia(deposito);
escreva(“Digite o valor da taxa de juros: “);
leia(taxa);

//Processamento de dados
rend  O  deposito * (taxa/100);
valor_final O deposito + rend;

//Saída de dados
escreva(“O valor do rendimento e: “, rend);
escreva(“O valor final com o rendimento e : “, valor_final);
fim.
Faça o rastreamento

11 - Faça um algoritmo que receba um número inteiro, calcule e imprima a tabuada
desse número.
Resolução:

algoritmo   tabuada;
inicio
inteiro num;

//Entrada de dados
escreva(“Digite um numero para a tabuada: “);
leia(num);
//Processamento e saída de dados
escreva(“A tabuada de multiplicação do numero “, num);
escreva(num , “ *    1 = “, num);
escreva(num , “ *    2 = “, 2*num);
escreva(num , “ *    3 = “, 3*num);
escreva(num , “ *    4 = “, 4*num);
escreva(num , “ *    5 = “,  5*num);
escreva(num , “ *    6 = “, 6*num);
escreva(num , “ *    7 = “, 7*num);

Programação de Computadores I Prof. Erlon Pinheiro
35/77
escreva(num , “ *    8 = “, 8*num);
escreva(num , “ *    9 = “, 9*num);
escreva(num , “ *  10 = “, 10*num);
fim.

Rastreamento

Memória Tela

num:  2

Digite um numero para a tabuada: 2  <Enter>
2 *   1 = 2
2 *   2 = 4
2 *   3 = 6
2 *   4 = 8
2 *   5 = 10
2 *   6 = 12
2 *   7 = 14
2 *   8 = 16
2 *   9 = 18
2 * 10 = 20

12 - Faça um algoritmo que receba um número real, calcule e imprima o valor referente
ao volume do cubo que tenha este número real como lado.

13 - Faça um algoritmo que receba um número inteiro, calcule e imprima:
a raiz quadrada desse número;
esse número elevado ao quadrado.


14 - Faça um algoritmo que receba o valor do salário de um funcionário e o valor do
salário mínimo. Calcule e imprima quantos salários mínimos ganha esse funcionário.

15 - Faça um algoritmo que calcule e imprima a área de um retângulo.

16 - Faça um algoritmo que receba o salário de um funcionário, calcule e imprima o
valor do imposto de renda a ser pago, sabendo que o imposto equivale a 5% do salário.

17 - Faça um algoritmo que receba o salário de um funcionário, calcule e imprima o
novo salário sabendo-se que este sofreu um aumento de 25%.
Resolução:

algoritmo   reajuste_salarial;
inicio

Programação de Computadores I Prof. Erlon Pinheiro
36/77
const real reaj = 25;
real salario, novo_sal;

//Entrada de dados
escreva(“Digite o valor do salario: “);
leia(salario);
//Processamento de dados
novo_sal O salario * (reaj/100) + salario;
//Saída de dados
escreva(“O valor do salario reajustado e: “, novo_sal);
fim.

18 - Faça um algoritmo que receba o peso de uma pessoa, um valor inteiro, calcule e
imprima:
o peso dessa pessoa em gramas;
se essa pessoa engordar 5%, qual será seu novo peso em gramas.

19 - Imprima o cálculo da seguinte equação sendo lidos os parâmetros a, b e c:
X = ((a + (2* b + c) * c) / a *a)

20 - Faça um algoritmo que leia as medidas de um retângulo (base, altura), calcule e
imprima sua área e seu perímetro.

Programação de Computadores I Prof. Erlon Pinheiro
37/77
UNIDADE IV – Comandos de Seleção
O que vamos ver:
• Seleção Simples
• Seleção Composta
• Seleção Encadeada
• Seleção Múltipla Escolha

Uma estrutura de seleção permite a escolha de um grupo de ações (bloco) a ser
executado quando determinadas condições, representadas por expressões lógicas ou
relacionais, são ou não satisfeitas.

1. Seleção Simples
Quando precisamos testar certa condição antes de executar uma ação, usamos uma
seleção simples, que segue o seguinte modelo:

se (<condição>) então
Comando; // comando único

<condição> é uma expressão lógica que, quando inspecionada, pode gerar um resultado
falso ou verdadeiro.

Se <condição> for verdadeira, a ação primitiva sob a cláusula então (Comando) será
executada; caso contrário (<condição>) for falsa), encerra-se a seleção (fim), neste caso
sem executar nenhum comando.

Através do exemplo anterior, observamos que, quando existir apenas uma ação após a
cláusula, então basta escrevê-la; já quando precisamos colocar diversas ações é
necessário usar um bloco, delimitado por início e fim conforme o seguinte modelo:

se (<condição>) então
início
     Comando-1;
     Comando-2;
           ...
     Comando-n;
fim;

Exemplo:

Programação de Computadores I Prof. Erlon Pinheiro
38/77
algoritmo    exemplo1;
inicio
    real n1, n2, n3, m;
    escreva(“DIGITE TRÊS NOTAS: “);
    leia(n1, n2, n3);
    m ←←←← (n1 + n2 + n3) / 3;
    se ( m >= 7 ) então
inicio
        escreva(“APROVADO”);
        escreva(“MÉDIA = “,m);
     fim;
fim.

2.   Seleção Composta
Quando tivermos situações em que duas alternativas dependem de uma mesma
condição, uma da condição ser verdadeira e outra da condição ser falsa, usamos a
estrutura de seleção composta. Supondo que um conjunto de ações dependa da
avaliação verdadeira uma única ação primitiva dependa da avaliação falsa, usaremos
uma estrutura de seleção semelhante ao seguinte modelo:

se (<condição>) então
início
    Comando-1;
    Comando-2;
     ....
    Comando-n;
fim;
senão
inicio
    Comando-z1;
    Comando-z2;
fim;

Programação de Computadores I Prof. Erlon Pinheiro
39/77
algoritmo exemplo02;
inicio
    inteiro  num1, num2;
    escreva(“Digite dois valores inteiros: “);
    leia(num1, num2);
    se (num1 == num2) então
escreva(“NÚMEROS IGUAIS”);
    senão
          escreva(“NÚMEROS DIFERENTES”);
fim.

Outro exemplo de estrutura condicional composta:
algoritmo exemplo2_1;
inicio
     real  n1, n2, n3, m;
    escreva(“DIGITE TRÊS NOTAS: “);
    leia(n1, n2, n3);
    m ← (n1 + n2 + n3) / 3;
    se (m >= 7) então
inicio
        escreva(“APROVADO”);
fim;
senão
inicio
        escreva(“ REPROVADO”);
fim;
escreva(“MÉDIA = “,m);
fim.

Programação de Computadores I Prof. Erlon Pinheiro
40/77
3. Seleção Encadeada

Quando precisarmos agrupar várias seleções, formaremos uma seleção encadeada.
Normalmente, tal formação ocorre quando uma determinada ação (ou bloco de ações)
deve ser executada de acordo com um conjunto de possibilidades.

se (<condição 1>) então
   se  (<condição 2>) então
    início
Comando-1;
Comando-2;
....
Comando-n;
   fim;
  senão
se  (<condição 3>) então
início
Comando-1;
Comando-2;
....
Comando-n;
fim;
senão
s e  (<condição 4>)  então
       se  (<condição 5>) então
Comando –v;
s enão
Comando-f;

Programação de Computadores I Prof. Erlon Pinheiro
41/77
Exemplo de estruturas condicionais encadeadas:
algoritmo exemploO3;
inicio
      real  N1, N2, N3, M, FALTA;
escreva(“DIGITE TRÊS NOTAS: “);
leia(N1, N2, N3);
M O (N1 + N2 + N3) / 3;
se ( M >= 7) então
inicio
escreva(“ALUNO APROVADO”);
fim;
senão
se ( M >= 3) então
       inicio
escreva(“PROVA DE RECUPERAÇÃO.”);
FALTA O10 – M;
escreva(“NOTA PARA TIRAR NO EXAME = “, FALTA);
     fim;
     senão
    inicio
          escreva(“ ALUNO REPROVADO”);
    fim;
          escreva(“ SUA MÉDIA FOI: “, M);
fim.

Programação de Computadores I Prof. Erlon Pinheiro
42/77
Exercícios de Fixação IV

1. Faça um algoritmo para ler três valores numéricos inteiros distintos e determinar o
menor deles.

2. Faça um algoritmo que leia o sexo (m ou M para masculino – f ou F para feminino) e a
idade de uma pessoa e determine se a pessoa já atingiu a maioridade, sabendo-se que:
as pessoas do sexo masculino atingem a maioridade aos 18 anos e as pessoas do sexo
feminino atingem a maioridade aos 21 anos. O algoritmo deve escrever o resultado
esperado.
RESOLUÇÃO

Rastreamento

Memória Tela
sexo: ‘F’
idade: 27
Digite seu sexo (M ou F ): F <Enter>
Digite sua idade: 27 <Enter>
Atingiu a maioridade!
sexo: ‘f’
idade: 15
Digite seu sexo (M ou F ): f <Enter>
Digite sua idade: 15 <Enter>
Nao atingiu a maioridade.
sexo: ‘M’
idade: 28
Digite seu sexo (M ou F ): M <Enter>
Digite sua idade: 28 <Enter>
Atingiu a maioridade!
sexo: ‘m’
idade: 14
Digite seu sexo (M ou F ): m <Enter>
Digite sua idade: 14 <Enter>
Nao atingiu a maioridade.
sexo: ‘$’
idade: 2
Digite seu sexo (M ou F ): $ <Enter>
Digite sua idade: 2 <Enter>
Sexo invalido.

3. Suponha que os termos b1, b2 e b3 abaixo sejam expressões Verdadeiras ou Falsas e
que c1, c2, c3, c4 e c5 sejam comandos quaisquer.

Programação de Computadores I Prof. Erlon Pinheiro
43/77
algoritmo ex03;
início
se  (b1)  então
início
c1;
fim
senão
início
se (b2)  então
início
se  (b3)  então
      início
c2;
fim
senão
início
c3;
c4;
fim
fim;
c5;
fim;
fim.

Dado o algoritmo acima, responda:
a) Se b1 for verdadeiro, b2 for verdadeiro e b3 for falso, quais os comandos que serão
executados ?
b) Se b1 for falso, b2 for verdadeiro e b3 for falso, quais os comandos que serão
executados ?
c) Quais os valores de b1, b2, b3 para que somente o comando C5 seja executado ?
d) Se b1 for verdadeiro, b2 for verdadeiro e b3 for verdadeiro, quais os comandos que
serão executados ?
e) Quais os valores de b1, b2 e b3 para que sejam executados os comandos c2 e c5?

4. Faça um algoritmo que leia dois números, some-os e imprima o resultado caso a soma
seja maior que 10.

5. Faça um algoritmo que leia um número inteiro e imprima a mensagem ‘Número par!’
caso ele seja divisível por 2.

6. Faça um algoritmo que leia 2 números inteiros para as variáveis A e B. Caso A seja
maior que B e B seja par, efetue a troca dos valores de forma que a variável A passe a
conter o valor da variável B e, a variável B passe a conter o valor da variável A.

Programação de Computadores I Prof. Erlon Pinheiro
44/77
7. Faça um algoritmo que leia um número inteiro positivo e imprima uma mensagem
dizendo se ele é par ou impar.

8. Faça um algoritmo que leia dois valores numéricos inteiros e distintos. Apresente a
diferença do maior pelo menor na tela.

9. O que está errado no algoritmo abaixo?
algoritmo erro
inicio
inteiro num1, num2, par;
printf(Digite um valor inteiro: ”)
leia (num1);
num2 ← num1 % 2.0; /* resto da divisão ou num2 ← num1 mod 2.0;*/
se ( num2 == 0 ) então
inicio
par ← ‘v’;
fim;
senão
inicio
par ← ‘f’;
fim;
fim.

10. Dado o algoritmo abaixo responda qual o valor de Result após a sua execução?
algoritmo valor_final;
início
real num1;
inteiro num2, result;
num1 ← 1.5;
num2 ← 3;
num1 ← num1 + 1;
se ( (num1+2<= num2) ou ((num1 + num2 > 5) ou (não (num1+pot(num2,2) / num1 + num2>=4 ))) então
inicio
result 0;
fim;
senão
inicio
result 1;
fim;
fim.

11. Faça um algoritmo que leia dois valores numéricos e imprima o maior. Caso os
números sejam iguais imprima a mensagem ‘Números iguais!’.

12. Faça um algoritmo que leia três números distintos e imprima o maior.

Programação de Computadores I Prof. Erlon Pinheiro
45/77
13. Faça um algoritmo que calcule e imprima o desconto do salário de um funcionário,
sabendo que:
a. se salário < R$ 1000, 00, desconto de 5% sobre o salário;
b. se salário >= R$ 1000, 00 e <= R$2000,00, desconto de 10% sobre o
salário;
c. se salário > R$ 2000, 00, desconto de 15% sobre o salário;

14. Faça um algoritmo que efetue a leitura de três valores numéricos reais distintos e
apresente os valores lidos em ordem crescente.

15. Faça um algoritmo que leia 2 notas e o número de faltas semestrais de um
determinado aluno e calcule a média aritmética entre elas. Imprima a média e uma
mensagem informando a situação final do aluno. O aluno estará aprovado caso sua média
seja maior ou igual a 7. O aluno terá direito a uma recuperação caso sua média seja maior
ou igual a 3, caso contrário estará reprovado. Mesmo que possua média para aprovação ou
recuperação, o aluno estará reprovado caso possua mais de 20 faltas.

16. Dado o algoritmo abaixo responda:
a) Se b1 = VERDADEIRO e b2 = VERDADEIRO, o que será impresso?
b) Se b1 = FALSO e b2 = VERDADEIRO, o que será impresso?
c) Se b1 = FALSO e b2 = FALSO, o que será impresso?
Onde c1, c2 e c3 são mensagens, isto e, cadeias de caracteres.
algoritmo teste;
início
se ( b1 )então
início
escreva (c1);
fim;
senão
início
se ( b2) então
início
escreva (c2);
fim;
senão
início
escreva (c3);
fim;
fim;
fim.

17. O que será impresso após a execução do algoritmo abaixo se:
a) num = 10 b) num = 0 c) num = - 4

algoritmo resultado;

Programação de Computadores I Prof. Erlon Pinheiro
46/77
início
/* declaração de variáveis */
inteiro num;
leia ( num);
se (num > 0) então
escreva (“numero positivo”)
senão
se (num < 0) então
escreva (“numero negativo”)
senão
escreva (“zero”);
fim.

18. Uma empresa decide dar um aumento de 4% aos funcionários cujo salário é inferior
a 500 reais. Escreva um algoritmo que receba o salário de um funcionário e imprima o
valor do salário reajustado ou uma mensagem caso o funcionário não tenha direito ao
aumento.

19. Faça um algoritmo que verifique a validade de uma senha fornecida pelo usuário. A
senha correta é o número: 12345. O algoritmo deve imprimir mensagem de permissão ou
negação de acesso.

20. Faça um algoritmo que receba a idade de uma pessoa e imprima mensagem de
maioridade ou não. Assuma que a maioridade ocorre somente aos 21 anos.

21. Faça um algoritmo que receba a altura e o sexo de uma pessoa, calcule e imprima o
seu peso ideal, utilizando as fórmulas abaixo. Assuma M ou F como sendo os valores
válidos para o sexo de uma pessoa.
• para homens: (72.7 * ALTURA) – 58
• para mulheres: (62.1 * ALTURA) – 44.7

Programação de Computadores I Prof. Erlon Pinheiro
47/77
4. Seleção de Múltipla Escolha

Quando um conjunto de valores discretos precisa ser testado e ações diferentes são
associadas a esses valores, estamos diante de uma seleção encadeada homogênea do
tipo se – senão – se. Como esta situação é bastante freqüente na construção de
algoritmos que dependem de alternativas, utilizaremos uma estrutura específica para
estes casos, a seleção de múltipla escolha.

O modelo que expressa as possibilidades é o seguinte:

escolha(X)
inicio
caso V1 : C1; pare;
caso V2 : C2; pare;
caso V3 : C3; pare;
caso V4 : C4;
fim;

Caso o contéudo da variável seletora X seja igual ao valor Vn, então, o comando Cn será
executado; caso contrário, serão inspecionados os outros casos até ser encontrada uma
igualdade ou terminarem os caso.

Para executramos um comando que possui mais de um valor em que se verifica sua
necessidade, agrupamos todos esses valores em único caso. E, para executarmos um
comando que se verifica com todos os outros valores, exceto os discriminados caso a
caso, incluímos outra situação: caso contrário.

escolha(X)
inicio
caso V1 : C1; pare;
caso V2: caso V3 : C2; pare;
caso V4 : C3; pare;
caso V5 : C4; pare;
caso contrário: C5;
fim;

Programação de Computadores I Prof. Erlon Pinheiro
48/77
Exemplos
1 – Construa um programa que leia um valor numérico inteiro e uma opção de operação
( 1 – Raiz Quadrada, e 2 – Valor ao Quadrado) a qual o número deve ser submetido.

algoritmo  exemplo_01;
inicio
    inteiro num, op;
    real  resultado;
    escreva(“Digite o valor inteiro: “);
    leia(num);
    escreva(“Escolha uma opção: “);
    escreva(“1: Raiz ou 2: Quadrado: “);
    leia(op);
    escolha(op)
    inicio
        caso 1: resultado  rad(num); pare;
        caso 2: resultado  pot(num, 2);
    fim;
    escreva(“O resultado é ”, resultado);
fim.

Outra versão:
algoritmo  exemplo_01_v2;
inicio
    inteiro num, op;
    escreva(“Digite o valor inteiro: “);
    leia(num);
    escreva(“Escolha uma opção: “);
    escreva(“1: Raiz ou 2: Quadrado: “);
    leia(op);
    escolha(op)
    inicio
        caso 1:  escreva(“ O resultado é “,rad(num));
                     pare;
        caso 2:  escreva(“O resultado é “,pot(num, 2));
                     pare;
        caso contrário: escreva(“Opção Inválida!!!!”);
    fim;
fim.

Importante! A restrição da estrutura escolha é que o seletor só pode ser variável do
tipo inteiro ou um único caractere.

Programação de Computadores I Prof. Erlon Pinheiro
49/77
2 – Construa um algoritmo que leia um caractere, e determine se este é uma vogal
maiúscula, ou um digito numérico (caractere numérico), ou um operador aritmetico, ou
senão um outro caractere.


algoritmo exemplo_02;
inicio
    caractere car;
    escreva(“Digite um caractere: “);
    leia(car);
    escolha (car)
     inicio
        caso ‘A’: caso ’E’: caso ‘I’: caso ‘O’: caso‘U’:  escreva(“Vogal maiúscula”);
                                                                                pare;
        caso ‘0’: caso ‘1’: caso ‘2’: caso ‘3’: caso ‘4’: caso ‘5’: caso ‘6’:
        caso ‘7’: caso ‘8’:  caso ’9’:  escreva(”Valor numérico”);
                                                                                pare;
        caso ‘+’: caso ‘-’: caso ‘*’: caso ‘/’:  escreva(“Operador aritmético”);
                                                                                pare;
        caso contrário          : escreva(“Você digitou outro caractere”);
    fim;
fim.

Exercícios de Fixação V
0000000
Comando de seleção múltipla
1. Leia uma vogal maiúscula e imprima a vogal subseqüente.
Resolução:
algoritmo exercício1;
inicio
    caractere car;
    escreva(“Digite uma vogal maiúscula: “);
    leia(car);
    escolha (car)
     inicio
        caso ‘A’: escreva(“Vogal subsequente: E”);
                       pare;
caso ’E’: escreva(“Vogal subsequente: I”);
                       pare;
caso ‘I’: escreva(“Vogal subsequente: O”);
                       pare;
caso ‘O’: escreva(“Vogal subsequente: U”);
                       pare;
   caso‘U’: escreva(“Vogal subsequente: A”);
                        pare;
        caso contrário : escreva(“Você digitou outro caractere”);
    fim;

Programação de Computadores I Prof. Erlon Pinheiro
50/77
fim.

2. Leia um caractere e imprima a mensagem ‘É uma vogal!’, caso o caractere lido seja
uma vogal. Caso contrário imprima ‘O caractere lido não é uma vogal!’.

Resolução:
algoritmo    acha_vogal;
inicio
    caractere   car;
    //Entrada de dados
    escreva(“Digite um caractere:  “);
    leia( car );
    //Processamento e saida de dados
    escolha( car )
    inicio
caso ‘A’:    caso ‘a’:   caso ‘E’: caso ‘e’: caso ‘O’:  caso ‘o’: caso ‘U’: caso ‘u’:
caso ‘ I’: caso ‘i’:  escreva(“ O caracter e uma vogal!”);
pare;
caso contrario:  escreva(“O caractere lido não e uma vogal!”);
    fim;
fim.


3. Leia o mês e o ano (em números) e exiba o número de dias do mês digitado.
Obs.: meses com 30 dias: 4, 6, 9, 11
meses com 31 dias: 1, 3, 5, 7, 8, 10, 12
fevereiro possui 28 dias em ano não bissexto e 29 dias em ano bissexto. Um
ano é identificado como bissexto quando ANO mod 4 = 0 e se Ano for divisível
por 100 ele também deve ser divisível por 400.

4. Leia o número de um mês e imprima o nome do mês por extenso.

5. Leia uma data (dia, mês e ano) em valores numéricos e a imprima por extenso como
mostrado no exemplo abaixo:
Lido: 21 04 1970
Escrito: 21 de abril de 1970

6. No curso de Introdução a Computação, a nota final do estudante é calculada a partir de 3
notas atribuídas respectivamente a um trabalho de laboratório, a uma avaliação semestral e
a um exame final. As notas variam de 0 a 10 e a nota final é a média ponderada das 3 notas
mencionadas. A tabela abaixo fornece os pesos das notas:
trabalho de laboratório - peso 2

Programação de Computadores I Prof. Erlon Pinheiro
51/77
avaliação semestral - peso 3
exame final - peso 5
Faça um algoritmo que receba as 3 notas, calcule e imprima a média final e o
conceito desse estudante. O conceito segue a tabela abaixo:
Média Final Conceito
8.0 |___| 10.0 A
7.0 |___ 8.0 B
6.0 |___ 7.0 C
5.0 |___ 6.0 D
< 5.0 E

7. Faça um algoritmo que receba um código de origem (número inteiro) e imprima a sua
procedência. A procedência obedece à tabela abaixo. Caso um código inválido seja digitado
imprima uma mensagem de erro.

Código de Origem Procedência
1 Sul
2 Norte
3 Leste
4 Oeste
5 ou 6 Nordeste
7,8 ou 9 Sudeste
10 até 20 Centro-Oeste
21 até 30 Nordeste
Resolução:

algoritmo identifica_regiao;
inicio
inteiro codigo;

//Entrada de dados
escreva(“ Digite o codigo da região: “);
leia(codigo);
//Processamento e saída de dados
escolha( codigo )
inicio
caso 1: escreva(“Procedencia: Regiao Sul”);
pare;
caso 2: escreva(“Procedencia: Regiao Norte”);
pare;
caso 3: escreva(“Procedencia: Regiao Leste”);
pare;
caso 4: escreva(“Procedencia: Regiao Oeste”);
pare;
caso 5: caso 6: escreva(“Procedencia: Regiao Nordeste”);
pare;
caso 7: caso 8: caso 9: escreva(“Procedencia: Regiao Sudeste”);

Programação de Computadores I Prof. Erlon Pinheiro
52/77
pare;
caso contrário: se ( (codigo>=10)&&(codigo<=20)) então
escreva(“Procedencia: Regiao Centro-Oeste”);
senão
se (( codigo>=21)&&(codigo<=30))
escreva(“Procedencia: Regiao Nordeste”);
senão
escreva(“Codigo invalido”);
fim //escolha
fim.//do algoritmo

Código de Origem Procedência
1 Sul
2 Norte
3 Leste
4 Oeste
5 ou 6 Nordeste
7,8 ou 9 Sudeste
10 até 20 Centro-Oeste
21 até 30 Nordeste

8. Faça um algoritmo que receba o código correspondente ao cargo de um funcionário e
imprima seu cargo e o percentual de a umento ao qual este funcionário tem direito seguindo
a tabela abaixo:

Programação de Computadores I Prof. Erlon Pinheiro
53/77
Código Cargo Percentual
1 Escriturário 50%
2 Secretário 35%
3 Caixa 20%
4 Gerente 10%
5 Diretor não tem aumento

9. Faça um algoritmo que mostre um menu com as seguintes opções:
1. soma
2. multiplicação
3. finalizar
O algoritmo deve receber a opção desejada, receber os dados necessários para a operação
de cada opção, realizar a operação e imprimir o resultado. Na opção finalizar nada deve
acontecer.

10. Uma companhia de seguros tem três categorias de seguros baseadas na idade e
ocupação do segurado. Somente pessoas com pelo menos 18 anos e não mais de 70 anos
podem adquirir apólices de seguros. As classes de ocupações foram definidas em três
grupos de risco. A tabela a seguir fornece as categorias em função da faixa de idade e do
grupo de risco:

Código do Grupo de Risco
Idade Baixo Médio Alto
18 a 24 7 8 9
25 a 40 4 5 6
41 a 70 1 2 3

Faça um algoritmo que receba a idade (um número inteiro) e o grupo de risco
(representados pelos caracteres: `b`: baixo`; `m`: médio ou `a`: alto) e determine e
imprima o código do seguro.

UNIDADE V – Comandos de Repetição

O que vamos ver:

Programação de Computadores I Prof. Erlon Pinheiro
54/77
• Comandos de Repetição com teste no início
• Comandos de Repetição com teste no final
• Comandos de Repetição com variável de controle

Definição: Comandos de Repetição
São comandos caracterizados por permitir que uma seqüência de comandos seja
executada um número repetido de vezes. (Lembrem-se do exemplo inicial do
algoritmo da troca da lâmpada )

1. Repetição com teste no início

Consiste de uma estrutura de controle do fluxo de execução que permite repetir
diversas vezes um mesmo trecho do algoritmo, porém, verificando ANTES de cada
execução se é permitido executar o mesmo trecho.

Forma geral do comando enquanto:
enquanto (<Condição>) faça
inicio
<comando1>;
<comando2>;
...
<comandon>;
fim;

Antes da seqüência de comandos ser executada, a condição é avaliada. Caso seja
verdadeira, a seqüência será repetidamente executada enquanto a condição
permanecer verdadeira.

Note que se a condição for falsa já na primeira avaliação, a seqüência de comandos
não será executada.

A condição deverá se tornar falsa em algum momento, caso contrário a seqüência
será executada indefinidamente (Loop infinito).

Exemplo 1: Mostrar os números inteiros de 1 a 10.
algoritmo numeros;
inicio
const inteiro maior = 10;
inteiro i;

i O 1;
escreva(“ Números inteiros de 1 até ”, maior, “ : “);
enquanto ( i <= maior) faça
início

Programação de Computadores I Prof. Erlon Pinheiro
55/77
escreva (i, “   “);
i O i + 1;
fim;
fim.

A aplicação do comando enquanto se dá em problemas onde o número de repetições
não é conhecido. O exemplo anterior tem apenas exemplo didático, pois existe outro
comando mais apropriado para este caso.

Exemplo 2: Ler uma seqüência de salários terminada por um salário menor que
zero. Para cada salário, mostrar o novo salário reajustado e, ao final, a média dos
salários reajustados. O valor do reajuste deve ser lido no início do algoritmo.
algoritmo mediasalarial;
início
   real  salario, reajuste, novo_sal, tot_reaj, media;
   inteiro  num_sal;
tot_reaj O 0;
num_sal O 0;
escreva (“Entre com o reajuste : “);
leia (reajuste);
escreva (“Entre com o salário ou salário negativo para parar: “);
leia (salario);
enquanto ( salario > 0) faça
início
novo_sal O salario + (salario * reajuste) / 100;
tot_reaj O tot_reaj + novo_sal;
num_sal O num_sal + 1;
escreva  (“Salário reajustado: “, novo_sal);
escreva (“Entre com o salário ou salário negativo para parar: “);
leia (salario);
fim;
se (num_sal > 0) então
início
     media O tot_reaj / num_sal;
escreva (“Média dos salários = “, media);
fim;
senão
     escreva (“Não existem dados a serem processados”);
fim.

Programação de Computadores I Prof. Erlon Pinheiro
56/77
Exemplo 3: Ler uma seqüência de vogais terminada por ponto e exibir os totais de
vogais e não vogais encontradas.
Resolução:
algoritmo conta_vogal;
início
       const caractere fim = ´.´;

       caractere car;
   inteiro cont_a, cont_e, cont_i, cont_o, cont_u, outros;

cont_a O 0;   cont_e O 0;   cont_i O 0;
cont_o O 0;   cont_u O 0;  outros O 0;
escreva (“Entre com o primeiro caractere ou   .    para parar: “);
leia (car);
enquanto ( car != fim) faça
início
escolha (car)
inicio
caso ‘a’: caso ‘A’ : cont_a O cont_a + 1; pare;
caso ‘e’: caso ‘E’ : cont_e O cont_e + 1; pare;
caso ‘i’ : caso ‘I’  : cont_i O cont_i   + 1; pare;
caso ‘o’: caso ‘O’ : cont_o O cont_o + 1; pare;
caso ‘u’: caso ‘U’ : cont_u O cont_u  + 1; pare;
caso contrário: outros O outros +1;
fim;
escreva (“Entre com o próximo caractere ou   .    para parar:  “);
leia (car);
fim;
escreva  (“O total de a’s é: “, cont_a);
escreva  (“O total de e’s é: “, cont_e);
escreva  (“O total de i’s é: “, cont_i);
escreva  (“O total de o’s é: “, cont_o);
escreva  (“O total de u’s é: “, cont_u);
escreva  (“O total de outros é: “, outros);
      fim.

Programação de Computadores I Prof. Erlon Pinheiro
57/77
2. Repetição com teste no final

Para realizar uma repetição com teste no final, utilizamos a estrutura faça enquanto,
que permite que o bloco ou ação primitiva seja repetido enquanto uma determinada
condição seja verdadeira. O modelo genérico desse tipo de repetição é o seguinte:

faça
início
<comando1>;
<comando2>;
...
<comandon>;
fim;
enquanto(<Condição>);

Este comando, assim como o comando ENQUANTO, é usado quando não é conhecido
o número de vezes que uma seqüência de comandos deverá ser executada. Porém a
seqüência será executada pelo menos uma vez, visto que a avaliação da condição
é feita ao final de cada interação.

A seqüência será executada repetidamente até que a condição seja falsa. Esta
condição deve ser uma expressão que retorne um valor lógico.

A condição deverá se tornar falsa em algum momento, caso contrário a seqüência
será executada indefinidamente (Loop infinito).

Exemplo 4: Mostrar os números inteiros de 1 a 10.
algoritmo numeros;
início
     const inteiro maior = 10;
     inteiro i;
     i O 1;
     escreva(“ Os números inteiros de 1 a 10:”);
     faça
     inicio
          escreva (i ,”  “);
          i O i + 1;
     fim;
     enquanto (i <= maior);
fim.

A aplicação do comando faça enquanto se dá em problemas onde o número de
repetições não é conhecido, mas se deseja que a seqüência de comandos seja
executada pelo menos uma vez. O exemplo anterior tem apenas exemplo didático,
pois existe um outro comando mais apropriado para este caso.

Programação de Computadores I Prof. Erlon Pinheiro
58/77
Exemplo 5: Mostrar os números inteiros de 1 a 10, sendo que para cada número
mostrado o algoritmo deve aguardar que sejam pressionadas a tecla C e ENTER para
continuar.

algoritmo numeros;
início
const inteiro maior = 10;
inteiro i ;
caractere tecla ;
i O 1;
escreva(“ Os números inteiros de 1 a 10:”);
faça
inicio
escreva  (i);
i O i+ 1;
faça
inicio
escreva (“tecle [C] para continuar…”);
leia (tecla);
                   fim;
enquanto ((tecla != ‘c’ ) e (tecla != ‘C’));
          fim;
enquanto (i <= maior);
fim.

3. Repetição com variável de controle

Nas estruturas de repetição vistas até agora, ocorrem casos em que se torna difícil
determinar o número de vezes em que o bloco de comandos será executado.
Sabemos que ele será executado enquanto uma condição for satisfeita. A estrutura
para é diferente, já que sempre repete a execução do bloco de comandos um número
determinado de vezes, pois ela não prevê uma condição e possui limites fixos.
Modelo genérico:
para (< inicialização da var> ;  <condição de repetição> ;  <incremento da var>)
início
<comando1>;
<comando2>;
...
<comandon>;
fim;
O comando para é utilizado quando se deseja executar uma seqüência de comando
repetidamente, um número conhecido e fixo de vezes.

O número de vezes é controlado pela variável de controle <var>. Na primeira parte <
inicialização da var> inicializa a variável de controle quando o comando é executado
pela primeira vez. A segunda parte <condição de repetição> testa se a repetição deve

Programação de Computadores I Prof. Erlon Pinheiro
59/77
continuar e a terceira parte incrementa a variável de controle <var> (que
geralmente é de uma unidade).

Nos exemplos abaixo a seqüência será executada 10 vezes.

Exemplo 5: Mostrar os números inteiros de 1 a 10 e de 10 a 1.
algoritmo numeros;
início
     const inteiro maior = 10;
     inteiro i;
     escreva(“ Os números inteiros de 1 a 10:”);
     para( i O 1 ; i<= maior ; i O i + 1)
     início
escreva  (i, “   “);
fim;
     escreva(“ Os números inteiros de 10 a 1:”);
para (i O 10 ;  i>= 1 ; i O i -1)
início
     escreva  (i , “   “);
//neste caso, o início/fim são dispensáveis (Apenas um comando)
fim;
fim.

O incremento/decremento da variável de controle é na maioria das vezes igual a 1
ou -1.

Geralmente o tipo da variável de controle é inteiro.

O que aconteceria se maior  = 0 ?

Exercícios de Complementares: Comando Enquanto
01. Escreva um algoritmo que receba a idade de um grupo de pessoas, calcule e imprima
a quantidade de pessoas maiores de idade (idade >= 18 anos). Para encerrar a entrada de
dados, deve ser digitado um valor < 0.
Resolução:
algoritmo   conta_maior_idade;
inicio
inteiro  idade, cont O 0;

escreva(“Digite a primeira idade ou idade < 0 para parar: “);
leia(idade);

enquanto ( idade >= 0 ) faça
inicio
se ( idade >= 18 ) então
cont O cont + 1;

Programação de Computadores I Prof. Erlon Pinheiro
60/77

escreva(“Digite a proxima idade ou idade < 0 para parar: “);
leia(idade);
fim;

se ( cont > 0 ) então
escreva ( “ Total que atingiu a maioridade: “, cont);
senão
escreva(“ Ninguém atingiu a maioridade!”);
fim.

02. Escreva um algoritmo que receba a idade de um grupo de pessoas, calcule e imprima
a porcentagem de cada faixa etária em relação ao total de pessoas.

As faixas etárias são:
01 - 15 anos - A
16 - 30 anos - B
31 - 45 anos - C
46 - 60 anos - D
>= 61 anos   - E

Para encerrar a entrada de dados, digite uma idade <= 0.

03. Escreva um algoritmo que receba um conjunto de valores inteiros e positivos,calcule
e imprima o maior e o menor valor do conjunto.
• Para encerrar a entrada de dados, deve ser digitado o valor zero.
• Para valores negativos, deve ser enviada uma mensagem.
• Esses valores (zero e negativo) não entrarão nos cálculos.

04. Faça um algoritmo que apresente um menu de opções (apresentado abaixo) para o
cálculo das operações entre dois números reais lidos previamente:
Programa Calculadora
   [1] – adição
[2] – subtração
[3] – multiplicacao
[4] – divisão
[5] – sair do programa

Programação de Computadores I Prof. Erlon Pinheiro
61/77
Escolha uma opcao:
Possibilitar ao usuário escolher a operação desejada, mostrar o resultado e voltar ao
menu de opções. O programa só deve permitir a saída se o usuário teclar 5.

05. Faça um algoritmo receba o valor e o código de várias mercadorias vendidas em um
determinado dia. Os códigos obedecem a tabela abaixo:

“L” ou “l” - limpeza
“A” ou “a” - alimentação
“H” ou “h” - higiene

Calcule e imprima:
• total vendido naquele dia, com todos os códigos juntos;
• total vendido naquele dia em cada um dos códigos.
Para encerrar a entrada de dados, digite o valor da mercadoria zero.

Exercícios Complementares: Comando faça/enquanto:
01. Faça um algoritmo que receba como entrada, uma lista de números positivos ou
negativos finalizada com o número zero e forneça, como saída, a soma dos
números positivos, a soma dos números negativos e a soma das duas parciais.
Resolução:
algoritmo  soma_numeros;
inicio
inteiro  num,  soma_pos O 0,  soma_neg O 0, soma_total;
//Entrada e processamento de dados
faça
inicio
    escreva(“Digite um numero inteiro ou 0 para parar: “);
    leia(num);
   se ( num != 0 ) entao
   inicio
se ( num > 0 ) entao
      soma_ pos O soma_pos + num;
senao
       soma_neg O soma_neg + num;
   fim; // fim se/entao
fim;  // fim do bloco faça/enquanto
enquanto ( num != 0 );
soma_total O soma_pos + soma_neg;
//Saída de dados
escreva(“Soma dos positivos: “, soma_pos);
escreva(“Soma dos negativos: “, soma_neg);
escreva(“Soma Total: “, soma_total);
fim.

Programação de Computadores I Prof. Erlon Pinheiro
62/77

02. Faça um algoritmo que receba a idade e a altura de várias pessoas, calcule e imprima
a média das alturas das pessoas com mais de 50 anos. Para encerrar a entrada de dados,
digite idade <= zero.

03. Construa um algoritmo que leia um conjunto de valores inteiros e positivos, e
determine qual o menor e o maior valor do conjunto. Para valor final de entrada
considerar o valor -1 que não deve ser considerado.

Exercícios Complementares: Comando para:
01. Escreva um algoritmo para calcular N! (fatorial de N),  sendo que o valor inteiro de
N é fornecido pelo usuário.

Sabe-se que: N! = 1 * 2 * 3 * ... * (N-1) * N;
                     0! = 1
Resolução:
algoritmo     calcula_fatorial;
inicio
    inteiro  num,  fat O 1,  i;

    //Entrada de Dados com tratamento de erro
    faça
    inicio
escreva(“Digite um numero inteiro >=0: “);
leia(num);
se ( num < 0 ) então
       escreva(“Numero Invalido!”);
    fim;
    enquanto( num < 0 );
    //Processamento de dados
    para( i O 2;  i < = num;  i O i + 1 )
fat O fat  *  i ;
   //Saída de dados
   escreva ( num, “ ! =  “, fat);
fim.

Programação de Computadores I Prof. Erlon Pinheiro
63/77
02. A conversão de graus Farenheit para Centígrados é obtida por C = (5/9.0) * (F - 32).
Faça um algoritmo que calcule e escreva  uma tabela de graus Centígrados e os graus
Farenheit, que  variam de 50 a 65 de 1 em 1.

03. Faça um algoritmo que receba a idade e o estado civil :  C - casado, S - solteiro, V -
viúvo e D - desquitado, de 10 pessoas. Calcule e imprima:

v a quantidade de pessoas casadas;
v a média das idades das pessoas viúvas.

Lembre-se do exercício 11 de algoritmos em Portugol:

11 - Faça um algoritmo que receba um número inteiro, calcule e imprima a
tabuada desse número.
Resolução:

algoritmo   tabuada;
inicio
inteiro i, num;
//Entrada de dados
escreva(“Digite um numero para a tabuada: “);
leia(num);
//Processamento e saída de dados
escreva(“A tabuada de multiplicação do numero “, num, “ : “);
para ( i O 1; i <= 10; i O i + 1 )
escreva(num , “ * ”,   i, “ = “,i * num);
fim.

Rastreamento

Memória Tela
    i: 1, 2, 3, 4, 5, 6, 7,
8, 9, 10, 11
num:  2

Digite um numero para a tabuada: 2  <Enter>
2 *   1 = 2
2 *   2 = 4
2 *   3 = 6
2 *   4 = 8
2 *   5 = 10
2 *   6 = 12
2 *   7 = 14
2 *   8 = 16

Programação de Computadores I Prof. Erlon Pinheiro
64/77
2 *   9 = 18
2 * 10 = 20

Exercícios de Fixação VI
1. Faça um algoritmo que imprima todos os números inteiros no intervalo [0, 100].

2. Faça um algoritmo que leia uma seqüência de N números positivos e calcule e
imprima a média aritmética entre eles. A leitura é encerrada quando um número
negativo ou nulo for digitado.

3. Faça um algoritmo que leia o peso, em quilogramas, de N bois e calcule e imprima:
• o peso médio do rebanho;
• o peso do boi mais gordo; e
• o peso do boi mais magro.
      Encerre a leitura quando um peso nulo for digitado.

4. Faça um algoritmo que leia 50 dados contendo as medidas de diferentes retângulos
(base, altura), e emita um relatório contendo o perímetro e a área de cada
retângulo.

5. Escreva um algoritmo que encontre o maior e o segundo maior número de uma
série de números lidos do teclado.
Obs: - Use uma marca (um flag) para a saída do comando de repetição, uma vez que o número de
repetições não é conhecido.

6. Faça um algoritmo que leia uma seqüência de números inteiros positivos (um por
vez), e verifique se eles são pares ou impares.
Obs:  - Use uma marca (um flag) para a saída do comando de repetição, uma vez que o número
de repetições não é conhecido.

7. Seja  S = 2,  3,  5,  8,  13,  21,  34,  55,  ...  um exemplo de uma série de Fibonacci.
Perceba que o  padrão de comportamento desta série é tal que cada número a partir
do terceiro é a soma dos dois  anteriores. Escreva um algoritmo que gere uma série
de Fibonacci até o n-ésimo termo, onde n será um valor lido.
Dica: - leia os dois primeiros termos.
Resolução:
algoritmo  serie_fibonacci;
inicio

Programação de Computadores I Prof. Erlon Pinheiro
65/77
inteiro  n, t1O 2, t2 O 3, t3,  cont O 2;
//Entrada de dados com trat. de erro
faça
inicio
escreva(“Entre com o numero de termos ( >=3): “);
leia( n );
se ( n < 3 ) então
escreva(“Numero de termos invalido!”);
fim;
enquanto( n < 3 );
//Processamento e saída de dados
escreva(“Serie de Fibonacci:  “, t1, “     “,     t2);
enquanto(  cont < n )
inicio
t3
O  t1  +  t2;
escreva(  t3, “    “);
t1
O  t2;
t2
O t3;
cont
O cont + 1;
fim;
fim.

8. Dada a série: 2  3  4  9  16  29  54  99...   onde cada elemento a partir do quarto é a
soma dos três termos que lhe antecedem. Faça um algoritmo que leia apenas os três
termos iniciais, que podem ser quaisquer, e, a partir daí, obtenha e imprima mais 20
termos da referida série.

9. Faça um algoritmo que calcule e imprima o valor da soma:
S = 1
+ 3 + 5 + 7 +   ...   + 99
                  1    2    3     4               50

10. Faça um algoritmo para calcular o valor da equação abaixo. Onde o valor de n será
lido.
∑
=
=
n
k
kS
1
2
6

11. Faça um algoritmo que leia um conjunto de 30 matrículas dos vendedores de uma
firma comercial, juntamente com os respectivos totais de vendas diárias e verifique
quantos deles estão na faixa compreendida entre R$500.00 e R$1500.00. Imprima
uma listagem contendo todas as matrículas das pessoas situadas no intervalo
especificado, bem como o total delas.

12. Faça um algoritmo que leia uma seqüência de N (o valor de N é lido durante a
execução do algoritmo) conjuntos de dados, cada conjunto contendo a conta do
correntista de uma caderneta de poupança e seu respectivo saldo médio. Imprima:

Programação de Computadores I Prof. Erlon Pinheiro
66/77
a) o total de clientes bons, clientes que possuem o saldo médio entre 500 e 1000
reais;
b) o total de clientes razoáveis, clientes que possuem o saldo médio menor 500 reais;
c) o número da conta com maior saldo médio.

13. Faça um algoritmo que leia 80 números reais, imprima o menor e o número de vezes
que ele aparece.
Resolução:
algoritmo   acha_e_conta_menor;
inicio
real  num, menor;
inteiro vezes , i;

escreva(“Digite o primeiro numero real: “);
leia( num );
menor
O num;
vezes
O 1;

para ( i
O2; i<= 80; i O i+1)
inicio
   escreva(“Digite o “, i,”o numero real: “);
   leia( num );
        se ( num < menor)
   inicio
       menor
O num;
       vezes
O 1;
   fim
   senão
      se ( num == menor )
vezes
O vezes + 1;
fim
escreva(“O menor numero foi “, menor, “ e apareceu “, vezes, “ vezes“);
fim

14. O sistema de avaliação de uma determinada disciplina obedece aos seguintes
critérios :
• durante o ano letivo são dadas três notas.
• a nota final é obtida pela média aritmética das notas dadas durante o curso.
• é considerado aprovado o aluno que obtiver a nota final superior ou igual a 7.0
e que tiver comparecido a um mínimo de 40 aulas.
Faça um algoritmo que:
a) Leia um conjunto de dados contendo a matricula, as três notas e a freqüência
de 100 alunos.
b) Imprima:

Programação de Computadores I Prof. Erlon Pinheiro
67/77
• para cada aluno, o número de matricula, a freqüência, a nota final e uma
mensagem informando se este esta aprovado ou reprovado;
• a maior e a menor nota da turma;
• a nota média da turma; e
• o total de alunos reprovados.

15. Faça um algoritmo que leia uma seqüência de dados contendo a matrícula e a
medida da altura dos funcionários de uma empresa e imprima:
• altura média dos funcionários;
• o total de funcionários baixos (altura inferior a 1.55 m); e
• o total de funcionários de altura mediana (1.55m <= Altura <= 1.75m).
Obs: - utilize uma marca (um flag) para indicar o final da entrada de dados.

16. Um serviço de correspondência sentimental mantém um fichário de seus clientes.
Cada ficha contém as seguintes informações: Matrícula, Sexo (M, m, F ou f), Idade,
Altura (em m), Peso (em quilogramas), Cor dos olhos (1-azul, 2-castanhos, 3-
outros), Cor dos cabelos (1- ruivos, 2- loiros, 3- outros).
Prepare um algoritmo que leia este fichário e imprima as matrículas de:
• Todos os homens loiros de olhos castanhos, altura maior que 1.75 m, pesando
entre 75Kg e 95 Kg.
• Todas as mulheres ruivas de olhos azuis, altura entre 1.65 m e 1.75 m, pesando
menos de 60 Kg.
Obs: - utilize uma marca (um flag) para indicar o final da entrada de dados.
Resolução:
//Usarei a digitação de uma matricula negativa ou nula como flag de parada

Algoritmo             correio_sentimental;
inicio
inteiro  matricula, idade, cor_olhos, cor_cab;
real  altura, peso;
caractere sexo;

faca
inicio
escreva(“Digite a matricula ou matricula <= 0 para parar: “);
leia(matricula);
se ( matricula > 0 )
inicio
  escreva(“Sexo (m ou f):  “);
  leia(sexo);
  escreva(“Idade:  “);
  leia(idade);
  escreva(“Altura e peso:  “);
  leia(altura,peso);
  escreva(“Cor dos olhos:  “);
  escreva(“1. Azul ou 2. Castanho ou 3. Outros “);

Programação de Computadores I Prof. Erlon Pinheiro
68/77
  leia(cor_olhos);
  escreva(“Cor dos cabelos:  “);
  escreva(“1. Ruivos ou 2. Loiros ou 3. Outros “);
  leia(cor_cab);
  se ( (sexo == ‘F’) ||(sexo==’f’))
       se ( cor_cab == 1 )
se (cor_olhos == 1 )
    se ( (altura>=1.65) && ( altura<=1.75))
         se ( peso < 60)
    escreva(“A matricula e “, matricula);

  se ( (sexo == ‘M’) ||(sexo==’m’))
       se ( cor_cab == 2 )
se (cor_olhos == 2 )
    se ( altura>1.75)
         se ( (peso >= 75) && ( peso <=95))
    escreva(“A matricula e “, matricula);
fim//se matricula
fim
enquanto(matricula>0);
fim

17. Faça um algoritmo à ser fornecido ao Detran para provimento das informações
abaixo descritas, referentes a acidentes em estradas:
• percentagem de motoristas não-habilitados;
• percentagem de homens no volante; e
• percentagem de motoristas inexperientes (menos de 20 anos).
   Os dados de entrada contém o ano de nascimento, o sexo e o código de habilitação dos
motoristas, sendo: Código de Habilitação = 1 - motorista habilitado e Código de
Habilitação = 2   - motorista não-habilitado.
Obs: - utilize uma marca (um flag) para indicar o final da entrada de dados.

18. Faça um algoritmo que teste a validade de uma senha digitada no teclado. A
digitação deve ser refeita até que a senha correta seja digitada ou o número de
tentativas seja maior que 5. A senha correta é o número 12345.

Programação de Computadores I Prof. Erlon Pinheiro
69/77
19. Faça um algoritmo que tendo lido uma vogal minúscula imprima sua
correspondente maiúscula. Repita a leitura quantas vezes for necessário até que
uma vogal maiúscula seja digitada como entrada.

20. Faça um algoritmo que leia um número inteiro no intervalo [1, 12] e imprima o
nome do mês correspondente. Garanta que somente números no intervalo [1, 12]
serão aceitos.

21. Faça um algoritmo que imprima a soma de todos os inteiros no intervalo [5, 30].

22. Faça um algoritmo que leia N notas, N é lido, calcule e imprima a média aritmética
entre elas.

23. Faça um algoritmo que leia 50 números e imprima o menor e o maior.

24. Dada a série 2  3  4  9  16  29  54 .... Faça um algoritmo que leia os três primeiros
termos e em seguida imprima os próximos 20 termos.

25. Faça um algoritmo que leia o preço e o código de 20 mercadorias presentes em uma
cesta  básica. Os códigos obedecem à tabela abaixo:
‘l’  ou  ‘L’ : limpeza
‘a’ ou  ‘A’ : alimentação
‘h’ ou  ‘H’ : higiene
Calcule e imprima:
- o preço total da cesta básica; e
- para cada código, o preço total das mercadorias presentes na cesta.

26. De posse de um conjunto de dados contendo a altura e o sexo (F, f, m ou M) de 15
pessoas. Faça um algoritmo que calcule e imprima:
• a maior e a menor altura do grupo;
• a altura média das mulheres; e
• o número de homens.

27. A conversão de graus Farenheit para Celsius é obtida por C = 5/9*(F-32). Faça um
algoritmo que calcule e escreva uma tabela de equivalência entre graus Celsius e
graus Farenheit, com os valores variando de 1 em 1 de 50 a 65 graus Farenheit.

28. Uma empresa decidiu fazer um levantamento dos seus 500 funcionários. Faça um
algoritmo que leia para cada funcionário a idade, o sexo (F, f, m ou M), experiência
de mais de 3 anos no serviço (S, s, n ou N). Calcule e escreva:
• o número de funcionários do sexo feminino;
• o número de funcionários do sexo masculino;
• a idade média dos homens com mais de 3 anos de experiência no serviço;
• a porcentagem dos homens com mais de 45 anos entre o total de homens;
• o número de mulheres com  idade inferior a 35 anos com mais de 3 anos de
experiência; e

Programação de Computadores I Prof. Erlon Pinheiro
70/77
• a menor idade entre as mulheres com experiência no serviço.

29. Faça um algoritmo que imprima as tabuadas de multiplicação dos números de 1 a
10.

30. Faça um algoritmo que receba 2 notas de 10 alunos. Calcule para cada aluno sua
média e imprima uma mensagem de acordo com a tabela abaixo:
Média   Mensagem
Abaixo de  3 Aluno Reprovado
Entre 3 e   7 Aluno de Recuperação
Maior ou igual a 7 Aluno Aprovado

Programação de Computadores I Prof. Erlon Pinheiro
71/77
UNIDADE VI – Estrutura de Dados Composta Homogênea e Unidimensional

O que vamos ver:

• Vetores
• Tipos Estruturados
• Variáveis Compostas Homogêneas
• Variáveis Compostas Unidimensionais – VETORES

1. Vetores
Retornando ao conceito de informações e tipos de informação, podemos notar que foi
feita uma divisão imaginária, a fim de tornar mais simples a classificação das
informações. Talvez alguns já tenham notado que a quantidade de tipos de dados
primitivos não é suficiente para representar toda e qualquer informação que possa
surgir. Portanto, em muitas situações, esses recursos são escassos, o que poderia ser
suprido se existissem mais tipos de dados ou, ainda melhor, se esses tipos pudessem ser
“construídos”, criados, à medida que se fizessem necessários.

2. Tipos Estruturados
São organizações de dados construídas a partir da composição dos tipos primitivos já
existentes (caractere, inteiro, real). Esses novos tipos podem armazenar um conjunto
de dados conhecidos como variáveis compostas. As variáveis que armazenam esses
tipos de dados podem ser classificadas em: variáveis compostas homogêneas e variáveis
compostas heterogêneas.

3. Variáveis Compostas Homogêneas

São variáveis que armazenam vários elementos do mesmo tipo primitivo.

Exemplo: alcatéia (vários lobos), conjunto de números inteiros, e outros.

As variáveis compostas são estruturas de dados (armazenam um conjunto de dados).
Esses dados podem ser armazenados em dois tipos de variáveis: as variáveis
unidimensionais (conhecidas como vetores) e as variáveis multidimensionais
(conhecidas como matriz).

4. Variáveis Compostas Unidimensionais - VETORES

Programação de Computadores I Prof. Erlon Pinheiro
72/77
São variáveis que necessitam de apenas um índice para individualizar um elemento do
conjunto.

Exemplo:
real media[40];
ou usando uma constante:

const inteiro TAM=40; // const int TAM = 40;

real media[TAM];     //    float  media[TAM];

Estrutura que se forma:

media:
0 1 2 3 4 5 6 ... ... 39
8.0 7.0 5.5 9.5 6.4 9.9 1.0 4.8

Para acessar cada elemento da variável composta unidimensional (vetor) é necessário
especificar o nome da variável seguido do número do elemento que se deseja acessar
(deverá estar entre colchetes). Este número tem o nome de índice. O índice pode varia
de 0 até n-1 (onde n é o número que representa a quantidade de variáveis simples do
vetor).
Exemplos de utilização de um vetor:
leia (media[1]);    // scanf(“%f”, &media[1]);
media [2] O 8.5;   // media[2] = 8.5;
escreva(media[3]);// printf(“%.2f\n”,       media[3]);
.......
Exemplo 1: Dados 5 valores numéricos reais elaborar um algoritmo que calcule e exiba a
média dos valores dados e quantos desses valores estão acima da média.

a) Resolução sem utilizar vetor:

algoritmo media_turma;
início
    inteiro  cont ;
    real  n1, n2, n3, n4, n5, media;
    contO 0;
    escreva(“ Digite o 1º número: “);
    leia (n1);
    escreva(“ Digite o 2º número: “);
    leia (n2);
    escreva(“ Digite o 3º número: “);
    leia (n3);
    escreva(“ Digite o 4º número: “);
    leia (n4);

Programação de Computadores I Prof. Erlon Pinheiro
73/77
    escreva(“ Digite o 5º número: “);
    leia (n5);
    media O (n1+n2+n3+n4+n5)/5;
    escreva(“A média dos números é “, media);
    se (n1>media) então
cont
← cont + 1;
    se (n2>media) então
cont
← cont + 1;
    se (n3>media) então
cont
← cont + 1;
    se (n4>media) então
cont
← cont + 1;
    se (n5>media) então
cont
← cont + 1;
    escreva(“Quantidade de números acima da média é “, cont);
fim;

b) Resolução utilizando variável composta:

algoritmo media_de_numeros;
início
const inteiro qn = 5; // Quantidade de números
real media, numeros[qn], soma;
inteiro i, cont;
cont
← 0;  soma ←0; // Inicialização das variáveis contadora e
// acumuladora

       para (iO0; i < qn ; i O i+1)
início
escreva(“Digite o “,i+1,”º número: “);
leia(numeros[i]);
       fim;

       para (iO0; i < qn ; i O i+1)
soma
← soma + numeros[i];

       media
← soma/qn;
       escreva(“ A média dos números é:  “, media);

       para (iO0; i < qn ; i O i+1)
inicio
               se (numeros[i]>media) então
cont
← cont +1;
fim;
        escreva(“ Quantidade de números acima da média: “, cont);

Programação de Computadores I Prof. Erlon Pinheiro
74/77
fim.

Exemplo 2 – Elabore um algoritmo que leia, some e imprima o resultado da soma entre
dois vetores inteiros de 50 posições.
Resolução:
algoritmo soma_dois_vetores;
início
const inteiro TAM = 50; // Tamanho do vetor
inteiro vet_a[TAM], vet_b[TAM], vet_r[TAM]; // Declaração dos vetores;
           inteiro i; // Declaração da var. inteira a ser utilizada para índice
// Entrada de dados para os dois vetores:
para (i O0; i<TAM; iO i+1)
inicio
escreva(“Digite o “, i+1 ,”º número do vetor a: “);
      leia(vet_a[i]);
escreva(“Digite o “, i+1 ,”º número do vetor b: “);
leia(vet_b[i]);
     fim;

// Processamento de dados
para (i O0; i<TAM; iO i+1)
       vet_r[i] O vet_a[i] + vet_b[i];

// Saída de dados
escreva (“ Vetor soma: “);
para (i O0; i<TAM; iO i+1)
       escreva(vet_r[i], “   “);
fim.

Exercícios Propostos:
1) Dado um vetor contendo 10 elementos numéricos elabore um algoritmo que
verifique se outro valor dado pertence ou não ao vetor, se pertencer exibir quantas
vezes ele aparece no vetor. Caso contrário, mostrar uma mensagem informando que o
número não está no vetor.

2) Considere um vetor de tamanho máximo 100 de números reais. Solicite ao
usuário qual o limite superior válido que ele deseja e em seguida desenvolva um
algoritmo que leia o vetor até o limite superior escolhido e determine qual é o menor
valor existente no vetor. O algoritmo deve ainda subtrair de todos os elementos este
valor. Exibir o vetor resultado.

3) Faça um algoritmo que receba as notas da primeira prova de 10 alunos e
armazene essas notas em um vetor. Receba as notas da Segunda prova de 10 alunos e
armazene essas notas em outro vetor. Calcule e imprima a média entre essas duas notas
de cada aluno.

Programação de Computadores I Prof. Erlon Pinheiro
75/77
4) Faça um algoritmo que receba as médias de 10 alunos e armazene essas média
em um vetor. Calcule e imprima:
- a média da classe;
- a quantidade de alunos aprovados, isto é, com média >= 7;
- a quantidade de alunos reprovados, isto é, com média < 7.

5) Faça um algoritmo que receba a temperatura média de cada mês do ano e
armazene essas temperaturas em um vetor; calcule e imprima a maior e a menor
temperatura do ano e em que mês estas temperaturas aconteceram.

Exercícios de Fixação VII

1. Faça um algoritmo que leia um vetor de 40 valores inteiros. Imprima os índices onde
o número 23 aparece.

2. Faça um algoritmo que leia dois vetores A e B de 30 componentes. Gere o vetor C, do
mesmo tipo de A e B, onde cada elemento de C é a subtração do elemento
correspondente de A com B.

3. Faça um algoritmo que tendo lido 2 vetores, A e B, de 20 e 30 elementos,
respectivamente, construa um vetor C composto pela junção dos vetores A e B.
Por exemplo:

const inteiro tam1 = 20, tam2 = 30;
inteiro vet_a[tam1], vet_b[tam2], vet_j[tam1+tam2];

Exemplo:

Vet_a:

0 1
8 7

Vet_b:

0 1 2
17 13 55

Vet_j:

0 1 2 3 4
8 7 17 13 55

Programação de Computadores I Prof. Erlon Pinheiro
76/77

4. Faça um algoritmo que leia um vetor A de 100 componentes. Construa um vetor B, do
mesmo tipo do vetor A, observando a seguinte lei de formação: se o índice do
componente em B é par este deve receber o componente correspondente em A
multiplicado por 2; se o índice em B é impar este recebe o componente correspondente
em A.
Exemplo:
Vet_a:
0 1 2 3 4 5 6 ... ... 99
8 7 5 9 6 9 1 4

Vet_b:
0 1 2 3 4 5 6 ... ... 99
16 7 10 9 12 9 2 4

5. Faça um algoritmo que leia a nota dos 60 alunos da disciplina de programação e
imprima:
• A nota média da turma
• A menor e a maior nota da turma
• O total de alunos cuja nota é inferior a nota média da turma

6. Faça um algoritmo que leia 50 notas e 50 matrículas dos alunos de Programação.
Informe os números de matrícula dos alunos cuja nota é inferior à nota média da
turma.

7. Um armazém trabalha com 100 mercadorias diferentes identificadas pelos números
inteiros de 1 a 100. O dono do armazém utiliza uma tabela para guardar o preço de cada
mercadoria. A tabela tem o formato mostrado abaixo:
1
2 3 4 5 ... 100
5 20 10 8 54 ... 4.5
onde, a posição 1 armazena o preço da mercadoria identificada pelo número 1, e
assim por diante.
Faça um algoritmo que tendo lido uma tabela com o formato acima imprima o
número das mercadorias cujo preço é maior que 5 reais.

8. Faça um algoritmo que tendo lido um vetor VET de 10 números inteiros positivos,
crie um novo vetor VETPAR com os elementos pares do vetor VET. Antes de preencher
o vetor VETPAR com os números pares de VET faça com que todos os componentes de
VETPAR recebam o valor zero.

Exemplo:
0 1 2 3 4 5 6 7 8 9
Vetor VET = 2 9 7 5 10 4 3 1 6 21

Programação de Computadores I Prof. Erlon Pinheiro
77/77
0 1 2 3 4 5 6 7 8 9
Vetor VETPAR = 2 10 4 6 0 0 0 0 0 0

9. Faça um algoritmo que leia dois vetores de 10 elementos do tipo real. Intercale os
elementos destes dois vetores criando um novo vetor de 20 elementos.

Exemplo:
Vetor1
1 2 3 4 5 6 7 8 9 10
2 9 7 5.5 10 4 3 -1 6 21
Vetor2
1 2 3 4 5 6 7 8 9 10
32 -4 12 6 90 -4 5 43 27 82
Vetor criado a partir dos anteriores
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
2 32 9 -4 7 12 5 6 10 90 4 -4 3 5 -1 43 6 27 21 82

10. Faça um algoritmo que leia a nota dos alunos da turma de Programação. Calcule a
média da turma e imprima as notas maiores ou iguais a média. Considere que a turma
possua no máximo 60 alunos e que existe a possibilidade de não estar completa.

11. Faça um algoritmo que leia 2 vetores, A e B, de 30 elementos e informe o número de
vezes que os elementos de A aparecem em B.

12. Uma empresa comercializa uma peça especial para a fábrica da Ferrari. O preço da
peça é determinado mensalmente de acordo com uma tabela anual (vetor). Faça um
programa C que receba a quantidade de peças vendidas por MÊS e armazene essas
quantidades em um vetor. Receba também o preço que a peça foi comercializada e
armazene esses preços em outro vetor. Em seguida o programa deve: (a) Calcular e
mostrar o total de peças vendidas e (b) calcular e mostrar o faturamento bruto total da
empresa em um ano (quantidade * preço).

Algoritmos em portugol

About This Presentation

Slide Content

Tags

Categories

Download

Quick Actions

Statistics

Related Slideshows

Algoritmos em portugol

About This Presentation

Slide Content

Slide 1

Slide 2

Slide 3

Slide 4

Slide 5

Slide 6

Slide 7

Slide 8

Slide 9

Slide 10

Slide 11

Slide 12

Slide 13

Slide 14

Slide 15

Slide 16

Slide 17

Slide 18

Slide 19

Slide 20

Slide 21

Slide 22

Slide 23

Slide 24

Slide 25

Slide 26

Slide 27

Slide 28

Slide 29

Slide 30

Slide 31

Slide 32

Slide 33

Slide 34

Slide 35

Slide 36

Slide 37

Slide 38

Slide 39

Slide 40

Slide 41

Slide 42

Slide 43

Slide 44

Slide 45

Slide 46

Slide 47

Slide 48

Slide 49

Slide 50

Slide 51

Slide 52

Slide 53

Slide 54

Slide 55

Slide 56

Slide 57

Slide 58

Slide 59

Slide 60

Slide 61

Slide 62

Slide 63

Slide 64

Slide 65

Slide 66

Slide 67

Slide 68

Slide 69

Slide 70

Slide 71

Slide 72

Slide 73

Slide 74

Slide 75

Slide 76

Slide 77