Guia de Estudos da Unidade 3 - Lógica de Programação Algorítmica

Prévia do material em texto

Lógica de Programação 
Algorítmica
UNIDADE 3
1
Palavras do Professor
Olá, aluno(a)!
Seja bem-vindo(a)!
Estamos iniciando a terceira unidade da nossa disciplina Lógica de Programação, cujo conteúdo já apre-
sentamos no vídeo de apresentação da disciplina. 
Na unidade anterior, vimos estruturas de repetição determinadas e indeterminadas, contadores, acumu-
ladores e tivemos um primeiro contato com os vetores, que serão abordados novamente nesta unidade.
Antes de prosseguir com esse texto, leia o capítulo 3 do livro-texto da disciplina. Depois disso, volte a este 
ponto para continuarmos o nosso estudo. 
Agora que você já leu o terceiro capítulo do nosso livro-texto, vamos iniciar os nossos estudos.
2
CoNCeITos de MaTrIZes
Na unidade anterior lidamos com vetores, ou seja, estruturas de armazenamento que tinham uma só 
dimensão. Nesta, vamos estender o conceito: vamos falar de matrizes. 
O uso de vetores é apropriado para resolver muitos problemas, mas existem alguns tipos de problemas 
que demandam o uso de estruturas mais sofisticadas. É nisso que as matrizes se encaixam. Seu uso é 
aplicável a diversos casos, e vamos ver agora um exemplo disso.
Por exemplo: suponha um prédio com 5 andares e 2 apartamentos por andar. Se quiséssemos representar 
num vetor, ficaria um pouco mais difícil de manipular.
Uma opção seria colocar os 10 apartamentos em um vetor com 10 posições, mas ficaria a pergunta: Como 
vamos enfileirar esses apartamentos dentro do vetor?
Nesse caso, cada apartamento ficaria armazenado em uma ocorrência dentro do vetor. Mas isso não seria 
a melhor forma de representar. Os apartamentos não ficam em fila, exceto quando só tem um por andar.
Os casos mais comuns têm prédios com dois ou mais apartamentos por andar. Como o mais comum é 
termos 2 por andar, vamos fazer a matriz refletir isso.
Portanto, podemos fazer isso com matrizes.
Mas, antes disso, vamos definir o que são matrizes.
definição de matrizes
Do ponto de vista da programação, uma matriz é equivalente a um conjunto de vetores empilhados. Como 
seria isso?
Suponha que você tenha 2 vetores, cada um representando um lado do prédio, e outro representando o 
outro lado.
Supondo que existem 5 andares, com 2 apartamentos por andar, poderíamos fazer assim:
O vetor LADO1 teria 5 apartamentos:
101 201 301 401 501 
O vetor LADO2 teria outros 5 apartamentos:
102 202 302 402 502 
As declarações seriam assim:
3
Var
LADO1, LADO2: VETOR [1..5] DE INTEIRO
Que tal se ao invés de ter 2 vetores você tivesse apenas 1 matriz? A matriz seria assim:
101 201 301 401 501 
102 202 302 402 502
A declaração não mudaria muito, e continuaria simples:
VAR
predio : vetor [1..5, 1..5] de inteiro
Ou seja, na prática, a matriz se comporta como 2 (ou mais) vetores empilhados.
Para preencher um vetor, você usava um PARA com a variável I, inteira, controlando a repetição, conforme 
exemplo abaixo:
ALGORITMO “REPETICAO DETERMINADA” 
VAR
I : inteiro
apto :vetor[1..10] de inteiro 
Inicio
Para i:=1 ate 10 faca 
Escreval(“informe número do apto”) 
leia(apto[i])
Fimpara
FIMALGORITMO
Agora, como você vai preencher uma matriz, precisaria de 2 variáveis de controle.
veja o vídeo!
Assista a esse vídeo com exemplo de uso de matrizes e depois volte para esse ponto 
do texto. Clique aqui para assistir. (Duração: 09:24). Para exemplificar, insira o código 
abaixo no Visualg e execute com F9. 
https://www.youtube.com/watch?v=gmtZSoyy0UI
4
ALGORITMO PRIMEIRAMATRIZ” 
VAR
I, J : inteiro
numero :vetor[1..3,1..3] de inteiro 
Inicio
Para i:=1 ate 3 faca
 Para j:=1 ate 3 faca
 Escreval(“informe numero da linha ”, i , “ coluna “, j) 
 leia(numero[i,j])
 Fimpara 
