Você está na página 1de 38

ALGORITMOS

Autor: Evandro Luís Viapiana


Adaptado por: Isac Zilli Rodrigues
Sumário
1 INTRODUÇÃO ................................................................................................................................... 4
1.1 Lógica ......................................................................................................................................... 4
1.2 Algoritmo .................................................................................................................................... 4
2 FORMA DE REPRESENTAÇÃO ...................................................................................................... 6
2.1 Português estruturado.................................................................................................................. 7
3 TIPOS DE DADOS ............................................................................................................................. 8
3.1 Dados .......................................................................................................................................... 8
3.2 Instruções .................................................................................................................................. 11
3.2.1 Exercícios Resolvidos........................................................................................................... 12
3.2.2 Exercícios ............................................................................................................................. 15
4 ESTRUTURAS DE CONTROLE ..................................................................................................... 16
4.1 Desvio Condicional Simples ..................................................................................................... 16
4.2 Desvio Condicional Composto ................................................................................................. 17
4.2.1 Exercícios ............................................................................................................................. 17
4.3 Desvio Condicional Encadeado ................................................................................................ 18
4.3.1 Exercícios ............................................................................................................................. 19
4.4 Operadores Lógicos .................................................................................................................. 19
4.4.1 .e. .......................................................................................................................................... 19
4.4.2 .ou. ........................................................................................................................................ 20
4.4.3 .não. ...................................................................................................................................... 20
4.5 Exercícios.................................................................................................................................. 21
5 LAÇOS DE REPETIÇÃO ................................................................................................................. 22
5.1 para ........................................................................................................................................... 22
5.1.1 Exercícios ............................................................................................................................. 24
5.2 enquanto .................................................................................................................................... 24
5.2.1 Exercícios ............................................................................................................................. 26
5.3 repita ......................................................................................................................................... 26
6 MODIFICADORES .......................................................................................................................... 27
6.1 Continue .................................................................................................................................... 27
6.2 Break ......................................................................................................................................... 27
6.3 Contadores ................................................................................................................................ 28
6.4 Multiplicadores ......................................................................................................................... 29
6.5 Sinalizadores ............................................................................................................................. 29
6.6 Maior......................................................................................................................................... 30
6.7 Menor ........................................................................................................................................ 30
6.8 Exercícios.................................................................................................................................. 30

2
7 SUB-ROTINAS ................................................................................................................................. 31
7.1 Procedimentos ........................................................................................................................... 32
7.2 Função....................................................................................................................................... 32
7.3 Parâmetros ................................................................................................................................ 33
8 VETORES E MATRIZES ................................................................................................................. 35
8.1 Vetor ......................................................................................................................................... 35
8.1.1 Exercício ............................................................................................................................... 36
8.2 Matriz Bidirecional ................................................................................................................... 37
8.2.1 Exercícios ............................................................................................................................. 37

3
1 INTRODUÇÃO
1.1 Lógica
É a forma correta de organizar os pensamentos e demonstrar
o raciocínio de maneira correta.

A utilização da lógica é a melhor forma de solucionar


problemas e atingir objetivos.

Sempre que se quer pensar, falar ou escrever corretamente,


deve-se colocar os pensamentos em ordem.

A lógica é muito importante em nossa vida, no dia-a-dia.


Veja os exemplos:

- A gaveta está fechada


- A bala está na gaveta
- Preciso primeiro abrir a gaveta para depois pegar a
bala

- Moramos em três pessoas


- Nenhum de nós dois quebrou o vaso da sala
- Quem quebrou o vaso?

1.2 Algoritmo
“Algoritmo : Conjunto de regras e operações bem definidas e
ordenadas, destinadas à solução de um problema, ou de uma
classe de problemas, em um número finito de etapas” -
Dicionário Aurélio

Para resolver um problema é necessária que seja primeiramente


encontrada uma maneira de descrever este problema de uma
forma clara e precisa.

É preciso encontrar uma sequência de passos que permitam que


o problema possa ser resolvido de maneira automática e
repetitiva.

4
Portanto, a resolução de um problema passa pela elaboração
da sequência de passos necessários para chegar-se até a
solução. Esta sequência de passos é chamada de algoritmo.

Um exemplo simples e prosaico de como um problema pode ser


resolvido caso seja fornecida uma sequência de passos que
mostrem a solução é uma receita para preparar um bolo.

Algoritmo não é a solução do problema, pois, se assim fosse,


cada problema teria um único algoritmo.

Algoritmo é um caminho para a solução de um problema, e, em


geral, os caminhos que levam à uma solução são muitos.

A solução é obtida por meio da execução do algoritmo, seja


mentalmente, ou manualmente usando lápis e papel ou por meio
de um computador.

Algoritmo é um conjunto finito de regras que fornece uma


sequência de operações para a resolução de um problema
específico.

É a lógica necessária para o desenvolvimento de um programa.

Um algoritmo opera sobre um conjunto de entradas (no caso do


bolo: farinha, ovos, fermento etc) de modo a gerar uma saída
que seja útil (ou agradável) para o usuário (o bolo pronto).

Um algoritmo tem cinco características importantes:

Finitude: um algoritmo deve sempre terminar após um número


