Escola Nacional de Ciências Estatísticas

Curso de Graduação em Estatística

(Bacharelado)

Computação

Unidade IX: Matrizes

Professor: Eduardo Corrêa

Data: 29/10/2007

1
 Escola Nacional de Ciências Estatísticas

Introdução

As matrizes representam estruturas de dados capazes de armazenar informações

em formato tabular (ou seja, informações dispostas em linhas e colunas). Esta unidade
apresenta as principais propriedades deste importante componente das linguagens de
programação.

IX.1 Revisão: Laços For-Do Aninhados

Antes de apresentar ao estudante os conceitos relativos à manipulação de matrizes,

realizaremos uma pequena revisão sobre o uso do comando for-do, mais precisamente
sobre a forma de utilizar dois comandos for-do aninhados (um dentro do outro).
O comando for é utilizado para permitir com que outros comandos subordinados a
ele possam ser executados por um número fixo de vezes1. No exemplo abaixo, os comandos
C1 e C2 (hipotéticos) serão executados 100 vezes, pois é isso que o comando for está
“ordenando” a eles.

for I:=1 to 100 do

begin
C1;
C2;
end;

É possível também programar um comando for (chamado de for externo) com um

outro comando for subordinado a ele (chamado de for interno). Veja o seguinte exemplo:

for I:=1 to 100 do

for J:=1 to 500 do
begin
C1;
C2;
end;

Dessa vez os comandos C1 e C2 serão executados nada menos do que 50000 vezes!
Isso ocorre por que o comando for I:=1 to 100 está mandando o comando abaixo
dele ser executado 100 vezes. E o comando abaixo dele é for J:=1 to 500 do, que está
mandando C1 e C2 serem executados 500 vezes. O resumo disso tudo é: o computador
repetirá 100 vezes um comando que manda repetir 500 vezes C1 e C2! O que significa que
C1 e C2 serão executados 100 x 500 vezes = 50000 vezes.
É possível utilizar mais de dois comandos for-do aninhados, caso isto seja desejado.
Se um problema requer o uso de três (ou mais) comandos for aninhados para ser resolvido,
você pode fazer isso sem qualquer problema.

1
Para maiores esclarecimentos, consulte a primeira seção da Unidade VII.

2
 Escola Nacional de Ciências Estatísticas

IX.2 Matrizes

As matrizes (ou arrays multidimensionais) representam estruturas de dados

similares aos vetores. No entanto, as matrizes são capazes de manter informações
armazenadas em formato tabular (ou seja, informações dispostas em linhas e colunas). A
Figura IX.1 apresenta uma matriz de números inteiros chamada M, com 4 linhas e 3
colunas.

| 10 42 2 |
| 5 90 25 |
| 80 7 44 |
| 35 3 6 |

Figura IX.1– Matriz de inteiros

IX.2.1 Declaração de Matrizes

A sintaxe para a declaração de uma matriz é similar à utilizada para a declaração de

um vetor. Devemos usar a palavra-chave array, especificar o nome da matriz, o tipo de
dado, a quantidade de linhas e a quantidade de colunas:

var NOME_DA_MATRIZ: array [li1..lin, col1..coln] of TIPO;

Onde:
• li1 .. lin representam os limites da dimensão linha.
• col1 .. coln representam os limites da dimensão coluna2.

O exemplo abaixo, ilustra a declaração da matriz M, de números inteiros, com 4

linhas e 3 colunas.

var M: array [1..4, 1..3] of integer;

Ao encontrar a declaração de uma matriz em um programa Pascal, o computador

reserva imediatamente o espaço de memória adequado para todas as suas células. A matriz
M, do exemplo acima, possui um total de 4 (linhas) x 3 (colunas) = 12 células. Os
exemplos seguintes mostram isso com maior clareza.

2
Nos livros de Pascal você verá que também é possível declarar matrizes com 3 ou mais dimensões. Mas este
tipo de matriz não será abordada neste curso.

3
 Escola Nacional de Ciências Estatísticas

Exemplo IX.1: Declare uma matriz chamada M1, do tipo char, com 2 linhas e 5 colunas.

var M1: array [1..2, 1..5] of char;

1 2 3 4 5
1
2

Exemplo IX.3: Declare uma matriz chamada NOTAS, do tipo real, com 60 linhas e 3 colunas.
Esta matriz pode ser utilizada, por exemplo, para armazenar notas de 3 provas de uma turma
com 60 alunos.

var NOTAS: array [1..60, 1..3] of real;

1 2 3
1
2
3
4
5
6
7
8
... ... ... ...
58
59
60