Fimpara
FIMALGORITMO
Se você inseriu o código acima no visualg e executou, percebeu que conseguiu inserir os 9 valores da 
matriz na seguinte ordem:
numero[1,1] 
numero[1,2] 
numero[1,3] 
numero[2,1] 
numero[2,2] 
numero[2,3] 
numero[3,1] 
numero[3,2] 
numero[3,3]
Ou seja, foram inseridos 9 (nove) números, já que a matriz tem 3 linhas por 3 colunas, que dá um total de 
3 X 3 = 9 elementos.
Esse é o primeiro conceito que você deve aprender sobre matrizes, que diz que o número total de elemen-
tos de uma matriz é igual ao produto do número de linhas pelo número de colunas.
No algoritmo acima, você apenas carregou os elementos da matriz. Que tal listarmos esses elementos? 
Vamos modificar o algoritmo, que agora ficará assim:
ALGORITMO “PRIMEIRAMATRIZMODIFICADO” 
VAR
I ,J : inteiro
numero :vetor[1..3,1..3] de inteiro 
Inicio
Para i:=1 ate 3 faca 
 Para j:=1 ate 3 faca
 Escreval(“informe número da linha ”, i , “ coluna “, j) 
 leia(numero[i,j])
 Fimpara 
Fimpara
5
Para i:=1 ate 3 faca 
 Para j:=1 ate 3 faca
 Escreval(“elemento da linha ”, i , “ coluna “, j , “ : ”, numero[i,j]) 
 Fimpara
Fimpara
FIMALGORITMO
No caso acima, usamos uma matriz com 2 dimensões. No caso de matrizes, não há limites: você pode ter 
matrizes com várias dimensões. Depende apenas do tipo de problema que você pretende resolver.
Carregando matrizes
Da mesma forma que vimos em vetores e em qualquer tipo de variável com as quais já trabalhamos, é 
possível carregar uma matriz por atribuição de valores aos seus elementos de forma direta ou lendo do 
teclado. Vamos ver alguns exemplos disso:
Carregamento de matrizes lendo pelo teclado
Insira o algoritmo abaixo no Visualg e teste. 
ALGORITMO “LENDOCIDADES”
VAR
I, J: inteiro
cidade :vetor[1..3,1..3] de literal 
Inicio
Para i:=1 ate 3 faca 
 Para j:=1 ate 3 faca
 Escreval(“informe nome da cidade”, i , “ coluna “, j) 
 leia(cidade[i,j])
 Fimpara 
Fimpara
Para i:=1 ate 3 faca 
 Para j:=1 ate 3 faca
 Escreval(“cidade linha ”, i , “ coluna “, j , “ : ”, cidade[i,j]) 
 Fimpara
Fimpara 
FIMALGORITMO
Vamos ver outro algoritmo que faz algo semelhante:
6
ALGORITMO “LENDONOTAS”
VAR
I, J: inteiro
nota :vetor[1..4,1..4] de literal 
Inicio
Para i:=1 ate 4 faca 
 Para j:=1 ate 4 faca
 Escreval(“informe nota “, i , “da unidade “, j) 
 leia(nota[i,j])
 Fimpara 
Fimpara
Para i:=1 ate 3 faca 
 Para j:=1 ate 3 faca
 Escreval(“nota “, i , “da unidade “, j ,“:” ,nota[i,j]) 
 Fimpara
Fimpara 
FIMALGORITMO
Legal, não é? Pelo que podemos ver, não tem muita diferença do que já fizemos em outros exemplos.
Por outro lado, podemos carregar uma matriz de forma automática. É o que veremos no item abaixo.
Carregando matrizes automaticamente
Você pode colocar diversos valores de forma automática numa matriz. Por exemplo, para zerar todos os 
elementos, você poderia fazer:
ALGORITMO “ZERANDOMATRIZ” 
VAR
I ,J : inteiro
numero :vetor[1..3,1..3] de inteiro 
Inicio
Para i:=1 ate 3 faca 
 Para j:=1 ate 3 faca
 Escreval(“informe número da linha ”, i , “ coluna “, j) 
 leia(numero[i,j])
 Fimpara 