finito de passos;
Definição: cada passo de um algoritmo deve ser precisamente
definido. As ações devem ser definidas rigorosamente e sem
ambiguidades;
Algoritmo
Entradas: um algoritmo deve ter zero ou mais entradas, isto
é, quantidades que são fornecidas antes do algoritmo iniciar;
Saídas: um algoritmo deve ter uma ou mais saídas, isto é,
quantidades que têm uma relação específica com as entradas;
Efetividade: um algoritmo deve ser efetivo. Isto significa
que todas as operações devem ser suficientemente básicas de
modo que possam ser, em princípio, executadas com precisão
em um tempo finito por um humano usando papel e lápis.

Ao longo dos anos surgiram muitas formas de representação


dos algoritmos, algumas utilizando linguagens semelhantes às
linguagens de programação, ou as próprias linguagens de

5
programação e outras utilizando formas gráficas de
representação dos algoritmos.

Dentre as formas de representação, nos últimos anos, deu-se


acentuada preferência por formas estruturadas, cuja
principal vantagem é a de facilitar a legibilidade e
compreensão dos algoritmos.

Todo ser humano sabe construir algoritmos. Se isso não fosse


verdade, ele não conseguiria sair de casa pela manhã, ir ao
trabalho, decidir qual o melhor caminho para chegar a um
lugar, voltar para casa etc.

Um fator importante é que pode haver mais de um algoritmo


para resolver um determinado problema.

Por exemplo, para ir de casa até o trabalho, pode-se escolher


diversos meios de transporte em função do preço, conforto,
rapidez etc.

A escolha será feita em função do critério que melhor se


adequar às necessidades.

O aprendizado de algoritmos só se consegue através de muitos


exercícios.

Algoritmos NÃO se aprende:


copiando algoritmos
estudando algoritmos

Algoritmos SÓ se aprende:
construindo algoritmos
testando algoritmos

2 FORMA DE
REPRESENTAÇÃO
Uma das dificuldades constatadas no aprendizado de
algoritmos é a passagem de uma língua natural, de expressão
completamente livre, para uma restrição de linguagem,
rigidamente formalizada, com sintaxe não familiar e, em
geral, um uma língua estrangeira.

6
Certamente, uma passagem por uma linguagem algorítmica,
embora mais restrita que a língua natural, mas com sintaxe1
conhecida e em português, representa uma transição mais
fácil.

2.1 Português estruturado


A forma geral da representação de um algoritmo na forma de
português estruturado (pseudocódigo) é a seguinte:

programa <nome_do_programa> //denominação do programa

const
// declaração de constantes se houverem

var
// declaração e classificação das variáveis

inicio // inicio do bloco principal


// iniciar as variáveis
// entrada de dados
// processamento
// saída de informações
fim // fim do bloco principal

Exemplo:

programa CALCULA_MEDIA
var
resultado : caractere
nota1, nota2, nota3, nota4 : real
soma, media : real
início

leia nota1, nota2, nota3, not4


soma = nota1 + nota2 + nota3 + nota4
media = soma / 4
se ( media >= 7 ) então
resultado = “aprovado”
senão
resultado = “reprovado”
fim-se
mostre ”nota 1 : “ , nota1

1
Segundo o Dicionário Aurélio, sintaxe é “Parte da gramática que
estuda a disposição das palavras na frase e a das frases no
discurso, bem como a relação lógica das frases entre si;
construção gramatical”. Podemos entender sintaxe em computação
como sendo a forma como os comandos devem ser escritos.

7
mostre ”nota 2 : “ , nota2
mostre ”nota 3 : “ , nota3
mostre ”nota 4 : “ , nota4
mostre ”soma : “ , media
mostre ”media : “ , resultado
fim

3 TIPOS DE DADOS
Tipos de Informações

Um computador nada mais é do que uma ferramenta utilizada


para solucionar problemas que envolvam a manipulação de
informações, sendo que essas informações classificam-se a
grosso modo em dois tipos básicos:

 DADOS
 INSTRUÇÕES

3.1 Dados
Os DADOS são representados pelas informações a serem tratadas
(processadas) por um computador.

Essas informações estão caracterizadas por três tipos de


dado:
 Dados numéricos (inteiros e reais)
 Dados caracteres
 Dados lógicos

Tipos Inteiros
São caracterizados como tipos inteiros os dados numéricos
positivos ou negativos, excluindo-se destes qualquer número
fracionário.

45
0
-56

Tipos Reais
São caracterizados como tipos reais os dados numéricos
positivos, negativos e números fracionários.

45
0

8
-56
1.2
-45.897

Tipos Caracteres
São caracterizados como tipos caracteres as sequencias
contendo letras, números e símbolos especiais.

Uma sequencia de caracteres deve ser indicada entre aspas (“


“).

Este tipo de dado é também conhecido como: alfanumérico,


string, literal ou cadeia

“PROGRAMACAO”
“Rua Alfa, 52 Ap. 1”
“Fone: 574-9988”
“04367-722”
“ “
“7”
“3.3”

Tipos Lógico
São caracterizados como tipos lógicos os dados com valores
VERDADEIRO e FALSO, sendo que este tipo de dado poderá
representar apenas um dos dois valores.

É chamado também de tipo booleano, devido à contribuição do


filósofo e matemático inglês George Boole
Para facilitar a citação de um dado tipo lógico, fica aqui
declarado eu estes deverão ser apresentados e delimitados
pelo caractere ponto (.)