IX.2.2 Acesso aos Dados de uma Matriz

Para acessar uma posição (ou célula) da matriz, devemos especificar a linha e a
coluna correspondente à posição desejada entre colchetes. O exemplo abaixo demonstra a
atribuição de diferentes valores para diferentes células da matriz M (após a execução destes
12 comandos, a matriz ficaria com o conteúdo igual ao apresentado na Figura IX.1,
mostrada na página 3).

M[1,1] := 10; M[2,1] := 5; M[3,1] := 80; M[4,1] := 35;

M[1,2] := 42; M[2,2] := 90; M[3,2] := 7; M[4,2] := 3;
M[1,3] := 2; M[2,3] := 25; M[3,3] := 44; M[4,3] := 6;

Em resumo: a manipulação de uma matriz é absolutamente idêntica à manipulação de

um vetor, exceto pelo seguinte fato:

4
 Escola Nacional de Ciências Estatísticas

- Para acessar uma posição da matriz, é preciso especificar uma linha e uma coluna.
- Para acessar uma posição do vetor, só é preciso especificar a linha. O vetor nada
mais é do que uma matriz que possui uma só coluna (matriz-coluna).

Alguns exemplos de acesso a células de matrizes:

if (M[3,1] = 80) then ... {testa se o valor da célula 3,1

é 80}

readln(NOTAS[60,2]); {lê um valor do teclado e armazena na

linha 60 e coluna 2 da matriz NOTAS}

IX.2.3 Operações com matrizes (o que pode e o que não pode...)

O programa a seguir, apresenta exemplos de algumas operações possíveis e algumas

operações que não podem ser realizadas com matrizes. As explicações são apresentadas
nos comentários dentro do próprio programa. Não tente copiar o programa para o Dev-
Pascal, pois ele não vai funcionar! Ele foi criado apenas com o propósito de apresentar a
forma correta e a forma errada de manipular uma matriz.
program OperacoesMatrizes;
var M1, M2, M3, M4: array[1..3, 1..2] of integer;{declara 4 matrizes 3x2}
I, J: integer;
IGUAIS: boolean;
begin
{atribuições}
M1[1,1] := 1000; M1[1,2] := 2;
M1[2,1] := -300; M1[2,2] := 0;
M1[3,1] := 999; M1[3,2] := -272;

M2:=M1; {CERTO: é possível atribuir todo o conteúdo de uma matriz

a outra matriz, contanto que ambas sejam do
mesmo tipo de dado e tenham o mesmo
número de linhas e de colunas}

M3 := M1 + 1; {ERRADO: não é possível somar, subtrair, multiplicar ou

dividir o valor de todos os elementos de uma
matriz desta forma. Só é possível através da
implementação de um laço que percorra todas
as células da matriz}

M4 := M1 – M2; {ERRADO: não é possível realizar operações com matrizes

desta forma. Mais uma vez é preciso criar um
laço e manipular os elementos da matriz
individualmente}

if (M1 = M2) then

5
 Escola Nacional de Ciências Estatísticas
writeln (‘M1 eh igual a M2’); {ERRADO: para comparar duas matrizes é
preciso construir um laço }
IGUAIS:=true;
for I:= 1 to 3 do
for J:= 1 to 2 do
if M1[I,J] <> M2[I,J] then {CERTO: aqui as matrizes estão sendo }
IGUAIS:=false; { comparadas em um laço, que verifica
seus elementos individualmente }

writeln(M1); {ERRADO: também não é possível imprimir todos os elementos

de uma matriz sem usar um laço}

for I:= 1 to 3 do {CERTO: usa-se laço para imprimir cada célula }

begin
for J:= 1 to 2 do write(M1[I,J]:6);
writeln;
end;
end.

IX.3 Problemas Resolvidos

Exemplo IX.3 - Escrever um programa que: (a) crie uma matriz 5 x 6 de inteiros e armazene o
valor 0 em todas as suas posições; (b) imprima a matriz no vídeo.

program Ex3;
var MAT: array[1..5,1..6] of integer; {declara a matriz 5x6}
I, J: integer;
begin
{ PASSO 1: preenche a matriz com 0 em todas as posições }
for I:= 1 to 5 do
for J:=1 to 6 do
MAT[I,J] := 0;

{ PASSO 2: imprime a matriz na tela }

for I:= 1 to 5 do
begin
for J:=1 to 6 do
write(MAT[I,J]:2); {obs1: o “:2” é usado apenas para formatar }
{a matriz na tela de uma forma “bonita” }

writeln; {obs2: veja que este “writeln” pertence (é subordinado)}