Fimpara
// NESSE PONTO, VAMOS ZERAR OS ELEMENTOS DA MATRIZ:
7
Para i:=1 ate 3 faca 
 Para j:=1 ate 3 faca
 Escreval(“informe numero da linha ”, i , “ coluna “, j) numero[i,j] : =0
 Fimpara 
Fimpara
// AGORA VAMOS LISTAR OS ELEMENTOS. PERCEBA QUE TODOS FICARAM IGUAIS A ZERO:
Para i:=1 ate 3 faca 
 Para j:=1 ate 3 faca
 Escreval(“elemento da linha ”, i , “ coluna “, j , “ : ”, numero[i,j]) 
 Fimpara
Fimpara 
FIMALGORITMO
operações diversas com matrizes
•	 Somando elementos equivalentes de matrizes
No exemplo abaixo, vamos criar uma terceira matriz que é equivalente à soma de duas outras matrizes 
já existentes.
ALGORITMO “SOMANDOMATRIZES” 
VAR
I ,J: inteiro
M1,M2,M3 :vetor[1..4,1..4] de literal 
Inicio
Para i:=1 ate 4 faca 
 Para j:=1 ate 4 faca
 Escreval(“número “, i , “da unidade “, j , “da matriz 1”) 
 leia(M1[i,j])
 Escreval(“número “, i , “da unidade “, j ,“da matriz 2”) 
 M3[i,j] := M1[i,j] + M2[i,j]
 Fimpara 
Fimpara
// agora vamos listar a matriz 3
Para i:=1 ate 4 faca 
 Para j:=1 ate 4 faca
 Escreval(M3[i,j]) 
 Fimpara
Fimpara 
FIMALGORITMO
8
•	 Produto de elementos equivalentes de matrizes
Do mesmo jeito quefizemos para a soma, poderíamos fazer o produto (que não é o mesmo que o produto 
de matrizes que você aprendeu no ensino médio).
No exemplo abaixo, vamos criar uma terceira matriz que é equivalente ao produto de duas outras matrizes 
já existentes.
ALGORITMO “PRODUTOMATRIZES” 
VAR
I ,J: inteiro
M1,M2,M3 :vetor[1..4,1..4] de literal 
Inicio
Para i:=1 ate 4 faca 
 Para j:=1 ate 4 faca
 Escreval(“número “, i , “da unidade “, j , “da matriz 1”) 
 leia(M1[i,j])
 Fimpara 
Fimpara
Para i:=1 ate 4 faca 
 Para j:=1 ate 4 faca
 Escreval(“número “, i , “da unidade “, j ,“da matriz 2”) 
 leia(M2[i,j])
 M3[i,j]:=M1[i,j]*M2[i,j] 
 M2[i,j]
 Fimpara 
Fimpara
Para i:=1 ate 4 faca 
 Para j:=1 ate 4 faca
 Escreval(M3[i,j]) 
 Fimpara
Fimpara 
FIMALGORITMO
Na prática, a mudança é bem pequena. As demais operações podem perfeitamente ser feitas dessa for-
ma. Experimente fazer divisão e subtração dessas matrizes, e liste o resultado. Use o Visualg para isso.
Vamos ver agora que as matrizes podem ser carregadas em qualquer ordem. Vamos começar com a carga 
de uma matriz do fim para o começo.
9
Carregando matrizes de trás para frente
Você também pode carregar uma matriz ao contrário, como no algoritmo abaixo. De toda forma, a listagem 
será feita da forma normal. Insira o código abaixo no Visualg e observe o comportamento.
ALGORITMO “CARREGANDAOCONTRARIO” 
VAR
I , J : inteiro
numero :vetor[1..3,1..3] de inteiro 
Inicio
Para i:=3 ate 1 passo -1 faca 
 Para j:= 3 ate 1 passo -1 faca
 Escreval(“informe número da linha ”, i , “ coluna “, j) 
 leia(numero[i,j])
 Fimpara 
Fimpara
Para i:=1 ate 3 faca 
 Para j:=1 ate 3 faca
 Escreval(“elemento da linha ”, i , “ coluna “, j , “ : ”, numero[i,j]) 
 Fimpara
Fimpara
Para i:=3 ate 1 passo -1 faca
 Para j:=3 ate 1 passo -1 faca
 Escreval(“elemento da linha ”, i , “ coluna “, j , “ : ”, numero[i,j]) 
 Fimpara
