Algoritmos Parte 2 (1)

Prévia do material em texto

Construção de 
Algoritmos 
 
(Parte 2) 
 
 
 
 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Profª: Kellen Nery 
 
 
 
 
Sumário 
VARIÁVEIS COMPOSTAS ......................................................................................................... 2 
Variáveis Vetoriais Unidimensionais .................................................................................. 2 
Exercícios ........................................................................................................................ 4 
Variáveis Vetoriais Multidimensionais ............................................................................... 8 
Exercícios ...................................................................................................................... 10 
SUBALGORITMOS ................................................................................................................. 13 
Elementos de um subalgoritmo ........................................................................................ 14 
Escopo de variáveis ........................................................................................................... 14 
Funções ............................................................................................................................. 16 
Procedimentos .................................................................................................................. 18 
Passagem de parâmetros ................................................................................................. 19 
Passagem de parâmetros por valor .............................................................................. 21 
Passagem de parâmetros por referência ..................................................................... 21 
Exemplo Passagem de Parâmetro Valor x Referência .................................................. 22 
 
 
 
 
 
 
 
 Profª: Kellen Nery 
2 
 
 
VARIÁVEIS COMPOSTAS 
Até o momento, vimos apenas variáveis que são utilizadas para o armazenamento de 
dados simples. Entretanto, as variáveis podem ser compostas, formadas por uma ou mais 
posições (campos ou entradas), podendo armazenar um ou mais dados. As variáveis 
compostas são classificadas em homogêneas (vetoriais) ou heterogêneas (registros). Em 
função de sua capacidade de armazenar diferentes valores, este tipo de variável pode ser 
encarado como uma “estrutura” de armazenamento. 
 
 
Variáveis Vetoriais Unidimensionais 
As variáveis vetoriais unidimensionais, chamadas muitas vezes simplesmente de variáveis 
vetoriais, são variáveis compostas homogêneas indexadas, as quais contêm um ou mais 
campos de mesmo tipo, onde cada campo é acessado pelo seu índice (posição). Sua declaração 
geral é definida da seguinte forma: 
 
var <nome>: vetor[<inicio>..<fim>] de <tipo_da_variavel> 
 
Exemplo 1: Declaração de uma variável chamada A que pode armazenar 10 números 
inteiros. 
 
var A: vetor[1..10] de inteiro 
 
Neste exemplo, a variável A será armazenada na memória do computador em uma área 
equivalente a 10 vezes o que é armazenado para uma única variável inteira. Esta variável é 
representada como na figura abaixo. Nela, os números 1, 2, 3...10 são os índices (posição ou 
localização) de cada número inteiro que pode ser armazenado. O índice serve para localizar 
qual elemento do vetor estará sendo referido em determinado instante. Por exemplo, o 
elemento A[5] é localizado no campo de índice 5 do vetor A e, no exemplo da figura, vale -12. 
 
 
 
 
Para atribuir um valor qualquer para um campo de posição i faz-se o seguinte: 
 
A[i]←←←←<valor_qualquer> 
 
Neste caso, diz-se que a posição i-ésima do vetor A foi indexada. 
 
 Profª: Kellen Nery 
3 
 
 
Exemplo 2: Algumas operações que podem ser realizadas com vetores. 
 
B[3] ←←←←”flor” 
A[6] ←←←←A[8] 
leia(B[2]) 
escreva(B[i]) 
A[i] ←←←←A[i+1]-C[j] 
 
 
Exemplo 3: Trecho de programa que inicializa todos os campos de um vetor A com o valor 
0 (zero). Diz-se “inicializar o vetor com zeros” ou simplesmente “zerar o vetor”. 
 
Primeira Opção: atribui-se 0 (zero) a todos os campos, um a um, da seguinte forma: 
A[1] ←←←←0 
A[2] ←←←←0 
A[3] ←←←←0 
A[4] ←←←←0 
A[5] ←←←←0 
A[6] ←←←←0 
A[7] ←←←←0 
A[8] ←←←←0 
A[9] ←←←←0 
A[10] ←←←←0 
 
Segunda Opção: utiliza-se uma variável para indexar as 10 posições com um comando de 
repetição. A ideia aqui é usar a própria variável de contagem do comando “para” para indexar 
o vetor todo, da seguinte forma: 
 
para i:=1 até 10 faça 
A[i] ←←←←0 
fimpara 
 
Neste exemplo dizemos que o vetor A foi completamente indexado (percorrido, visitado, 
pesquisado, varrido, ...) em todas as suas entradas e para cada uma um valor zero foi inserido. 
Dizemos que para cada iteração do “para”, ou seja, para cada valor de i, o elemento i-ésimo 
(elemento da vez, elemento corrente, elemento atual etc...) é zerado. A figura abaixo mostra 
uma possível representação gráfica da indexação com comando de repetição. 
 
 
 
 
 Profª: Kellen Nery 
4 
 
 
Exercícios 
 
1) Faça um algoritmo que leia, via teclado, 200 valores do tipo inteiro e os guarde na 
memória. 
2) Amplie o exercício anterior emitindo um relatório com todos os números pares que 
você leu. 
3) Faça um algoritmo que determine qual o menor valor existente no vetor do exercício 
número 1. 
4) Faça um algoritmo que determine qual o maior valor existente no vetor do exercício 
número 1. 
5) Faça um algoritmo que imprima quantos dos valores do exercício número 1 são 
maiores que a média desses valores. 
6) Faça um algoritmo para ler 20 valores e que imprima os que são maiores que a média 
dos valores. 
 