end; { ao comando for I e não ao comando for J! }
readln; { Ele serve para “pular” uma linha na tela, após }
end. { imprimir todas as células de uma linha da matriz }

No exemplo anterior, a variável “I” foi usada para controlar a posição da linha,
enquanto a variável “J” foi usada para controlar a posição da coluna, tanto no PASSO 1,

6
 Escola Nacional de Ciências Estatísticas

como no PASSO 2. No PASSO 1, a matriz é preenchida linha por linha. Inicialmente todas
as células da linha 1 são preenchidas; depois todas as células da linha 2; e assim por diante,
até a linha 5. No PASSO 2 a matriz é exibida na tela da mesma forma: primeiro todas as
células da linha 1, depois todas as células da linha 2, até chegar a linha 5. Veja que, para
poder manipular uma matriz corretamente, o aluno deve dominar o comando for.
Embora MAT seja uma matriz de inteiros, foi utilizado o comando
write(MAT[I,J]:2), que usa o parâmetro “:2”. Este parâmetro faz com que sejam
reservados dois “espacinhos” na tela para a impressão do valor de MAT[I,J]. Com isto a
visualização dos elementos matriz fica mais agradável (experimente retirar o parâmetro :2
para ver o que acontece).

Exemplo IX.4 - Escrever um programa que: crie uma matriz 5 x 5 de inteiros, armazene o
valor 1 na diagonal principal e o valor 0 nas demais células. Em seguida, imprima a matriz.

program Ex4;
const N=5;
var MAT: array[1..N,1..N] of integer;
I, J: integer;
begin
{ PASSO 1: preenche a matriz }
for I:= 1 to N do
for J:=1 to N do
if I=J then
MAT[I,J] := 1 {se I=J, certamente estou em um elemento da}
else {diagonal principal}
MAT[I,J] := 0;

{ PASSO 2: imprime a matriz na tela }

for I:= 1 to N do
begin
for J:=1 to N do
write(MAT[I,J]:2);
writeln;
end;
readln;
end.

Nesse exemplo, basta modificar o valor da constante N de 5 para outro valor (tente
10 ou 20, por exemplo) para que o Pascal mude o tamanho da matriz quadrada
automaticamente.
Exemplo IX.5 - Elaborar um programa que: crie duas matrizes M1 e M2, ambas do tipo 3 x 3
de reais. Em seguida implemente as seguintes rotinas:

7
 Escola Nacional de Ciências Estatísticas

(a) a matriz M1 deve ser carregada a partir do teclado.

(b) a matriz M2 deve receber o conteúdo de M1 multiplicado por 2.

program Ex5;
const N=3;
var M1, M2: array[1..N,1..N] of real;
I, J: integer;
begin

{ PASSO 1: carrega M1 a partir do teclado }

for I:= 1 to N do
for J:=1 to N do
begin
write('Digite o valor da celula ', I, ':', J, '= ');
readln(M1[I,J]);
end;

{ PASSO 2: gera M2 – percorre todas as células e multiplica o valor de

cada uma por 2}
for I:= 1 to N do
for J:=1 to N do
M2[I,J] := M1[I,J] * 2;

{ PASSO 3: imprime M1 e M2 na tela }

writeln; writeln('M1');
for I:= 1 to N do
begin
for J:=1 to N do
write(M1[I,J]:15:2);
writeln;
end;

writeln; writeln('M2');
for I:= 1 to N do

8
 Escola Nacional de Ciências Estatísticas
begin
for J:=1 to N do
write(M2[I,J]:15:2);
writeln;
end;

readln;
end.

Não é possível multiplicar (ou somar, subtrair e dividir) todos os elementos de uma
matriz com um comando simples como M2 := M1 * 2. Ao invés disso, é necessário
programar um laço para percorrer todas as células da matriz e multiplicar o valor
armazenado em cada uma delas por 2.

Exemplo IX.6 - Escrever um programa que leia uma matriz responsável por armazenar notas
de 3 provas (P1, P2 e P3) de uma turma de Computação formada por 12 alunos. A seguir,
para cada aluno, imprima a nota de suas 3 provas e a média destas notas.

program Ex6;
var NOTAS: array[1..12,1..3] of real;
I, J: integer;
SOMA, MEDIA: real;
begin
{ PASSO 1: Carrega matriz com as 3 notas de cada aluno }
for I:= 1 to 12 do
for J:=1 to 3 do
begin
write('Digite o valor da nota ', J, ' do aluno ', I, ' = ');
readln(NOTAS[I,J]);
end;
{ PASSO 2: - imprime as notas de cada aluno.
- calcula e imprime a média de cada aluno }