.Falso.
.F.
.N.
.Verdadeiro.
.V.
.S.

Uso de Variáveis

Tem-se como definição de variável tudo aquilo que é sujeito


a variações, incerto, instável ou inconstante.
Todo dado a ser armazenado na memória de um computador deve
ser previamente identificado, ou seja, primeiro é necessário
saber qual o seu tipo para depois fazer o seu armazenamento
adequado.
Estando armazenado o dado desejado, ele poderá ser utilizado
e manipulado a qualquer momento.

9
O nome de uma variável é utilizado para a sua identificação
e posterior uso dentro de um programa.

 Nomes de uma variável poderão ser atribuídos com um ou


mais caracteres;
 O primeiro caractere do nome de uma variável não poderá
ser, em hipótese alguma, um número; sempre será uma
letra
 O nome de uma variável não poderá possuir espaços em
branco;
 Não poderá ser nome de uma variável uma palavra
reservada a uma instrução de programa;
 Não poderão ser utilizados outros caracteres a nãos ser
letras e números. Pode ser utilizado o _.

Válidos:

NOMEUSUARIO
FONE1
X
DELTA25
Z4
CODIGO_PRODUTO

Inválidos:

NOME USUÁRIO
1X
FONE#
MOSTRE

Uso de Constantes

Tem-se como definição de constante tudo aquilo que é fixo ou


estável.
Existirão vários momentos em que este conceito deverá estar
em uso:

RESULTADO = ENTRADA * 1.23

Operadores Aritméticos

Tanto variáveis como constantes poderão ser utilizadas na


elaboração de cálculos matemáticos, ou seja, na elaboração
de expressões aritméticas.

10
Expressões Aritméticas

Será muito comum trabalharmos com expressões aritméticas ou


fórmulas matemáticas, uma vez que a maior parte do trabalho
computacional está relacionado e envolve a utilização de
cálculos

x = 2 + 3
x = 4 * 5 * 3
x = 4 + 6 / 2
x = ( 4 + 6 ) / 2
area = 3.14 * raio * raio
area = 3.14 * raio ^ 2
area = ( base * altura ) / 2

3.2 Instruções
As instruções são representadas pelo conjunto de palavras-
chave (vocabulário) de uma determinada linguagem de
programação.
Tem por finalidade comandar em um computador o seu
funcionamento e a forma como os dados armazenados serão
tratados.
A mesma instrução poderá ser escrita de forma diferente
dependendo da linguagem

11
Portugol ou Português Estruturado:

programa <nome_do_programa> //denominação prg


const
// declaração de constantes se houverem
var
// declaração e classificação das variáveis
inicio // inicio do bloco principal
// iniciar as variáveis
// entrada de dados
// processamento
// saída de informações
fim // fim do bloco principal

Teste de Mesa

É a forma de verificar se o algoritmo está correto e fazendo


o que se deseja.

É a execução passo-a-passo (pelo programador) do algoritmo,


anotando todos os valores das variáveis

3.2.1 Exercícios Resolvidos


Exercício

Uma equipe de futebol resolveu trocar toda a grama de seu


campo de futebol. Agora necessita encomendar a grama para
uma floricultura. FUAQ que ajude a equipe de futebol, lendo

12
as dimensões do campo, calculando a área total de grama
necessitada e mostrando na tela esta área

Exercício: faça o teste de mesa do algoritmo abaixo:

programa atribuicao
var nome : caractere
valor1, valor2 : real
valor3 : inteiro
início
nome = "algoritmos"
valor1 = 2.34
valor2 = 7.01
valor3 = 3
valor1 = 5.5 * 3
valor3 = 100 - 66
nome = "quarta"
valor2 = valor1
valor1 = valor2 * 2 + 5.8
valor3 = valor3 / 2
valor2 = valor2 + valor1 - 233
leia nome
leia valor1
valor1 = valor1 * ( 4 - 2 )  3
mostre "fim: ", nome, valor1, valor2, valor3
fim

NOME VALOR1 VALOR2 VALOR3

13
Observe este algoritmo:

programa troca_variaveis

var valor1, valor2 : inteiro

início
leia valor1, valor2
mostre valor1, valor2
valor1 = valor2
valor2 = valor1
mostre valor1, valor2
fim

Ele não vai fazer a troca do valor de duas variáveis. O


correto para fazer a troca do valor de duas variáveis entre
si é através do uso de uma terceira variável, auxiliar, como
mostra o algoritmo abaixo:

programa troca_variaveis

var valor1, valor2, temp : inteiro

início
leia valor1, valor2
mostre valor1, valor2
temp = valor1
valor1 = valor2
valor2 = temp
mostre valor1, valor2
fim

Exemplo de um programa com constantes

programa constantes

const PI = 3.1415

var area , raio : real

início
leia raio
area = PI * raio  2
mostre area
fim

14
3.2.2 Exercícios
1) FUAQ leia três notas de um aluno. Após, calcule a média
das notas e mostre-as.

2) FUAQ que calcule e mostre a área de um quadrado, de um


retângulo, de um círculo e de um triângulo equilátero

3) FUAQ leia o número de peças do tipo 1, o valor de cada