7) Faça um algoritmo que leia 18 números inteiros e calcule e imprima a soma dos 
mesmos. 
 
8) Faça um programa que leia 4 números inteiros e apresente: 
• Média dos ímpares 
• Maior número par 
• Diferença entre o maior e o menor número 
 
9) Faça um programa que leia um conteúdo com 100 números inteiros e apresente a 
media dos números. 
 
10) Faça um programa que leia 2 conjuntos com 50 números inteiros e gere um terceiro 
conjunto com a media dos elementos de A e B. Apresente o C. 
 
11) Faça um programa que leia um conjunto A com 30 números inteiros e que armazene 
em um conjunto B do mesmo tipo os elementos de A multiplicados por 3. Apresente o 
conjunto B. 
 
12) Faça um programa que leia um conjunto A com 100 números inteiros e que gere um 
conjunto B com os elementos de A de acordo com a seguinte regra. Se o elemento de 
A for par, armazene em B multiplicando por 5. Se o elemento de A for impar, 
armazene em B somando 5. 
 
13) Faça um programa que leia dois conjuntos A e B com 20 inteiros e troque os valores de 
A com B. 
 
14) Faça um programa que leia dois conjuntos A e B com 15 números inteiros e gere um 
conjunto de 30 elementos, onde os 15 primeiros elementos são de A e o resto de B. 
Apresente o conjunto C. 
 
15) Criar um programa que lê 20 números inteiros e depois os escreve na ordem inversa. A 
ideia aqui é mostrar no vídeo os elementos começando da última posição e vindo em 
direção a primeira posição. 
 Profª: Kellen Nery 
5 
 
 
16) Criar um programa que a partir de um vetor A de n números inteiros, calcula a soma 
dos pares e a soma dos ímpares. A ideia aqui é semelhante a anterior, entretanto 
usam-se duas variáveis de somatória (somapar e somaimpar). Para cada elemento 
indexado, uma comparação é feita para determinar em qual das somatórias ele será 
acumulado. 
 
17) Criar um programa que procura dentro de um vetor A de n inteiros o elemento mais 
próximo da média. Diga qual é a posição deste elemento. 
 
18) Criar um programa que a partir de um vetornumérico A de tamanho n, eleva os 
valores de cada campo deste vetor ao índice de sua posição. Assim, A[1]←(A[1])1, 
A[2]←(A[2])2, A[3]←(A[3])3 e assim sucessivamente até que A[n]:=(A[n])n. A ideia aqui 
é percorrer o vetor com um comando “para” e para cada iteração usar um outro 
comando “para” para calcular uma potenciação. 
 
19) Faça um algoritmo que leia Nome e notas ( total de 12 ) de N alunos de um colégio. 
Após a leitura faça: 
a) Imprima o Nome e a média dos alunos aprovados ( Média >= 7.0 ). 
b) Imprima o Nome e a média dos alunos em Recuperação ( 5.0 >= Média < 7.0 ). 
c) Imprima o Nome e a média dos alunos reprovados ( Média < 5.0 ). 
d) Imprima o percentual de alunos aprovados. 
e) Imprima o percentual de alunos reprovados. 
 
20) Um teste composto por 10 questões foi proposto numa classe de n alunos. Cada 
questão admite as alternativas identificadas pelas letras A, B, C, D e E. Para cada aluno 
tem-se o registro contendo o seu nome e as suas respostas. Sendo dado o gabarito das 
questões faça um algoritmo que: 
a) Escreva uma relação contendo o nome e o número de acertos de cada aluno; 
b) Determine quantos alunos acertaram as questões 1 e 2 e tiveram 7 acertos; 
c) Escreva o nome do aluno, que obteve a melhor nota e pior nota; 
 
21) Faça um algoritmo que leia 10 valores numéricos inteiros. Após a leitura emita um 
relatório com cada valor diferente e o número de vezes que o mesmo apareceu no 
vetor. 
 
22) Dado uma ralação de N nomes, faça um algoritmo que verifique se uma determinada 
pessoa está neste vetor. O Nome da pessoa a ser pesquisada deverá ser lido, bem 
como os nomes a serem colocados no vetor. 
 
23) Faça um algoritmo que leia N letras e armazene cada uma em uma posição de 
memória. Coloque no vetor, após a última letra lida, o caracter “$”, indicando final dos 
caracteres 
 
24) Faça um algoritmo que: 
a) Leia um vetor A e um vetor B com 10 elementos cada, do tipo caracter. 
b) Intercale estes vetores A e B, formando outro vetor C da seguinte forma. 
 C[1] ← A[1] 
 C[2] ← B[1] 
 C[3] ← A[2] 
 C[4] ← B[2] 
 Profª: Kellen Nery 
6 
 
 
25) Dado um vetor X de n elementos faça um algoritmo que: 
a) Crie outro vetor Y contendo os elementos de x que estão na faixa entre 10 e 40; 
b) Crie outro vetor W contendo os números que estão nas posições pares; 
c) Pesquise a existência de um determinado elemento Y no vetor X; 
d) Escreva o menor e maior elemento do vetor X; 
 