for I:= 1 to 12 do { loop externo – percorre os 12 alunos}

{ (linhas da matriz) }
begin
writeln; writeln('ALUNO ', I);
SOMA:=0; {inicializar a soma das notas de um aluno}

for J:=1 to 3 do {loop interno – percorre as notas dos alunos}

{ (colunas da matriz) }
begin
writeln('P', J, ' = ', NOTAS[I,J]:3:2); {imprime uma nota}
SOMA := SOMA + NOTAS[I,J]; { atualiza a soma das }
{ notas de um aluno }
end;
MEDIA := SOMA / 3; {calula e imprime a média de um aluno}
writeln('MEDIA = ', MEDIA:3:2);
end;

readln;
end.

9
 Escola Nacional de Ciências Estatísticas

Exemplo IX.7 - Escrever um programa que leia e depois imprima uma matriz MxN do tipo
char, onde o tamanho máximo de M e N deve ser 100.

program Ex7;
const MAX = 100;
var MAT: array[1..MAX,1..MAX] of char;
I, QTD_LIN, J, QTD_COL: integer;
begin

{ PASSO 1: pergunta para o usuário qual a quantidade de linhas

e qual a quantidade de colunas da matriz}
repeat
write('Digite a quantidade de linhas da matriz (MAX = ', MAX, '): ');
readln(QTD_LIN);
until (QTD_LIN <= MAX);

repeat
write('Digite a quantidade de colunas da matriz (MAX = ', MAX, '): ');
readln(QTD_COL);
until (QTD_COL <= MAX);

{ PASSO 2: carrega a matriz, fazendo um for que usa

as quantidades espeficicadas pelo usuário }
for I:= 1 to QTD_LIN do
for J:=1 to QTD_COL do
begin
write('Elemento[', I, ',', J, '] = ');
readln(MAT[I,J]);
end;

{ PASSO 3: - imprime a matriz }

for I:= 1 to QTD_LIN do
begin
for J:=1 to QTD_COL do write(MAT[I,J], ' ');
writeln;
end;

readln;
end.

Os “macetes” usados foram os seguintes: dimensionar a matriz como 100 x 100

(valores máximos para linha e coluna) e depois perguntar para o usuário: qual a quantidade
de linhas? qual a quantidade de colunas? As respostas dadas pelo usuário são armazenadas

10
 Escola Nacional de Ciências Estatísticas

nas variáveis QTD_LIN e QTD_COL e estas variáveis são utilizadas como limite superior
em todos os comandos for subseqüentes.

Exemplo IX.8 - Faça um programa que leia uma matriz A de inteiros 2x3. A seguir, obtenha e
imprima tA (a matriz transposta de A).

Exemplo: Se

A = | 2 0 3 |
| 1 -1 2 |

então tA = | 2 1 |
t | 0 -1 |
t | 3 2 |

program Transposta;
var A: array[1..2,1..3] of integer; {matriz original}
tA: array[1..3,1..2] of integer; {matriz transposta}
I, J: integer;
begin

{ PASSO 1: carrega a matriz A }

writeln('Digite os elementos da matriz A:');writeln;
for I:= 1 to 2 do
for J:=1 to 3 do
begin
write('A[', I, ',', J, '] = ');
readln(A[I,J]);
end;

{ PASSO 2: ATENÇÃO – aqui se obtém a transposta de A }

for J:= 1 to 3 do
for I:=1 to 2 do tA[J,I] := A[I,J]; {se tiver dificuldade em}
{entender esse passo, tente fazer um desenho}

