Apostila 1 Algoritmo e Linguagem de Programação

Prévia do material em texto

DIM0320 - Algoritmo e programac¸a˜o de
computadores
material
de
apoio
Suma´rio
1 Introduc¸a˜o 7
1.1 Definic¸o˜es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2 Programac¸a˜o Estruturada . . . . . . . . . . . . . . . . . . . . 7
1.3 Formas de representac¸a˜o de algoritmos . . . . . . . . . . . . . 7
1.3.1 Descric¸a˜o narrativa . . . . . . . . . . . . . . . . . . . . 7
1.3.2 Fluxograma . . . . . . . . . . . . . . . . . . . . . . . . 8
1.3.3 Pseudo-co´digo . . . . . . . . . . . . . . . . . . . . . . 9
2 Tipos de dados 11
2.1 Dados nume´ricos . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.2 Dados literais . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.3 Dados lo´gicos . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.4 Armazenamento de Dados na Memo´ria . . . . . . . . . . . . . 12
2.4.1 Dados do tipo inteiro . . . . . . . . . . . . . . . . . . . 12
2.4.2 Dados do tipo real . . . . . . . . . . . . . . . . . . . . 12
2.4.3 Dados do tipo lo´gico . . . . . . . . . . . . . . . . . . . 13
2.4.4 Dados do tipo literal . . . . . . . . . . . . . . . . . . . 13
3 Varia´veis e expresso˜es 15
3.1 Varia´veis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.2 Expresso˜es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.2.1 Expresso˜es aritme´ticas . . . . . . . . . . . . . . . . . . 16
3.2.2 Expresso˜es lo´gicas . . . . . . . . . . . . . . . . . . . . 17
3.2.3 Expresso˜es literais . . . . . . . . . . . . . . . . . . . . 17
3.3 Avaliac¸a˜o de expresso˜es . . . . . . . . . . . . . . . . . . . . . 17
3.4 Exerc´ıcios propostos . . . . . . . . . . . . . . . . . . . . . . . 18
4 Instruc¸o˜es primitivas 19
4.1 Dispositivo de entrada . . . . . . . . . . . . . . . . . . . . . . 19
4.2 Dispositivo de sa´ıda . . . . . . . . . . . . . . . . . . . . . . . 19
4.3 Sintaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.4 Semaˆntica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.5 Instruc¸a˜o de Atribuic¸a˜o . . . . . . . . . . . . . . . . . . . . . 19
4.6 Instruc¸a˜o de Entrada de Dados . . . . . . . . . . . . . . . . . 20
4.7 Instruc¸a˜o de Sa´ıda de Dados . . . . . . . . . . . . . . . . . . . 20
4.8 Regras ba´sicas (interface com o usua´rio: fase de execuc¸a˜o) . . 21
4.9 Exemplos de algoritmos . . . . . . . . . . . . . . . . . . . . . 21
4.10 Rastreamento de um algoritmo . . . . . . . . . . . . . . . . . 23
4.11 Exerc´ıcios propostos . . . . . . . . . . . . . . . . . . . . . . . 24
2
5 Controle de fluxo de execuc¸a˜o 25
5.1 Estrutura de decisa˜o . . . . . . . . . . . . . . . . . . . . . . . 25
5.1.1 Estrutura de decisa˜o do tipo SE . . . . . . . . . . . . 25
5.1.1.1 SE’s aninhados ou encaixados . . . . . . . . . . . . . 27
5.1.2 Estrutura de decisa˜o do tipo ESCOLHA . . . . . . . . 30
5.2 Estrutura de repetic¸a˜o . . . . . . . . . . . . . . . . . . . . . . 32
5.2.1 Estrutura de repetic¸a˜o do tipo PARA-FAC¸A . . . . . 32
5.2.2 Estrutura de repetic¸a˜o do tipo ENQUANTO-FAC¸A . 33
5.2.3 Estrutura de repetic¸a˜o do tipo REPITA-ATE´ . . . . . 34
5.3 Exerc´ıcios propostos . . . . . . . . . . . . . . . . . . . . . . . 36
6 Exemplos de algoritmos 37
7 Estrutura de dados homogeˆneos 40
7.1 Introduc¸a˜o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
7.2 Varia´veis compostas homogeˆneas . . . . . . . . . . . . . . . . 40
7.3 Vetores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
7.3.1 Declarac¸a˜o de vetores . . . . . . . . . . . . . . . . . . 41
7.3.2 Operac¸o˜es com vetores . . . . . . . . . . . . . . . . . . 41
7.3.2.1 Atribuic¸a˜o de vetores . . . . . . . . . . . . . . . . . 42
7.3.2.2 Leitura de vetores . . . . . . . . . . . . . . . . . . . 42
7.3.2.3 Escrita de vetores . . . . . . . . . . . . . . . . . . . 43
7.3.3 Exemplos de algoritmos com vetores . . . . . . . . . . 44
7.3.4 Exerc´ıcios propostos . . . . . . . . . . . . . . . . . . . 49
7.4 Matrizes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
7.4.1 Declarac¸a˜o de matrizes . . . . . . . . . . . . . . . . . . 50
7.4.2 Operac¸o˜es com matrizes . . . . . . . . . . . . . . . . . 51
7.4.2.1 Atribuic¸a˜o de matrizes . . . . . . . . . . . . . . . . 51
7.4.2.2 Leitura de matrizes . . . . . . . . . . . . . . . . . . 52
7.4.2.3 Escrita de matrizes . . . . . . . . . . . . . . . . . . 52
7.4.3 Exemplos de algoritmos com matrizes . . . . . . . . . 53
7.4.4 Exerc´ıcios propostos . . . . . . . . . . . . . . . . . . . 56
7.5 Cadeias e subcadeias de caracteres . . . . . . . . . . . . . . . 57
7.5.1 Declarac¸a˜o de cadeia de caracteres . . . . . . . . . . . 58
7.5.2 Subcadeia de caracteres . . . . . . . . . . . . . . . . . 58
7.5.3 Exemplos de algoritmos com cadeias e subcadeias de
caracteres . . . . . . . . . . . . . . . . . . . . . . . . . 59
7.5.4 Exerc´ıcios propostos . . . . . . . . . . . . . . . . . . . 61
8 Subalgoritmos 62
8.1 Introduc¸a˜o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
8.2 Elementos de um subalgoritmo . . . . . . . . . . . . . . . . . 62
8.3 Func¸o˜es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
8.3.1 Instruc¸a˜o “Retorne” . . . . . . . . . . . . . . . . . . . 63
3
8.3.2 Chamada de uma func¸a˜o . . . . . . . . . . . . . . . . 64
8.3.3 Exemplos de algoritmos com func¸o˜es . . . . . . . . . . 64
8.3.4 Exerc´ıcios propostos de func¸o˜es . . . . . . . . . . . . . 67
8.4 Procedimentos . . . . . . . . . . . . . . . . . . . . . . . . . . 67
8.4.1 Chamada de um procedimento . . . . . . . . . . . . . 68
8.4.2 Mecanismos de passagem de paraˆmetros . . . . . . . . 68
8.4.3 Exemplos de algoritmos com procedimentos . . . . . . 69
8.4.4 Exerc´ıcios propostos de subalgoritmos . . . . . . . . . 72
9 Estrutura de dados heterogeˆneos 73
9.1 Introduc¸a˜o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
9.2 Registros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
9.2.1 Criac¸a˜o de registros . . . . . . . . . . . . . . . . . . . 73
9.2.2 Declarac¸a˜o de varia´veis do tipo registro . . . . . . . . 74
9.2.3 Referenciando membros de um registro . . . . . . . . . 75
9.2.4 Registros dentro de registros . . . . . . . . . . . . . . 75
9.2.5 Vetores de registros . . . . . . . . . . . . . . . . . . . 77
9.2.6 Exerc´ıcios propostos . . . . . . . . . . . . . . . . . . . 79
4
Lista de Figuras
1 In´ıcio ou fim do fluxograma. . . . . . . . . . . . . . . . . . . . 8
2 Entrada de dados. . . . . . . . . . . . . . . . . . . . . . . . . 8
3 Ca´lculo de expresso˜es. . . . . . . . . . . . . . . . . . . . . . . 8
4 Sa´ıda de resultados. . . . . . . . . . . . . . . . . . . . . . . . 8
5 Tomada de decisa˜o. . . . . . . . . . . . . . . . . . . . . . . . . 8
6 Fluxo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
7 Algoritmo “me´dia aritme´tica”. . . . . . . . . . . . . . . . . . 9
8 Representac¸a˜o de uma memo´ria de computador. . . . . . . . 11
9 Fluxograma do comando SE em sua forma expandida. . . . . 26
10 Fluxograma do comando SE em sua forma compacta. . . . . 26
11 Fluxograma do comando SE aninhado. . . . . . . . . . . . . . 28
12 Fluxograma do comando ESCOLHA. . . . . . . . . . . . . . . 31
13 Fluxograma dos lac¸os PARA-FAC¸A e ENQUANTO-FAC¸A. . 33
14 Fluxograma do lac¸o REPITA-ATE´. . . . . . . . . . . . . . . . 35
15 Uma ficha cadastral. . . . . . . . . . . . . . . . . . . . . . . . 75
5
Lista de Tabelas
1 Unidades computacionais. . . . . . . . . . . . . . . . . . . . . 11
2 Tabela ASCII com alguns caracteres. . . . . . . . . . . . . . . 13
3 Operadores aritme´ticos. . . . . . . . . . . . . . . . . . . . . . 16
4 Operadores lo´gicos. . . . . . . . . . . . . . . . . . . . . . . . . 17
5 Operadores relacionais. . . . . . . . . . . . . . . . . . . . . . . 17
6
1 Introduc¸a˜o
1.1 Definic¸o˜es
Algoritmo e´ uma sequ¨eˆncia ordenada e finita de operac¸o˜esbem definidas
e eficazes que, quando executadas sobre dados convenientes, produz uma
soluc¸a˜o ou a indicac¸a˜o de que a soluc¸a˜o na˜o poˆde ser obtida.
Um programa computacional consiste na traduc¸a˜o de um algoritmo em
uma forma “intelig´ıvel” para o computador.
1.2 Programac¸a˜o Estruturada
Programac¸a˜o estruturada e´ a te´cnica de construir e formular algorit-
mos de uma forma sistema´tica. Consiste numa metodologia de projeto de
programas visando facilitar a escrita, a leitura, a verificac¸a˜o apriori, a manu-
tenc¸a˜o e a modificac¸a˜o de programas. Os algoritmos estruturados utilizam
em sua sintaxe um nu´mero muito limitado de instruc¸o˜es e estruturas ba´sicas
(sequeˆncia, selec¸a˜o e repetic¸a˜o), que correspondem a formas de racioc´ınio
intuitivamente o´bvias.
1.3 Formas de representac¸a˜o de algoritmos
1.3.1 Descric¸a˜o narrativa
Esta forma de representac¸a˜o de algoritmos utiliza a linguagem natural
para descrever o comportamento na resoluc¸a˜o de uma determinada ativi-
dade.
Ela possui a inconvenieˆncia da ma´ interpretac¸a˜o, originando ambigu¨ida-
des e impreciso˜es.
Exemplo: Algoritmo para a troca de uma laˆmpada queimada.
- acionar o interruptor;
- se a la^mpada n~ao acender, ent~ao:
- pegar uma escada;
- posicionar a escada embaixo da la^mpada;
- buscar uma la^mpada nova;
- subir na escada;
- retirar a la^mpada queimada;
- colocar a la^mpada nova;
- acionar o interruptor;
- enquanto a la^mpada n~ao acender, fac¸a:
- retirar a la^mpada queimada;
- colocar uma la^mpada nova;
- acionar o interruptor;
7
1.3.2 Fluxograma
Esta forma de representac¸a˜o de algoritmos utiliza formas geome´tricas
distintas que produzem ac¸o˜es espec´ıficas.
Principais figuras:
Figura 1: In´ıcio ou fim do fluxograma.
Figura 2: Entrada de dados.
Figura 3: Ca´lculo de expresso˜es.
Figura 4: Sa´ıda de resultados.
Figura 5: Tomada de decisa˜o.
Figura 6: Fluxo.
8
Exemplo: Algoritmo para o ca´lculo da me´dia aritme´tica de dois valores
com um determinado teste.
Figura 7: Algoritmo “me´dia aritme´tica”.
1.3.3 Pseudo-co´digo
Esta forma de representac¸a˜o de algoritmos utiliza uma linguagem pro´-
pria, aproximando-se mais das linguagens de alto n´ıvel, chamada tambe´m
de “pseudo-linguagem”.
Uma linguagem natural (portugueˆs, ingleˆs, espanhol, etc.) apresenta o
inconveniente da ambigu¨idade de alguns termos, apesar de muitos recursos
de comunicac¸a˜o.
Uma linguagem de programac¸a˜o apresenta os inconvenientes das poucas
instruc¸o˜es existentes (poucos recursos de comunicac¸a˜o) apesar da grande
precisa˜o nos comandos.
O pseudo-co´digo na˜o tem os inconvenientes da ambigu¨idade de uma lin-
guagem natural, nem os rigores de uma linguagem de programac¸a˜o de alto
n´ıvel. E´ um portugueˆs estruturado em “frases” (comandos) correspondentes
as estruturas ba´sicas de programac¸a˜o.
9
Forma geral:
Algoritmo <nome_do_algoritmo>
<declarac¸~ao_de_varia´veis>
Inı´cio
<instruc¸~oes>
Fim
Exemplo: Algoritmo do exemplo anterior.
Algoritmo Me´dia_do_aluno
Real: m1,m2,media
Inı´cio
Escreva("Digite as duas notas:")
Leia(m1,m2)
media <- (m1+m2)/2
Se(me´dia >= 5)ent~ao
Escreva("APROVADO")
Sen~ao
Escreva("REPROVADO")
Fim_se
Fim
E´ esse tipo de representac¸a˜o de algoritmo que sera´ adotado no presente
curso.
10
2 Tipos de dados
Qualquer trabalho realizado por um computador e´ baseado na mani-
pulac¸a˜o das informac¸o˜es contidas em sua memo´ria. A grosso modo, estas
informac¸o˜es podem ser classificadas em dois tipos:
• as instruc¸o˜es: leituras, atribuic¸o˜es, operac¸o˜es, etc.;
• os dados propriamente ditos: valores a serem processados.
A memo´ria e´ um conjunto de ce´lulas identificadas univocamente por um
nu´mero chamado enderec¸o.
Figura 8: Representac¸a˜o de uma memo´ria de computador.
1 ce´lula = 1 byte = 8 bits.
1 bit possui 2 estados: 0 e 1 (d´ıgitos bina´rios).
1 byte possui 28 = 256 estados poss´ıveis.
1 Kilobyte (Kb) = 1024 bytes
1 Megabyte (Mb) = 1024 Kilobytes
1 Gigabyte (Gb) = 1024 Megabytes
Tabela 1: Unidades computacionais.
Os dados podem ser nume´ricos, literais e lo´gicos. Sa˜o os chamados tipos
ba´sicos. Os dados nume´ricos dividem-se em nu´meros inteiros e nu´meros
reais.
2.1 Dados nume´ricos
Os nu´meros inteiros e os nu´meros reais sa˜o armazenados de formas dife-
rentes nos computadores.
Nu´meros inteiros: representados sem parte fraciona´ria e sem ponto (cha-
mado tambe´m de nu´mero de ponto fixo).
Exemplo: 86, 0, -19, 23456
11
Nu´meros reais: representados com parte fraciona´ria e com ponto (chama-
do tambe´m de nu´mero de ponto flutuante).
Exemplo: 85.3, -9.453, 10.0, 6., 0.00
2.2 Dados literais
Sa˜o sequeˆncias de caracteres contendo letras, d´ıgitos e/ou s´ımbolos es-
peciais. Sa˜o chamados, tambe´m, “alfanume´ricos”, “cadeia de caracteres” ou
“strings”.
Sera˜o representados nos algoritmos entre aspas.
O comprimento de um dado literal e´ a quantidade de caracteres que ele
tem.
Exemplo:
"UFRN" – comprimento 4
" " – comprimento 1
"" – comprimento 0
"18/04/99" – comprimento 8
2.3 Dados lo´gicos
Usados para representar dois u´nicos valores lo´gicos poss´ıveis: verdadeiro
e falso. Eles sa˜o representados nos algoritmos como:
.V. (verdadeiro)
.F. (falso)
2.4 Armazenamento de Dados na Memo´ria
2.4.1 Dados do tipo inteiro
Ocupa a memo´ria com um nu´mero de bytes de acordo com a chamada
“palavra do computador”. Num computador de 32 bits ele ocupa 4 bytes.
Nu´mero inteiro: 4 bytes (-2.147.483.648 a 2.147.483.647)
2.4.2 Dados do tipo real
Ocupa a memo´ria com 4 bytes, sendo chamado tambe´m de precisa˜o
simples. A precisa˜o dupla ocupa o dobro da precisa˜o simples.
12
Nu´mero real: 4 bytes (3.4E-38 a 3.4E+38)
Precisa˜o dupla: 8 bytes (1.7E-308 a 1.7E+308)
.V. ou .F.
2.4.3 Dados do tipo lo´gico
Ocupa 1 byte na memo´ria.
2.4.4 Dados do tipo literal
Nesse tipo de dado, ha´ a alocac¸a˜o de espac¸o cont´ıguo de memo´ria igual
ao comprimento do literal, destinando um byte para cada caractere da in-
formac¸a˜o.
Cada caractere e´ associado a um co´digo nume´rico variando de 0 a 255.
Dentre as diversas tabelas propostas para a representac¸a˜o de caracte-
res, a de maior aceitac¸a˜o foi a Tabela ASCII (American Standard Code for
Information Interchange).
co´digo caractere co´digo caractere co´digo caractere
48 0 76 L 103 g
49 1 77 M 104 h
50 2 78 N 105 i
51 3 79 O 106 j
52 4 80 P 107 k
53 5 81 Q 108 l
54 6 82 R 109 m
55 7 83 S 110 n
56 8 84 T 111 o
57 9 85 U 112 p
65 A 86 V 113 q
66 B 87 W 114 r
67 C 88 X 115 s
68 D 89 Y 116 t
69 E 90 Z 117 u
70 F 97 a 118 v
71 G 98 b 119 w
72 H 99 c 120 x
73 I 100 d 121 y
74 J 101 e 122 z
75 K 102 f – –
Tabela 2: Tabela ASCII com alguns caracteres.
13
Exemplo: "casa".
Enderec¸o Informac¸a˜o
1000 c (99)
1001 a (97)
1002 s (115)
1003 a (97)
14
3 Varia´veis e expresso˜es
3.1 Varia´veis
Varia´vel e´ uma entidade destinada a guardar dados. Ela possui treˆs
atributos: nome, tipo e informac¸a˜o.
O nome de uma varia´vel tem a func¸a˜o de diferencia´-la das demais. Ado-
taremos as seguintes regras para o nome:
• deve necessariamente comec¸ar com uma letra;
• na˜o deve conter nenhum s´ımbolo especial, exceto o caractere sublinha
(_).
Exemplos: A2, max, hora_aula, LADO1, nome_do_aluno.
O tipo de uma varia´vel e´ o tipo de dado que ela pode armazenar, e a
informac¸a˜o e´ o valor que ela armazena naquele momento.
Todas as varia´veis utilizadas em um algoritmo devem ser definidas (de-
claradas) antes de serem utilizadas.
Uma declarac¸a˜o de varia´veis e´ uma instruc¸a˜o para reservar uma quan-
tidade de memo´ria apropriada para armazenar o tipo especificado e indicar
que o seu conteu´do sera´ refenciado pelo nome dado.
Utilizaremos a seguinte sintaxe para declarac¸a˜o das varia´veis nosnossos
algoritmos:
<tipo> : <lista_de_varia´veis>
Numa mesma linha podera˜o ser definidas uma ou mais varia´veis do
mesmo tipo. Deve-se separa´-las por v´ırgulas. Varia´veis de tipos diferen-
tes em linhas diferentes.
Exemplo:
Inteiro: ano, mes, idade
Real: sala´rio, troco
Lo´gico: opc¸~ao, sinalizador
Literal[30]: nome, profiss~ao
Nesta u´ltima declarac¸a˜o, o valor 30, entre colchetes, indica o nu´mero
ma´ximo de caracteres que cada varia´vel (“nome” ou “profissa˜o”) pode ar-
mazenar.
15
3.2 Expresso˜es
Expressa˜o e´ uma combinac¸a˜o de varia´veis, constantes e operadores que,
uma vez avaliada, resulta num valor.
Operadores sa˜o elementos funcionais que atuam sobre operandos e pro-
duzem um determinado resultado.
Os operadores se classificam quanto ao nu´mero de operandos em:
• bina´rios (dois operandos);
• una´rios (um operando).
E quanto ao tipo de dados dos operandos em:
• aritme´ticos;
• lo´gicos;
• literais.
Temos ainda os operadores relacionais, que e´ um caso especial, pois
permitem comparar pares de operandos de tipos de dados iguais (apenas
nume´ricos ou literais), resultando sempre um valor do tipo lo´gico.
3.2.1 Expresso˜es aritme´ticas
O resultado da avaliac¸a˜o e´ do tipo nume´rico (inteiro ou real).
Operador Tipo Operac¸a˜o Prioridade
+ bina´rio adic¸a˜o 4
- bina´rio subtrac¸a˜o 4
* bina´rio multiplicac¸a˜o 3
/ bina´rio divisa˜o em geral 3
\ ou div bina´rio divisa˜o de inteiros 3
** ou ˆ bina´rio exponenciac¸a˜o 2
+ una´rio manutenc¸a˜o de sinal 1
- una´rio inversa˜o de sinal 1
Tabela 3: Operadores aritme´ticos.
Se todos os operandos da expressa˜o sa˜o inteiros, o resultado e´ inteiro.
Se todos os operandos da expressa˜o sa˜o reais, o resultado e´ real.
Se os operandos sa˜o mistos (inteiros e reais), o resultado da expressa˜o e´
real.
16
3.2.2 Expresso˜es lo´gicas
O resultado da avaliac¸a˜o e´ do tipo lo´gico (.V. ou .F.).
Operador Tipo Operac¸a˜o Prioridade
.OU. bina´rio disjunc¸a˜o 3
.E. bina´rio conjunc¸a˜o 2
.NA˜O. una´rio negac¸a˜o 1
Tabela 4: Operadores lo´gicos.
Operador Comparac¸a˜o
= igual
<> diferente
< menor
<= menor ou igual
> maior
>= maior ou igual
Tabela 5: Operadores relacionais.
Os operadores relacionais sa˜o usados quando se deseja efetuar com-
parac¸o˜es entre expresso˜es de mesmo tipo (apenas expresso˜es nume´ricas ou
literais, na˜o expreso˜es lo´gicas), e o resultado e´ sempre um valor lo´gico.
3.2.3 Expresso˜es literais
Na˜o ha´ padronizac¸a˜o para seus operadores. Vamos considerar apenas o
operador de concatenac¸a˜o (+) .
Exemplo: "sonha" + "dor" resulta "sonhador".
3.3 Avaliac¸a˜o de expresso˜es
Regras:
• Observar a prioridade dos operadores (os de maior prio-
ridade devem ser avaliados primeiro). Se houver empate,
considera-se a expressa˜o da esquerda para a direita.
• Os pareˆnteses alteram a prioridade, forc¸ando a avaliac¸a˜o da
subexpressa˜o em seu interior.
• Entre os quatro grupos de operadores existentes a ordem
de avaliac¸a˜o e´:
– aritme´ticos;
17
– literais;
– relacionais;
– lo´gicos.
3.4 Exerc´ıcios propostos
Escrever as expresso˜es matema´ticas, utilizando os operadores aritme´ticos
dados (como devem ser escritos nos algoritmos).
1. 5x3 + 7x2 − 3x− 1
2. x0 + v0t− gt
2
2
3.
√
p(p− a)(p− b)(p− c)
4. 3
√
(5x2 + 4x3)2
5.
√
(x2 − x1)2 + (y2 − y1)2
6.
−b+√b2 − 4ac
2a
7.
4pir3
3
8.
3a+ 2b
x− a− 1
1 +
a+ b
2x
9. (xx+2y + yy+2x)x+y
18
4 Instruc¸o˜es primitivas
Sa˜o os componentes ba´sicos que efetuam tarefas essenciais para a opera-
c¸a˜o dos computadores, como entrada e sa´ıda de dados e a movimentac¸a˜o
dos mesmos na memo´ria.
4.1 Dispositivo de entrada
E´ o meio pelo qual as informac¸o˜es sa˜o transferidas pelo usua´rio ou pelos
n´ıveis secunda´rios de memo´ria ao computador. Exemplos: teclado, fitas,
discos magne´ticos, mouse, scanner.
4.2 Dispositivo de sa´ıda
E´ o meio pelo qual as informac¸o˜es (geralmente os resultados da exe-
cuc¸a˜o de um programa) sa˜o transferidas pelo computador ao usua´rio ou aos
n´ıveis secunda´rios de memo´ria. Exemplos: v´ıdeo, impressora, fitas, discos
magne´ticos.
4.3 Sintaxe
E´ a forma como os comandos devem ser escritos, a fim de que possam
ser entendidos pelo tradutor de programas.
4.4 Semaˆntica
E´ o significado, ou seja, o conjunto de ac¸o˜es que sera˜o exercidas pelo
computador durante a execuc¸a˜o do referido comando.
4.5 Instruc¸a˜o de Atribuic¸a˜o
E´ a principal maneira de se armazenar uma informac¸a˜o numa varia´vel.
Sintaxe :
<nome_da_varia´vel> <- <express~ao>
• avaliac¸a˜o da expressa˜o;
• armazenamento do valor resultante na posic¸a˜o de memo´ria correspon-
dente a` varia´vel que aparece a` esquerda do comando.
Importante :
Deve haver compatibilidade entre o tipo de dado resultante da avaliac¸a˜o
da expressa˜o e o tipo de dado da varia´vel (a na˜o ser, propositadamente, com
tipos nume´ricos).
19
Exemplos:
area <- base * altura
delta <- b ** 2 - 4.0 * a * c
contador <- contador + 1
nome <- "Caetano Veloso"
musica <- "Dias de Luta" + " e Flores em Voce^"
w <- .V.
p <- x > y .E. y > z
q <- (a > = 0 .E. a <= 10) .OU. (a >= 100 .E. a <= 1000)
4.6 Instruc¸a˜o de Entrada de Dados
Sintaxe :
Leia(<lista_de_varia´veis>)
Os dados sa˜o fornecidos ao computador por meio de um dispositivo de
entrada e armazenados nas posic¸o˜es de memo´ria das varia´veis cujos nomes
aparecem na lista.
Exemplo:
Leia(x)
Leia(a, b, c)
4.7 Instruc¸a˜o de Sa´ıda de Dados
Sintaxe :
Escreva(<lista_de_express~oes>)
Os argumentos sa˜o enviados para o dispositivo de sa´ıda. No caso de uma
lista de varia´veis, o conjunto de cada uma delas e´ pesquisado na posic¸a˜o
de memo´ria correspondente a varia´vel. No caso de argumento constante
(nu´mero, literal ou lo´gico) este e´ enviado diretamente ao referido dispositivo.
E no caso de expresso˜es, apo´s sua avaliac¸a˜o, segue como uma constante.
Exemplos:
Escreva ("Programa elaborado pelo aluno Thiago.")
Escreva ("Digite um nu´mero inteiro positivo:")
20
Escreva ("Lados do tria^ngulo: ", L1 , L2 , L3 )
Escreva ("Area do circulo = ", pi*r**2)
Escreva ("Area = ", x*y, "Perimetro = ", 2*(x + y))
4.8 Regras ba´sicas (interface com o usua´rio: fase de exe-
cuc¸a˜o)
• Toda vez que um programa estiver esperando que o usua´rio fornec¸a a
ele um determinado dado (operac¸a˜o de leitura), ele deve antes enviar
uma mensagem dizendo o que o usua´rio deve digitar, por meio de um
instruc¸a˜o de sa´ıda.
• Antes de enviar qualquer resultado ao usua´rio, um programa deve
escrever uma mensagem explicando o significado do mesmo.
4.9 Exemplos de algoritmos
1. Dado o prec¸o unita´rio e a quantidade de um produto, imprimir o valor
total da compra.
Algoritmo Total
Real: preco_unitario, preco_total
Inteiro: quantidade
Inı´cio
Escreva("Programa que calcula o preco de uma
certa quantidade de um produto.")
Escreva("Digite o preco unita´rio e a
quantidade: ")
Leia(preco_unitario, quantidade)
preco_total <- preco_unitario * quantidade
Escreva("Preco total = ", preco_total)
Fim
2. Calcular a a´rea e o per´ımetro de um retaˆngulo, sendo dados as medidas
dos lados.
Algoritmo Reta^ngulo
Real: L1, L2, area, perimetro
Inı´cio
Escreva("Digite as medidas dos lados do
retangulo: ")
Leia(L1, L2)
area <- L1 * L2
perimetro <- 2 * (L1 + L2)
Escreva("O valor da area e´ : ", area)
21
Escreva("O valor do perimetro e´ : ", perimetro)
Fim
3. Calcular o valor da func¸a˜o f(x) =
(3x− 1)
5
nos extremos do intervalo
[a, b] (dados os valores de a e b), e em mais dois valores do seu inte-
rior, de modo que os quatros valores do intervalo estejam igualmente
espac¸ados.
Algoritmo Valor_de_uma_func¸~ao
Real: a, b, h, y1, y2, y3, y4
Inı´cio
Escreva("Entre com dois nu´meros distintosna ordem crescente: ")
Leia(a, b)
h <- (b - a) / 3.
y1 <- ( 3. * a - 1. ) / 5.
y2 <- ( 3. * ( a + h ) - 1. ) / 5.
y3 <- ( 3. * ( b - h ) - 1. ) / 5.
y4 <- ( 3. * b - 1. ) / 5.
Escreva(" x = ", a, " y = ", y1)
Escreva(" x = ", a + h, " y = ", y2)
Escreva(" x = ", b - h, " y = ", y3)
Escreva(" x = ", b, " y = ", y4)
Fim
4. Algoritmo para dizer a soma de cinco nu´meros com, no ma´ximo, 4
d´ıgitos, antes mesmo das cinco parcelas serem digitadas.
Algoritmo Advinha
Inteiro: x
Inı´cio
Escreva("Digite um nu´mero com 4 algarismos: ")
Leia(x)
Escreva("O resultado da nossa conta sera´: ",
19998 + x)
Escreva("Digite o segundo nu´mero com 4
dı´gitos: ")
Leia(x)
Escreva("O meu nu´mero <terceiro> e´ : ",
9999 - x)
Escreva("Digite o quarto nu´mero com 4
dı´gitos: ")
Leia(x)
22
Escreva("Finalmente o quinto nu´mero e´ : ",
9999 - x)
Fim
4.10 Rastreamento de um algoritmo
O rastreamento de um algoritmo consiste na execuc¸a˜o manual, com da-
dos representativos para registrar os valores tomados pelas varia´veis em cada
passo do algoritmo.
Para facilitar o acompanhamento, colocamos todos os dados numa tabela
de varia´veis. Devemos fazer tantos testes quantos forem necessa´rios para nos
convencermos de que o algoritmo esta´ perfeito.
Exemplo de um rastreamento do algoritmo do exemplo 4 acima:
x
3452
1538
5172
Sa´ıda:
Digite um nu´mero com 4 algarismos: 3452
O resultado da nossa conta sera´: 23450
Digite o segundo nu´mero com 4 dı´gitos: 1538
O meu nu´mero <terceiro> e´: 8461
Digite o quarto nu´mero com 4 dı´gitos: 5172
Finalmente o quinto nu´mero e´: 4827
Exemplo de um rastreamento do algoritmo do exemplo 3 acima:
a b h y1 y2 y3 y4
4.0 8.5 1.5 2.2 3.1 4.0 4.9
Sa´ıda:
Entre com dois nu´meros distintos na ordem crescente: 4.0
8.5
x = 4.0 y = 2.2
x = 5.5 y = 3.1
x = 7.0 y = 4.0
x = 8.5 y = 4.9
23
4.11 Exerc´ıcios propostos
Fac¸a algoritmos para resolver os problemas abaixo.
1. Encontrar o consumo me´dio de um ve´ıculo, conhecidos a
distaˆncia total e o volume de combust´ıvel consumido para
percorrer tal distaˆncia.
2. Calcular a me´dia parcial de um aluno da UFRN, dadas as
suas treˆs primeiras notas.
3. Calcular o valor da func¸a˜o f(x, y) = 3x2 + 2y2− xy em um
ponto qualquer do plano cartesiano.
4. Leia uma temperatura em graus Cent´ıgrados e imprima a
equivalente em graus Fahrenheit (F =
9C + 160
5
).
5. Leia uma quantidade de chuva dada em polegadas e im-
prima a equivalente em mil´ımetros (1 polegada = 25,4 mi-
l´ımetros).
24
5 Controle de fluxo de execuc¸a˜o
Controle de fluxo de execuc¸a˜o e´ a sequeˆncia em que as instruc¸o˜es (ou
comandos) sa˜o executadas num algoritmo.
Cada instruc¸a˜o e´ executada somente apo´s o te´rmino da instruc¸a˜o anterior
(estrutura sequ¨eˆncial).
Um conjunto de instruc¸o˜es (ou comandos simples) e´ chamado de bloco
de instruc¸o˜es (ou comando composto).
5.1 Estrutura de decisa˜o
O fluxo de instruc¸a˜o a ser seguido e´ escolhido em func¸a˜o do resultado da
avaliac¸a˜o de uma ou mais condic¸o˜es.
Classificac¸a˜o quanto ao nu´mero de condic¸o˜es:
• uma condic¸a˜o (decisa˜o simples): estrutura do SE;
• va´rias condic¸o˜es (decisa˜o mu´ltipla): estrutura do ESCOLHA.
5.1.1 Estrutura de decisa˜o do tipo SE
Sintaxe:
Se(<condic¸~ao>)ent~ao
<bloco_de_instruc¸~oes_1>
sen~ao
<bloco_de_instruc¸~oes_2>
Fim_se
ou
Se(<condic¸~ao>)ent~ao
<bloco_de_instruc¸~oes>
Fim_se
A condic¸a˜o e´ avaliada. Se o resultado for verdadeiro enta˜o o bloco de
instruc¸~oes 1 e´ executado e o fluxo do algoritmo prossegue com o pri-
meiro comando apo´s o Fim_se. Se o resultado for falso, enta˜o o bloco de
instruc¸~oes 2 e´ executado e, ao te´rmino do mesmo, o fluxo de execuc¸a˜o
prossegue com o primeiro comando apo´s o Fim_se. Ha´ casos em que sen~ao
bloco de instruc¸~oes 2 e´ omitido. Dessa forma, quando a condic¸a˜o e´ falsa,
o fluxo de execuc¸a˜o prossegue normalmente para a primeira instruc¸a˜o apo´s
o Fim_se, como se o comando Se na˜o existisse.
25
Figura 9: Fluxograma do comando SE em sua forma expandida.
Figura 10: Fluxograma do comando SE em sua forma compacta.
Nas figuras 9 e 10 sa˜o mostrados os fluxogramas das duas formas de
utilizac¸a˜o do comando SE.
Exemplos:
1. Determinar se uma pessoa e´ maior ou menor de idade.
Algoritmo Maioridade
Inteiro: idade
Inı´cio
Escreva("Digite a idade (maior do que zero): ")
Leia(idade)
26
Se(idade > 0)ent~ao
Se(idade >= 18)ent~ao
Escreva("Maior de idade.")
sen~ao
Escreva("Menor de idade.")
Fim_se
Sen~ao
Escreva("Idade incorreta.")
Fim_se
Fim
2. Calcular o quociente e o resto de uma divisa˜o inteira.
Algoritmo Divis~ao
Inteiro: x, y, quo, res
Inı´cio
Escreva("Digite dois nu´meros inteiros: ")
Leia(x,y)
Se(y <> 0)ent~ao
quo <- x \ y
res <- x - quo * y
Escreva("Quociente = ", quo ,"Resto = ", res)
sen~ao
Escreva("N~ao existe divis~ao por zero.")
Fim_se
Fim
5.1.1.1 SE’s aninhados ou encaixados
Sintaxe:
Se(<condic¸~ao1>)ent~ao
<bloco_de_instruc¸~oes_1>
sen~ao
Se(<condic¸~ao2>)ent~ao
<bloco_de_instruc¸~oes_2>
sen~ao
Se(<condic¸~ao3>)ent~ao
<bloco_de_instruc¸~oes_3>
sen~ao
.
.
.
Fim_se
Fim_se
27
A figura 11 mostra o fluxograma do comando SE’s aninhados.
Figura 11: Fluxograma do comando SE aninhado.
28
Exemplo:
å Dados treˆs nu´meros, determinar o maior e o menor entre eles.
Algoritmo Max_min
Real: a, b, c, max, min
Inı´cio
Escreva("Digite tres numeros: ")
Leia(a, b, c)
Se(a < b)ent~ao
Se(b < c)ent~ao
min <- a
max <- c
sen~ao
max <- b
Se(a < c)ent~ao
min <- a
sen~ao
min <- c
Fim_se
Fim_se
sen~ao
Se(b > c)ent~ao
min <- c
max <- a
sen~ao
min <- b
Se(a > c)ent~ao
max <- a
sen~ao
max <- c
Fim_se
Fim_se
Fim_se
Escreva("Maior numero = ", max)
Escreva("Menor numero = ", min)
Fim
29
5.1.2 Estrutura de decisa˜o do tipo ESCOLHA
Sintaxe:
Escolha(<express~ao>)
Caso(<condic¸~ao1>)fac¸a
<bloco_de_instruc¸~oes_1>
Caso(<condic¸~ao2>)fac¸a
<bloco_de_instruc¸~oes_2>
.
.
.
Caso(<condic¸~aoN>)fac¸a
<bloco_de_instruc¸~oes_N>
sen~ao
<bloco_alternativo>
Fim_escolha
O comando ESCOLHA, corresponde ao comando SE mas de uma forma
mais compacta nas operac¸o˜es de selec¸a˜o. O valor assumido pela expressa˜o e´
comparado ao valor de cada condic¸a˜o de cada caso. Quando a comparac¸a˜o e´
avaliada como verdadeira, o bloco de instruc¸o˜es referente ao caso e´ executado
e o fluxo de execuc¸a˜o passa para o primeiro comando apo´s o Fim_escolha.
Caso em nenhuma das comparac¸o˜es resulte em verdadeiro, um bloco alter-
nativo de instruc¸o˜es e´ executado e o fluxo de execuc¸a˜o do algoritmo segue
adiante.
O comando ESCOLHA na˜o aceita valores do tipo real e nem cadeias de
caracteres (na expressa˜o e nas condic¸o˜es dos casos), somente valores inteiros
e caracteres (um apenas em cada situac¸a˜o).
A figura 12 mostra o fluxograma do comando ESCOLHA.
Exemplo:
å Programa que simula uma calculadora com as quatro operac¸o˜es
aritme´ticas.
Algoritmo Calculadora
Real: num1, num2
Literal[2]: op
Inicio
Escreva("Digite um numero, o operador e outro
numero:")
Leia(num1,op,num2)
Escolha(op)
Caso(op="+")fac¸a
30
Escreva(num1,op,num2," = ",num1 + num2)
Caso(op="-")fac¸a
Escreva(num1,op,num2," = ",num1 - num2)
Caso(op="*")fac¸a
Escreva(num1,op,num2," = ",num1 * num2)
Caso(op="/")fac¸a
Se(num2 <> 0)ent~ao
Escreva(num1,op,num2," = ",num1 / num2)
Sen~ao
Escreva("N~ao existe divis~ao por zero.")
Fim_se
Sen~ao
Escreva("Operador desconhecido.")
Fim_escolha
Fim
Figura 12: Fluxograma do comando ESCOLHA.
31
5.2 Estrutura de repetic¸a˜o
Uma estrutura de repetic¸a˜o tem por objetivo repetir um trecho de pro-
grama um certo nu´mero de vezes. E´ tambe´m chamada de lac¸o. Os lac¸os
podem ser contados ou condicionais.Os lac¸os contados possuem um nu´mero
de repetic¸o˜es conhecido. E´ a estrutura de repetic¸a˜o do tipo PARA-FAC¸A.
Os lac¸os condicionais possuem um nu´mero indeterminado de repetic¸o˜es, de-
pendendo de uma condic¸a˜o. Com a condic¸a˜o no in´ıcio do trecho, temos
a estrutura de repetic¸a˜o do tipo ENQUANTO-FAC¸A. Com a condic¸a˜o no
final do trecho, temos a estrutura de repetic¸a˜o do tipo REPITA-ATE´.
5.2.1 Estrutura de repetic¸a˜o do tipo PARA-FAC¸A
Sintaxe:
Para <var> de <ini> ate´ <fim> passo <inc> fac¸a
<bloco_de_instruc¸~oes>
Fim_para
var e´ necessariamente uma varia´vel inteira (varia´vel de controle do lac¸o).
ini, fim e inc, sa˜o expresso˜es inteiras (constantes, varia´veis ou expresso˜es).
Costumamos omitir o passo <inc> quando inc e´ 1. var assume inicialmente
o valor de ini e testa se na˜o ultrapassou o valor de fim. Caso afirmativo
o trecho a ser repetido (bloco de instruc¸~oes) e´ executado e var e´ incre-
mentado do valor inc, e novamente e´ feito o teste. Caso o teste seja negativo
(em algum momento sera´) a repetic¸a˜o chega ao seu final e a sequeˆncia de
execuc¸a˜o prossegue.
Em vez de ocorrer a operac¸a˜o de incremento, pode ocorrer a operac¸a˜o
de decremento (dec), onde var e´ decrementado do valor dec.
O Fluxograma do lac¸o PARA-FAC¸A e´ mostrado na figura 13.
Exemplo:
å Ca´lculo do fatorial de um nu´mero inteiro na˜o-negativo.
Algoritmo Fatorial
Inteiro: num, k, fat
Inı´cio
Escreva("Digite um nu´mero:")
Leia(num)
Se(num >= 0)ent~ao
fat <- 1
Para k de 2 ate´ num fac¸a
fat <- fat*k
Fim_para
Escreva("Fatorial de",num," igual a ",fat)
32
Sen~ao
Escreva("N~ao existe fatorial de nu´mero negativo.")
Fim_se
Fim
Figura 13: Fluxograma dos lac¸os PARA-FAC¸A e ENQUANTO-FAC¸A.
5.2.2 Estrutura de repetic¸a˜o do tipo ENQUANTO-FAC¸A
Sintaxe
Enquanto(<express~ao_lo´gica>)fac¸a
<bloco_de_instruc¸~oes>
Fim_enquanto
Se o valor lo´gico da express~ao lo´gica e´ verdadeiro, enta˜o o trecho
(bloco de instruc¸~oes) sera´ executado, e novamente a express~ao lo´gica
e´ avaliada, e assim por diante. Quando o valor da express~ao lo´gica e´
falso, a execuc¸a˜o segue para a instruc¸a˜o apo´s Fim_enquanto. No trecho a
ser repetido, a express~ao lo´gica deve ser alterada para que na˜o tenhamos
um lac¸o infinito.
Na figura 13 e´ mostrado o fluxograma do lac¸o ENQUANTO-FAC¸A.
33
Exemplo:
å Ca´lculo do mdc entre dois nu´meros inteiros positivos.
Algoritmo MDC
Inteiro: a, b
Inı´cio
Escreva("Digite dois numeros inteiros positivos: ")
Leia(a,b)
Se(a>0 .E. b>0)ent~ao
Enquanto(a <> b)fac¸a
Se(a > b)ent~ao
a <- a - b
sen~ao
b <- b - a
Fim_se
Fim_enquanto
Escreva("mdc = ", a)
Sen~ao
Escreva("Dados incorretos.")
Fim_se
Fim
5.2.3 Estrutura de repetic¸a˜o do tipo REPITA-ATE´
Sintaxe:
Repita
<bloco_de_instruc¸~oes>
Ate´(<express~ao_lo´gica>)
Como o crite´rio de parada fica no final da estrutura, o trecho (bloco de
instruc¸~oes) a ser repetido e´ executado, sempre, pelo menos, uma vez. O
lac¸o chega ao seu final, quando o valor da express~ao lo´gica e´ verdadeiro,
o contra´rio do lac¸o ENQUANTO-FAC¸A.
O fluxograma do lac¸o REPITA-ATE´ e´ mostrado na figura 14.
Exemplo:
å Imprimir os divisores de um nu´mero inteiro positivo dado.
Algoritmo Divisores
Inteiro: num, dv
Inı´cio
Repita
Escreva("Digite um numero inteiro positivo: ")
Leia(num)
34
Ate´(num > 0)
Escreva("Divisores do nu´mero ", num)
dv <- 1
Repita
Se((num - num \ dv * dv) = 0)ent~ao
Escreva(dv)
Fim_se
dv <- dv + 1
Ate´(dv > num)
Fim
Figura 14: Fluxograma do lac¸o REPITA-ATE´.
35
5.3 Exerc´ıcios propostos
Fac¸a algoritmos para resolver os problemas abaixo.
1. Calcular a soma dos nu´meros pares entre 15 e 55.
2. Calcular a soma dos nu´meros ı´mpares compreendidos entre
dois outros nu´meros inteiros dados (na˜o inclui-los na soma).
3. Dado um nu´mero inteiro positivo maior que 1, dizer se ele
e´ primo ou na˜o.
4. Imprimir o maior, o menor e a me´dia aritme´tica de n nu´me-
ros quaisquer dados.
5. Imprimir os n primeiros nu´meros da sequ¨eˆncia de Fibonacci
(1 1 2 3 5 8 13 21 . . . ).
6. Calcular a soma de todos os mu´ltiplos de um certo nu´mero
inteiro dado compreendidos entre dois outros nu´meros in-
teiros tambe´m dados (na˜o inclui-los na soma).
36
6 Exemplos de algoritmos
1. A multa por excesso de velocidade e´ baseada em quanto voceˆ se ex-
cedeu ale´m do limite ma´ximo permitido. Supo˜e-se que a multa seja
computada da seguinte forma:
velocidade acima do limite (km/h) multa
1 a 10 R$ 10,00
11 a 20 R$ 20,00
21 a 30 R$ 30,00
31 a 40 R$ 40,00
41 ou mais R$ 50,00
Dados o limite de velocidade e a velocidade com que voceˆ vinha, qual
o valor de sua multa?
Algoritmo Velocidade
Inteiro: lim_vel, vel_mot, dif_vel, aux
Real: multa
Inicio
Escreva("Digite o limite ma´ximo permitido: ")
Leia(lim_vel)
Escreva("Digite a velocidade com que vinha o
motorista: ")
Leia(vel_mot)
Se(vel_mot > lim_vel)ent~ao
dif_vel <- vel_mot - lim_vel
aux <- (dif_vel - 1) / 10
Escolha(aux)
Caso(aux = 0)fac¸a
multa <- 10.00
Caso(aux = 1)fac¸a
multa <- 20.00
Caso(aux = 2)fac¸a
multa <- 30.00
Caso(aux = 3)fac¸a
multa <- 40.00
Sen~ao
multa <- 50.00
Fim_escolha
Escreva("Valor da multa = ", multa)
Sen~ao
Escreva("N~ao existe multa.")
Fim_se
Fim
37
2. Ca´lculo do ma´ximo divisor comum entre dois nu´meros dados.
Algoritmo MDC
Inteiro: a, b, r
Inı´cio
Escreva("Digite dois nu´meros inteiros: ")
Leia(a,b)
Se(a < 0)ent~ao
a <- -a
Fim_se
Se(b < 0)ent~ao
b <- -b
Fim_se
Enquanto(b <> 0)fac¸a
r <- a - a\b*b
a <- b
b <- r
Fim_enquanto
Escreva("MDC = ", a)
Fim
3. Imprime os divisores de um nu´mero inteiro dado.
Algoritmo Divisores
Inteiro: num, dv
Inı´cio
Repita
Escreva("Digite um nu´mero inteiro positivo: ")
Leia(num)
Ate´(num > 0)
Escreva("Divisores do nu´mero ", num)
Para dv de 1 ate´ num fac¸a
Se(num - num\dv*dv = 0)ent~ao
Escreva(dv)
Fim_se
Fim_para
Fim
4. Imprime o maior, o menor e a me´dia aritme´tica de n nu´meros dados.
Algoritmo Maior_menor
Real: x, maior, menor, me´dia
Inteiro: n, i
Inı´cio
Escreva("Digite a quantidade de nu´meros: ")
Leia(n)
Escreva("Digite o primeiro nu´mero : ")
Leia(x)
menor <- x
38
maior <- x
media <- x
Para i de 2 ate´ n fac¸a
Escreva("Digite mais um nu´mero: ")
Leia(x)
Se(x > maior)ent~ao
maior <- x
Sen~ao
Se(x < menor)ent~ao
menor <- x
Fim_se
Fim_se
media <- media + x
Fim_para
media <- media / n
Escreva("Maior nu´mero = ", maior)
Escreva("Menor nu´mero = ", menor)
Escreva("Media aritmetica = ", media)
Fim
5. Ca´lculo do fatorial de um nu´mero inteiro na˜o-negativo.
Algoritmo Fatorial
Inteiro: numero, fatorial, aux
Inı´cio
Escreva("Digite um nu´mero inteiro n~ao-negativo: ")
Leia(numero)
Se(numero >= 0)ent~ao
fatorial <- 1
aux <- 2
Enquanto(aux <= numero)fac¸a
fatorial <- fatorial * aux
aux <- aux + 1
Fim_enquanto
Escreva("Fatorial de ", numero, " = ", fatorial)
Sen~ao
Escreva("N~ao existe fatorial de nu´mero negativo!")
Fim_se
Fim
39
7 Estrutura de dados homogeˆneos
7.1 Introduc¸a˜o
Ate´ agora, vimos os quatro tipos ba´sicos de informac¸a˜o: Inteiro, Real,
Lo´gico e Literal. Mas eles na˜o sa˜o suficientes para representar toda e qual-
quer informac¸a˜o que possa surgir. Portanto, construiremos novos tipos a
partir dos tipos ba´sicos, a` medida que se fizerem necessa´rios. Esses novos
tipos teˆm um formato denominado estrutura de dados, que define como os
tipos ba´sicos esta˜o organizados.
Uma varia´vel simples e´ uma entidade criada para permitir o acesso a uma
posic¸a˜o de memo´ria onde se armazena uma informac¸a˜o de um determinado
tipo de dado pela simples refereˆncia a um nome simbo´lico.
Neste cap´ıtulo, veremos estrutura de dados homogeˆneos, como vetores,matrizes e cadeias de caracteres, que nos permitira´ referenciar um grupo de
varia´veis do mesmo tipo pelo mesmo nome simbo´lico.
7.2 Varia´veis compostas homogeˆneas
Quando uma determinada estrutura de dados e´ composta de varia´veis
com o mesmo tipo ba´sico, temos um conjunto homogeˆneo de dados.
Varia´veis compostas homogeˆneas, tambe´m chamadas de varia´veis indexa-
das, correspondem a um conjunto de varia´veis do mesmo tipo, referencia´veis
pelo mesmo nome e individualizadas entre si atrave´s de sua posic¸a˜o dentro
desse conjunto (os ı´ndices).
Uma varia´vel indexada pode ser definida contendo um ou mais ı´ndices.
Quando possui um u´nico ı´ndice a varia´vel e´ chamada de vetor e quando
possui dois ı´ndices e´ chamada de matriz. Com treˆs ou mais ı´ndices na˜o
recebe nome especial, tambe´m, na pra´tica, sua ocorreˆncia e´ pouco frequ¨ente.
Ao nu´mero de ı´ndices necessa´rios a` localizac¸a˜o de um componente dentro
da varia´vel indexada da´-se o nome de dimensa˜o.
7.3 Vetores
As varia´veis indexadas que possui apenas um ı´ndice sa˜o chamadas de
vetores ou varia´veis compostas unidimensionais.
Notac¸a˜o:
<nome_varia´vel>[<ı´ndice>]
x[i]: varia´vel indexada.
i: ı´ndice (expressa˜o inteira positiva).
40
Exemplos:
1. A[3]: representa o terceiro elemento do vetor A.
2. Nome[p]: representa o p-e´simo elemento do vetor Nome.
3. x[2*i + 3*j - 4*k]: a avaliac¸a˜o da expressa˜o entre colchetes, que
devera´ ser um nu´mero inteiro positivo, dara´ a posic¸a˜o do elemento no
vetor x.
7.3.1 Declarac¸a˜o de vetores
Como qualquer varia´vel simples, para usarmos vetores precisamos antes
declara´-lo.
Sintaxe:
<tipo> : <nome>[<limite>]
Onde <tipo> podera´ ser qualquer dos tipos va´lidos, <nome> e´ qualquer
nome de uma varia´vel simples representativa do conjunto e <limite> e´ um
nu´mero inteiro positivo que limita o valor ma´ximo para o ı´ndice da varia´vel
indexada, ou seja, nu´mero ma´ximo de elementos do vetor.
Exemplos:
1.
Real: vetor1[10], vetor2[20]
2.
Inteiro: pares[30], impares[50]
3.
Lo´gico: opcoes[20]
4.
Literal[30]: nomes[10], datas[20], cidades[30]
7.3.2 Operac¸o˜es com vetores
Na˜o e´ poss´ıvel operar diretamente com conjuntos, como um todo, mas
apenas com cada um de seus componentes, um por vez. O acesso individual
a cada componente de um conjunto e´ realizado pela especificac¸a˜o de sua
posic¸a˜o, no mesmo, por meio de um ou mais ı´ndices. Por exemplo, para
somar dois vetores e´ necessa´rio somar cada um dos seus componentes, dois
a dois.
Na˜o se deve confundir o nu´mero entre colchetes na declarac¸a˜o de varia´-
veis indexadas com o nu´mero entre colchetes no processamento de alguma
operac¸a˜o. No primeiro caso, o nu´mero representa o limite superior para os
ı´ndices, enquanto que no segundo caso, o nu´mero representa a posic¸a˜o do
elemento no conjunto (o ı´ndice).
41
7.3.2.1 Atribuic¸a˜o de vetores
Cada vez que se processa uma varia´vel indexada, qualquer que seja a
operac¸a˜o, o ı´ndice deve ser um valor conhecido.
A sintaxe da atribuic¸a˜o para varia´veis indexadas e´ a mesma, sendo que
a varia´vel, ale´m do nome, deve conter o(s) ı´ndice(s) do componente do
conjunto, onde devera´ ser armazenado o valor da expressa˜o. A expressa˜o
tambe´m podera´ conter varia´veis indexadas.
Exemplos:
1.
x[1] <- 0
2.
y[10] <- 2*x**3+1
3.
num[3] <- 3*num[1] + 5*num[2]
4.
fibo[n] <- fibo[n-2] + fibo[n-1]
5.
Para i de 1 ate´ 10 fac¸a
p[i] <- 3*i-1
Fim_para
6.
Para u de 1 ate´ n fac¸a
Se (u - u\2*2 = 0) ent~ao
x[u] <- 0
sen~ao
x[u] <- 1
Fim_se
Fim_para
7.3.2.2 Leitura de vetores
A leitura de um conjunto e´ feita passo a passo, um componente por vez,
usando a mesma sintaxe da instruc¸a˜o primitiva de entrada de dados, ou
seja, a instruc¸a˜o Leia(<lista_de_varia´veis>), sendo que, mais uma vez,
explicitando a posic¸a˜o do componente lido. E´ bastante frequ¨ente o uso de
estruturas de repetic¸a˜o na leitura de varia´veis indexadas.
Exemplos:
1.
Leia(x[1], x[2], x[3], x[4], x[5])
42
2.
Para i de 1 ate´ 100 fac¸a
Leia(x[i])
Fim_para
3.
Para k de 1 ate´ n fac¸a
Repita
Escreva("Digite um nu´mero positivo:")
Leia(num[k])
Ate´(num[k] > 0)
Fim_para
4. Para i de 1 ate´ n fac¸a
Repita
Escreva("Digite um nu´mero positivo:")
Leia(p)
Ate´(p > 0)
x[i] <- p
Fim_para
7.3.2.3 Escrita de vetores
A escrita de um conjunto obedece a` mesma sintaxe da instruc¸a˜o primitiva
de sa´ıda, ou seja, a instruc¸a˜o Escreva(<lista_de_express~oes>). E de
forma ana´loga ao item anterior, utilizamos as estruturas de repetic¸a˜o para
escrever todos os elementos de um conjunto.
Exemplos:
1.
Para i de 1 ate´ p fac¸a
Escreva(x[i])
Fim_para
2.
Escreva("Vetor Soluc¸~ao: ")
Para j de 1 ate´ n fac¸a
Escreva("x[",j,"]=", x[j])
Fim_para
3.
Escreva ("i X[i] Y[i] Z[i]")
Para i de 1 ate´ n fac¸a
Escreva(i, x[i], y[i], z[i])
Fim_para
43
7.3.3 Exemplos de algoritmos com vetores
1. Imprimir a soma de n nu´meros dados.
Algoritmo Soma
Real: x[100], soma
Inteiro: n, i
Inı´cio
Repita
Escreva("Quantos nu´meros? ")
Leia(n)
Ate´(n > 0 .E. n <= 100)
Escreva("Digite os ", n , " nu´meros: ")
Para i de 1 ate´ n fac¸a
Leia(x[i])
Fim_para
soma <- 0
Para i de 1 ate´ n fac¸a
soma <- soma + x[i]
Fim_para
Escreva("Soma = ", soma)
Fim
2. Imprimir os n primeiros termos da sequ¨eˆncia de Fibonacci (1 1 2 3 5
8 13 21 . . . ):
Algoritmo Fibonacci
Inteiro: f[100], n, i
Inı´cio
Repita
Escreva("Quantos termos?")
Leia(n)
Ate´(n>0 .E. n <=100)
f[1] <- 1
f[2] <- 1
Para i de 3 ate´ n fac¸a
f[i] <- f[i-2] + f[i-1]
Fim_para
Escreva("Seque^ncia de Fibonacci: ")
Para i de 1 ate´ n fac¸a
Escreva(f[i])
Fim_para
Fim
3. Dados dois vetores com n componentes cada, calcular o produto escalar
entre eles.
Algoritmo Produto_escalar
Real: x[10], y[10], pesc
44
Inteiro: n, i
Inı´cio
Repita
Escreva("Quantos componentes tem cada vetor? ")
Leia(n)
Ate´(n>0 .E. n<=10)
Escreva("Digite os nu´meros do primeiro vetor: ")
Para i de 1 ate´ n fac¸a
Leia(x[i])
Fim_para
Escreva("Digite os nu´meros do segundo vetor: ")
pesc <- 0
Para i de 1 ate´ n fac¸a
Leia(y[i])
pesc <- pesc + x[i]*y[i]
Fim_para
Escreva("Produto Escalar = ", pesc)
Fim
4. Dados n nu´meros inteiros positivos, imprimi-los, separadamente, como
pares e ı´mpares.
Algoritmo Par_ı´mpar
Inteiro: x[30], par[30], impar[30], n, k, p, i
Inı´cio
Repita
Escreva("Quantos nu´meros?")
Leia(n)
Ate´(n>0 .E. n<=30)
Escreva("Digite os", n, " nu´meros inteiros
positivos:")
p <- 0
i <- 0
Para k de 1 ate´ n fac¸a
Repita
Leia(x[k])
Ate´(x[k] > 0)
Se(x[k] - x[k]\2*2 = 0)ent~ao
p <- p + 1
par[p] <- x[k]
sen~ao
i <- i + 1
impar[i] <- x[k]
Fim_se
Fim_para
Escreva("Nu´meros pares: ")
Para k de 1 ate´ p fac¸a
Escreva(par[k])
Fim_para
45
Escreva("Nu´meros ı´mpares: ")
Para k de 1 ate´ i fac¸a
Escreva(ı´mpar[k])
Fim_para
Fim
5. Calcular e imprimir o conjunto intersec¸a˜o entre dois conjuntos nume´-
ricos quaisquer dados.
Algoritmo Intersec¸~ao
Real: a[20], b[20], c[20]
Inteiro: m, n, i, j, k
Inı´cio
Repita
Escreva("Quantos nu´meros tem o primeiro conjunto? ")
Leia(m)
Ate´(m>0 .E. m<=20)
Escreva("Digite os nu´meros do primeiro conjunto:")
Para i de 1 ate´ m fac¸a
Leia(a[i])
Fim_para
Repita
Escreva("Quantos nu´meros tem o segundo conjunto? ")
Leia(n)
Ate´(n>0.E.n<=20)
Escreva("Digite os nu´meros do segundo conjunto:")
Para i de 1 ate´ n fac¸a
Leia(b[i])
Fim_para
k <- 0
Para i de 1 ate´ m fac¸a
Para j de 1 ate´ n fac¸a
Se(a[i] = b[j])ent~ao
k <- k + 1
c[k] <- a[i]
Fim_se
Fim_para
Fim_para
Se(k=0)ent~ao
Escreva("Intersec¸~ao Vazia.")
Sen~ao
Escreva("Conjunto Intersec¸~ao:")
Para i de 1 ate´ k fac¸a
Escreva(c[i])
Fim_para
Fim_se
Fim
6. Dado um nu´meroverificar se o mesmo se encontra num vetor com n
46
elementos. Utilizar pesquisa sequ¨eˆncial1.
Algoritmo Pesquisa_sequencial
Real: x[100], num
Inteiro: n, i
Lo´gico: achou
Inı´cio
Repita
Escreva("Quantos nu´meros?")
Leia(n)
Ate´(n>0 .E. n<=100)
Escreva("Digite todos os nu´meros:")
Para i de 1 ate´ n fac¸a
Leia(x[i])
Fim_para
Escreva("Digite o nu´mero que procura: ")
Leia(num)
achou <- .F.
i <- 1
Enquanto(i <= n .E. .N~ao. achou)fac¸a
Se(x[i] = num)ent~ao
achou <- .V.
sen~ao
i <- i+1
Fim_se
Fim_enquanto
Se(achou)ent~ao
Escreva("Nu´mero encontrado. ")
Sen~ao
Escreva("Nu´mero n~ao encontrado.")
Fim_se
Fim
7. Dado um nu´mero verificar se o mesmo se encontra num vetor com n
elementos. Utilizar pesquisa bina´ria2.
Algoritmo Pesquisa_bina´ria
Real: x[100], num
Inteiro: n, i, meio, alto, baixo
Lo´gico: achou
Inı´cio
Repita
Escreva("Quantos nu´meros?")
Leia(n)
Ate´(n>0 .E. n<=100)
1Pesquisa sequ¨encial ou linear e´ o me´todo para se encontrar um elemento particular
num conjunto na˜o classificado.
2Pesquisa bina´ria e´ semelhante a` pesquisa sequ¨encial quanto ao objetivo, sendo que os
elementos do vetor esta˜o previamente classificados segundo algum crite´rio.
47
Escreva("Digite todos os nu´meros:")
Para i de 1 ate´ n fac¸a
Leia(x[i])
Fim_para
Escreva("Digite o nu´mero que procura: ")
Leia(num)
alto <- n
baixo <-1
achou <- .F.
Enquanto(baixo<=alto .E. .N~ao. achou)fac¸a
meio <- (baixo + alto)\2
Se(num < x[meio])ent~ao
alto <- meio - 1
sen~ao
Se(num > x[meio])ent~ao
baixo <- meio + 1
sen~ao
achou <- .V.
Fim_se
Fim_se
Fim_enquanto
Se(achou)ent~ao
Escreva("Nu´mero encontrado.")
Sen~ao
Escreva("Nu´mero n~ao encontrado.")
Fim_se
Fim
8. Colocar na ordem crescente n nu´meros quaisquer dados.
Algoritmo Ordem_crescente
Real: x[100], aux
Inteiro: n, i, j
Inı´cio
Repita
Escreva("Quantos nu´meros?")
Leia(n)
Ate´(n>0 .E. n<=100)
Escreva("Digite os nu´meros: ")
Para i de 1 ate´ n fac¸a
Leia(x[i])
Fim_para
Para j de n ate´ 2 passo -1 fac¸a
Para i de 1 ate´ (j-1) fac¸a
Se(x[i] > x[i+1])ent~ao
aux <- x[i]
x[i] <- x[i+1]
x[i+1] <- aux
Fim_se
48
Fim_para
Fim_para
Escreva("Vetor ordenado: ")
Para i de 1 ate´ n fac¸a
Escreva(x[i])
Fim_para
Fim
7.3.4 Exerc´ıcios propostos
1. Dados dois vetores com n componentes cada um, calcular e
imprimir a soma deles.
2. Calcular o cosseno do aˆngulo formado por dois vetores da-
dos, com o mesmo nu´mero de coordenadas, atrave´s da fo´r-
mula:
Cosseno =
A.B
|A||B|
Onde A.B e´ o produto escalar entre os vetores A e B, e |A|
e´ o mo´dulo do vetor A, dado por |A| = √A.A.
3. Calcular a me´dia aritme´tica de n nu´meros reais dados.
4. Calcular o n-e´simo termo da sequ¨eˆncia de Fibonacci.
5. Leia n nu´meros maiores que 1, e imprima-os, separada-
mente, como primos e na˜o-primos.
6. Dado um vetor A com n nu´meros reais, obter um outro
vetor B, tambe´m com n nu´meros, da seguinte forma:
B[1] = 2*A[1]
B[2] = 3*A[1] + 2*A[2]
B[3] = 4*A[1] + 3*A[2] + 2*A[3]
.
.
. (...e assim por diante)
7. Calcular o Desvio padra˜o (D.P.) de uma amostra x de n
nu´meros quaisquer dados.
D.P. =
√√√√√√
n∑
i=1
(x[i]−M)2
n− 1
Onde M e´ a me´dia dos n nu´meros dados.
8. Leia um conjunto com n nu´meros e informe se existe algum
elemento repetido no conjunto.
9. Leia n nu´meros quaisquer e imprima-os sem repetic¸o˜es.
10. Dado um nu´mero inteiro positivo, do sistema decimal, ob-
tenha o seu valor correspondente no sistema bina´rio.
49
7.4 Matrizes
Os vetores, ou varia´veis compostas unidimensionais, teˆm como principal
caracter´ıstica a necessidade de apenas um ı´ndice para enderec¸amento. Uma
estrutura que precise de mais de um ı´ndice, como no caso de matrizes, sera´
denominada estrutura composta multidimensional.
As varia´veis compostas multidimensionais, mais utilizadas sa˜o as bidi-
mensionais, ou matrizes, devido a` sua relac¸a˜o direta com muitas aplicac¸o˜es.
A aplicac¸a˜o com as demais varia´veis indexadas, isto e´, com treˆs ı´ndices,
quatro ı´ndices, etc., se faz por analogia a esta.
Notac¸a˜o:
<nome_varia´vel>[<ı´ndice1>,<ı´ndice2>, ... , <ı´ndiceN>]
x[i,j,k]: varia´vel indexada de dimensa˜o treˆs.
i, j, k: ı´ndices (valores inteiros positivos).
Exemplos:
1. x[2,3]: elemento de uma matriz (varia´vel indexada bidimensional) da
segunda linha e terceira coluna (posic¸a˜o na matriz).
2. mat[i+1,j-1]: os ı´ndices podem ser expresso˜es desde que sejam in-
teiras.
7.4.1 Declarac¸a˜o de matrizes
Veremos, de agora em diante, apenas matrizes (dois ı´ndices) como vari-
a´veis compostas multidimensionais.
Sintaxe:
<tipo>: <nome>[<limite1>,<limite2>]
Exemplos:
1.
Real: mat1[10,10]
2.
Inteiro: x[15,15], y[20,20], z[10,10]
3.
Lo´gico: achou[5,5]
4.
Literal[20]: nomes[15,15]
50
7.4.2 Operac¸o˜es com matrizes
Percebemos que uma estrutura bidimensional e´ um conjunto de estru-
turas unidimensionais, ou seja, uma matriz e´ um conjunto de vetores. Por-
tanto, para operarmos com matrizes, geralmente, lanc¸amos ma˜o de duas
estruturas de repetic¸a˜o (para vetores utilizamos uma).
7.4.2.1 Atribuic¸a˜o de matrizes
A atribuic¸a˜o e´ uma das formas de qualquer varia´vel armazenar algum va-
lor. Como na˜o operamos diretamente com a matriz, somente seus elementos
armazenam valores numa atribuic¸a˜o.
Exemplos:
1.
mat[3,4] <- 3.75
2.
Para i de 1 ate´ 10 fac¸a
Para j de 1 ate´ 10 fac¸a
Se(i = j)ent~ao
x[i,j] <- 1
sen~ao
x[i,j] <- 0
Fim_se
Fim_para
Fim_para
3.
Para i de 1 ate´ m fac¸a
Para j de 1 ate´ n fac¸a
Se(i > j)ent~ao
a[i,j] <- 2*i + 3*j
sen~ao
Se(i = j)ent~ao
a[i,j] <- i**2
sen~ao
a[i,j] <- 5*i**3 - 2*j**2
Fim_se
Fim_se
Fim_para
Fim_para
51
7.4.2.2 Leitura de matrizes
De forma ana´loga a leitura de vetores, utilizamos dois lac¸os para a leitura
de matrizes.
Exemplos:
1.
Para i de 1 ate´ m fac¸a
Para j de 1 ate´ n fac¸a
Leia(mat[i,j])
Fim_para
Fim_para
2.
Escreva("Digite nu´meros positivos:")
Para a de 1 ate´ p fac¸a
Para b de 1 ate´ p fac¸a
Repita
Escreva("Atenc¸~ao! Positivo.")
Leia(x)
Ate´(x > 0)
matriz[a,b] <- x
Fim_para
Fim_para
7.4.2.3 Escrita de matrizes
De forma semelhante a leitura fazemos a escrita de matrizes.
Exemplos:
1.
Para i de 1 ate´ m fac¸a
Para j de 1 ate´ n fac¸a
Escreva(matriz[i,j])
Fim_para
Fim_para
2.
Para i de 1 ate´ m fac¸a
Para j de 1 ate´ n fac¸a
Escreva("x[",i,",",j,"] = ",x[i,j])
Fim_para
Fim_para
52
7.4.3 Exemplos de algoritmos com matrizes
1. Imprimir a matriz identidade de ordem n.
Algoritmo Matriz_identidade
Inteiro: ident[20,20], n, i, j
Inı´cio
Repita
Escreva("Digite a ordem da matriz <=20:")
Leia(n)
Ate´(n>0 .E. n<=20)
Para i de 1 ate´ n fac¸a
Para j de 1 ate´ n fac¸a
Se(i = j)ent~ao
ident[i,j] <- 1
sen~ao
ident[i,j] <- 0
Fim_se
Fim_para
Fim_para
Para i de 1 ate´ n fac¸a
Para j de 1 ate´ n fac¸a
Escreva(ident[i,j])
Fim_para
Fim_para
Fim
2. Dada uma matriz quadrada de ordem n > 3, calcular:
(a) a soma dos elementos da primeira linha;
(b) a soma dos elementos da terceira coluna;
(c) a soma dos elementos da diagonal principal;
(d) a soma dos elementos da diagonal secunda´ria;
(e) a soma de todos os elementos da matriz.
Algoritmo Ca´lculos_matriciais
Real: mat[15,15], sa, sb, sc, sd, se
Inteiro: n, i, j
Inı´cio
Repita
Escreva("Digite a ordem da matriz >3:")
Leia(n)
Ate´(n>3 .E. n<=15)
Escreva("Digite os elementos da matriz por linha:")
Para i de 1 ate´ n fac¸a
Para j de 1 ate´ n fac¸a
Leia(mat[i,j])
Fim_para
53
Fim_para
sa <- 0
sb <- 0
sc <- 0
sd <- 0
se <- 0
Para i de 1 ate´ n fac¸a
sa <- sa + mat[1,i]
sb <- sb + mat[i,3]
sc <- sc + mat[i,i]
sd <- sd + mat[i,n - i + 1]
Para j de 1 ate´n fac¸a
se <- se + mat[i,j]
Fim_para
Fim_para
Escreva("sa=",sa," sb=",sb," sc=",sc," sd=",sd,
" se=", se)
Fim
3. Dada uma matriz quadrada de ordem n, calcular e imprimir a soma
dessa matriz com a sua transposta.
Algoritmo Soma_transposta
Real: x[10,10], y[10,10]
Inteiro: n, i, j
Inı´cio
Repita
Escreva("Digite a ordem da matriz <=10: ")
Leia (n)
Ate´(n>0 .E. n<=10)
Escreva("Digite os nu´meros da matriz:")
Para i de 1 ate´ n fac¸a
Para j de 1 ate´ n fac¸a
Leia(x[i,j])
Fim_para
Fim_para
Para i de 1 ate´ n fac¸a
Para j de 1 ate´ n fac¸a
y[i,j] <- x[i,j] + x[j,i]
Fim_para
Fim_para
Escreva("Matriz resultante:")
Para i de 1 ate´ n fac¸a
Para j de 1 ate´ n fac¸a
Escreva(y[i,j])
Fim_para
Fim_para
Fim
54
4. Dada uma matriz A qualquer de nu´meros inteiros positivos, gerar uma
matriz B tal que: B[i,j] = 0, se A[i,j] e´ par e B[i,j] = 1, se
A[i,j] e´ ı´mpar.
Algoritmo Matriz_B
Inteiro: A[10,10], B[10,10], m, n, i, j
Inı´cio
Repita
Escreva("Digite o nu´mero de linhas e o nu´mero
de colunas <=10: ")
Leia(m,n)
Ate´(m>0 .E. m<=10 .E. n>0 .E. n<=10)
Escreva("Digite os nu´meros da matriz de inteiros
positivos: ")
Para i de 1 ate´ m fac¸a
Para j de 1 ate´ n fac¸a
Repita
Leia(A[i,j])
Ate´(A[i,j] > 0)
Se(A[i,j] - A[i,j]\2*2 = 0)ent~ao
B[i,j] <- 0
sen~ao
B[i,j] <- 1
Fim_se
Fim_para
Fim_para
Escreva("Matriz pedida:")
Para i de 1 ate´ m fac¸a
Para j de 1 ate´ n fac¸a
Escreva(B[i,j])
Fim_para
Fim_para
Fim
5. Obtenha o produto entre duas matrizes conformes3.
Algoritmo Produto_matricial
Real: a[10,10], b[10,10], c[10,10]
Inteiro: m, n, p, i, j, k
Inı´cio
Repita
Escreva("Digite o nu´mero de linhas e o nu´mero de
colunas da primeira matriz, e tambe´m o
nu´mero de colunas da segunda matriz: ")
Leia(m, n, p)
3Obs.: Dadas duas matrizes de tipos poss´ıveis de se efetuar o produto entre elas, por
exemplo a matriz A do tipo m por n, e a matriz B do tipo n por p, enta˜o obteremos uma
outra matriz C do tipo m por p.
55
Ate´(m>0 .E. m<=10 .E. n>0 .E. n<=10 .E. p>0 .E. p<=10)
Escreva("Digite os nu´meros da primeira matriz: ")
Para i de 1 ate´ m fac¸a
Para j de 1 ate´ n fac¸a
Leia(a[i,j])
Fim_para
Fim_para
Escreva("Digite os nu´meros da segunda matriz: ")
Para i de 1 ate´ n fac¸a
Para j de 1 ate´ p fac¸a
Leia(b[i,j])
Fim_para
Fim_para
Para i de 1 ate´ m fac¸a
Para k de 1 ate´ p fac¸a
c[i,k] <- 0
Para j de 1 ate´ n fac¸a
c[i,k] <- c[i,k] + a[i,j]*b[j,k]
Fim_para
Fim_para
Fim_para
Escreva("Matriz Produto: ")
Para i de 1 ate´ m fac¸a
Para j de 1 ate´ p fac¸a
Escreva(c[i,j])
Fim_para
Fim_para
Fim
7.4.4 Exerc´ıcios propostos
1. Gerar e imprimir uma matriz com m linhas e n colunas onde
seus elementos sa˜o da forma:
A[i, j] =

2i+ 7j − 2 se i < j
3i2 − 1 se i = j
4i3 − 5j2 + 1 se i > j.
2. Calcular a soma dos elementos de uma matriz nume´rica
quadrada qualquer dada, que esta˜o acima da diagonal prin-
cipal.
3. Obtenha e imprima um vetor que seja a soma dos elementos
de cada coluna de uma matriz nume´rica qualquer dada.
4. Verificar se uma matriz quadrada dada e´ ou na˜o sime´trica.
56
5. Gerar e imprimir a matriz quadrada de ordem n abaixo.
1 n− 1 n− 2 · · · 1
2 1 n− 2 · · · 1
3 3 1 · · · 1
...
...
...
. . .
...
n n n · · · 1

6. A matriz abaixo, quadrada 4x4, foi obtida de acordo com
uma determinada definic¸a˜o para seus elementos. Fac¸a um
algoritmo que leia um nu´mero inteiro positivo n e imprima
essa matriz com n linhas e n colunas.
3 4 5 6
5 5 6 7
7 8 7 8
9 10 11 9

7.5 Cadeias e subcadeias de caracteres
A maior parte dos processamentos efetuados atualmente exige a mani-
pulac¸a˜o de cadeias de caracteres alfanume´ricos. Uma cadeia de caracteres
e´ uma sequeˆncia de letras, algarismos ou s´ımbolos (sinais de pontuac¸a˜o,
pareˆnteses, etc.). Cada caractere e´ uma informac¸a˜o e a cadeia de caracteres
e´ um conjunto de informac¸o˜es.
A relac¸a˜o de ordem entre as cadeias depende da relac¸a˜o de ordem vigente
para os caracteres e esta depende da linguagem de programac¸a˜o utilizada
na codificac¸a˜o do algoritmo.
Conforme ja´ vimos na apresentac¸a˜o do tipo de dados literal, esta or-
dem esta´ estabelecida pela ordem dos caracteres no sistema de codificac¸a˜o
utilizado ASCII.
A representac¸a˜o de uma cadeia de caracteres como um dado de proces-
samento e´ feita atrave´s da sequ¨eˆncia de seus caracteres entre aspas duplas.
Por exemplo: "JANEIRO", "abcdefg", "Rio Grande do Norte",
"etc.".
As varia´veis do tipo literal armazenam cadeias de caracteres.
Lembramos que o u´nico operador literal, que nos permite operar ca-
deias de caracteres, e´ o operador de concatenac¸a˜o + ("abc" + "de" resulta
"abcde").
Exemplo:
mes <- "FEVEREIRO"
nome <- "Ana Maria Duarte"
endereco <- "Rua Afonso Pena, 625. Tirol"
57
7.5.1 Declarac¸a˜o de cadeia de caracteres
A declarac¸a˜o de varia´veis do tipo literal, e´ feita como se fosse um vetor
onde seus elementos sa˜o caracteres, sendo que o nu´mero que indicaria o
limite ma´ximo de elementos do vetor na˜o fica junto a` varia´vel, e sim, ao
lado do tipo, mas o objetivo continua sendo reservar espac¸o na memo´ria
para armazenamento de constantes. No momento da declarac¸a˜o o espac¸o
reservado fica cheio de caracteres vazios ("") e, durante o processamento,
a medida que a varia´vel vai recebendo caracteres, os vazios va˜o sumindo,
mas o programador deve providenciar para que tenhamos pelo menos um
caractere vazio em qualquer momento do processamento, pois isso o ajudara´
a saber quantos caracteres podera˜o ser acessados, ou seja, ele devera´ declarar
n caracteres e utilizar, no ma´ximo, n-1, sendo n uma constante inteira maior
que 1.
Sintaxe:
Literal[<limite>]: <lista_varia´veis>
Exemplos:
1. Literal[41]: nome, endereco
nome e endereco podem armazenar ate´ 40 caracteres.
2. Literal[21]: nomes[50], cidades[50]
nomes e cidades sa˜o conjuntos (vetores) com, no ma´ximo,
50 cadeias de caracteres, contendo, no ma´ximo, 20 caracte-
res cada cadeia.
Como em um vetor, todos os caracteres de uma cadeia sa˜o armazenados
em unidades consecutivas de armazenamento de caracteres (1 byte para cada
caractere). O nu´mero de caracteres (ou de unidades de armazenamento) de
uma cadeia e´ o comprimento da cadeia, e a cada caractere corresponde um
nu´mero (posic¸a˜o) dentro da cadeia (como o ı´ndice nos vetores).
7.5.2 Subcadeia de caracteres
Uma subcadeia de caracteres e´ uma sequ¨eˆncia de um ou mais caracteres
consecutivos dentro de uma cadeia. Por exemplo, "JANE" e´ uma subcadeia
de "JANEIRO", mas "JAIRO" na˜o e´.
O recurso da subcadeia propicia a manipulac¸a˜o (o processamento) de
partes de uma determinada cadeia de caracteres.
Notac¸a˜o da subcadeia:
<nome_cadeia>[<inı´cio_cadeia>:<fim_cadeia>]
58
<nome_cadeia> e´ um nome qualquer de uma varia´vel declarada do
tipo literal.
<inı´cio_cadeia> e´ um nu´mero inteiro positivo que indica a posic¸a˜o
dentro da cadeia onde a subcadeia inicia.
<fim_cadeia> e´ um nu´mero inteiro positivo que indica a posic¸a˜o den-
tro da cadeia onde a subcadeia termina.
Exemplos: x[3:6], nome[4:10], me^s[3:3]
Exemplo: Seja a cadeia vogal "AEIOU". Enta˜o:
a subcadeia vogal[3:4] corresponde a "IO"
a subcadeia vogal[1:5] corresponde a "AEIOU"
a subcadeia vogal[2:2] corresponde a "E"
7.5.3 Exemplos de algoritmos com cadeias e subcadeias de ca-
racteres
1. Diga como sera´ a sa´ıda do algoritmo abaixo.
Algoritmo Cadeia_caracteres
Literal[11]: cadeia
Inı´cio
cadeia[1:3] <- "ABC"
cadeia[4:7] <- "DEFG"
cadeia[6:10] <- "HIJKL"
Escreva(cadeia)
Fim
Sa´ıda: ABCDEHIJKL
2. Diga como sera´ a sa´ıda do algoritmo abaixo.
Algoritmo Branco
Literal[52]: branco, z
Inteiro: n
Inı´cio
Para n de 1 ate´ 50 fac¸a
branco[n:n] <- " "
z <- branco[1:n]+ "Z"
Escreva(z)
Fim_para
Fim
Sa´ıda:
59
Z
Z
Z
Z
.
.
.
3. Calcular o comprimento de uma cadeia de caracteres dada.
Algoritmo Comprimento
Literal[81]: nome
Inteiro: n
Inı´cio
Escreva("Digite a cadeia: ")
Leia(nome)
n <- 0
Enquanto(nome[n+1:n+1] <> "")fac¸a
n <- n + 1
Fim_enquanto
Escreva("Comprimento = ", n)
Fim
4. Converter uma letra minu´scula em letra maiu´scula.
Algoritmo Maiu´sculo
Literal[27]: alfa, ALFA
Literal[2]: letra
Inteiro: i
Inı´cio
Repita
Escreva("Digite uma letra minu´scula: ")
Leia(letra)
Ate´(letra>="a" .E. letra<="z")
alfa <- "abcdefghijklmnopqrstuvwxyz"
ALFA <- "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
i <- 1
Enquanto(letra <> alfa[i:i])fac¸a
i <- i + 1
Fim_enquanto
letra <- ALFA[i:i]
Escreva(letra)
Fim
60
7.5.4 Exerc´ıcios propostos
1. Converta uma letra maiu´scula em letra minu´scula.
2. Fac¸a um algoritmo para converter uma cadeia de caracteres
de letras maiu´sculas em letras minu´sculas.
3. Dado o nome completo de uma pessoa imprimir apenas o
primeiro nome.
4. Dado o nome completo de uma pessoa imprimir apenas as
iniciais seguidas cada uma de ponto e espac¸o.
5. Dada uma cadeia de caracteres, inserir um caractere dado
numa posic¸a˜o da cadeia tambe´m dada e imprimir a nova
cadeia.
6. Dada uma cadeia de caracteres, eliminar o caractere de uma
posic¸a˜o dada nessa cadeia e imprimir a nova cadeia.
7. Dado um texto com, no ma´ximo, 80 caracteres, diga quan-
tas consoantes existem no texto.
8. Dado um texto com, no ma´ximo, 80 caracteres, diga quan-
tas vogais existem no texto.
9. Calcular o custo de um telegrama, onde os 30 primeiros
caracteres custam 9 centavos cada, os demais, a partir da´ı,
custam 6 centavos cada e os espac¸os em branco na˜o sa˜o
cobrados.
10. Dado um nu´mero inteiro positivo do sistema bina´rio, con-
verteˆ-lo no nu´mero correspondente do sistema decimal.
61
8 Subalgoritmos
8.1 Introduc¸a˜o
Sempre e´ poss´ıvel dividir problemas grandes e complicados em proble-
mas menores e de soluc¸a˜o mais simples. A decomposic¸a˜o de um problema
e´ fator determinante para a reduc¸a˜o da complexidade. A complexidade e´
sinoˆnimo de variedade, ou seja, a quantidade de situac¸o˜es diferentes que um
problema pode apresentar. Assim, quando decompomos um problema em
subproblemas, estamos invariavelmente dividindo tambe´m a complexidade
e, por consequ¨eˆncia, simplificando a resoluc¸a˜o. Outra grande vantagem da
decomposic¸a˜o e´ que permite focalizar a atenc¸a˜o em um problema pequeno
de cada vez, o que ao final produzira´ uma melhor compreensa˜o do todo.
Cada um desses pequenos problemas sera´ solucionado atrave´s de subalgorit-
mos. Nesse caso, o algoritmo completo e´ dividido num algoritmo principal
e diversos subalgoritmos (tantos quantos forem necessa´rios ou convenien-
tes). O algoritmo principal e´ aquele por onde comec¸a a execuc¸a˜o, e chama,
eventualmente, os demais subalgoritmos.
Subalgoritmo e´ um algoritmo que, geralmente, resolve um pequeno pro-
blema, e que esta´ subordinado a um outro algoritmo. Esta subordinac¸a˜o
deve-se ao fato de que o subalgoritmo so´ sera´ acionado se solicitado pelo
algoritmo principal. E´ poss´ıvel que um subalgoritmo chame outro subalgo-
ritmo.
Em resumo, os subalgoritmos sa˜o importantes:
• na subdivisa˜o de algoritmos complexos, facilitando o seu entendimen-
to;
• na estruturac¸a˜o de algoritmos, facilitando, principalmente, a detecc¸a˜o
de erros e a documentac¸a˜o de sistemas;
• na modularizac¸a˜o de sistemas, que facilita a manutenc¸a˜o de softwares
e reutilizac¸a˜o de subalgoritmos ja´ implementados.
8.2 Elementos de um subalgoritmo
A definic¸a˜o de um subalgoritmo consta de:
• cabec¸alho, onde esta˜o definidos o nome e o tipo do subalgoritmo, bem
como os seus paraˆmetros e suas varia´veis locais;
• corpo do subalgoritmo, onde se encontram as instruc¸o˜es, que sera˜o
executadas cada vez que ele e´ chamado.
O nome de um subalgoritmo e´ um nome simbo´lico pelo qual ele e´ cha-
mado por outro algoritmo.
62
As varia´veis locais sa˜o aquelas definidas dentro do pro´prio subalgoritmo
e so´ podem ser utilizadas pelo mesmo.
Os paraˆmetros sa˜o canais por onde os dados sa˜o transferidos pelo algo-
ritmo chamador a um subalgoritmo, e vice-versa. Para ser executado, a`s
vezes, um subalgoritmo precisa receber dados do algoritmo que o chamou,
e ao terminar sua tarefa, precisa fornecer os resultados ao mesmo. Esta
comunicac¸a˜o bidirecional e´ chamada de passagem de paraˆmetros.
O tipo de um subalgoritmo e´ definido em func¸a˜o do nu´mero de valores
que o subalgoritmo retorna ao algoritmo que o chamou.
Os subalgoritmos podem ser de dois tipos:
• as func¸o˜es, que retornam um, e somente um valor ao algoritmo cha-
mador;
• os procedimentos, que retornam va´rios valores, ou nenhum, ao algo-
ritmo chamador.
8.3 Func¸o˜es
O conceito de func¸o˜es e´ origina´rio da ide´ia de func¸a˜o matema´tica, onde
um valor e´ calculado a partir de outro(s) valor(es) fornecido(s) a` func¸a˜o.
Forma geral de uma func¸a˜o (sintaxe):
Func¸~ao <nome>(<para^metros>)
<declarac¸~ao_de_varia´veis>
Inı´cio
<bloco_de_instruc¸~oes>
Fim
8.3.1 Instruc¸a˜o “Retorne”
A instruc¸a˜o Retorne e´ um comando simples usado apenas nas func¸o˜es e
tem o efeito de parar a execuc¸a˜o da func¸a˜o e enviar um valor para o algoritmo
principal ou para outro subalgoritmo que o tenha chamado. Toda func¸a˜o
deve ter em seu corpo de instruc¸o˜es, pelo menos, uma instruc¸a˜o Retorne.
Sintaxe:
Retorne(<express~ao>)
Exemplos:
Retorne(1)
Retorne(.V.)
Retorne(area)
63
Retorne(pi*r*r)
Retorne(nome1)
Retorne(3.*x**2 + 4.*x - 1.5)
Exemplo de uma func¸a˜o:
Func¸~ao quad(w)
Real: w, z
Inı´cio
z <- w*w
Retorne(z)
Fim
8.3.2 Chamada de uma func¸a˜o
A chamada de uma func¸a˜o por parte do algoritmo principal ou por ou-
tro subalgoritmo e´ feita pelo simples aparecimento de seu nome, seguido
pelos respectivos paraˆmetros entre pareˆnteses, dentro de uma expressa˜o. Os
paraˆmetros utilizados no algoritmo principal, no ato da chamada da func¸a˜o
(chamados paraˆmetros reais) devem manter uma correspondeˆncia (nu´mero,
ordem e tipo) com os paraˆmetros definidos na func¸a˜o (chamados paraˆmetros
formais).
A func¸a˜o e´ executada, e ao seu te´rmino, o trecho do comando que a
chamou e´ substitu´ıdo pelo valor retornado pela mesma dentro da expressa˜o
em que se encontra, e a avaliac¸a˜o desta prossegue normalmente.
Exemplo de um algoritmo principal utilizando a func¸a˜o do exemplo an-
terior:
Algoritmo Quadrado
Real: x, y
Inı´cio
Escreva("Digite um nu´mero: ")
Leia(x)
y <- quad(x)
Escreva(" y = " , y)
Fim
8.3.3 Exemplos de algoritmos com func¸o˜es
1. Fac¸a uma func¸a˜o para calcular o fatorial de um nu´mero inteiro. Uti-
lize esta func¸a˜o num algoritmo principal para calcular o nu´mero de
combinac¸o˜es de m elementos tomados p a p, sendo m e p dados.
Func¸~ao fatorial(x)
Inteiro: x, f, i
64
Inı´cio
f <- 1
Para i de 2 ate´ x fac¸a
f <- f*i
Fim_para
Retorne(f)
Fim
Algoritmo Combinac¸~ao
Inteiro: m, p, comb
Inı´cio
Escreva("Digite dois nu´meros para obter as
combinac¸~oes: ")
Repita
Escreva("valores n~ao-negativos: ")
Leia(m, p)
Ate´(m >= 0 .E. p >= 0 .E. m >= p)
comb <- fatorial(m)/( fatorial(m-p)*fatorial(p))
Escreva("Nu´mero de combinac¸~oes = ", comb)
Fim
2. Fac¸a uma func¸a˜o para determinar se um nu´mero inteiro e´ par ou na˜o.
Utilize esta func¸a˜o para calcular dois somato´rios: um com os nu´meros
pares e outro com os nu´meros ı´mpares, dentre n nu´meros inteiros po-
sitivos dados.
Func¸~ao par(p)
Inteiro: p
Inı´cio
Se(p\2*2 = p)ent~ao
Retorne(.V.)
sen~ao
Retorne(.F.)
Fim_se
Fim
Algoritmo Soma_par_impar
Inteiro: n, x, i, sp, si
Inı´cio
Repita
Escreva("Quantos nu´meros? ")
Leia (n)
Ate´(n>0)sp <- 0
si <- 0
Escreva("Digite os nu´meros: ")
Para i de 1 ate´ n fac¸a
Repita
Escreva("positivos.")
65
Leia(x)
Ate´(x>0)
Se(par(x))ent~ao
sp <- sp + x
sen~ao
si <- si + x
Fim_se
Fim_para
Escreva("Soma dos pares = ", sp)
Escreva("Soma dos ı´mpares = ", si)
Fim
3. Fac¸a uma func¸a˜o para calcular o produto escalar entre dois vetores de
mesmas dimenso˜es e a utilize para calcular o cosseno do aˆngulo entre
dois vetores dados.
Func¸~ao prodesc(x, y, n)
Real: x[20], y[20], pe
Inteiro: n, i
Inı´cio
pe <- 0
Para i de 1 ate´ n fac¸a
pe <- pe + x[i]*y[i]
Fim_para
Retorne(pe)
Fim
Algoritmo Cosseno
Real: a[20], b[20], cos, pab, ma, mb
Inteiro: n, i
Inı´cio
Repita
Escreva("Digite a dimens~ao do vetor: ")
Leia(n)
Ate´(n>0 .E. n<=20)
Escreva("Digite os nu´meros do prim. Vetor:")
Para i de 1 ate´ n fac¸a
Leia(a[i])
Fim_para
Escreva("Digite os nu´meros do seg. vetor:")
Para i de 1 ate´ n fac¸a
Leia(b[i])
Fim_para
pab <- prodesc (a, b, n)
ma <- prodesc (a, a, n)**0.5
mb <- prodesc (b, b, n)**0.5
cos <- pab/(ma*mb)
Escreva("Cosseno do a^ngulo entre a e b = ", cos)
Fim
66
8.3.4 Exerc´ıcios propostos de func¸o˜es
1. Fac¸a uma func¸a˜o para calcular o mmc entre dois nu´meros inteiros.
2. Fac¸a uma func¸a˜o para informar se um nu´mero inteiro e´ primo ou na˜o.
Fac¸a um algoritmo principal para imprimir um determinado nu´mero
par dado, diferente de dois, como a soma de dois nu´meros primos (isto
e´ sempre poss´ıvel). Por exemplo: 28 = 23 + 5 ou 28 = 17 + 11.
3. Fac¸a uma func¸a˜o para calcular o valor absoluto de um nu´mero.
4. Fac¸a uma func¸a˜o para calcular o mo´dulo de um vetor com n nu´meros.
5. Fac¸a uma func¸a˜o para verificar se um vetor possui elementos repetidos.
6. Fac¸a uma func¸a˜o para verificar se um caractere pertence a uma cadeia
de caracteres.
7. Fac¸a uma func¸a˜o para converter uma letra minu´scula em uma letra
maiu´scula.
8.4 Procedimentos
Um procedimento e´ um subalgoritmo que retorna va´rios valores, ou ne-
nhum, ao programa principal, ou a outro subalgoritmo que o chame. Estes
valores sa˜o sempre retornados por meio dos paraˆmetros, e nunca explicita-
mente como no caso das func¸o˜es que usa a instruc¸a˜o Retorne.
Forma geral de um procedimento (sintaxe):
Procedimento <nome>(<para^metros>)
<declarac¸~ao_de_varia´veis>
Inı´cio
<bloco_de_instruc¸~oes>
Fim
Exemplo de um procedimento:
Procedimento Retangulo(lado1, lado2, perim, area)
Real: lado1, lado2, perim, area
Inı´cio
perim <- 2*(lado1 + lado2)
area <- lado1 * lado2
Fim
67
8.4.1 Chamada de um procedimento
A chamada de um procedimento so´ e´ feita em comandos isolados dentro
do algoritmo principal ou outro subalgoritmo, como os comandos simples,
tipo as instruc¸o˜es Leia, Escreva, Retorne, etc., e nunca no meio de expresso˜es
ou em atribuic¸o˜es como no caso de func¸o˜es.
Exemplo de um algoritmo principal com o procedimento anterior:
Algoritmo Area_perimetro
Real: x,y,p,a
Inı´cio
Escreva("Digite dois nu´meros: ")
Leia(x,y)
Retangulo(x,y,p,a)
Escreva("Perı´metro = ", p, "Area = ", a)
Fim
8.4.2 Mecanismos de passagem de paraˆmetros
Dados sa˜o passados pelo algoritmo principal (ou outro subalgoritmo) ao
subalgoritmo, ou retornados por este ao primeiro, por meio de paraˆmetros.
Paraˆmetros formais sa˜o os nomes simbo´licos (varia´veis) introduzidos no
cabec¸alho dos subalgoritmos, utilizados na definic¸a˜o dos paraˆmetros do
mesmo. Dentro do subalgoritmo trabalha-se com estes nomes da mesma
forma como se trabalha com varia´veis locais.
Paraˆmetros reais sa˜o aqueles que substituem os paraˆmetros formais quan-
do da chamada de um subalgoritmo. Os paraˆmetros formais sa˜o u´teis so-
mente na definic¸a˜o do subalgoritmo. Os paraˆmetros reais podem ser dife-
rentes a cada chamada de um subalgoritmo.
Nos procedimentos os paraˆmetros sa˜o divididos em paraˆmetros de en-
trada e paraˆmetros de sa´ıda, ja´ que os valores a serem retornados pelo pro-
cedimento (paraˆmetros de sa´ıda) sa˜o transferidos atrave´s dos paraˆmetros,
enquanto que os dados passados pelo algoritmo principal para o procedi-
mento (paraˆmetros de entrada) sa˜o tambe´m atrave´s de paraˆmetros.
Os paraˆmetros reais substituem os paraˆmetros formais no ato da cha-
mada de um subalgoritmo. Esta substituic¸a˜o e´ denominada passagem de
paraˆmetros e pode se dar por dois mecanismos: passagem por valor (ou por
co´pia) ou passagem por refereˆncia.
Na passagem de paraˆmetros por valor o paraˆmetro real e´ calculado e
uma co´pia de seu valor e´ fornecida ao paraˆmetro formal, no ato da chamada
do subalgoritmo. As modificac¸o˜es feitas no paraˆmetro formal na˜o afetam o
paraˆmetro real, durante a execuc¸a˜o do subalgoritmo, pois trabalha-se ape-
nas com uma co´pia do mesmo. Os paraˆmetros formais possuem locais de
memo´ria exclusivos para que possam armazenar os valores dos paraˆmetros
reais.
68
Na passagem de paraˆmetros por refereˆncia na˜o e´ feita uma reserva de
espac¸o de memo´ria para os paraˆmetros formais. Quando um subalgoritmo
com paraˆmetros passados por refereˆncia e´ chamado, o espac¸o de memo´ria
ocupado pelos paraˆmetros reais e´ compartilhado pelos paraˆmetros formais
correspondentes. Assim, as eventuais modificac¸o˜es feitas nos paraˆmetros
formais tambe´m afetam os paraˆmetros reais correspondentes.
Como norma, vamos adotar que, quando a passagem de paraˆmetros for
feita com varia´veis simples, cujos valores na˜o sa˜o modificados, a passagem
sera´ por valor, e quando for feita com varia´veis simples, cujos valores sa˜o
modificados, e com varia´veis indexadas, a passagem de paraˆmetros sera´ por
refereˆncia. Isto quer dizer que se for do nosso interesse manter intactos
vetores ou matrizes apo´s a chamada de subalgoritmos, que os utilizaram e
os modificaram como paraˆmetros formais no ato da chamada dos mesmos,
enta˜o devemos antes disso guardar co´pias dos seus valores.
8.4.3 Exemplos de algoritmos com procedimentos
1. Fac¸a um procedimento que soma duas matrizes nume´ricas. Fac¸a um
outro procedimento que obte´m a transposta de uma matriz. Fac¸a um
algoritmo principal para somar uma matriz quadrada dada com a sua
transposta utilizando os procedimentos.
Procedimento Soma_matriz(a, b, m, n, soma)
Real: a[10,10], b[10,10], soma[10,10]
Inteiro: m, n, i, j
Inı´cio
Para i de 1 ate´ m fac¸a
Para j de 1 ate´ n fac¸a
soma[i,j] <- a[i,j] + b[i,j]
Fim_para
Fim_para
Fim
Procedimento Transposta(x, p, q, y)
Real: x[10,10], y[10,10]
Inteiro: p, q, i, j
Inı´cio
Para i de 1 ate´ q fac¸a
Para j de 1 ate´ p fac¸a
y[i,j] <- x[j,i]
Fim_para
Fim_para
Fim
Algoritmo Matriz_quadrada
Real: mat[10,10], t[10,10], s[10,10]
Inteiro: n, i, j
69
Inı´cio
Repita
Escreva("Digite a ordem da matriz quadrada <= 10:")
Leia(n)
Ate´(n>0 .E. n<=10)
Escreva("Digite os nu´meros da matriz: ")
Para i de 1 ate´ n fac¸a
Para j de 1 ate´ n fac¸a
Leia(mat[i,j])
Fim_para
Fim_para
Transposta(mat,n,n,t)
Soma_matriz(mat,t,n,n,s)
Escreva("Matriz resultante: ")
Para i de 1 ate´ n fac¸a
Para j de 1 ate´ n fac¸a
Escreva(s[i,j])
Fim_para
Fim_para
Fim
2. Fac¸a um procedimento para calcular o somato´rio de n nu´meros. E
utilize este procedimento para calcular o desvio padra˜o de n nu´meros
dados. (Essa questa˜o tambe´m pode ser feita com func¸a˜o)
Procedimento Soma_vetor (v, n, som)
Real: v[30], som
Inteiro: n, i
Inı´cio
som <-0.0
Para i de 1 ate´ n fac¸a
som <- som + v[i]
Fim_para
Fim
Algoritmo Desvio_padr~ao
Real: x[30], desvio, y[30], s, m
Inteiro: n, i
Inı´cio
Repita
Escreva("Quantos nu´meros?")
Leia(n)
Ate´(n>0 .E. n<=30)
Escreva("Digite os nu´meros: ")
Para i de 1 ate´ n fac¸a
Leia(x[i])
Fim_para
Soma_vetor(x, n, s)
m <- s/n
70
Para i de 1 ate´ n fac¸a
y[i] <- (x[i] - m)**2
Fim_para
Soma_vetor(y, n, s)
desvio <-