26) Em uma cidade do interior, sabe-se que, de janeiro a abril de 1976 (121 dias), não 
ocorreu temperatura inferior a 15o C nem superior a 40o C. As temperatura verificadas 
em cada dia estão disponíveis em uma unidade de entrada de dados. 
Fazer um algoritmo que calcule e escreva: 
a) a menor temperatura ocorrida; 
b) a maior temperatura ocorrida; 
c) a temperatura média 
d) o número de dias nos quais a temperatura foi inferior a média à temperatura 
média. 
 
27) Fazer um algoritmo que: 
a) leia o valor de n (n <= 1000) e os n valores de um variável indexada A de valores 
inteiros ordenados de forma crescente; 
b) determine e escreva, para cada número que se repete no conjunto, a quantidade 
de vezes em que ele aparece repetido; 
c) elimine os elementos repetidos, formando um novo conjunto; 
d) escreva o conjunto obtido no item c; 
 
28) Uma grande firma deseja saber quais os três empregados mais recentes. Fazer um 
algoritmo para ler um número indeterminado de informações (máximo de 300) 
contendo o número do empregado e o número de meses de trabalho deste 
empregado e escrever os três mais recentes. 
Observações: A última informação contém os dois números iguais a zero. Não existem 
dois empregados admitidos no mesmo mês. 
 
Exemplo: 
EMPREGADOS 
224 1731 2210 4631 … 526 
1 2 3 4 300 
 
MESES 
17 3 9 2 … 10 
1 2 3 4 300 
 
Empregado mais recente: 4631. 
 
 
29) Fazer um programa que: 
a) leia o valor de M (M<=30) e os valores de uma variável indexada A; 
b) leia o valor de N (N<=20) e os valores de uma variável indexada B; 
c) determine o conjunto C = A ∪ B (união de A com B), onde C não deverá conter 
elementos repetidos (A e B não contém elementos repetidos); 
d) escreva os elementos contidos em A, B e C; 
 
 Profª: Kellen Nery 
7 
 
30) Intercalação é o processo utilizado para construir uma tabela ordenada, de tamanho n 
+m, a partir de duas tabelas já ordenadas de tamanhos n e m. Por exemplo, a partir 
das tabelas: 
 
A= 1 3 6 7 
 
e 
B= 2 4 5 
 
construímos a tabela 
 
C= 1 2 3 4 5 6 7 
 
Fazer um algoritmo que: 
a) leia NA, número de elementos do conjunto A (NA<=100); 
b) leia, em seguida, os elementos do conjunto A; 
c) leia, logo após o valor de NB, número de elementos do conjunto B (NB<=100); 
d) leia, finalmente, os elementos do conjunto B; 
e) crie e imprima um conjunto C, ordenado, de tamanho NA+NB, a partir dos 
conjuntos originais A e B. 
 
Observação: Considerar os elementos de A e B como inteiros. 
 
 
31) Para cada nota de compra , tem-se o Nome do produto comprado, o valor e o imposto. 
Faça um algoritmo que escreva Nome, valor e imposto de cada produto. Bem como o 
valor total bruto, o imposto total cobrado e o valor total líquido de todas as notas. 
Considere 500 notas 
 
32) Um armazém trabalha com 100 mercadorias diferentes identificadas pelos números 
inteiros de 1 a 100. O dono do armazém anota a quantidade de cada mercadoria 
vendida durante o mês. Ele tem uma tabela que indica para cada mercadoria o preço 
de venda. Escreva o algoritmo para calcular o faturamento mensal de armazém, isto é: 
 
A tabela de preço e quantidade é fornecida em dois conjuntos, sendo que um conjunto 
contém a quantidade vendida e o outro o preço de cada mercadoria. 
 
 
 
 
 
 
 
 Profª: Kellen Nery 
8 
 
 
Variáveis Vetoriais Multidimensionais 
São variáveis homogêneas que possuem duas ou mais dimensões, ou se preferir, seus 
campos podem ser acessados por mais de 1 índice. Podemos imaginar como sendo tabelas de 
dados distribuídas no espaço. Conforme a dimensão, fica difícil a sua representativa gráfica. 
Sua sintaxe é definida abaixo: 
 
var <nome>: vetor[<interv1>,<interv2>,....,<intervn>] de <tipo> 
 
Onde <intervi> corresponde ao intervalo discreto da dimensão i, comumente composto de 
valores indicando o início e o fim da sequência de elementos discretos que compõe o 
intervalo. A sintaxe da especificação do intervalo é: 
 
<inicio>..<fim> 
 
onde <início> e <fim> podem ser constantes ou variáveis contendo normalmente valores 
inteiros ou caracteres. Outros tipos menos comuns também são permitidos. Um exemplo de 
vetor Tetra-Dimensional capaz de armazenar valores reais é declarado abaixo, mas a sua 
representação gráfica é complicada. 
 
Exemplo 1: 
 
var tetra: vetor[1..10,1..20,1..15,1..5] de real 
 
Já no caso de variável vetorial bidimensional, também chamada de matriz, sua 
representação pode ser vista no exemplo a seguir: 
 
Exemplo2: 
 
var A: vetor[1..6,1..5] de inteiro 
 