{ PASSO 3: - imprime as duas matrizes (A e transposta de A }

writeln; writeln('Matriz A:'); writeln;
for I:= 1 to 2 do
begin
for J:=1 to 3 do write(A[I,J]:6);
writeln;
end;
writeln; writeln('Matriz Transposta de A:'); writeln;
for I:= 1 to 3 do
begin
for J:=1 to 2 do write(tA[I,J]:6);

11
 Escola Nacional de Ciências Estatísticas
writeln;
end;

readln;
end.

Exemplo IX.9 - Elabore um programa que carregue uma matriz quadrada 5x5 de números
reais. Altere a matriz digitada da seguinte forma: multiplique cada elemento de uma linha
pelo elemento da diagonal principal da linha em questão. Mostre a matriz após as
multiplicações.

program Ex9;
var M: array[1..5,1..5] of real;
I, J: integer;
D: real; {elemento da diagonal principal}
begin

{PASSO 1: CARGA DA MATRIZ VIA TECLADO}

writeln('Entre com os elementos da Matriz: ');
writeln;
for I:=1 to 5 do
for J:=1 to 5 do
begin
write('M[',I,',',J,'] = ');
readln(M[I,J]); {lê uma célula}
end;

{MULTIPLICA CADA ELEMENTO DE UMA LINHA PELO ELEMENTO DA

DIAGONAL PRINCIPAL NESTA LINHA}
for I:=1 to 5 do
begin
D := M[I,I]; {aqui está a mágica: recupera o elemento
da diagonal principal linha antes de percorrer
as células desta linha}

for J:=1 to 5 do M[I,J]:=M[I,J] * D; {aqui eu faço a multiplicação

e altero a célula da matriz}
end;

{IMPRIME A MATRIZ ALTERADA}

for I:=1 to 5 do
begin
for J:=1 to 5 do
begin
write(M[I,J]:10:2); {imprime elementos de uma linha}
end;
writeln; {pula linha}
end;
readln;
end.
Exemplo IX.10 - Elabore um programa onde o usuário possa digitar o nome de um país e o
sistema possa informar qual é a capital do país. Apenas os seguintes conjuntos de
países/capitais devem estar cadastrados no programa.

12
 Escola Nacional de Ciências Estatísticas

PAÍS CAPITAL
Nigéria Abuja
Somália Mogadíscio
Quênia Nairóbi
Argélia Argel
Moçambique Maputo
Madagascar Antananarivo
Mongólia Ulan Bator
Uganda Campala
Zâmbia Lusaca

program Ex10;
var I: integer;
{ matriz de 9 linhas e 2 colunas do tipo string[12] }
{ (pode armazenar uma palavra de até 12 caracteres em cada célula }

{a coluna 1 receberá os nomes dos países

a coluna 2 receberá os nomes das capitais}
P: array[1..9,1..2] of string[12];

busca: string; {valor que o usuário irá digitar}

achou: boolean; {usado para que seja possível saber se o país foi
achado na matriz}

begin

{PASSO 1: CADASTRO DOS PAÍSES E CAPITAIS}

P[1,1] := 'NIGERIA'; P[1,2] := 'ABUJA';
P[2,1] := 'SOMALIA'; P[2,2] := 'MOGADISCIO';
P[3,1] := 'QUENIA'; P[3,2] := 'NAIROBI';
P[4,1] := 'ARGELIA'; P[4,2] := 'ARGEL';
P[5,1] := 'MOCAMBIQUE'; P[5,2] := 'MAPUTO';
P[6,1] := 'MADAGASCAR'; P[6,2] := 'ANTANANARIVO';
P[7,1] := 'MONGOLIA'; P[7,2] := 'ULAN BATOR';
P[8,1] := 'UGANDA'; P[8,2] := 'CAMPALA';
P[9,1] := 'ZAMBIA'; P[9,2] := 'LUSACA';

{PASSO 2: SOLICITA O NOME DE UM PAÍS AO USUÁRIO}

writeln('PAISES E CAPITAIS');
writeln('=================');
writeln;

13
 Escola Nacional de Ciências Estatísticas
writeln('Digite o nome de um pais (use apenas letras maiusculas)');
readln(busca);

{PASSO 3: PROCURA PELO PAÍS NA MATRIZ (OLHANDO A COLUNA 1).

SE ENCONTRAR EXIBE A CAPITAL (COLUNA 2)
SE NAO ENCONTRAR EXIBE A MENSAGEM: "PAIS NAO CADASTRADO"}

achou := false; {supõe que país não será achado}

for I:=1 to 9 do {laço que percorre as 9 linhas da matriz}

if (busca = P[I,1]) then {testa se valor digitado é igual ao

conteúdo armazenado na linha I, coluna 1 da matriz}
begin
achou := true; {se isso ocorre, então achei o país}
writeln;
writeln('PAIS = ', busca, ' - CAPITAL = ',P[I,2]);
writeln;
end;
{atenção, aqui o loop for já acabou! O único comando subordinado ao
for é if busca = P[I,1]}

{se o país não tiver sido achado, manda mensagem ao usuário}

if (not achou) then {OBS: isso é o mesmo que if achou = FALSE}
writeln('DESCULPE, O PAIS ',busca, ' NAO ESTA CADASTRADO EM NOSSO SISTEMA');

readln;
end.

EXERCÍCIO ESPECIAL- Visando fazer um levantamento das atuais condições de tráfego de

uma rodovia importante que cruza diversas cidades do Sudeste foi realizada uma pesquisa.
Os motoristas que paravam no pedágio eram entrevistados por um pesquisador, que
realizava três perguntas e anotava as respostas dos motoristas num questionário. Estas
perguntas e as possíveis respostas são relacionadas a seguir:

1) DE ONDE VEIO?
(A) Rio de Janeiro (B) Minas Gerais (C) Espírito Santo

2) PARA ONDE VAI?