peça do tipo 1, o número de peças do tipo 2, o valor de cada
peça do tipo 2 e o percentual de impostos (em %) a ser
acrescentado. Calcula e escreve o valor total a ser pago por
esta compra.

4) FUAQ leia o código de um vendedor, o seu salário fixo, o


total de vendas por ele efetuadas e o percentual que ganha
sobre o total de suas vendas. Calcular o salário total do
vendedor e escrever o código e o salário do vendedor.

5) O custo ao consumidor, de um carro novo, é a soma do custo


de fábrica com a percentagem do distribuidor e o percentual
dos impostos (aplicados ao custo de fábrica). Escrever um
algoritmo que lê o custo de fábrica, o percentual do
distribuidor e o percentual dos impostos e calcula e escreve
o valor a ser pago pelo consumidor por este carro.

6) Uma farmácia paga o seu funcionário a cada sexta-feira e


deseja deixar pronto o envelope de pagamento. Escrever um
algoritmo que lê o valor do salário do funcionário em
cruzeiros e calcula qual o menor número possível de notas de
100, 50, 10, 5 e 1, em que o valor lido pode ser decomposto.
Escrever o valor lido e o número de notas de cada tipo que
compõe o envelope de pagamento.

7) Escrever um algoritmo que lê a hora de início de um jogo


e a hora de fim do jogo, considerando apenas horas inteiras
e jogos que começam e terminam no mesmo dia, calcular e
escrever o tempo de duração do jogo em horas.

15
4 ESTRUTURAS DE
CONTROLE

4.1 Desvio Condicional Simples


Estrutura:

se ( <condição> ) então
<instruções para condição verdadeira>
fim_se

Exemplo:

a = 23
se ( a > 12 ) então
mostre “VIVA O COLORADO”
fim_se

Operadores Relacionais

16
4.2 Desvio Condicional Composto
Estrutura:

se ( <condição> ) então
<instruções para condição verdadeira>
senão
<instruções para condição falsa>
fim_se

Exemplo:

a = 23
se ( a > 12 ) então
mostre “VIVA O COLORADO”
senão
mostre “O DIA ESTÁ LINDO”
fim_se

4.2.1 Exercícios
8) FUAQ leia nos números NUM1 e NUM2 e calcula a adição dos
mesmos. Caso a soma seja maior ou igual a 10 deve ser
calculado e mostrado o resultado da soma adicionado de 5; se
não, deve ser calculado e mostrado o resultado da soma
subtraído de 7

9) FUAQ que leia o código de um vendedor, seu salário bruto,


o total de vendas dele e o índice da sua comissão. Do salário
bruto do vendedor deve ser descontado 8% se o mesmo receber
menos de 2000 por mês e 12% se receber 2000 ou mais por mês.
Calcular e mostrar o desconto, o valor da comissão e o
salário líquido.

10) FUAQ leia dois valores VALOR1 e VALOR2, verifica se são


múltiplos entre si e mostra uma mensagem na tela dizendo se
são ou não múltiplos.

11) FUAQ Um supermercado vende cerveja de três tipos (c1, c2


e c3). Como o supermercado deseja fazer uma promoção destas
3 marcas de cerveja e atender, ao mesmo tempo, um bom número
de clientes, o número de cervejas de cada tipo foi limitado
por cliente em 18 do tipo c1, 12 do tipo c2 e 6 do tipo c3.
Escrever um algoritmo que lê a quantidade de cervejas do
tipo c1, o valor unitário da cerveja c1, a quantidade de
cervejas do tipo c2, o valor unitário da cerveja do tipo c2,
a quantidade de cervejas do tipo c3 e o valor unitário de
cada cerveja do tipo c3. O algoritmo deve considerar as

17
limitações impostas pelo supermercado, isto é, se o cliente
pediu mais unidades do que o permitido deve-lhe ser debitado
apenas o limite permitido. Deverá escrever o número de itens
de cada tipo efetivamente fornecido e o valor total a ser
pago

4.3 Desvio Condicional Encadeado


se ( <condição1> ) então
<instruções para condição1 verdadeira>
senão
se ( <condição2> ) então
<instruções para condição2 verdadeira>
senão
<instruções para condição2 falsa>
fim_se
fim_se

...
a, b, c, d // 10 30 8 8
se ( a+b+c <> d ) então
d = a+b+c
fim_se
se ( a > b ) então
b = a*3
a = 10
senão
a = b*3
b = 10
fim_se
mostre a, b
se ( c == d ) então
se ( a+b == c ) então
c = a+b
senão
c = a*b
fim_se
b = a+c+d
fim_se
mostre a, b, c, d

18
4.3.1 Exercícios
12) FUAQ lê duas notas de alunos e calcule a média aritmética
delas. Se o aluno ficar com média abaixo de 3 mostrar na
tela “REPROVADO”. Se a média for maior ou igual a 7 mostrar
“APROVADO”. Se não for nenhum dos dois casos, mostrar “EM
EXAME”.

13) FUAQ lê valores para 2 variáveis. Se o resultado da soma


dessas 2 variáveis for maior ou igual a 100 verificar se a
soma for par ou impar. Se for par, mostrar a soma, se não
for par mostrar a mensagem “NÃO PAR”; caso a soma não seja
maior ou igual a 100, mostrar quanto vale 85% do total.

4.4 Operadores Lógicos


4.4.1 .e.