Neste exemplo, o primeiro intervalo da dimensão é normalmente chamado de linha e o 
segundo de coluna, por questões de simplicidade de entendimento, já que estamos 
acostumados com esta representação tradicional da matemática escolar. No entanto, não 
existe esta obrigatoriedade e nada impede o programador de entender que o segundo 
intervalo seja a linha e o primeiro a coluna. O importante neste caso é padronizar o uso dentro 
do programa. Para todos os efeitos, melhor o entendimento tradicional. 
 
 Profª: Kellen Nery 
9 
 
 
Os campos de uma variável multidimensional podem ser acessados pela combinação de 
seus índices, também chamada de coordenada. O exemplo da figura anterior deixa em 
destaque dois campos da variável A, posicionados nas coordenadas (3,2)e (5,4). 
 
Exemplo 3: Programa que preenche uma matriz mxn com elementos nulos. 
 
programa matriz_nula 
var m, n, lin, col: inteiro 
Max: vetor[1..200,1..200] de inteiro 
início 
leia(m,n); {m linhas e n colunas} 
para lin←←←←1 até m faça 
para col←←←←1 to n do 
Max[lin,col] ←←←←0 
fimpara 
fimpara 
fim 
 
Este exemplo mostra a forma mais comum de percorrer uma matriz mxn, usando dois 
comandos “para” para indexar todas as linhas e colunas da matriz. Note que o “para” mais 
externo é o responsável pela indexação das linhas e o mais interno das colunas. Assim, 
conforme feito neste exemplo, para cada linha o algoritmo percorre os elementos de todas as 
colunas e atribui a ele o valor zero. 
Outra observação se faz necessária, note que a matriz Max foi declarada com 40.000 
campos inteiros. A declaração reserva espaço de memória para os campos, mas o uso destes 
não é obrigatório. 
No programa, o que determina o tamanho válido da matriz é o controle que fazemos dela. 
Neste caso, usamos m e n para delimitar os campos válidos. Normalmente devemos reservar 
espaço suficiente para as situações de uso máximo, mas todo cuidado é pouco. Neste 
exemplo, 40.000 valores inteiros são 80.000 bytes, ou seja, aproximadamente 80K bytes. 
Imaginem agora se o tipo básico dos campos da matriz fosse real. Então teríamos uma reserva 
de 240K bytes, bem mais do que a memória disponível nos primeiros computadores. Este uso 
deve ser controlado, reservando o mínimo possível de memória, a fim de facilitarmos o 
trabalho o sistema operacional e permitir uma execução mais rápida do programa gerado. 
 
 
 
 Profª: Kellen Nery 
10 
 
 
Exercícios 
 
1) Crie um algoritmo que receba uma matriz 3x3 e depois exiba uma determinada linha 
da matriz indicada pelo usuário (linha válida da matriz). 
 
2) Faça um algoritmo que leia uma matriz 3x4 de inteiros e em seguida troque a primeira 
linha com a última linha. Ao final a matriz alterada deve ser exibida. 
 
3) Elabore um algoritmo que preencha uma matriz 5x5 de inteiros e depois faça: 
a) a troca entre a segunda e a quinta linha; 
b) a troca entre a primeira e a quarta coluna; 
c) a exibição de como ficou a matriz. 
 
4) Elabore um algoritmo que seja capaz de ler números inteiros para uma matriz 3x3 e 
depois gire a matriz em 90° no sentido anti-horário, conforme exemplo abaixo: 
 
 
5) Com base no exercício anterior, escreva outro algoritmo que gire a matriz 3x3 em 90º 
no sentido horário. 
 
6) Elabore um algoritmo que leia uma matriz 4x4 e indique se ela é uma matriz triangular 
superior. Matriz triangular superior é uma matriz quadrada onde todos os elementos 
abaixo da diagonal principal são nulos (com valor zero). Veja um exemplo: 
 
 
Dica: os elementos abaixo da diagonal principal possuem o índice da linha maior que 
o índice da coluna. 
 
7) Escreva um algoritmo que leia duas matrizes reais de dimensão 3 x 5, calcule e 
imprima a soma de cada elemento das matrizes, em uma nova matriz. 
 
8) Dada uma matriz MAT de 4 x 5 elementos, faça um algoritmo para somar os elementos 
de cada linha gerando o vetor SOMALINHA. Em seguida, somar os elementos do vetor 
SOMALINHA na variável TOTAL que deve ser impressa no final: 
 
Exemplo: 
 Profª: Kellen Nery 
11 
 
 
 
9) Escrever um algoritmo para armazenar valores inteiros em uma matriz (5,6). A seguir, 
calcular a média dos valores pares contidos na matriz e escrever seu conteúdo. 
 
10) Escreva um algoritmo que lê uma matriz M(5,5) e calcula as somas: 
a) da linha 4 de M. 
b) da coluna 2 de M. 
c) da diagonal principal. 
d) da diagonal secundária. 
e) de todos os elementos da matriz. 
f) Escreva estas somas e a matriz. 
 
Exemplo: 
 
 
11) Escrever um algoritmo que lê uma matriz M(5,5) e cria 2 vetores SL(5), SC(5) que 
contenham respectivamente as somas das linhas e das colunas de M. Escrever a matriz 
e os vetores criados. 
 