Fimpara
Ou seja, podemos fazer várias operações com diversas matrizes. Vamos agora ver um tópico muito inte-
ressante: contabilização de dados em matrizes, ou seja, contagens, somas, médias, maior, menor, etc. 
Com esse tipo de contabilização, podemos tornar bastante útil o uso de matrizes. Vejamos a seguir.
Contabilizando dados de matrizes
Observe o algoritmo abaixo:
ALGORITMO “CONTABILIZANDO MATRIZES” 
VAR
I , J: inteiro
numero :vetor[1..3,1..3] de inteiro 
Inicio
10
Para i:=1 ate 3 faca 
 Para j:=1 ate 3 faca
 Escreval(“informe número da linha ”, i , “ coluna “, j) 
 leia(numero[i,j])
 Fimpara 
Fimpara
Para i:=1 ate 3 faca 
 Para j:=1 ate 3 faca
 Escreval(“elemento da linha ”, i , “ coluna “, j , “ : ”, numero[i,j]) 
 Fimpara
Fimpara 
FIMALGORITMO
Nele, estamos fazendo a leitura e depois a listagem do vetor. É claro que isso não basta, ou seja, é inte-
ressante contar quantos elementos são iguais a zero, por exemplo. 
Com o exemplo, podemos perceber que temos muitas coisas a contabilizar dentro de uma matriz. É o que 
vamos ver como fazer.
Para isso, usaremos um contador chamado “qtdzero”. E colocaremos a instrução “qtdzero := qtdzero +1“ 
dentro do programa sempre que ele encontrar algum elemento igual a zero. Usaremos o comando “SE”, 
que já vimos anteriormente. O programa ficará assim:
ALGORITMO “CONTABILIZANDO MATRIZES2” 
VAR
I , J: inteiro
numero :vetor[1..3,1..3] de inteiro 
qtdzero : inteiro
Inicio
Para i:=1 ate 3 faca 
 Para j:=1 ate 3 faca
 Escreval(“informe número da linha ”, i , “ coluna “, j) 
 leia(numero[i,j])
 se numero[i,j] = 0 então 
 qtdzero := qtdzero + 1
 fimse 
 Fimpara
Fimpara
Para i:=1 ate 3 faca 
 Para j:=1 ate 3 faca
 Escreval(“elemento da linha ”, i , “ coluna “, j , “ : ”, numero[i,j]) 
 Fimpara
Fimpara
escreval(“nesta matriz existem “, qtdzero , “ elementos iguais a zero”) 
FIMALGORITMO
11
Legal, não é?
Já que contamos quantos elementos são iguais a zero, também podemos somar todos esses elementos. 
Para isso precisaremos de uma variável ACUMULADORA, ou seja, que soma os elementos do vetor. Pode-
mos, portanto, criar a variável SOMA que terá esse papel. Além disso, colocaremos o comando “soma := 
soma + numero[i,j]” para realizar essa soma. O algoritmo ficará assim:
ALGORITMO “CONTABILIZANDO MATRIZES2” 
VAR
I ,J : inteiro
numero :vetor[1..3,1..3] de inteiro 
qtdzero : inteiro
soma : inteiro 
Inicio
Para i:=1 ate 3 faca 
 Para j:=1 ate 3 faca
 Escreval(“informe número da linha ”, i , “ coluna “, j)
 leia(numero[i,j])
 se numero[i,j] = 0 então 
 qtdzero := qtdzero + 1
 fimse
 soma : = soma + numero[i,j] 
 Fimpara
Fimpara
Para i:=1 ate 3 faca 
 Para j:=1 ate 3 faca
 Escreval(“elemento da linha ”, i , “ coluna “, j , “ : ”, numero[i,j]) 
 Fimpara