programa TESTA_LOGICA_E

var
NUMERO : inteiro

início
leia NUMERO
se (NUMERO >= 20) .e. (NUMERO <= 90) então
mostre “Numero entre 20 a 90”
senão
mostre “Numero fora de 20 a 90”
fim_se
fim_se

19
4.4.2 .ou.

programa testa_logica_ou

Var
sexo : caractere

Início
leia sexo
se (sexo == “m”) .ou. (sexo == “f”) então
mostre “sexo válido”
senão
mostre “sexo inválido”
fim_se
Fim_se

4.4.3 .não.

programa testa_logica_nao

20
Var
a, b, c, x : inteiro

Início
leia a, b, x
se .não. ( x > 5 ) então
c = ( a+b ) * x
senão
c = ( a-b ) * x
fim_se
mostre c
Fim_se

EXEMPLO:

programa triangulo
var a, b, c : inteiro
início
leia a, b, c
se (a<b+c) .e. (b<a+c) .e. (c<a+b) então
se (a==b) .e. (b==c) então
mostre “triângulo equilátero”
senão
se (a==b) .ou. (a==c) .ou. (c==b) então
mostre “triângulo isóceles”
senão
mostre “triângulo escaleno”
fim_se
fim_se
senão
mostre “as medidas não formam triangulo”
fim_se
fim

4.5 Exercícios
14) FUAQ leia o salário de um funcionário e calcula seu
reajuste. O funcionário deverá receber um reajuste de 15%
caso seu salário seja < 500. Se o salário for >= 500 e
<=1000, o reajuste deverá ser de 10%. E caso seja > 1000 o
índice de reajuste deverá ser lido do teclado. No final,
mostre o valor do antigo salário, o valor do reajuste e o
valor do novo salário.

21
15) FUAQ leia as médias finais de 3 alunos nas variáveis
MEDIA1, MEDIA2 e MEDIA3. Se o valor correspondente a 50% da
média dos 3 médias dos 3 alunos for maior que 30 o algoritmo
deve mostrar a maior média dentre os 3 alunos, senão deve
mostrar as médias em ordem decrescente.

16) FUAQ lê valores para 2 variáveis. Se o resultado da soma


dessas 2 variáveis for > 100 e < 500 trocar o valor entre as
variáveis. Se não, mostrar a variável com menor valor. No
final, sempre mostrar o valor correspondente a 65% a mais do
valor contido na segunda variável.

17) FUAQ lê valores para 3 variáveis e mostre as mesmas em


ordem crescente

18) Escrever um algoritmo que lê o número de um funcionário,


o número de horas por ele trabalhadas, o valor que recebe
por hora, o número de filhos com menos de 14 anos, a idade
do funcionário, o tempo de serviço do funcionário e o valor
do salário família por filho. Calcular o salário bruto, o
desconto do INSS ( 8.5% do salário bruto) salário família.
Calcular o desconto do Imposto de Renda na fonte como segue:

Se Salário Bruto > 1500,00 então Imposto de Renda = 15% do Salário Bruto;
Se Salário Bruto > 500,00 e Salário Bruto ≤ 1500,00 então Imposto de
Renda = 10% do Salário Bruto
Se Salário Bruto < 500,00 então Imposto de Renda = 0.

Calcular o adicional conforme especificado:


Se idade > 40 anos então adicional = 2% do Salário Bruto;
Se tempo de serviço > 15 anos então adicional = 3.5% do Salário Bruto;
Se tempo de serviço < 15 anos mas superior a 5 anos e idade > 30 anos
então adicional = 1.5% do Salário Bruto.

Calcular o Salário Líquido

5 LAÇOS DE REPETIÇÃO
5.1 para
para <var> de <inicio> até < fim> passo <incr> faça
......
fim_para

onde

22
<var> variável de controle do laço
<inicio> valor de início do laço
pode ser uma variável, expressão ou
constante
<fim> valor de fim do laço
pode ser uma variável, expressão ou
constante
<incr> valor de incremento ou decremento do laço
pode ser uma variável, expressão ou
constante

Exemplos:

para i de 1 até 5 passo 1 faça


mostre i
fim_para

para f de -2 até 1 passo 2 faça


mostre f
fim_para

a = 20; b = 30; c = 3;
para kk de a até b-2 passo c faça
mostre kk
fim_para

para m de 2 até -1 passo -1 faça


mostre m
fim_para

para s de 1 até 10-s passo s faça


mostre s
fim_para

leia a; leia b; leia c;


para XX de a até b passo c faça
mostre xx
fim_para

programa MEDIA_ALUNOS
var qtde_alunos , i : inteiro
nota1, nota2, media : real
inicio
leia qtde_alunos
para i de 1 ate atde_alunos passo 1
leia nota1, nota1
media = ( nota1 – nota2 ) / 2

23
mostre media
fim_para
fim

5.1.1 Exercícios
19) FUAQ leia 2 notas de um total de 50 alunos, calcule e
mostre a média aritmética das 2 notas de cada aluno. Por
fim, mostrar qual a maior média de notas obtida pelos alunos.

20) FUAQ leia a quantidade e valor unitário de 100 produtos.


Mostrar o valor total gasto com os 100 produtos.

21) FUAQ leia 200 valores numéricos. No final deve mostrar