12) Escrever um algoritmo que lê duas matrizes N1(4,6) e N2(4,6) e cria: 
a) Uma matriz M1 que seja a soma de N1 e N2 
b) Uma matriz M2 que seja a diferença de N1 com N2 
Escrever as matrizes lidas e calculadas. 
 
13) Escreva um algoritmo para um programa que leia uma matriz quadrada 20 x 20 de 
elementos reais, divida cada elemento da linha da matriz pelo elemento da diagonal 
principal desta linha e imprima a matriz assim modificada. 
 
 Profª: Kellen Nery 
12 
 
 
Exemplo: 
� � 9 1012 � 1520 8 
 � ⇒ �
1 4.5 56 1 55 2 1� 
 
14) A matriz dada a seguir contém, em cada linha, as cinco notas de provas obtidas por um 
aluno durante o período letivo. O índice das linhas corresponde ao número do aluno. 
Assim, por exemplo, o aluno número 3 obteve as notas, 8,9 – 3,8 –8,7 – 6,0 – 6,5 
 
 
 
A turma contém 30 alunos 
As notas são lidas a partir de um arquivo de entrada, sendo que cada linha da matriz 
contém as cinco notas de provas obtidas por alunos. 
Faça um algoritmo que calcule a média de cada aluno e a média geral da turma e que 
imprima o resultado da seguinte forma. 
 
 
 
 
 
 Profª: Kellen Nery 
13 
 
 
SUBALGORITMOS 
Você pode reduzir a complexidade de um algoritmo, sabendo utilizar o raciocínio lógico 
para dividir um problema grande em diversos problemas menores. Dessa forma, a 
complexidade é reduzida, favorecendo a compreensão. 
E é nesse contexto que entram os subalgoritmos, que são trechos de programas que 
podem ser utilizados dentro de um programa maior, sempre que necessário ou conveniente. 
Você conhecerá os conceitos acerca de subalgoritmos, classificando-os em funções e 
procedimentos. Você irá conhecer também os conceitos, sintaxe e aplicações das funções e 
procedimentos. Veremos como criar, declarar e em que parte do algoritmo eles devem ficar 
posicionados. Você aprenderá, também, como fazer a chamada de funções e procedimentos 
dentro do algoritmo principal e os conceitos de escopo de variáveis, definindo variáveis globais 
e locais e a comunicação entre as funções e procedimentos e o algoritmo através dessas 
variáveis. 
os conhecimentos que você adquiriu até hoje, você sabe que é capaz de construir 
algoritmos que podem resolver problemas de diversos tipos. 
Além da diversidade de tipos de problemas, nos algoritmos, poderemos nos deparar com 
diversas situações diferentes dentro de um mesmo problema. E quanto maior essa 
diversidade, podemos dizer que maior é a complexidade do algoritmo. 
Para reduzir essa complexidade, é interessante utilizarmos a nossa habilidade de raciocínio 
lógico para decompor os problemas grandes e complexos em diversos problemas menores e 
mais simples. 
Dessa forma, fica mais fácil manter o foco em cada ‘subproblema’ por vez, aumentando a 
compreensão. 
Em algoritmos, essa decomposição é possível quando utilizamos os subalgoritmos. 
 
Observação: Um subalgoritmo é um trecho de programa que contém início e fim, 
executa um determinado conjunto de instruções e possui um identificador, por meio do qual 
pode ser chamado em qualquer parte do algoritmo, como se fosse um comando. 
 
Imagine que um determinado algoritmo precisa realizar um mesmo conjunto de ações 
repetidas vezes ao longo de sua execução. Ao invés de escrevermos esse conjunto de ações 
várias vezes ao longo do algoritmo, criamos um subalgoritmo e o algoritmo principal o ‘chama’ 
sempre que precisar dele. 
Por exemplo: ao preencher um formulário com dados de diversas pessoas, o usuário digita, 
em dado momento, o ano de nascimento da pessoa e, automaticamente, é preenchido o 
campo seguinte, com a idade da pessoa. 
Em um programa que não utiliza subalgoritmos, a expressão ‘idade <- ano_atual – 
ano_nascimento’ é calculada cada vez que novos dados são inseridos. Se utilizarmos um 
subalgoritmo que realize esse cálculo, apenas chamamos o subalgoritmono momento 
necessário. 
Ao terminar a execução do subalgoritmo chamado, o fluxo de execução natural do 
algoritmo principal prossegue. 
Dessa forma, quando um algoritmo é muito complexo, a estratégia é dividi-lo em um 
algoritmo principal e diversos (tantos quantos forem necessários) subalgoritmos. 
Se, ainda assim, algum nível de complexidade for mantido, é possível os subalgoritmos 
chamarem outros subalgoritmos. 
 Profª: Kellen Nery 
14 
 
A utilização de subalgoritmos facilita o trabalho do programador, pois, além de melhorar a 
compreensão e reduzir a complexidade, permite que se detectem e corrijam eventuais falhas 
com maior precisão e agilidade e favorece, também, a reutilização de subalgoritmos que foram 
implementados em outros programas. Dessa forma, reduzimos, além da complexidade, o 
tempo gasto para escrever o programa. 
 
Elementos de um subalgoritmo 
Os elementos de um subalgoritmo são o corpo e o cabeçalho. 
No corpo, são definidas as instruções, ou seja, as ações que o subalgoritmo vai executar 
cada vez que for chamado dentro do algoritmo principal. 
No cabeçalho, definimos o nome, os parâmetros, as variáveis locais e o tipo. Veja a 
descrição de cada um desses elementos a seguir. 
 