Fimpara
escreval(“nesta matriz existem “, qtdzero , “ elementos iguais a zero”) 
escreval(“a soma dos elementos dessa matriz é “, soma)
FIMALGORITMO
Repare que a soma deve ficar fora do comando SE, para contar todos os elementos. Se ela ficar dentro 
do comando SE, dará zero porque dentro desse SE a matriz só tem números iguais a zero, ou seja, o que 
estiver dentro desse SE só vai ser acionado se o número for zero. E a soma de zeros só poderia dar zero 
mesmo. Por isso, a soma deve ficar FORA do se.
Ora, se temos a soma temos a média. Então, nesse caso, podemos exibir a média dos números da matriz 
simplesmente dividindo a soma pela quantidade de elementos, que no caso acima são 9 elementos com-
pondo a matriz.
O algoritmo ficaria assim:
12
ALGORITMO “CONTABILIZANDO MATRIZES3” 
VAR
I , J: inteiro
numero :vetor[1..3,1..3] de inteiro 
qtdzero : inteiro
soma : inteiro 
Inicio
Para i:=1 ate 3 faca 
 Para j:=1 ate 3 faca
 Escreval(“informe número da linha ”, i , “ coluna “, j) 
 leia(numero[i,j])
 se numero[i,j] = 0 então 
 qtdzero := qtdzero + 1
 fimse
 soma : = soma + numero[i,j] 
 Fimpara
Fimpara
Para i:=1 ate 3 faca 
 Para j:=1 ate 3 faca
 Escreval(“elemento da linha ”, i , “ coluna “, j , “ : ”, numero[i,j])
 Fimpara 
Fimpara
escreval(“nesta matriz existem “, qtdzero , “ elementos iguais a zero”) 
escreval(“a soma dos elementos dessa matriz é “, soma)
escreval(“a média dos elementos dessa matriz é “, soma / 9) 
FIMALGORITMO
Com certeza, é muito interessante!
E se pudéssemos descobrir qual o maior valor entre os elementos dessa matriz?
Para isso, vamos precisar de uma variável para armazenar esse maior valor. Podemos chamá-la (Isso, você 
já adivinhou!) de MAIORVALOR.
Por estar sendo utilizada para buscar o maior valor entre os elementos de um grupo de inteiros, com cer-
teza essa variável também é inteira. Declararemos dessa forma:
maiorvalor : inteiro
Mas como podemos descobrir o maior valor? Da seguinte forma:
Para cada número, perguntamos se ele é maior do que o valor que está armazenado em MAIORVALOR. Se 
não for, é porque ele é menor do que ela, e nada é alterado.
13
Mas se ele for maior do que ela, então significa que essa variável foi superada e precisa se recuperar. 
Como ela faz isso? Assumindo pra si o valor que foi maior do que ela, então nesse caso essa variável 
passará a ter o maior valor.
Como fazer isso dentro do algoritmo? É simples. Basta que você coloque a seguinte pergunta, usando o 
comando SE:
Se numeros[i,j] > maiorvalor então 
 maiorvalor:= numeros [i,j]
fimse
E, no fim do algoritmo, você exibe a variável maiorvalor. O algoritmo ficará assim:
ALGORITMO “CONTABILIZANDO MATRIZES4” 
VAR
I , J: inteiro
numero :vetor[1..3,1..3] de inteiro 
qtdzero : inteiro
soma : inteiro 
maiorvalor : inteiro 
Inicio
Para i:=1 ate 3 faca 
 Para j:=1 ate 3 faca
 Escreval(“informe número da linha ”, i , “ coluna “, j) 
 leia(numero[i,j])
 se numero[i,j] = 0 então 
 qtdzero := qtdzero + 1
 fimse
 soma : = soma + numero[i,j]
 se numero[i,j] > maiorvalor então 
 maiorvalor := numero[i,j]
 fimse
 Fimpara 
Fimpara
Para i:=1 ate 3 faca 
 Para j:=1 ate 3 faca
 Escreval(“elemento da linha ”, i , “ coluna “,j , “ : ”, numero[i,j])
 Fimpara