o maior valor que entrou, o menos valor que entrou, a média
dos valores e o somatório de todos os valores.

5.2 enquanto
enquanto <condição> faça
....
fim_enquanto

onde:

<condição> teste lógico (pode usar .e. .ou. .não)

Os comandos serão executados enquanto a condição for


VERDADEIRA

Exemplos:

i = 1
enquanto ( i <= 5) faça
mostre i
i = i + 1
fim_enquanto

f = -2
enquanto ( f <= 1 ) faça
mostre f
f = f + 2
fim_enquanto

24
a = 20; b = 30; c = 3;
enquanto ( a < b-2 ) faça
mostre a
a = a + C
fim_enquanto

leia a
enquanto ( a <= 10 )faça
mostre a
fim_enquanto

leia a
enquanto ( a <= 10 )faça
mostre a
leia a
fim_enquanto

opcao = ”s”;
enquanto ( opcao <> ”f” ) faça
leia valor1, valor2
mostre ”soma dos valores: ”, valor1 + valor2
mostre ”Continua? (s/n)”
leia opcao
fim_enquanto

leia nome
enquanto ( nome <> ”viapas” )faça
leia nota1, nota2;
mostre ”Media do ” , nome , ” = ” , (nota1+nota2)/2
mostre nome
leia nome
fim_enquanto

programa MEDIA_ALUNOS
var qtde_alunos , i : inteiro
nota1 , nota2 : real
inicio
leia qtde_alunos
i = 1
enquanto ( i <= qtde_alunos ) faça
leia nota1 , nota2
media = ( nota1 + nota2 ) / 2
mostre media
i = i + 1

25
fim_enquanto
fim

5.2.1 Exercícios
22) FUAQ lê 10 valores, um de cada vez, e conta quantos deles
estão no intervalo [10,20] e quantos deles estão fora deste
intervalo, escrevendo estas informações.

23) FUAQ lê 50 valores para uma variável VALOR. Contar e


mostrar quantos valores ímpares foram digitados e calcular
e mostrar a média dos valores pares digitados

24) FUAQ lê a um valor para a variável QUANT. Após, leia a


quantidade de valores conforme informado em QUANT ou até que
o valor lido seja 0 (zero). Para cada valor lido, mostre a
raiz quadrada dele (função SQRT).

5.3 repita
repita
...
até_que <condição>

onde:

<condição> teste lógico (pode usar .e. .ou. .não)

Os comandos serão executados enquanto a condição for FALSA

Exemplos:

i = 1
repita
mostre i
i = i + 1
até_que ( i == 5 )

f = -2
repita
f = f + 2
mostre f
até_que ( f > 1 )

a = 20; b = 30; c = 3;

26
repita
a = a + c
mostre “AMOR”
até_que ( a >= b-2 )

repita
leia nome
leia nota1, nota2;
mostre ”Media do ” , nome , ” = ” , (nota1+nota2)/2
mostre nome
até_que ( nome == ”viapas” )

programa MEDIA_ALUNOS
var qtde_alunos , i : inteiro
nota1 , nota2 : real
inicio
leia qtde_alunos
i = 1
repita
leia nota1 , nota2
media = (nota1+nota2) / 2
mostre media
i = i + 1
até_que ( i == QTDE_ALUNOS )
fim

6 MODIFICADORES
6.1 Continue
Força uma próxima iteração do laço. Ou seja, faz com que o
algoritmo pule deste ponto para o teste de condição de fim
de laço, ignorando os comandos que vierem após o continue

6.2 Break
Força o encerramento do laço. O algoritmo continua no
primeiro comando após o fim do laço

para i de 1 até 100 passo 1 faça


leia sensor
se ( sensor > 100 ) continue

27
pressao = sensor * 4.56
mostre pressao
fim_para

repita
leia produto, valor, qtde
se ( qtde <= 0 ) continue
mostre ”Custo do” , produto , ” : ” , qtde*valor
até_que ( produto == ”banana” )

para i de 1 até 100 passo 1 faça


leia sensor
se ( sensor > 100 ) break
pressao = sensor * 4.56
mostre pressao
fim_para

repita
leia temperatura
se ( temperatura < 0 ) break
mostre temperatura
até_que ( temperatura == 24 )

6.3 Contadores
programa contar_par
var i , valor, cont : inteiro
inicio
cont = 0
para i de 1 ate 10 passo 1 faça
ler valor
se ( valor % 2 == 0 )
então
cont = cont + 1
fim_se
fim_para
mostre “total de pares : “, cont
fim

programa somar_carga
var i , peso , soma: inteiro
produto : caractere
inicio

28
soma = 0
para i de 1 ate 20 passo 1 faça
ler produto , peso
soma = soma + peso
fim_para
mostre “Peso total da carga : “, soma
fim

6.4 Multiplicadores
programa fatorial
var i , num , fat : inteiro
inicio
fat = 1
ler num
para i de num ate 1 passo -1 faça
fat = fat * i
fim_para
mostre “Fatorial de “ , num , “ : “ , fat
fim

6.5 Sinalizadores
programa entrou_negativo
var i , num , flag : inteiro
inicio
flag = 0
para i de 1 ate 10 passo 1 faça
ler num
se ( num < 0 )
então
flag = 1
fim_se
fim_para
se ( flag == 1 )
então
mostre “Foi digitado valor negativo”
senão
mostre “Nao foi digitado valor negativo”
fim_se
fim