a. Nome – é o identificador pelo qual o subalgoritmo será chamado no algoritmo 
principal. 
b. Parâmetros – são os dados que permitem as relações entre o subalgoritmo e o 
algoritmo. Ou seja, são os dados que o subalgoritmo precisa receber para executar 
suas instruções e os dados que ele retorna quando termina de executar. Por exemplo, 
para realizar uma soma, os parâmetros recebidos são os números que serão somados. 
Ao efetuar a soma, retornamos o resultado dessa soma. 
c. Variáveis locais – são as variáveis declaradas no subalgoritmo e que só podem ser 
utilizadas dentro dele. 
d. Tipo – os subalgoritmos podem ser de dois tipos: funções ou procedimentos. A 
diferença entre ambos é que uma função retorna sempre a um único valor. Um 
procedimento não retorna valores, mas os recebe e modifica. 
 
 
Escopo de variáveis 
As variáveis que criamos no início de um algoritmo podem ser utilizadas em qualquer lugar 
dentro do algoritmo. Se desejarmos utilizar tais variáveis dentro de um subalgoritmo, por 
exemplo, podemos fazer isso sem problemas. Essas variáveis são as variáveis globais. 
Ao criarmos um subalgoritmo, porém, criamos variáveis específicas para utilizarmos em 
seu interior. Tais variáveis são inicializadas no momento em que o subalgoritmo está sendo 
executado e são válidas somente em seu interior. Elas não são visualizadas fora dos limites do 
subalgoritmo. São as variáveis locais. 
A essa visibilidade das variáveis (se ela é local ou global), damos o nome de escopo de 
variáveis. Trata-se da abrangência de uma variável, ou seja, em que limites do algoritmo ela é 
visível e pode ser utilizada. 
Veja, na Figura 1, como podemos ilustrar a hierarquia da visibilidade das variáveis. 
 
 Profª: Kellen Nery 
15 
 
 
Figura 1 
 
Veja que as variáveis A e B estão declaradas no algoritmo principal. Logo, elas são variáveis 
globais que podem ser utilizadas em qualquer subalgoritmo do conjunto que vemos na Figura 
1. 
Porém, declaramos a variável A novamente, em outro contexto, no subalgoritmo 1. Essa 
nova variável A, nesse caso, não é a mesma que foi criada no algoritmo principal. Trata-se de 
uma variável local do subalgoritmo 1 e que pode ser utilizada no subalgoritmo 1.1 (ou em 
qualquer subalgoritmo interno ao subalgoritmo 1). A variável X é, também, local ao 
subalgoritmo 1 e pode ser utilizada no subalgoritmo 1.1. 
É declarada, no subalgoritmo 2.1 outra variável X, que é local naquele subalgoritmo (ela 
não tem relação alguma com a variável X do subalgoritmo 1). A variável M é local ao 
subalgoritmo 2 e pode ser utilizada no subalgoritmo 2.1. a variável W é local ao subalgoritmo 
1.1 e somente neste subalgoritmo pode ser visualizada. 
 
Observação: Uma variável local pode ter o mesmo nome de uma variável global. Porém, 
uma vez declaradas em contextos diferentes, elas são distintas. 
 
Além de melhorar o desempenho do algoritmo, essa divisão entre variáveis locais e globais 
serve para definir os parâmetros de um subalgoritmo. Ou seja, elas estabelecem a 
comunicação entre o subalgoritmo e o algoritmo principal, que o chamou. 
As variáveis globais do algoritmo servem como dados de entrada para o subalgoritmo e as 
variáveis locais do subalgoritmo armazenam os dados recebidos para, com eles, efetuar os 
cálculos necessários. 
No caso das funções, como veremos adiante, a variável (local) de retorno (através do 
comando retorne) serve como dado de saída da função para o algoritmo principal e uma 
variável global recebe e armazena essa informação. Ao acessar essa variável global, temos 
acesso ao valor de retorno da função. 
 
Observação: A maneira com que tratamos as variáveis dentro do algoritmo pode afetar 
de forma direta o desempenho do programa, pois uma variável local é liberada (um espaço 
na memória é liberado) assim que o subalgoritmo que a utiliza termina de executar. Dessa 
forma, se uma variável vai ser utilizada somente no interior de um subalgoritmo, não há 
necessidade de declará-la como variável global. 
 
 Profª: Kellen Nery 
16 
 
Você pode utilizar variáveis globais nos subalgoritmos que você criar. Porém, é 
recomendável que você utilize variáveis locais, pois isso permite que o subalgoritmo seja 
executado sem interferir em outros subalgoritmos que possam estar utilizando as mesmas 
variáveis. 
 
 
Funções 
As funções, em algoritmos, seguem o mesmo princípio das funções matemáticas que 
aprendemos na escola. Quando dizemos que f(x)=x+1, temos duas variáveis (x e f(x)) e, com 
base no valor de uma delas, encontramos o valor da outra. 
Você viu, há pouco, que um subalgoritmo tem, como elementos, dentre outros, os 
parâmetros, que são os dados que ele recebe para poder executar suas instruções (as variáveis 
globais). Dessa forma, em uma função soma, teríamos como parâmetros os números a serem 
somados (no caso da função matemática acima, o x, que é informado pelo usuário) e como 
valor de retorno o resultado da soma entre os números (nesse mesmo caso, o f(x), que é a 
variável local onde fica armazenado o valor de retorno). 
 