Fimpara
escreval(“nesta matriz existem “, qtdzero , “ elementos iguais a zero”) 
escreval(“a soma dos elementos dessa matriz é “, soma)
escreval(“a média dos elementos dessa matriz é “, soma / 9) 
escreval(“o maior elemento dessa matriz é “, maiorvalor )
FIMALGORITMO
14
Da mesma forma que conseguimos identificar o maior valor, podemos fazer isso para o menor valor. Mas 
como podemos descobrir o menor valor? É semelhante ao do maior? Quase. 
Tem uma pequena diferença, mas que é fundamental saber para não correr risco de o algoritmo não con-
tabilizar esse menor valor. É muito importante que você esteja atento a este detalhe.
Ele funciona da seguinte forma: para cada número, perguntamos se ele é menor do que o valor que está 
armazenado em MENORVALOR. Se não for, é porque ele é maior do que ela, e nada é alterado.
Mas se ele for menor do que ela, então significa que essa variável foi superada e precisa se recuperar. 
Como ela faz isso? Assumindo pra si o valor que foi menor do que ela, então nesse caso, essa variável 
passará a ter o menor valor.
Do mesmo jeito que fizemos para o maior valor, como fazer isso dentro do algoritmo para o menor valor?
Vamos experimentar fazendo praticamente a mesma coisa, trocando o sinal e observando.
ALGORITMO “CONTABILIZANDO MATRIZES5” 
VAR
I , J : inteiro
numero :vetor[1..3,1..3] de inteiro 
qtdzero : inteiro
soma : inteiro
maiorvalor, menorvalor : inteiro 
Inicio
Para i:=1 ate 3 faca 
 Para j:=1 ate 3 faca
 Escreval(“informe número da linha ”, i , “ coluna “, j) 
 leia(numero[i,j])
 se numero[i,j] = 0 então
 qtdzero := qtdzero + 1
 fimse
soma : = soma + numero[i,j]
 se numero[i,j] > maiorvalor então 
 maiorvalor := numero[i,j]
 fimse
 se numero[i,j] < menorvalor então 
 menorvalor := numero[i,j]
 fimse 
 Fimpara
Fimpara
Para i:=1 ate 3 faca
 Para j:=1 ate 3 faca
 Escreval(“elemento da linha ”, i , “ coluna “, j , “ : ”, número[i,j]) 
 Fimpara
Fimpara
15
escreval(“nesta matriz existem “, qtdzero , “ elementos iguais a zero”) 
escreval(“a soma dos elementos dessa matriz é “, soma)
escreval(“a média dos elementos dessa matriz é “, soma / 9) 
escreval(“o maior elemento dessa matriz é “, maiorvalor ) 
escreval(“o menor elemento dessa matriz é “, menorvalor )
FIMALGORITMO
Coloque esse algoritmo no visualg e teste. Depois volte para esse texto. E aí, funcionou? NÃO?
Qual o motivo de não ter funcionado?
Se você só colocou números inteiros acima de zero, não vai conseguir achar o menor valor, sabe por quê? 
Porque o visualg atribui inicialmente valor ZERO às variáveis inteiras. 
Nesse caso, você precisará de um artifício para o algoritmo funcionar. No mundo da programação, isso é 
chamado (de forma bem humorada) de GAMBIARRA. 
Acho que você já deve ter ouvido isso em outras situações – saiba que o mundo da programação também 
tem as suas gambiarras – nem sempre são recomendadas, mas em casos de urgência acabam funcionando. 
Não estamos encorajando você a usá-las, mas todo profissional da área deve conhece-las até para saber 
quando NÃO usar. Como toda boa gambiarra, essa é bem simples. Basta atribuir inicialmente um alto 
valor para a variável MENORVALOR. Por exemplo, podemos colocar menorvalor:= 9999.
Se logo depois de “inicio” você fizer essa atribuição, o algoritmo vai funcionar. O algoritmo vai ficar assim:
ALGORITMO “CONTABILIZANDO MATRIZES6” 
VAR
I, J : inteiro
numero :vetor[1..3,1..3] de inteiro q
tdzero : inteiro
soma : inteiro
maiorvalor, menorvalor : inteiro 
Inicio
menorvalor:: = 9999 
Para i:=1 ate 3 faca
 Para j:=1 ate 3 faca
 Escreval(“informe número da linha ”, i , “ coluna “, j) 
 leia(numero[i,j])
 se numero[i,j] = 0 então 
 qtdzero := qtdzero + 1 
 fimse
 soma : = soma + numero[i,j]
 se numero[i,j] > maiorvalor então 
16
 maiorvalor := numero[i,j]
 fimse
 se numero[i,j] < menorvalor então 
 menorvalor := numero[i,j]
 fimse 
 fimse 
 Fimpara
Fimpara
Para i:=1 ate 3 faca 
 Para j:=1 ate 3 faca
 Escreval(“elemento da linha ”, i , “ coluna “, j , “ : ”, número[i,j]) 
 Fimpara