(A) Rio de Janeiro (B) Minas Gerais (C) Espírito Santo

3) TIPO DE COMBUSTÍVEL DO VEÍCULO

(A) Gasolina (B) Álcool (C) Gás

Faça um programa que leia os dados desta pesquisa via teclado e armazene numa matriz de
1000 x 3 do tipo char (“1000” representa a quantidade máxima de questionários. O sistema
deve perguntar ao usuário quantos questionários serão processados antes de iniciar o
recebimento de dados).

Após carregar a matriz, calcule e imprima:

14
 Escola Nacional de Ciências Estatísticas

14.1) A quantidade de veículos que têm Minas Gerais como origem.

14.2) A porcentagem de veículos que têm Rio de Janeiro como origem.

14.3) A porcentagem de veículos movidos a Gasolina, Álcool e Gás que têm como origem
Rio de Janeiro.

14.4) A quantidade de veículos que têm Rio de Janeiro como origem e Espírito Santo como
Destino.

14.5) A quantidade de veículos que têm Espírito Santo como origem, Minas Gerais como
Destino e são movidos a Gás.

program PesqMatriz;
const TOT_QUEST = 1000; {aqui eu defino uma constante que indica o número
de linhas da minha matriz... isso facilita testes no programa}

var M: array[1..TOT_QUEST,1..3] of char; {matriz que armazena resultados

da pesquisa}
I: integer; {usada para percorrer linhas da matriz}

{ * * VARIÁVEIS USADAS NAS CONTABILIZAÇÕES * * }

QTD_ORIG_MG: integer; {quantidade de veículos com origem em MG}

QTD_ORIG_RJ: integer; {quantidade de veículos com origem no RJ}

QTD_ORIG_RJ_ALC: integer; {quantidade de veículos com origem no RJ

movidos a Alcool}

QTD_ORIG_RJ_GASOL: integer;{quantidade de veículos com origem no RJ

movidos a Gasolina}

QTD_ORIG_RJ_GAS: integer; {quantidade de veículos com origem no RJ

movidos a Gas}

QTD_RJ_ES: integer; {quantidade com origem no RJ e destino = ES}

QTD_ES_MG_GAS: integer; {quantidade com origem no ES, destino = MG e

movidos a GAS}

begin