Observação: Uma função é um subalgoritmo que é chamado dentro do algoritmo através 
da citação de seu nome (identificador) e deve retornar um único valor. 
 
As funções, assim como as variáveis, devem ser declaradas antes de serem inicializadas. 
Essa declaração deve estar posicionada no espaço após a declaração das variáveis e antes do 
início da execução do algoritmo. Assim: 
 
 
 
 Profª: Kellen Nery 
17 
 
 
Veja o algoritmo abaixo, que utiliza uma função que soma dois números: 
 
 
Observe que, após a declaração das variáveis globais do algoritmo (os números a e b a 
serem somados e a variável soma, para armazenar o resultado), criamos a função. O nome da 
função é fsoma. Os parâmetros são os números inteiros que serão armazenados nas 
variáveis a1 eb1(variáveis locais de fsoma). O tipo de retorno da função é inteiro. Outra 
variável local é a variável resultado, onde será armazenado o resultado da soma entre a1 e b1. 
No algoritmo principal, são recebidos dois números inteiros, que são armazenados nas 
variáveisa e b. Chamamos, então, em uma expressão de atribuição (nesse caso), a 
função fsoma, que armazenará em a1 e b1 os valores de a e b, digitados, e retornará o valor 
encontrado na soma, que está armazenado na variável resultado. Esse valor é, então, 
armazenado na variável soma(por atribuição) e exibido, em seguida. 
Execute o algoritmo no VisuAlg. 
 
É importante salientar alguns pontos, descritos a seguir. 
 
a. Os parâmetros da função são separados por vírgula (comona declaração de variáveis), 
se forem do mesmo tipo. Se forem de tipos diferentes, devemos separá-los por ponto-
e-vírgula (;). 
b. O tipo de retorno da função, bem como todas as suas variáveis locais, pode ser 
qualquer um entre os tipos de dados básicos que conhecemos: inteiro, real, lógico, 
literal ou caractere. Porém, o VisuAlg não suporta variáveis compostas (vetores e 
matrizes) como parâmetros de subalgoritmos. 
c. O comando retorne é utilizado para informar o valor de retorno da função ao 
algoritmo, no momento em que a função é chamada. 
d. A função é chamada sempre em uma expressão, em que o valor armazenado na 
variável de retorno da função é atribuído a uma variável do algoritmo. 
e. Sempre que chamar a função é imprescindível que os parâmetros passados (no caso 
do nosso exemplo, os valores das variáveis globais a e b) devem, obrigatoriamente, 
estar entre parêntesis, na mesma ordem, ser do mesmo tipo e em igual quantidade 
aos parâmetros da função (variáveis locais a1 e b1). 
 Profª: Kellen Nery 
18 
 
 
Procedimentos 
Um procedimento é um subalgoritmo, assim como a função. A principal diferença entre 
ambos é que a função retorna um valor, enquanto o procedimento não retorna, mas modifica 
os valores recebidos. 
Um procedimento é um subalgoritmo que é chamado dentro do algoritmo através da 
citação de seu nome (identificador) e deve alterar os valores dos parâmetros recebidos. 
Você viu, na aula anterior, que uma função retorna um único valor, enquanto um 
procedimento não retorna, mas modifica os valores. Existem, porém outras diferenças 
importantes entre os dois: 
 
Funções Procedimentos 
As funções retornam o seu valor de 
forma explícita, por meio do comando 
retorne. 
Os procedimentos não retornam valor. 
Não existe comando retorne. 
As chamadas às funções ocorrem sempre 
em expressões ou instruções de atribuição. 
Os procedimentos são chamados em 
comandos isolados, com as instruções de 
entrada e saída de dados (leia e escreva), e 
nunca em expressões ou atribuições. 
 
Os procedimentos devem ser criados e declarados na mesma posição que as funções: após 
a declaração de variáveis dos algoritmos e antes do início da execução do mesmo. Veja: 
 
Algoritmo “<nome do algoritmo>” 
Var 
 <declaração de variáveis do algoritmo> 
<declaração do procedimento> 
Inicio 
 <corpo do algoritmo> 
fimalgoritmo 
 
A sintaxe da criação de um procedimento é a seguinte: 
//cabeçalho, com o nome e os parâmetros 
procedimento <identificador> (var <lista de parâmetros>:<tipo dos parâmetros>) 
//inicio da execução do procedimento 
Inicio 
<instruções> 
fimprocedimento 
 
Veja o algoritmo abaixo, que utiliza um procedimento que calcula a área de um triângulo: 
 Profª: Kellen Nery 
19 
 
 
 