29
6.6 Maior
programa maior_valor
var i , num , maior: inteiro
inicio
para i de 1 ate 10 passo 1 faça
ler num
se ( i == 1 ) então maior = num
se ( num > maior ) então maior = num
fim_para
mostre “Maior valor digitado : “ , maior
fim

6.7 Menor
programa menor_valor
var i , num , menor: inteiro
inicio
para i de 1 ate 10 passo 1 faça
ler num
se ( i == 1 ) então menor = num
se ( num > menor ) então menor = num
fim_para
mostre “Menor valor digitado : “ , menor
fim

6.8 Exercícios
25) Escrever um algoritmo que gera e escreve os números
ímpares entre 100 e 200

26) FUAQ lê valores para uma variável VALOR até que seja
digitado o valor 0 (zero) para a variável VALOR. Verificar
a cada VALOR lido se ele é maior que 100 e menor que 500. Se
for, calcular e mostrar o somatório de todos os valores entre
101 e o VALOR lido; se não for, mostrar a mensagem “FORA DO
INTERVALO”.

Nos próximos exercícios, pode usar qualquer tipo de laço

27) FUAQ lê um valor para uma variável VALOR e, após, mostra


a tabuada de 1 a 10 do VALOR (fazer 3 vezes este algoritmo,
cada um usando uma forma de laço de repetição)

30
28) FUAQ lê uma quantidade indeterminada de valores para uma
variável VALOR (após cada valor lido para VALOR o algoritmo
deve solicitar ao usuário se ele quer ler mais valores ou
não). Para cada VALOR lido verificar se é impar ou par. Se
for par, calcular e mostrar o fatorial de VALOR; se for
ímpar, calcular e mostrar o somatório dos valores entre 1 e
VALOR.

29) Escrever um algoritmo que lê um número não determinado


de valores para m, todos inteiros e positivos, um de cada
vez. Se m for par, verificar quantos divisores possui e
escrever esta informação. Se m for ímpar e menor do que 12
calcular e escrever o fatorial de m. Se m for ímpar e maior
do que 12, calcular e escrever a soma dos inteiros de 1 até
m.

30) Escrever um algoritmo que lê um número não determinado


de valores a, todos inteiros e positivos, um de cada vez, e
calcule e escreva a média aritmética dos valores lidos, bem
como, a quantidade de valores pares, a quantidade de valores
ímpares, a percentagem dos valores pares e a percentagem dos
valores ímpares.

31) Escrever um algoritmo que escreve os números primos entre


100 e 200, bem como, a soma destes números primos.

7 SUB-ROTINAS
Utilizadas para isolar trechos de códigos que façam uma
finalidade específica

Evitam a duplicidade de código

Colaboram na organização do código

Melhoram a manutenção do código

Quando a chamada à uma sub-rotina for encontrada, o código


é desviado para a execução desta sub-rotina, retornando ao
comando seguinte de onde estava quando a rotina encerrar

Uma sub-rotina pode chamar outra sub-rotina

Elas podem ser divididas em:

 Procedimentos : quando a sub-rotina não retorna nenhum


valor para a rotina que a chamou

31
 Funções : quando a sub-rotina retorna valor para a
rotina que a chamou

7.1 Procedimentos
Estrutura:

procedimento nome_procedimento
var //var. locais–se houver
início
... // comandos
...
fim

exemplo:

procedimento calcula_fatorial
var valor , i , fat : inteiro
início
leia valor
fat = 1
para i de 1 até valor passo 1 faça
fat = fat * i
fim_para
mostre fat
fim

Chamada de um procedimento:

programa x
var i , qtd: inteiro
início
leia qtd
para i de 1 ate qtd passo 1 faça
calcula_fatorial()
fim_para
fim

7.2 Função
Estrutura:

32
função nome_func: <tipo_dado_retorno>
var //var.locais – se houver
início
... // comandos
...
retorna xxxxxx //valor dev.
fim

Exemplo:

função calcula_fatorial : inteiro


var valor , i , fat : inteiro
início
leia valor
fat = 1
para i de 1 até valor passo 1 faça
fat = fat * i
fim_para
retorna fat
fim

Chamada de uma função:

programa x
var i , qtd , result : inteiro
início
leia qtd
para i de 1 ate qtd passo 1 faça
result = calcula_fatorial
mostre result
fim_para
fim

7.3 Parâmetros
São informações (valores) que passamos ou recebemos de uma
função ou procedimento

 Passagem por valor : A função ou procedimento recebe a


informação e o que for alterada nela não refletirá na
variável que passou a informação

33
 Passagem por referência : A função ou procedimento
recebe a informação e o que for alterada nela refletirá
na variável que passou a informação

Passagem por valor

procedimento X (VARIÁVEL <tipo_dado> )

função X (VARIÁVEL <tipo_dado>) : <tipo_dado>

Exemplo:

procedimento x ( num : inteiro )


var soma , i : inteiro
início
soma = 0
para i de 1 até num passo 1 faça
soma = soma + i
fim_para
mostre soma
fim

função x ( num : inteiro): inteiro


var soma , i : inteiro
início
soma = 0
para i de 1 até num passo 1 faça
soma = soma + i
fim_para
retorna soma
fim