{PASSO 1: carga da matriz via teclado

(claro que ninguém vai carregar 1000 questionários em casa!
Mudem o valor da constante TOT_QUEST se quiser testar o programa}
writeln('Entre com as respostas de cada questionário: '); writeln;
for I:=1 to TOT_QUEST do
begin
writeln;
writeln('Questionario ',I);
write('De onde veio? (A= "RJ", B= "MG", C= "ES"): ');
readln(M[I,1]);
write('Para onde vai? (A= "RJ", B= "MG", C= "ES"): ');
readln(M[I,2]);
write('Qual o tipo de combustível? (A="Gasolina", B="Alcool", C="Gas"): ');

15
 Escola Nacional de Ciências Estatísticas
readln(M[I,3]);
end;
{PASSO 2: computação dos resultados}
QTD_ORIG_MG :=0;
QTD_ORIG_RJ :=0;
QTD_ORIG_RJ_ALC := 0;
QTD_ORIG_RJ_GASOL := 0;
QTD_ORIG_RJ_GAS := 0;
QTD_RJ_ES :=0;
QTD_ES_MG_GAS := 0;

for I:=1 to TOT_QUEST do

begin
{determina quant. de veículos com origem em MG}
if (M[I,1] = 'B') then QTD_ORIG_MG := QTD_ORIG_MG + 1;

{calculos envolvendo veículos com origem no RJ}

if (M[I,1] = 'A') then
begin
QTD_ORIG_RJ := QTD_ORIG_RJ + 1;

{origem = RJ e combustivel = Gasolina}

if (M[I,3] = 'A') then QTD_ORIG_RJ_GASOL := QTD_ORIG_RJ_GASOL + 1;

{origem = RJ e combustivel = Alcool}

if (M[I,3] = 'B') then QTD_ORIG_RJ_ALC := QTD_ORIG_RJ_ALC + 1;

{origem = RJ e combustivel = GAS}

if (M[I,3] = 'C') then QTD_ORIG_RJ_GAS := QTD_ORIG_RJ_GAS + 1;

{origem = RS e destino = ES}

if (M[I,2] = 'C') then QTD_RJ_ES := QTD_RJ_ES + 1;
end;

{origem ES, destino MG, movido a GAS}

if (M[I,1] = 'C') and (M[I,2] = 'B') and (M[I,3] = 'C') then
QTD_ES_MG_GAS := QTD_ES_MG_GAS + 1;
end;

{exibe os resultados}
writeln;
writeln('Quant. Origem "MG" = ',QTD_ORIG_MG);
writeln('Porcent. Origem "RJ" = ',(QTD_ORIG_RJ / TOT_QUEST)*100:3:2);
writeln('Porcent. Origem "RJ" + Gasolina = ',(QTD_ORIG_RJ_GASOL /
TOT_QUEST)*100:3:2,'%');
writeln('Porcent. Origem "RJ" + Alcool = ',(QTD_ORIG_RJ_ALC /
TOT_QUEST)*100:3:2,'%');
writeln('Porcent. Origem "RJ" + Gas = ',(QTD_ORIG_RJ_GAS /
TOT_QUEST)*100:3:2,'%');
writeln('Quant. Origem "RJ" e Destino "ES" = ',QTD_RJ_ES);
writeln('Quant. Origem "ES" + Destino "MG" + Gas = ',QTD_ES_MG_GAS);

readln;
end.

16
 Escola Nacional de Ciências Estatísticas

Por motivos didáticos, nesse programa a contabilização dos resultados foi feita após
a carga da matriz via teclado (desse jeito o programa fica com dois blocos distintos: um que
só faz a carga e outro que só faz contabilizações).
A maneira mais eficiente de contar os resultados seria com o uso de IF’s-ELSE’s,
conforme ilustrado a seguir. O código fica um pouco mais complicado de entender, porém
mais eficiente.

for I:=1 to TOT_QUEST do

begin
{determina quant. de veículos com origem em MG}
if (M[I,1] = 'B') then QTD_ORIG_MG := QTD_ORIG_MG + 1

{-- calculos envolvendo veículos com origem no RJ --}

else if (M[I,1] = 'A') then
begin
QTD_ORIG_RJ := QTD_ORIG_RJ + 1;

if (M[I,3] = 'A') then {origem = RJ e combustivel = Gasolina}

QTD_ORIG_RJ_GASOL := QTD_ORIG_RJ_GASOL + 1

else
if (M[I,3] = 'B') then {origem = RJ e combustivel = Alcool}

QTD_ORIG_RJ_ALC := QTD_ORIG_RJ_ALC + 1

17
 Escola Nacional de Ciências Estatísticas

else {origem = RJ e combustivel = GAS}

QTD_ORIG_RJ_GAS := QTD_ORIG_RJ_GAS + 1;

{origem = RJ e destino = ES}

if (M[I,2] = 'C') then QTD_RJ_ES := QTD_RJ_ES + 1;

end

{origem ES, destino MG, movido a GAS}

else if (M[I,1] = 'C') and (M[I,2] = 'B') and (M[I,3] = 'C') then
QTD_ES_MG_GAS := QTD_ES_MG_GAS + 1;

end;

Exercícios Propostos

(1) Faça um programa que carregue uma matriz 2x3 de inteiros, calcule e mostre a
quantidade de elementos da matriz que não pertencem ao intervalo [5,15].

(2) Faça um programa que gere automaticamente (sem ler do usuário) uma matriz 5x5
cujos elementos são:

| 1 2 3 4 5|
| 6 7 8 9 10|
|11 12 13 14 15|
|16 17 18 19 20|
|21 22 23 24 25|

(3) Faça um programa que carregue uma matriz 4x4 de inteiros, e que depois imprima
apenas os elementos localizados acima da diagonal principal.

(4) Construir um programa que calcule e mostre a média dos elementos da diagonal
principal de uma matriz 10x10 de reais.

(5) Elabore um programa que carregue uma matriz 5x5 de números reais. Altere a matriz
digitada da seguinte forma: divida cada elemento de uma linha pelo elemento da diagonal
secundária da linha em questão. Mostre a matriz após a modificação.

(6) Elabore um programa que carregue uma matriz quadrada A de reais, de ordem 3. Em
seguida calcule e imprima o valor do determinante de A. Para o cálculo do determinante,
obtenha o valor da multiplicação de todos os elementos da diagonal principal e subtraia do
valor da multiplicação de todos os elementos da diagonal secundária.

18
 Escola Nacional de Ciências Estatísticas

(7) Faça um programa que carregue duas matrizes A e B de dimensão 4x5 com números
inteiros; depois calcule e mostre: (a) a soma das duas matrizes, resultando também em uma
terceira matriz C de dimensão 4x5; (b) a diferença das duas matrizes, resultando em uma
quarta matriz D de dimensão 4x5.

(8) Elabore um programa que carregue uma matriz 6x3 de inteiros. Altere a matriz digitada
da seguinte forma: cada elemento de uma linha deve ter o seu valor multiplicado pelo valor
do maior elemento da linha em questão. Mostre a matriz resultante.

(9) Foi realizada uma pesquisa envolvendo 200 alunos de escolas de segundo-grau. De cada
aluno foram coletados os seguintes dados: idade, altura (em cm), peso (em kg). Faça um
programa que leia esses dados, armazenando-os em uma matriz de inteiros. Em seguida
calcule e mostre:

9.1 A média de altura dos alunos.

9.2 O número de alunos com mais de 18 anos.
9.3 O percentual de alunos com idade menor ou igual a 16 anos e altura superior a 190cm.

(10) Faça um programa que leia uma matriz A de inteiros com M linhas e N colunas (onde
o valor máximo tanto para M como para N deve ser igual a 50). Obtenha e imprima a
matriz transposta de A.

(11) Implementar um programa que efetue um produto matricial. Seja A (m x n) e B (n x p)

as matrizes-fatores, lidas do teclado, onde m ≤ 10, n ≤ 10 e p ≤ 10. Deverão ser impressas
as matrizes A, B e a matriz produto obtida (P).

(12) Faça um programa que leia uma matriz quadrada real A, de dimensão MxM (M ≤ 50).
A seguir, verifique se a matriz é simétrica, ou seja, se A[I,J] = A[J,I] para todo I, J ≤ M.
Imprima na tela a palavra “SIMÉTRICA” se a matriz A for simétrica e “NÃO-
SIMÉTRICA” caso contrário.

(13) Dada uma matriz real A com m linhas e n colunas e um vetor real V (de tamanho n),
escreva o trecho de código que determina o produto de A por V e armazena o resultado em
um outro vetor, chamado R (de tamanho M).

(14) Dizemos que uma matriz quadrada inteira é um quadrado mágico se a soma dos
elementos de cada linha, a soma dos elementos de cada coluna e a soma dos elementos das
diagonais principal e secundária são todas iguais. Exemplo:

|8 0 7|
|4 5 6|
|3 10 2|

19
 Escola Nacional de Ciências Estatísticas

Escreva o trecho de código Pascal capaz de identificar se uma matriz quadrada de ordem M
é um quadrado mágico.
(15) Dizemos que uma matriz inteira Amxm é uma matriz de permutação se em cada linha e
em cada coluna houver m-1 elementos nulos e um único elemento igual a 1. Exemplo:
|0 1 0 0|
|0 0 0 1|
|1 0 0 0|
|0 0 1 0|

Escreva o trecho de código Pascal capaz de identificar se uma matriz quadrada de ordem M
é uma matriz de permutação.

(16) Escreva o trecho de código Pascal que consiga descobrir se uma matriz MAT com 20
linhas e 15 colunas possui algum elemento repetido.

(17) Considere um programa que mantenha em memória uma matriz 7x7, de números reais,
denominada DIST, cujo conteúdo é apresentado abaixo:

DIST 1 2 3 4 5 6 7
1 0 20.8 5.6 7.8 14.3 6.5 9.2
2 20.8 0 15.1 12.9 20.1 10 8
3 5.6 15.1 0 1.5 7 12 27
4 7.8 12.9 1.5 0 6.2 7.9 4.1
5 14.3 20.1 7 6.2 0 2 3.3
6 6.5 10 12 7.9 2 0 11
7 9.2 8 27 4.1 3.3 11 0

Esta matriz armazena as distâncias (em km) entre 7 cidades. Tem-se, por exemplo, que
DIST[1,2] armazena a distância entre as cidades 1 e 2. O valor desta distância é igual a
20.8km.

Escreva um trecho de programa Pascal que receba como entrada um percurso entre cidades
e, como saída, imprima a quilometragem que será percorrida.

Exemplo: usuário digita o caminho 1, 3, 6, 2. O sistema deve obter as distâncias entre 1 e

3, 3 e 6 e 6 e 2, somar estas distâncias e exibir a quilometragem total na tela (neste caso 5.6
+ 12 + 10 = 27.6km).

OBS: o sistema deve receber caminhos formados por, no máximo, 5 cidades.

20