Fimpara
escreval(“nesta matriz existem “, qtdzero , “ elementos iguais a zero”) 
escreval(“a soma dos elementos dessa matriz é “, soma)
escreval(“a média dos elementos dessa matriz é “, soma / 9) 
escreval(“o maior elemento dessa matriz é “, maiorvalor ) 
escreval(“o menor elemento dessa matriz é “, menorvalor )
FIMALGORITMO
Muito interessante, não é? 
Sem dúvida, podemos ver que existem inúmeras possibilidades quando usamos matrizes. É importante 
relembrar que você pode ter matrizes de várias dimensões.
Mas também é bom lembrar que, quanto mais dimensões uma matriz tiver, mais complexa se tornará a 
sua manipulação.
Dependendo do caso, pode ser mais interessante trabalhar com mais de uma matriz e relacioná-las pelos 
números de linha e coluna.
Vamos tratar desse tema a seguir.
Trabalhando com matrizes relacionadas
Suponha que você esteja trabalhando com a contabilização das informações de um condomínio pequeno, 
com apenas 4 apartamentos, com 2 andares, ou seja, 2 apartamentos por andar. Para cada apartamento, 
você vai armazenar o valor devido de condomínio, que pode ser de zero (não deve nada) até qualquer valor.
Teremos as seguintes matrizes:
apto : vetor [1..2, 1..2] de literal, para armazenar o número do apartamento. Valordevido : vetor [1..2, 1..2] 
de real, para armazenar o valor devido por aquele apartamento. Inicialmente o programa ficaria assim, 
com a declaração das variáveis:
17
ALGORITMO “CONTABILIZANDOAPTOS” 
VAR
apto : vetor [1..2, 1..2] de literal
Valordevido : vetor [1..2, 1..2] de real 
I,J : inteiro
INICIO 
FIMALGORITMO
Naturalmente, precisaremos carregar esses vetores. Nesse caso, o algoritmo ficará assim:
ALGORITMO “CONTABILIZANDOAPTOS” 
VAR
apto : vetor [1..2, 1..2] de literal
valordevido : vetor [1..2, 1..2] de real
I,J : inteiro
INICIO
Para i:=1 ate 2 faca 
 Para j:=1 ate 2 faca
 Escreval(“informe número do apto da linha “, i, “ coluna “, j ) 
 leia(apto[i,j])
 Escreval(“informe valor devido pelo apto “ , apto[i,j])
 leia(valordevido[i,j]))
 Fimpara 
Fimpara
FIMALGORITMO
Até esse ponto, o algoritmo apenas carrega os valores nos vetores. Mas não vamos fazer apenas isso. 
Nessa contabilização, precisamos saber:
•	 Quantos apartamentos estão devendo;
•	 Qual o valor total devido;
•	 Qual a média de dívida por apartamento;
•	 Qual o apartamento que deve mais e o valor dessa dívida.
Vamos por partes:
Primeiro, vamos contar quantos apartamentos estão devendo. Criaremos a variável “qtddevedores”, que 
vai contar os apartamentos que têm dívida maior do que zero.
A declaração dela é: qtddevedores : inteiro E a sentença que faz essa contagem é: 
18
se valordevido[i,j]) >0 então
 qtddevedores := qtddevedores + 1
fimse
A mensagem que exibe isso é:
Escreval(“ a quantidade total de devedores é “, qtdevedores) 
Com isso, o algoritmo fica assim:
ALGORITMO “CONTABILIZANDOAPTOS”
VAR
apto : vetor [1..2, 1..2] de literal 
Valordevido : vetor [1..2, 1..2] de real 
qtddevedores : inteiro
I,J : inteiro
INICIO
Para i:=1 ate 2 faca 
 Para j:=1 ate 2 faca
 Escreval(“informe número do apto da linha “, i, “ coluna “, j ) 
 leia(apto[i,j])
 Escreval(“informe valor devido pelo apto “ , apto[i,j]) 
 leia(valordevido[i,j]))
 se valordevido[i,j]) > 0 então 
 qtddevedores := qtddevedores + 1
 fimse 
 Fimpara