Passagem por referência

procedimento X ( var VARIÁVEL <tipo_dado> )

função X (var VARIÁVEL <tipo_dado>) : <tipo_dado>

Exemplo:

procedimento x (var num : inteiro)


var valor : inteiro

34
início
leia valor
num = num * valor
fim

função x ( var num : inteiro): inteiro


var valor : inteiro
início
leia valor
num = num * valor
retorna valor
fim

8 VETORES E MATRIZES
Agrupamento de várias informações dentro de uma mesma
variável

Este agrupamento ocorrerá obedecendo sempre ao mesmo tipo de


dado

Chamado de ESTRUTURAS HOMOGÊNEAS DE DADOS

Também conhecida como variáveis indexadas, variáveis


compostas, variáveis subscritas, arranjos, vetores, matrizes
ou arrays.

As matrizes são tipos de dados que podem ser “construídos”


à medida que se fazem necessários, pois nem sempre os tipos
básicos e/ou variáveis simples são suficientes para
representar a estrutura de dados utilizada em um programa.

8.1 Vetor
 Matrizes de uma dimensão (unidimensional)
 Definida uma única variável com um determinado tamanho
(constante inteira e positiva)

Forma de representação:

nome_variável[ índice ]

Cada índice de um vetor pode ser visto como uma variável

Definição:

Var

35
nome : conjunto[1..TAM] de <tipo_dado>

Exemplo

dados: conjunto[1..10] de inteiro

Atribuição a vetores:

dados[ 1 ] = 10
dados[ 8-3 ] = num * 3
dados[ indice ] = 34

Leitura de valores em vetores:

valor = dados[ 4+1 ]


valor = dados[ indice ]
valor = dados[ 2 ] * 3

8.1.1 Exercício
32) FUAQ que crie uma rotina para leitura de um vetor de
inteiros de tamanho 10. Após, fazer outra rotina que mostre
o conteúdo do vetor

33) FUAQ crie uma rotina para leitura de um vetor de inteiros


de tamanho 60. A seguir, crie outra rotina que conte quantos
valores do vetor são positivos. Por fim, crie uma terceira
rotina que mostre quantos são os valores positivos presentes
no vetor.

34) FUAQ crie uma rotina para fazer a leitura de um vetor


numérico de tamanho 50. A seguir, crie outra rotina para
mostrar todas as posições (índices) do vetor que possuem um
valor menor ou igual a 10. Por fim, crie uma rotina para
transferir o conteúdo deste vetor para um outro vetor (de
mesmo tamanho e tipo), na ordem inversa: índice 0 para 49,
1 para 48, 2 para 47, mostrando o segundo vetor.

35) FUAQ crie uma rotina que leia os índices pares de um


vetor de reais de tamanho 500 (considere o índice 0 como
índice par). Após, crie uma rotina que preencha os índices

36
ímpares do vetor da seguinte forma: cada índice ímpar
receberá a soma de todos os valores contidos nos índices
pares anteriores a ele. Por fim, crie uma rotina que mostre
todo o vetor.

36) FUAQ crie uma rotina para ler um vetor X de caracteres


com tamanho 15. Após, crie uma rotina para ler um vetor Y de
caracteres com tamanho 34. Então, crie uma rotina que receba
os vetores X e Y como parâmetro e gere um vetor Z com a
concatenação de Y em X, retornando este vetor. Por fim, crie
uma rotina que mostrará o vetor concatenado.

8.2 Matriz Bidirecional


 Matrizes de 2 dimensões
 Definidas duas variáveis

Forma de representação:

nome_variável[ nd_lin ] [ nd_col ]

Cada índice de uma matriz pode ser visto como uma variável

Definição

Var
nome : conjunto[1..TAM_LIN][1..TAM_COL] de <tipo_dado>

Exemplo

dados: conjunto[1..3][1..5] de inteiro

Atribuição a uma matriz

dados[ 1 ][ 2 ] = 10
dados[ 8 ][ i ] = num * 3
dados[ ind1 ][ ind2 ] = 34

Leitura de dados de uma matriz

valor = dados[ 4 ][ 1 ]
valor = dados[ a ][ b ]
valor = dados[ 2 ][ 2 ] * 3

8.2.1 Exercícios
37
37) FUAQ leia uma matriz de inteiros de tamanho [20][20] e
mostre o somatório de todos os valores presentes na matriz.
Após, mostre o totalizador dos valores que estão na diagonal
principal.

38) FUAQ crie uma rotina para a leitura de uma matriz


[100][50] de inteiros. Após mostre o somatório dos valores
contidos em cada linha da matriz. Por fim, mostre o somatório
dos valores contidos em cada coluna da matriz.

39) FUAQ crie uma rotina para leitura de uma matriz [30][20]
de inteiros. Após, crie uma rotina para colocar em um vetor
os maiores valores contido em cada linha da matriz (no índice
0 do vetor colocar o maior valor contido na linha 0 da
matriz, assim sucessivamente). Por fim, crie uma rotina para
mostrar os valores do vetor.

40) FUAQ crie uma rotina que leia uma matriz [22][22] de
inteiros. Após, crie outra rotina que calcule o somatório do
triângulo superior da matriz, retornando este valor. Mostre
este somatório no programa principal.

38