Veja que o procedimento é criado após a declaração das variáveis globais do algoritmo. No 
momento da declaração do procedimento, seus parâmetros (variáveis locais) são informados 
entre parêntesis, precedidos da palavra chave var. Isso ocorre porque os procedimentos, como 
vimos há pouco, modifica valores por meio dos parâmetros, diferente das funções, que 
utilizam a instrução retorne. 
Sabemos que os parâmetros permitem a comunicação entre o subalgoritmo e o algoritmo 
que o chama. 
Dessa forma, o procedimento recebe os valores através das variáveis globais (no 
caso, altura ebase) e os armazena em suas variáveis locais (h e b). Após realizar o cálculo da 
área, o valor resultante é passado, por meio da variável local ar, e armazenado na variável 
global area. 
Por isso, ao chamarmos o procedimento no algoritmo principal, devemos fornecer os 
parâmetros (variáveis globais do algoritmo), entre parêntesis, na mesma ordem, quantidade e 
tipo que os parâmetros (variáveis locais) do procedimento. 
 
 
Passagem de parâmetros 
 
Sabemos que, em funções e procedimentos, deve haver uma comunicação entre o 
subalgoritmo e o algoritmo que o chama, através das variáveis globais do algoritmo e as 
variáveis locais do subalgoritmo. A essa comunicação, damos o nome de passagem de 
parâmetros. 
Os tipos de parâmetros que utilizamos nesse processo são dois, veja-os a seguir. 
1. Parâmetros formais – são aquelas variáveis locais que declaramos entre parêntesis, 
nos cabeçalhos dos subalgoritmos. São utilizados para realizar os cálculos dentro do 
subalgoritmo. 
2. Parâmetros reais – são os valores que substituem os parâmetros formais no momento 
da chamada de um subalgoritmo. 
 
 Profª: Kellen Nery 
20 
 
Por exemplo, veja o cabeçalho da função fsoma, a seguir. 
 
Funcao fsoma (a1, b1 : inteiro) : inteiro 
 
As variáveis a1 e b1 são os parâmetros formais da função. 
Veja, agora, o seguinte trecho do algoritmo que chama essa função: 
 
leia (a) 
leia (b) 
soma <- fsoma (a,b) 
 
Os valores armazenados nas variáveis globais a e b são os parâmetros reais. Note que 
poderíamos, simplesmente, chamar a função, passando os valores diretamente: soma <- 
fsoma (3,5). Nesse caso, os números 3 e 5 seriam os parâmetros reais. 
No processo de passagem de parâmetros, são passados dados de entrada do algoritmo 
para o subalgoritmo e dados de saída no sentido oposto. Veja esse processo ilustrado na 
Figura 2. 
 
Figura 2 
 
Na Figura 2, podemos ver uma função, no módulo da esquerda, que calcula uma soma 
entre dois números. No módulo da direita, temos o corpo do algoritmo que chama essa 
função. 
O algoritmo passa os dados de entrada (números armazenados nas variáveis a e b, que são 
os parâmetros reais) para a função, que os armazena em suas variáveis locais a1 e b1 
(parâmetros formais). O cálculo é efetuado e o valor encontrado é armazenado na variável 
local resultado. Através do comando retorne, esse valor é passado como dado de saída para o 
algoritmo (no momento da chamada da função), que o armazena na variável global soma para, 
então, ser exibido. 
Em um procedimento, essa passagem de parâmetros é feita de uma forma um pouco 
diferente. Veja a Figura 3. 
 Profª: Kellen Nery 
21 
 
 
Figura 3 
 
No procedimento, a comunicação de saída não é feita de forma explícita como na função. 
Veja que, ao contrário do que é feito na função, a palavra reservada var é utilizada nos 
parâmetros do procedimento. Veja, também, que, na chamada ao procedimento, todos os 
dados são passados como parâmetros, ao passo que na função, são passados apenas os dados 
de entrada (os números armazenados em a e b). Por que será que isso ocorre? 
Porque os parâmetros, na função da Figura 2, estão sendo passados por valor e, no 
procedimento da Figura 3, os parâmetros estão sendo passados por referência. 
 
 
Passagem de parâmetros por valor 
Quando um parâmetro é passado por valor, no momento da chamada do subalgoritmo, o 
valor do parâmetro real é ‘copiado’ para o parâmetro formal. Dessa forma, não há alteração 
no valor do parâmetro real, sejam quais forem os cálculos realizados no subalgoritmo. 
Na passagem de parâmetros por valor, são criadas as variáveis (é reservado um espaço na 
memória) locais como parâmetros formais para armazenar uma cópia do valor dos parâmetros 
reais. 
 
 
Passagem de parâmetros por referência 
No mecanismo de passagem de parâmetros por referência, não há reserva de espaço extra 
na memória para os parâmetros formais. Nesse caso, no momento da chamada ao 
subalgoritmo, os parâmetros reais e formais correspondentes compartilham o mesmo espaço 
em memória. Desse modo, as modificações feitas nos parâmetros formais dos subalgoritmos 
afetam os parâmetros reais. 
Para diferenciar a passagem de parâmetros por valor da passagem por referência, 
utilizamos, neste segundo método, a palavra reservada var antes dos parâmetros, no 
cabeçalho do subalgoritmo. É o que você viu na Figura 2. 
 
 
 Profª: Kellen Nery 
22Exemplo Passagem de Parâmetro Valor x Referência 
 
 
 
Saída do programa: N1 = 0 N2 = 1 
 
No programa acima a variável N2 que é representada por Y (e tem a passagem por 
referencia), é afetado seu valor real e sendo assim tem se como resultado o valor 1. A variável 
N1 (como o calculo ficou retido dentro do procedimento) não foi alterada em nada.