Fimpara
Escreval(“ a quantidade total de devedores é “, qtdevedores)
FIMALGORITMO
Para obter o valor total devido, é simples: basta colocar uma variável acumuladora. A variável TOTAL-
DEVIDO serve bem a esse propósito. Declarando-a como real e colocando o comando TOTALDEVIDO := 
TOTALDEVIDO + valordevido[i,j] no programa, teremos o algoritmo assim:
ALGORITMO “CONTABILIZANDOAPTOS” 
VAR
apto : vetor [1..2, 1..2] de literal
 Valordevido : vetor [1..2, 1..2] de real 
 qtddevedores : inteiro
 totaldevido:real 
I,J : inteiro 
INICIO
19
Para i:=1 ate 2 faca 
 Para j:=1 ate 2 faca
 Escreval(“informe número do apto da linha “, i, “ coluna “, j ) 
 leia(apto[i,j])
 Escreval(“informe valor devido pelo apto “ , apto[i,j]) 
 leia(valordevido[i,j]))
 totaldevido := totaldevido + valordevido[i,j] 
 se valordevido[i,j]) > 0 então
 qtddevedores := qtddevedores + 1 
 fimse
 Fimpara 
Fimpara
Escreval(“ valor total devido é “, total devido)
Escreval(“ a quantidade total de devedores é “, qtdevedores) 
FIMALGORITMO
Para exibir a média de dívida, é só colocar o comando abaixo: 
escreval(“ o valor médio devido é “ , totaldevido /qtddevedores)
Para saber o maior valor devido pelo apartamento e qual o apartamento que deve mais, devemos utilizar 
duas variáveis: maiordivida e aptomaiordivida. A primeira variável guarda o maior valor devido e a segun-
da, o número do apto que deve mais.
Declaramos essas variáveis assim:
Maiordivida : real 
Aptomaiordivida : literal.
Além disso, inseriremos os seguintes trechos de programa:
Se valordevido[i,j] > maiordivida entao 
 Maiordivida:= valordevido[i,j] 
 Aptomaiordivida:= apto[i,j]
Fimse.
Inserindo esse código no algoritmo, ele fica assim: 
ALGORITMO “CONTABILIZANDOAPTOS” 
VAR
apto : vetor [1..2, 1..2] de literal 
Valordevido : vetor [1..2, 1..2] de real 
qtddevedores : inteiro
 totaldevido: real 
Maiordivida : real 
Aptomaiordivida : literal.
20
I,J : inteiro 
INICIO
Para i:=1 ate 2 faca 
 Para j:=1 ate 2 faca
 Escreval(“informe número do apto da linha “, i, “ coluna “, j ) 
 leia(apto[i,j])
 Escreval(“informe valor devido pelo apto “ , apto[i,j]) 
 leia(valordevido[i,j]))
 totaldevido := totaldevido + valordevido[i,j] 
 se valordevido[i,j]) > 0 então
 qtddevedores := qtddevedores + 1 
 fimse
 Se valordevido[i,j] > maiordivida entao 
 Maiordivida:= valordevido[i,j] 
 Aptomaiordivida:= apto[i,j]
 Fimse. 
 Fimpara
Fimpara
Escreval (“o total de apto devedores é”, qtddevedores) 
Escreval (“o valor total devido ”, totaldevido)
Escreval(“apto que deve mais é ”, aptomaiordivida)
escreval (“ o valor médio devido é “ , totaldevido /qtddevedores) 
FIMALGORITMO
Muito legal, não é? Teste esse algoritmo, modifique e adeque a outras situações. Teste, experimente, 
busque aprender através da construção e modificação deste algoritmo e outros.
21
Palavra fINal
Prezado(a) aluno(a)!
Chegamos à conclusão do conteúdo da terceira unidade da nossa disciplina. 
Terminamos aqui, a nossa terceira unidade. Nela vimos: 
•	 Matrizes, com seus conceitos e exemplos.
•	 Contabilizações e operações diversas em matrizes.
Aproveite para realizar os exercícios de fixação do livro. Insira suas dúvidas nos fóruns da disciplina. 
Para consolidar os seus conhecimentos, releia a unidade 3 do nosso livro-texto e depois responda aos 
exercícios no Ambiente Virtual de Aprendizagem (AVA).
Terminando os exercícios, seguiremos para a unidade 4. 
Lembre-se! Caso necessite esclarecer alguma dúvida, entre em contato com o seu tutor. 
Ele está a sua disposição para orientá-lo(a) no que for necessário.
Encontramos-nos na próxima unidade!
Desejo bons estudos.