Construção de Algoritmos - Apostila

Construo de
Algoritmos
Jander Moreira
DC-UFSCar
Construo de algoritmos i
Sumrio
Sumrio
Unidade 1 - Conceitos bsicos sobre algoritmos....................... 1-1
1.1 Primeiras palavras ............................................................. 1-1
1.2 Algoritmos no cotidiano ...................................................... 1-1
1.3 Conceitos bsicos de algoritmos e sua lgica ......................... 1-2
1.3.1
Delimitaes necessrias aos algoritmos formais ..................... 1-2
1.3.2
Ordem de execuo ............................................................ 1-2
1.3.3
Definio para algoritmos .................................................... 1-4
1.4
1.5
Apresentao visual dos algoritmos...................................... 1-4

Consideraes finais .......................................................... 1-6
Unidade 2 - Conceitos bsicos para o desenvolvimento de

algoritmos ............................................................. 2-1
2.2 Por que dados tm tipos ..................................................... 2-1
2.3 Representao das informaes e processamento dos
algoritmos ................................................................................ 2-2
2.3.1
Tipos abstratos de dados ..................................................... 2-2
2.3.2
Modelo de computador ........................................................ 2-3
2.3.3
Formalizao da notao de algoritmos.................................. 2-4
2.3.4
Entrada, sada e atribuio................................................... 2-5
2.3.5
Regras para a formao de identificadores ............................. 2-9
2.4
Consideraes finais ........................................................ 2-10
Unidade 3 - Expresses algortmicas........................................ 3-1

3.2 Matemtica e preciso da notao ....................................... 3-1
3.3 Expresses em algoritmos .................................................. 3-1
3.3.1
Linearidade das expresses, operadores e precedncia ............ 3-2
3.3.2
Expresses aritmticas ........................................................ 3-2
3.3.3
Expresses literais .............................................................. 3-6
3.3.4
Expresses relacionais......................................................... 3-7
3.3.5
Expresses lgicas .............................................................. 3-8
3.3.6
Ordem global de precedncias de operadores ....................... 3-10
3.3.7
Uso de parnteses nas expresses ...................................... 3-10
3.3.8
Organizao visual nas expresses...................................... 3-11
3.4
Unidade 4 - Estratgia de desenvolvimento de algoritmos ....... 4-1

4.2 Organizao para resolver problemas ................................... 4-1
4.3 Estratgia de abordagem para desenvolvimento de algoritmos. 4-2
4.3.1
Abordagem top-down .......................................................... 4-2
4.3.2
Abordagem do problema...................................................... 4-4
Construo de algoritmos ii
Sumrio
4.3.3
4.4
Resoluo de problemas por refinamentos sucessivos .............. 4-8
Unidade 5 - Comandos condicionais ......................................... 5-1

5.2 Situaes de deciso.......................................................... 5-1
5.3 Alterao condicional do fluxo de execuo ........................... 5-1
5.3.1
Condicionais simples e completos.......................................... 5-2
5.3.2
Aninhamento de comandos .................................................. 5-4
5.3.3
Comandos de seleo mltipla .............................................. 5-5
5.3.4
Testes de mesa .................................................................. 5-7
5.4
Unidade 6 - Comandos de repetio ......................................... 6-1

6.2 Por que fazer de novo?....................................................... 6-1
6.3 Fluxo de execuo com repetio......................................... 6-1
6.3.1
Condies de execuo de repetio: estado anterior, critrio
de trmino, estado posterior .............................................................. 6-8
6.3.2
6.4
Aplicaes prticas de repeties .......................................... 6-9
Unidade 7 - Ponteiros............................................................... 7-1

7.2 Uma questo de organizao............................................... 7-1
7.3 Ponteiros e endereos na memria....................................... 7-1
7.3.1
Memria e endereamento ................................................... 7-2
7.3.2
Acesso memria com ponteiros .......................................... 7-2
7.4
Unidade 8 - Estruturas compostas heterogneas: registros ..... 8-1

8.2 Preenchendo fichas ............................................................ 8-1
8.3 Conceito de estruturas compostas de dados .......................... 8-2
8.3.1
8.4
Declarao e uso de registros ............................................... 8-2
Unidade 9 - Sub-rotinas ........................................................... 9-1

9.2 Separando para organizar................................................... 9-1
9.3 Conceituao de sub-rotinas e fluxo de execuo ................... 9-1
9.3.1
Procedimentos ................................................................... 9-6
9.3.2
Parmetros formais............................................................. 9-7
9.3.3
Regras de escopo de declaraes .......................................... 9-9
9.3.4
Funes .......................................................................... 9-12
Construo de algoritmos iii

Sumrio
9.4
Unidade 10 - Estruturas compostas homogneas: arranjos...... 10-1

10.1 Primeiras palavras ........................................................... 10-1
10.2 Lembrar , muitas vezes, importante ................................. 10-1
10.3 Estruturao dos dados .................................................... 10-2
10.3.1
Declarao e uso de arranjos unidimensionais....................... 10-2
10.3.2
Aplicaes prticas de arranjos unidimensionais .................... 10-5
10.3.3
Declarao e uso de arranjos bidimensionais .......................10-13
10.3.4
Aplicaes prticas de arranjos bidimensionais.....................10-13
10.3.5
Arranjos multidimensionais ...............................................10-17
10.4 Consideraes finais ...................................................... 10-17

Unidade 11 - Estruturas compostas mistas: homogneas e
heterogneas ...................................................... 11-1
11.1 Primeiras palavras ........................................................... 11-1
11.2 Listas mais sofisticadas .................................................... 11-1
11.3 Declarao e uso de arranjos de registros ........................... 11-1
11.4 Consideraes finais ........................................................ 11-5
Lista de figuras
Figura 2-1. Unidades constituintes do modelo de computador. ...............2-4
Figura 3-1. (a-c) Exemplos de expresses matemticas. (d-f) Verses
algortmicas das mesmas expresses. .........................................3-2
Figura 3-2. Operadores aritmticos. ...................................................3-3
Figura 3-3. Operadores lgicos. .........................................................3-8
Figura 3-4. Ordem de avaliao de uma expresso composta. ............. 3-10
Figura 4-1. Problema de lanamento de objeto. ...................................4-5
Figura 5-1. Teste de mesa para o trecho especificado em Algoritmo 5-6. .5-8
Figura 6-1. Exemplos de trechos de algoritmo com o comando para e seus
respectivos testes de mesa. .......................................................6-3
Figura 6-2. Teste de mesa para o Algoritmo 6-2. (O texto traz mais
detalhes.) ...............................................................................6-6
Figura 8-1. Esquema da varivel ponto1, que um registro com trs
campos reais, x, y e z, declarada no Algoritmo 8-1. ......................8-3
Figura 8-2. Exemplos de declaraes de tipos, incluindo o uso de outros
registros como campos. ............................................................8-7
Figura 9-1. Exemplo de escopo de declaraes. ................................. 9-11
Figura 10-1. Ilustrao do arranjo valor do Algoritmo 10-1.................. 10-3
Figura 11-1. Ilustrao de um arranjo de registros como uma tabela. ... 11-4
Construo de algoritmos iv
Sumrio
Lista de algoritmos
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
1-1 .................................................................................1-3
1-2 .................................................................................1-3
1-3 .................................................................................1-5
2-1 .................................................................................2-5
2-2 .................................................................................2-5
2-3 .................................................................................2-7
2-4 .................................................................................2-8
2-5 ............................................................................... 2-10
3-1 .................................................................................3-5
3-2 .................................................................................3-7
3-3 .................................................................................3-9
4-1 .................................................................................4-2
4-2 .................................................................................4-3
4-3 .................................................................................4-3
4-4 .................................................................................4-6
4-5 .................................................................................4-6
4-6 .................................................................................4-8
4-7 .................................................................................4-9
4-8 .................................................................................4-9
4-9 .................................................................................4-9
5-1 .................................................................................5-2
5-2 .................................................................................5-3
5-3 .................................................................................5-4
5-4 .................................................................................5-6
5-5 .................................................................................5-7
5-6 .................................................................................5-8
6-1 .................................................................................6-2
6-2 .................................................................................6-4
6-3 .................................................................................6-7
6-4 .................................................................................6-7
6-5 .................................................................................6-9
6-6 ............................................................................... 6-10
6-7 ............................................................................... 6-11
6-8 ............................................................................... 6-12
6-9 ............................................................................... 6-13
6-10.............................................................................. 6-14
6-11.............................................................................. 6-15
7-1 .................................................................................7-2
7-2 .................................................................................7-3
7-3 .................................................................................7-4
Construo de algoritmos v
Sumrio
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
Algoritmo
8-1 .................................................................................8-2
8-2 .................................................................................8-4
8-3 .................................................................................8-5
9-1 .................................................................................9-2
9-2 .................................................................................9-4
9-3 .................................................................................9-7
9-4 ............................................................................... 9-12
10-1.............................................................................. 10-3
10-2.............................................................................. 10-5
10-3.............................................................................. 10-6
10-4.............................................................................. 10-8
10-5............................................................................ 10-11
10-6............................................................................ 10-12
10-7............................................................................ 10-13
11-1.............................................................................. 11-2
Lista de tabelas
Tabela 3-I. Lista das funes usuais para expresses aritmticas. ..........3-4
Tabela 3-II. Lista das funes usuais para expresses literais ................3-6
Tabela 3-III. Operadores relacionais...................................................3-7
Tabela 3-IV. Tabela verdade para o operador no. ...............................3-8
Tabela 3-V. Tabela verdade para o operador e.....................................3-9
Tabela 3-VI. Tabela verdade para o operador ou. .................................3-9
Tabela 3-VII. Exemplos de expresses com parnteses....................... 3-11
Tabela 9-I. Exemplos de declaraes de parmetros.............................9-9
Tabela 10-I. Ilustrao passo a passo dos valores de um arranjo para
atribuies sucessivas. ............................................................ 10-4
Construo de algoritmos 1-1

Conceitos bsicos sobre algoritmos
Unidade 1 -
1.1 Primeiras palavras

Os alunos que chegam a um curso universitrio possuem, em geral,
formao relativamente heterognea. Em particular, no que tange a
algoritmos e programao, muitos nunca tiveram contato com programas
ou mesmo com computadores diretamente; alguns conhecem o computador
como usurios eventuais, conhecem a Internet, j usaram os mensageiros
instantneos e salas de bate-papo; outros, ainda, por curiosidade prpria
ou por terem feito um curso tcnico, j programaram e adquiriram uma
noo e conhecimento do que programar e de como desenvolver
programas.
Esta disciplina voltada a todos os alunos e, portanto, cada aluno
utilizar o material apresentado de forma diferente.
Para comear, importante delimitar os objetivos da disciplina. Um
primeiro ponto a destacar aponta para aquilo que a disciplina no : esta
no uma disciplina que ensina a programar. Seu objetivo um pouco
mais independente dos programas de computador, embora esteja
claramente relacionado a eles. A disciplina Construo de algoritmos visa
orientar o aluno a resolver um determinado problema usando ferramental
apropriado e propondo uma soluo que, no final, poder ser codificada em
uma linguagem de programao e se tornar um programa de verdade.
Assim, pretende-se delinear uma metodologia de como abordar um
problema, como entend-lo e como propor uma soluo algortmica de
qualidade que resolva o problema proposto.
1.2 Algoritmos no cotidiano

Para iniciar, preciso que se entenda o que um algoritmo.
Genericamente, pode-se ver um algoritmo como uma coleo de passos que
orientam as aes para se chegar a um resultado. Por exemplo, ao chegar
de uma viagem praia, o motorista fica curioso (ou ansioso) para saber o
consumo mdio do automvel. Como foi cuidadoso, lembrou-se de anotar
todas as vezes que abasteceu, alm de, ao partir, zerar o hodmetro parcial
ao encher o tanque. De tanque cheio novamente, pede ao filho caula que
faa as contas para ele. Com os papis na mo, o filho os olha e depois
encara o pai, com bvia cara de dvida. A orientao do pai a seguinte:
some os valores dos litros de combustvel e veja o total; depois, veja o
quanto andamos olhando o nmero indicado no hodmetro; divida a
distncia total pela quantidade total de litros; faa a conta, que o
consumo mdio, e me diga quanto deu. Esta orientao um algoritmo,
pois define claramente quais os passos que o filho deve seguir para gerar o
resultado esperado (ou seja, a soluo para o problema).
Da mesma forma, outros tipos algoritmos se apresentam no dia-adia, como, por exemplo, na parte do manual de um telefone celular que
ensina a cadastrar um novo contato na agenda, na receita que orienta em
como fazer um brigadeiro ou mesmo nas instrues que algum solicita na
rua quando est perdido.
jander moreira

1.3 Conceitos bsicos de algoritmos e sua lgica

1.3.1 Delimitaes necessrias aos algoritmos formais
A noo de um algoritmo conhecida por todos, mesmo que
desconheam que tais instrues possam ser chamadas de algoritmo.
Entretanto, alguns pontos devem ser destacados, pois so importantes para
que programas com objetivos computacionais sejam escritos.
O primeiro ponto a definio do problema. De volta ao exemplo da
viagem praia, o problema em questo poderia ser colocado da seguinte
forma: dados os valores, em litros, de combustvel usado nos diversos
abastecimentos feitos em uma viagem, juntamente com o total de
quilmetros percorrido, calcule e reporte o consumo mdio. ( claro que,
nestas palavras, fica um pouco menos potico, mas o problema o
mesmo.) Deve ser observado que o problema bastante especfico: j se
tem o total de quilmetros percorridos e os valores individuais de todos os
abastecimentos, dados em litros. O problema seria diferente caso se tivesse
a quilometragem percorrida por partes, entre cada um dos abastecimentos.
Tambm seria diferente se o custo dos abastecimentos fosse envolvido.
Entender qual o problema permite propor uma soluo adequada. Assim,
se fosse preciso somar as distncias dos diversos trechos para se obter a
distncia total, a orientao dada pelo pai no seria adequada, pois, seguida
risca, o filho dividiria somente o ltimo trecho (indicado no hodmetro)
pelo total de litros. Ou seja, a soluo deveria ser outra, pois o problema
diferente.
A soluo proposta pelo pai clara o suficiente para que o filho, que
j est em idade escolar, faa as contas e produza o resultado. Se o filho
fosse mais novo, talvez tivesse grandes dificuldades para seguir as
orientaes. Poderia ter dvidas, como, por exemplo, pai, o que dividir?.
Um algoritmo deve ter claro quem (ou o qu) o executar, sendo que as
instrues devem ter clareza suficiente e necessria para se chegar ao final
sem duvidar que o procedimento foi feito corretamente. Para um filho mais
velho, a orientao do pai talvez fosse, simplesmente, calcule o consumo;
as anotaes esto no porta-luvas.
O uso do imperativo um indicativo que cada instruo uma
ordem. Assim, verbos como calcule, some, multiplique devem ser usados.
Outro ponto, tambm muito importante, a clareza de cada instruo
em si. Para isso, pensem na av, que gosta de cozinhar doces e quer
ensinar o neto a fazer um brigadeiro. Em algum momento, a panela j no
fogo, a orientao deixe ferver at dar ponto. Como muitos, o neto deve
ter pensado dar ponto?!? Como eu posso saber que deu ponto?. Portanto,
em um algoritmo mais formal, a instruo de cada passo deve ser precisa e,
seguida risca, deve produzir o mesmo resultado. Boa sorte com o
brigadeiro.
1.3.2 Ordem de execuo

Uma caracterstica bsica de um algoritmo, embora um tanto bvia,
deve ser destacada. A ordem em que os passos so seguidos importante.
Para ilustrar isso, o Algoritmo 1-1 apresenta o clculo do consumo mdio.
jander moreira

Um formato um pouco mais formal j usado, mas no se deve preocupar
com isso no momento. Alm disso, a numerao das linhas feita apenas
para que cada comando possa ser referenciado no texto e, assim, no faz
parte dos algoritmos.
Algoritmo 1-1
1
{ clculo do consumo mdio de um veculo, dados a distncia total e
os valores de litros consumidos em cada abastecimento realizado }
3
4
algoritmo
calcule o total de litros perguntando por cada valor e somando-os
pergunte pela distncia total percorrida
calcule a diviso da distncia total pelo total de litros
8
9
apresente o resultado do clculo

fim-algoritmo
No difcil ver que, caso a ordem de algumas instrues fossem

alteradas, o resultado no se modificaria. Este o caso de inverter as linhas
5 e 6 do algoritmo. Porm, a alterao de outras linhas produziria um
resultado incorreto, como seria o caso de trocar as linhas 6 e 7, ou seja,
tentar calcular a diviso antes de se ter o valor da quilometragem.
Para os algoritmos formais utilizados nesta disciplina, a regra de
execuo de cada instruo vem descrita pelos itens:
1) As instrues so executadas seqencialmente e na ordem em que
esto apresentadas;
2) A prxima instruo somente executada quando a anterior tiver
terminado.
Considere o Algoritmo 1-2. Leia-o com ateno e veja se o resultado
desejado (o consumo mdio) pode ser corretamente obtido a partir dele.
Algoritmo 1-2
1
{ clculo do consumo mdio de um veculo, dados a distncia total e
os valores de litros consumidos em cada abastecimento realizado }
3
4
algoritmo
pergunte pela distncia total percorrida
calcule a diviso da distncia total pelo total de litros
calcule o total de litros perguntando por cada valor e somando
8
9
apresente o resultado do clculo

fim-algoritmo
Deve-se notar que, se as instrues forem seguidas por uma pessoa,

o resultado desejado pode at ser calculado corretamente. No seria difcil
para algum ler a instruo da linha 7 antes de terminar a da linha 6,
deduzindo que o total de litros obtido pela soma das quantias individuais.
Seria como se as linhas 6 e 7 fossem executadas simultaneamente. Neste
caso, a linha 7 funciona quase que como uma observao para a linha 6.
jander moreira

Segundo as regras de execuo apresentadas, o algoritmo seguinte
no executado corretamente. A preciso da linguagem adotada
importante, pois no h margens para dedues ou interpretaes pessoais.
Deve-se sempre ser lembrado que um algoritmo um conjunto preciso de
instrues, e no um conjunto de boas intenes.
Em particular, o termo lgica de programao usado para indicar
que a seqncia de aes que so definidas para resolver um dado
problema segue um conceito geral de causa e efeito. Resultados produzidos
em um passo podem ser aproveitados nos passos subseqentes, todos
cooperando para produzir o resultado final esperado.
1.3.3 Definio para algoritmos

Como visto, os algoritmos existem em formas e caractersticas
variadas, desde em manuais mais ou menos rgidos at em informais
receitas culinrias. Para esta disciplina, entretanto, o termo algoritmo ter
um uso bastante restrito, sendo preciso, portanto, estabelecer seus limites.
Definio: Um algoritmo um conjunto finito de instrues que, se
executadas, permitem a manipulao de um conjunto finito de dados de
entrada para produzir um conjunto finito de dados de sada, dentro de um
tempo finito.
Desta definio, destaca-se inicialmente o termo finito. Os
algoritmos devem ter um tamanho limitado, ou seja, ser composto por um
nmero finito de instrues. Tambm a quantidade de dados que est
disponvel assim como a quantidade de dados produzida como resposta
devem ser limitadas. Note que se pode desconhecer, em princpio, qual o
volume de dados, mas esta quantidade no infinita. Da mesma forma,
mesmo demorando, um algoritmo produzir um resultado.
Outra questo a associao desta definio com os problemas que
devem ser resolvidos. Os chamados dados de entrada so os dados que
esto disponveis para serem usados. A funo do algoritmo , a partir
destes dados e de manipulaes adequadas, produzir um resultado (dados
de sada) que corresponda resposta do problema proposto.
1.4 Apresentao visual dos algoritmos

Adicionalmente ao que j foi apresentado, ainda h uma questo de
organizao. Como se deseja que os algoritmos sejam claros e precisos, sua
organizao visual essencial. Portanto, ser exigido que algumas regras
bsicas sejam seguidas, embora algumas delas possam ser contornadas,
pois podem remeter a estilos pessoais de organizao.
O bsico destas regras inclui:
1) Todo algoritmo escrito deve conter uma documentao, que um
comentrio (escrito sempre entre chaves) em seu incio, indicando
sua finalidade e fazendo uma breve descrio do problema que o
algoritmo deve resolver; se este algoritmo for ser enviado a outra
pessoa, deve tambm conter autor(es) e data;
jander moreira

2) Linhas em branco devem sempre ser inseridas para separar grupos
de instrues relacionadas, como ser utilizado nos exemplos deste
texto e apresentados no AVA;
3) Cada instruo deve ocupar uma linha diferente; caso no haja
espao na linha para especific-la, pode ser continuada na linha de
baixo, mas com tabulao maior, para indicar que uma
continuao;
4) O uso da tabulao para deixar claros os limites dos comandos deve
ser sempre empregado; este um dos itens no opcionais;
5) Comentrios (entre chaves) devero ser inseridos quando necessrio,
para deixar claros os objetivos dos trechos do algoritmo; usado em
algoritmos mais longos, so essenciais para a clareza e devem
sempre obedecer organizao visual dos demais comandos;
6) Opcionalmente alguns comentrios podem ser inseridos direita, na
mesma linha das instrues, mas apenas quando forem curtos e se
esclarecerem uma questo especfica daquela instruo em
particular.
O Algoritmo 1-3 um algoritmo fictcio, ou seja, que no prope
nenhuma soluo, mas apenas ilustra alguns comandos (em modo
informal), a documentao, comentrios e outros elementos importantes da
organizao visual.
Algoritmo 1-3
1
{ esta descrio de um algoritmo; ela relata seu propsito, o qual,
no caso, apenas ilustrar esta prpria documentao e tambm as
regras de organizao visual para os algoritmos
4
5
Jander Moreira
Novembro de 2007 }
7
8
algoritmo
{ este comentrio para a parte inicial }
10
apresente mensagem instruindo quais dados devem ser fornecidos
11
pergunte pelos dados principais
12
13
{ este comentrio para o primeiro processamento }
14
calcule algumas coisas com os dados principais, gerando dados
15
16
17
secundrios
{ note aqui a continuao em outra linha }

{ note, tambm, comentrios direita }
apresente alguns resultados preliminares calculados
18
19
{ comentrio para outra parte do processamento }
20
calcule mais algumas coisas
21
se for necessrio, pergunte por dados complementares
22
23
24
25
{ este comentrio para a parte que apresenta os resultados,

mas como longo, pode ser dividido em duas linhas }
apresente os resultados principais
jander moreira

26
se resultados adicionais foram tambm calculados, tambm devem
27
ser apresentados
28
29
{ comentrio sobre o trmino }
30
apresente uma mensagem indicando o fim do processamento
31 fim-algoritmo
No algoritmo, as linhas 1 a 6 mostram a documentao bsica, que

descreve o propsito do algoritmo. As linhas 8 e 31 delimitam os comandos
do algoritmo s linhas internas (de 9 a 30). Os diversos blocos de
comandos, ou seja, conjuntos de comandos que delineiam aes especficas
so separados por linhas em branco (linhas 12, 18, 22 e 28), sendo que
cada um deles contm um comentrio identificando sua funo (linhas 9,
13, 19, 23 e 29). Deve ser notado tambm que todos os comandos em si
so precedidos por uma tabulao, deixando-os mais direita do par
algoritmo/fim-algoritmo e mostrando que esto inclusos nestes
delimitadores. Alguns comandos no cabem em uma nica linha e so
continuados na linha de baixo (linhas 15 e 16 e tambm 26 e 27), assim
como o comentrio que faz a descrio geral no incio do algoritmo e o
comentrio que se inicia na linha 23 e termina na linha 24. Deve-se notar
que sempre que h continuao na outra linha, a organizao visual no
prejudicada, mantendo-se as tabulaes necessrias. Outros comentrios,
ainda, sendo especficos a um comando, esto direita, como o caso dos
situados nas linhas 15 e 16.
Cada um possui um estilo para a organizao visual, o que admite
que pequenas variaes nas regras possam ser feitas. O mais importante
que, havendo uma visualizao rpida do algoritmo, seja sempre possvel
observar claramente os comandos, suas continuaes em outras linhas e os
blocos, sem que seja necessrio grande esforo para isso. Se mais do que
poucos segundos forem necessrios para saber se o comando usa mais que
uma linha ou onde est o delimitador final de um comando, ento a
organizao visual no est boa. O mesmo ocorre se no h clareza nas
tabulaes. Nestes casos, preciso mudar a organizao visual.
1.5 Consideraes finais

Algoritmos, como observado, propem solues para problemas. Para
fins computacionais, os algoritmos devem obedecer a um modo formal de
apresentao e possuir uma organizao visual relativamente rigorosa. O
uso de comentrios e da correta disposio visual dos comandos um
hbito e o estudante no deve se iludir com a idia de que isso uma
etapa posterior; todos os aspectos visuais devem ser feitos durante o
desenvolvimento e no aps. Nunca demais lembrar que o que
provisrio quase sempre fica permanente.
Alm disso, para que uma soluo proposta no dependa de
interpretaes subjetivas de quais aes os comandos descrevem, os
algoritmos devem ser rigorosos tambm neste aspecto. Devem, ento,
cumprir regras de execuo que indicam a ordem de execuo de cada um
dos comandos (seqencial, comeando pelo primeiro), alm de estabelecer
jander moreira

que um comando s executado aps o anterior ter sido totalmente
concludo, sem voltas ou jeitinhos.
A compreenso destes aspectos de importncia crucial para que os
desenvolvimentos futuros sejam feitos adequadamente. Portanto, mesmo
que alguns deles paream ser simples, ou mesmo bvios, todos merecem
uma reviso, certificando-se de que foram corretamente compreendidos.
jander moreira

Conceitos bsicos para o desenvolvimento de algoritmos
Unidade 2 - Conceitos bsicos para o

desenvolvimento de algoritmos
Para resolver problemas utilizando computadores, necessrio que
uma soluo seja projetada de forma adequada, ou seja, de forma que um
computador tenha condies de realiz-la.
Assim, um primeiro passo para se aprender a propor uma soluo
algortmica lembrar que um algoritmo simplesmente um manipulador de
dados. Em outras palavras, os algoritmos representam informaes
importantes para um dado problema (como nomes de pessoas, valores de
salrios e taxas, medidas estatsticas ou at figuras) na forma de dados.
Estes dados so lidos, modificados e reestruturados para produzir os
resultados desejados. Neste contexto, esta unidade trabalha o conceito de
representao de dados, comeando sobre quais os tipos de dados que
qualquer computador j usualmente capaz de armazenar e relacionando
esta representao ao modo como o computador interpreta os algoritmos
(ou seja, os passos para gerar as solues de um problema).
A execuo das instrues de um algoritmo requer que se tenha
conhecimento do computador que o executar, ou seja um modelo deste
computador. Deste modo, pode-se ento propor uma formalizao da
notao para os algoritmos aqui tratados, permitindo introduzir os primeiros
comandos formais.
2.2 Por que dados tm tipos

O entendimento do conceito de tipos abstratos de dados pode ser
relacionado a conceitos usados cotidianamente. Por exemplo, pense em sua
idade. Pense, agora, na idade de seus pais, ou de seus irmos, ou de seu
namorado ou sua namorada. Para comear, bem provvel que as idades
que pensou sejam medidas em anos (e no em meses ou dias). Outro
ponto que, raramente, voc pensou na sua idade como 19,7 anos, por
exemplo, pois natural que idades sejam valores inteiros. Valores de
idades, geralmente, esto associados a nmeros como 8, 10, 18, 25, 55, 58
ou 70 e menos freqentemente a nmeros como 2,93 ou -14, por exemplo.
Idades usualmente so valores inteiros e, quase sempre, positivos.
Similarmente, pense em uma conta ou saldo bancrio. No faz sentido que
seja um valor inteiro, mas que tenha tambm uma parte decimal, que na
nossa moeda dada em centavos. Pense tambm no consumo mdio de
combustvel de um veculo: ser algo como 9,6 quilmetros por litro. Alguns
valores so, intrinsecamente, reais (isto , tm tambm parte decimal).
Existem, alm destes, outros tipos de dados, que so associados
tambm a textos (como nomes, endereos ou placas de carros) ou at a
condies, como se um saldo est negativo ou no, se um funcionrio
possui ou no filhos ou se dois conjuntos so iguais.
jander moreira

2.3 Representao das informaes e processamento dos

algoritmos
Compreender como um algoritmo manipula as informaes recai em
se ter um conhecimento prvio de quais os tipos de informaes (dados)
podem ser utilizados e como um computador (ou um modelo dele)
interpreta estas informaes e as instrues que o algoritmo indica fazer.
2.3.1 Tipos abstratos de dados

As informaes que precisam ser armazenadas e manipuladas por
algoritmos recaem em um conjunto bastante restrito de tipos abstratos
de dados. Estes tipos incluem os inteiros, os reais, os literais e os
lgicos, alm de um outro tipo complementar denominado ponteiros.
O tipo de dados denominado inteiro compreende, como o nome
implica, os valores numricos que no possuem parte decimal. Valores
como 3, 15, 334565, -443, 0 e 2000 so representantes dos inteiros. Alm
do conjunto de valores, o tipo abstrato inteiro inclui o elenco das operaes
vlidas para valores inteiros. Dentre estas operaes podem ser destacadas
as j conhecidas soma e multiplicao, a ttulo de exemplo. O conjunto de
operaes sobre os diversos tipos de dados coberto na Unidade 3, que
trata das expresses algortmicas.
Outro tipo de dados o tipo real. O conjunto de valores relativo aos
reais inclui, por exemplo, 2,7, -3,8, 6,223, 400,0 e 0,0, entre outros. Para
diferenciar valores inteiros dos reais, os decimais iguais a zero so
indicados explicitamente. Como ser visto mais adiante, nem sempre esta
diferenciao necessria. As operaes sobre o tipo real so similares
quelas sobre o tipo inteiro e tambm sero vistas na prxima Unidade.
Alm dos tipos numricos, h ainda trs outras classes de tipos de
dados.
Para o armazenamento e manipulao de valores textuais, como
nomes, cdigos alfanumricos e textos com e sem pontuao, existe o tipo
abstrato denominado literal. Um literal corresponde, portanto, a uma
cadeia de caracteres, seja l quais forem. Alm disso, para que no haja
qualquer confuso, todas as constantes literais, sem exceo, so indicadas
entre aspas. Por exemplo: Aristteles, Jos de Arimatia, Avenida
Carlos Gomes, 1233, Qual sua senha?, smbolos: @#$%&* e
*** ATENO ***.
Um tipo de dado mais singular o tipo lgico. O conjunto de valores
lgicos inclui apenas dois elementos: o verdadeiro e o falso. Dados lgicos
esto normalmente associados a condies, como a presena ou ausncia
de um atributo ou se um dado item foi ou no localizado em uma lista.
Assim como os demais, h tambm operaes que se aplicam ao tipo
lgico.
Finalmente, h um tipo em destaque, denominado ponteiro. Devido
ao seu uso muito particular, este tipo tratado em separado, na Unidade 7.
Os valores escritos explicitamente so chamados valores constantes
e a cada constante est associado um tipo especfico, dentre os citados
anteriormente. Para deixar mais claro, 10, 18, -3 e 9 so constantes
jander moreira

inteiras, 1,0, -0,001, 14,2 e -99,001 so constantes reais, sadio,
solteiro, custo do empreendimento e 18 so constantes literais e,
finalmente, verdadeiro e falso so os nicas constantes lgicas.
Uma observao importante deve ser feita, ainda. A diferena entre
as constantes 18 e 18 deve ser bastante clara. Enquanto 18 refere-se a
um nmero inteiro, quantificando o equivalente a dezoito unidades, 18
um texto formado por dois caracteres (o 1 e o 8) e no se refere a
grandeza numrica nenhuma. Esta distino importante, pois no pode
haver ambigidade nas representaes. Outro exemplo, 43,8 e 43,8
formam outro par com propriedades similares ao exemplo anterior; agora,
43,8 um nmero real, correspondendo a uma quantia, e 43,8 um
texto formado por quatro caracteres (4, 3, , e 8) e tem tanto valor
numrico quanto teria ABC, Juvenal Urbino ou a1b2c3d4; ou seja,
nenhum.
2.3.2 Modelo de computador

Como apresentado na Unidade 1, um algoritmo deve ter claro quem
ou o qu o executar, o que interfere no grau de detalhamento das
instrues.
Para os algoritmos desta disciplina, a execuo ser feita por um
computador fictcio, similar em funcionalidade a um computador real, mas
sem que se necessite explorar em demasia seus detalhes.
Este computador fictcio define, assim, um modelo de computador,
que de agora at o fim do texto, ser tratado apenas por computador.
Quando for necessria a distino do modelo de computador de um
computador real, o texto deixar isto bastante claro.
Deste modo, o computador que executa os algoritmos deve ter as
seguintes caractersticas:
1) Poder guardar o algoritmo e ser capaz de execut-lo, instruo a
instruo;
2) Poder armazenar os dados necessrios para resolver o problema por
meio do algoritmo;
3) Permitir que dados sejam transferidos para dentro do computador;
4) Permitir que dados sejam transferidos para fora do computador.
O esquema do computador apresentado na Figura 2-1, destacando
seus quatro mdulos principais: unidade de processamento, memria e
unidades de entrada e de sada.
jander moreira

Entrada
Unidade de
processamento
Sada
Memria
Figura 2-1. Unidades constituintes do modelo de computador.
A unidade de processamento o crebro do computador e

responsvel por controlar tudo o que acontece. o dispositivo capaz de
interpretar as instrues dos algoritmos e executar as aes especificadas.
O algoritmo armazenado na memria, que, alm do algoritmo, armazena
tambm os dados que este utiliza. A unidade de processamento, quando
necessrio, armazena e recupera dados e instrues guardados na
memria.
A interface com o mundo real feita pelas unidades de entrada e
sada. A unidade de entrada capaz de pegar dados externos ao
computador e, por intermdio da unidade de processamento, armazen-los
na memria. Como dispositivos associados unidade de entrada esto, por
exemplo, o teclado, um leitor ptico, o modem (que recebe dados via linha
telefnica), o mouse, o disco rgido (do qual so lidos dados) e um escner,
entre outros. Dispositivos ligados unidade de sada so, por exemplo, a
tela (monitor de vdeo), a impressora, um modem (quando este envia
dados), o disco rgido (quando neles so armazenados dados) etc. Assim, o
mundo externo tudo que no pertence ao computador e o mundo interno
o que est armazenado na memria e o que manipulado pela unidade
de processamento.
2.3.3 Formalizao da notao de algoritmos

O modelo de computador, assim como o computador real, tem suas
limitaes de entendimento de dados e de interpretao de instrues. Os
algoritmos, desta forma, devem ser compostos de um conjunto finito de
instrues, que recebem o nome de comandos. Cada comando tem um
comportamento especfico e claramente definido, de modo a no introduzir
ambigidade na interpretao da ao associada ao comando.
Desta maneira, os algoritmos so tratados segundo um modelo
bastante formal, seguindo uma notao relativamente rgida.
Para comear, todos os algoritmos atendem ao formato geral
apresentado pelo Algoritmo 2-1. As partes em texto destacadas (em negrito
com itlico) so partes que variam dependendo da soluo que o algoritmo
apresenta; os delimitadores algoritmo e fim-algoritmo indicam a
localizao das instrues pelas quais a unidade de processamento inicia a
execuo dos comandos. importante apontar que no permitido
misturar as instrues de declaraes locais com os comandos, ou seja, so
feitas primeiramente todas as declaraes e, depois, especificados os
comandos.
jander moreira

Algoritmo 2-1
1
documentao_do_algoritmo
2
3
declaraes_globais
4
5
6
algoritmo
declaraes_locais
7
8
9
lista_de_comandos
fim-algoritmo
Os algoritmos esto disponveis para a unidade de processamento,

ficando armazenados na memria. A explicao de como os algoritmos so
transferidos para a memria e o modo como ficam armazenados nela est
fora do escopo desta disciplina e no sero tratados neste texto.
2.3.4 Entrada, sada e atribuio

At este momento, sabe-se que toda a execuo de um algoritmo
de responsabilidade da unidade de processamento e que o algoritmo fica
armazenado na memria. O algoritmo, por sua vez, indica como os dados,
que tambm devem ficar armazenados na memria, so transformados
para produzir a resposta a um problema. Sabe-se, tambm, que o conjunto
de comandos que pode ser usado nos algoritmos limitado.
Para iniciar, porm, preciso definir como os dados so armazenados
na memria e quais os comandos necessrios para efetivar estes
armazenamentos.
O conceito de variveis o ponto chave para entender a
manipulao de dados. Uma varivel corresponde a um dado armazenado
na memria. Como muitas coisas so armazenadas na memria, a
interpretao correta deste dado depende de identificar seu tipo. Portanto,
uma varivel sempre tem um tipo associado a ela. Para identificar os
diversos dados existentes, preciso dar um nome a eles. O nome de uma
varivel chamado identificador.
O Algoritmo 2-2 ilustra a declarao de duas variveis.
Algoritmo 2-2
1
{ leitura de nome e idade com escrita de mensagem usando estes dados }
2
3
4
algoritmo
declare
nome: literal
idade: inteiro
7
8
{ leitura de nome e idade do teclado }
leia(nome)
10
leia(idade)
11
jander moreira

12
{ sada da mensagem na tela }
13
escreva(nome, tem , idade, anos.)
14 fim-algoritmo
Na linha 4 existe a indicao da declarao de variveis. Uma

declarao equivale a informar que uma dada parte da memria deve ser
reservada para guardar um determinado dado. Associado a estes dados
est seu tipo, que pode ser inteiro, real, literal, lgico ou ponteiro.
Nas linhas 5 e 6 esto as declaraes propriamente ditas. O
identificador nome, do tipo literal (isto , capaz de armazenar textos),
associado a um dado na memria. Da mesma forma, outro dado da
memria, que ser tratado como um inteiro, recebe o identificador idade.
As linhas 4, 5 e 6 podem ser lidas como declare as variveis nome, como
um dado literal, e a varivel idade, como um dado inteiro. Deve ser
observado que, uma vez definidas as reas de memrias para variveis e
seus nomes, nenhum destes elementos se altera at o final do algoritmo.
Uma declarao, em sua forma geral, dada conforme a
especificao seguinte.
declare lista_de_identificadores: nome_do_tipo
Na declarao, a lista de identificadores uma lista separada por

vrgulas. Caso haja separao entre as declaraes (por tipos diferentes,
por exemplo), pode-se omitir o declare nas declaraes subseqentes,
como foi feito no algoritmo ilustrado.
Na linha 9 encontra-se o primeiro comando que apresentado. O
comando leia instrui o processador a realizar a seguinte ao: copiar do
mundo externo um dado e o armazenar na(s) varivel(eis) relacionada(s).
No exemplo, o mundo externo pode ser visto como algum digitando dados
no teclado do computador. O comando indica que um nome (literal) que for
digitado deve ser armazenado na memria, sob o identificador nome. A
linha 10 indica que um valor numrico (inteiro) digitado deve ser
armazenado na memria na parte referenciada por idade. A unidade de
processamento aguarda que cada comando leia seja finalizado para
prosseguir.
Suponha que o usurio (pessoa que usa o computador) tenha
digitado Sigmund e pressionado ENTER. A esta ao, o valor literal
Sigmund copiado para a memria referenciada por nome. Em seguida,
digitado 21 e digitado ENTER novamente, o que faz a unidade de
processamento interpretar o que foi escrito e transferir o valor inteiro 21
para parte da memria chamada idade.
Seguindo seu tratamento usual, o prximo comando feito pela
unidade de processamento o escreva da linha 13. Um comando escreva
instrui cpia dos dados indicados para o dispositivo de sada. Neste caso,
pode-se assumir que a sada a tela do computador, na qual o usurio
pode visualizar o resultado. No exemplo, o comando escreva indica que
quatro itens sejam copiados para a tela: o contedo da varivel nome, um
valor literal constante ( tem ), o contedo da varivel idade e, por fim,
jander moreira

uma outra constante literal ( anos.). O resultado , neste caso, Sigmund
tem 21 anos..
O comando leia tem o formato indicado abaixo.
leia(lista_de_variveis)
A lista de variveis corresponde a uma coleo de um ou mais

identificadores, separados por vrgulas e indicados entre os parnteses.
O comando escreva tem o formato indicado na seqncia.
escreva(lista_de_expresses)
Similarmente ao comando leia, cada item especificado dentro dos

parnteses e cada um separado dos demais por vrgulas. Porm, enquanto
no comando leia os itens so os identificadores, no escreva aceita-se uma
lista de expresses, que podem ser valores de variveis, constantes de
quaisquer tipos e mesmo expresses propriamente ditas. Como um
exemplo simples, se o comando fosse escreva(idade + 1), o valor 22
seria escrito. Mais detalhes sobre expresses sero tratados na Unidade 3.
Retomando um problema de consumo mdio como o visto na Unidade
1, porm um pouco mais simples, proposto o seguinte: Escreva um
algoritmo que calcule o consumo mdio de um veculo, dadas as
quantidades em litros de exatamente 2 abastecimentos realizados (um no
meio da viagem e outro no final) e tambm a quilometragem total
percorrida, apresentando o resultado. Considere que o veculo saiu de
tanque cheio e em ambos os abastecimentos o tanque foi novamente
completado.
O Algoritmo 2-3 prope uma possvel soluo para este novo
problema (que diferente do visto na Unidade 1).
Algoritmo 2-3
1
{ clculo do consumo mdio de um veculo, dados a quilometragem total
percorrida e o nmero de litros utilizados nos dois nicos
abastecimentos realizados }
4
5
6
7
algoritmo
declare
quilometragem, abastecimento1, abastecimento2: real
8
9
{ obteno da quilometragem e litros consumidos }
10
leia(quilometragem)
11
leia(abastecimento1, abastecimento2)
12
13
{ escrita do resultado do consumo }
14
escreva(quilometragem/(abastecimento1 + abastecimento2), km/l)
15 fim-algoritmo
jander moreira

O
algoritmo
declara
trs
variveis
(quilometragem,
abastecimento1 e abastecimento2) para guardar os dados necessrios
ao clculo, como apresentado nas linhas 6 e 7. As linhas 10 e 11
especificam dois comandos de leitura, para que o usurio digite os valores,
todos reais, para as trs variveis. Quando o usurio as digitar, seus
valores sero transferidos para a memria, segundo os identificadores
especificados. No final, na linha 14, est o comando de escrita, que indica
que seja transferido para a tela o valor equivalente ao contedo da varivel
quilometragem dividido pela soma do consumo de litros, indicados nas
variveis abastecimento1 e abastecimento2, seguido por um texto
(constante literal) com valor km/l.
Por exemplo, assumindo-se que tenha sido digitado 218 para o valor
total da quilometragem, indicando 218 km, e 11,7 e 8,3 respectivamente
para os dois os abastecimentos (representando 11,7 e 8,3 litros), o
resultado produzido seria 10,9 km/l.
At agora, a nica forma de colocar um dado na memria, na rea
reservada para uma varivel, usando o comando leia. Em vrias
situaes, preciso colocar os valores em variveis, mas estes valores no
esto no mundo exterior (ou seja, no sero digitados, por exemplo), mas
foram calculados pelo prprio algoritmo. O comando de atribuio usado
para esta finalidade.
Para continuar o exemplo, suponha que a alternativa para o clculo
do consumo fosse, ao invs de usar o comando escreva com a
especificao da expresso do clculo, armazenar o resultado da conta na
memria, para depois escrev-lo. Nesta situao, o formato fica como no
Algoritmo 2-4.
Algoritmo 2-4
1
{ clculo do consumo mdio de um veculo, dados a quilometragem total
percorrida e o nmero de litros utilizados nos dois nicos
abastecimentos realizados }
4
5
6
algoritmo
declare
quilometragem, consumo,
abastecimento1, abastecimento2: real
9
10
{ obteno da quilometragem e litros consumidos }
11
leia(quilometragem)
12
leia(abastecimento1, abastecimento2)
13
14
{ clculo do consumo }
15
consumo quilometragem/(abastecimento1 + abastecimento2)
16
17
{ sada do resultado calculado }
18
escreva(consumo, km/l)
19 fim-algoritmo
jander moreira

A linha 15 mostra como o valor de uma expresso (o clculo do
consumo) alocado para a memria indicada pelo identificador consumo,
que est associado a um dado real. Para que possa ser usada, a varivel
consumo tambm teve que ser declarada (linha 7).
A atribuio sempre indicada com o identificador esquerda na
linha de comando, seguido de uma seta para a esquerda () que indica que
toda a expresso que estiver direita ser calculada e o valor resultante
ser armazenado na memria da varivel especificada pelo identificador.
O comando de atribuio tem sempre o formato indicado na
seqncia.
identificador expresso
sempre importante destacar que deve haver uma compatibilidade

de tipos entre a expresso e a varivel. Assim, no faz sentido a expresso
ser real se a varivel tiver o tipo literal ou lgico. Como regra geral, o tipo
resultante da expresso deve ser igual ao da varivel. A nica exceo
quanto a reais e inteiros pois, como ambos so numricos, h a promoo
para real ao se atribuir um valor inteiro para uma varivel real, assim como
a perda da parte fracionria ao se atribuir um dado real para uma varivel
inteira. Importante observar que, neste ltimo caso, no feito o
arredondamento, mas sim a simples eliminao da parte fracionria, de
modo que 5,02 e 5,999, ao serem atribudos a um inteiro, produziriam o
valor 5.
2.3.5 Regras para a formao de identificadores

Para que no haja dvidas de interpretao nem outros problemas
decorrentes, algumas regras so definidas para que um identificador seja
criado. So elas
1) Todo identificador formado apenas por letras do alfabeto (a a z),
por dgitos (0 a 9) e pela sublinha (_);
2) O primeiro caractere sempre uma letra ou a sublinha; nunca um
dgito;
3) O identificador escolhido deve ser significativo.
Decorrentes da primeira regra, no so permitidos espaos, smbolos
(&, #, ! etc.) ou outros caracteres. Tambm no so permitidas letras ou
smbolos de outros alfabetos, como o grego ou o cirlico.
A terceira regra obriga que uma varivel tenha nome significativo, ou
seja, que o nome ajude a entender sua funo no algoritmo. Por exemplo,
pia um identificador corretamente formado, mas no faz sentido que seja
usado se, no algoritmo, a varivel for usada para guardar a taxa de juros da
poupana. No Algoritmo 2-3 so usados identificadores que deixam clara a
funo de cada varivel no contexto do algoritmo.
Recomenda-se, ainda, que seja adotado o seguinte estilo para os
algoritmos:
1) O uso de minsculas deve ser privilegiado;
jander moreira

2) Quando um identificador for formado pela justaposio de duas ou
mais partes, a partir da segunda deve-se usar uma maiscula para
indicar a transio de uma palavra para outra.
O uso de minsculas mais legvel e agradvel leitura, pois produz
linhas menos densas, alm de, atualmente, escritas em maisculas terem
uma conotao de falar alto ou gritar, como usual nos fruns e salas
de bate-papo. A nica tolerncia no uso de maisculas no caso da
segunda regra, que abrange nomes compostos. Segundo esta sugesto,
usada internacionalmente pelos programadores, so recomendados
identificadores como salrioMnimo, consumoTotal e taxaCpmf, por
exemplo. Todos os algoritmos deste texto utilizam estas convenes e
fortemente recomendado que todos faam sua adeso ao estilo.
Como exemplo (ou contra-exemplo), o Algoritmo 2-5 mostra o
Algoritmo 2-4 usando apenas maisculas, o que o torna desagradvel de
ler.
Algoritmo 2-5
1
{ CLCULO DO CONSUMO MDIO DE UM VECULO, DADOS A QUILOMETRAGEM TOTAL
PERCORRIDA E O NMERO DE LITROS UTILIZADOS NOS DOIS NICOS
ABASTECIMENTOS REALIZADOS }
4
5
6
ALGORITMO
DECLARE
QUILOMETRAGEM, CONSUMO,
ABASTECIMENTO1, ABASTECIMENTO2: REAL
9
10
{ OBTENO DA QUILOMETRAGEM E LITROS CONSUMIDOS }
11
LEIA(QUILOMETRAGEM)
12
LEIA(ABASTECIMENTO1, ABASTECIMENTO2)
13
14
{ CLCULO DO CONSUMO }
15
CONSUMO QUILOMETRAGEM/(ABASTECIMENTO1 + ABASTECIMENTO2)
16
17
{ SADA DO RESULTADO CALCULADO }
18
ESCREVA(CONSUMO, KM/L)
19 FIM-ALGORITMO

Um modelo de computador foi definido, cuja responsabilidade
executar os algoritmos. Para tanto, este modelo define uma interface com o
mundo, permitindo a entrada de dados (obteno de dados do mundo
externo) e tambm a sada (que fornece dados do algoritmo para o meio
externo). Alm disso, existe a unidade de processamento, que capaz de
interpretar as instrues dos algoritmos e realizar suas aes, usando para
isso a memria, a qual responsvel por armazenar tanto o algoritmo em si
quanto os diversos dados utilizados.
jander moreira

A memria pode ser vista como um conjunto de dados, cada qual
ocupando uma parte dela. Para saber exatamente como interpretar os
dados de cada parte da memria, um tipo de dados deve ser associado a
ele, sendo os tipos inteiro, real, lgico, literal e ponteiro os tipos bsicos
vlidos.
Uma rea de memria, qual se associa um tipo, pode ser
manipulada pelo algoritmo por meio de um identificador. Esta parte da
memria, por poder ter seu valor modificado com o tempo, recebe o nome
genrico de varivel. atravs da manipulao dos contedos armazenados
nas variveis que os algoritmos, por meio de instrues adequadas,
resolvem um problema.
As principais formas de se modificar o contedo de uma varivel
por meio de um comando de leitura (comando leia), ou seja, solicitando
unidade de processamento que transfira dados externos (teclado, por
exemplo) para a memria no local definido pelo identificador, ou atravs da
atribuio de um valor diretamente varivel (usando o comando de
atribuio).
jander moreira

Expresses algortmicas
Unidade 3 -

Se algoritmos so manipuladores de dados utilizados para que um
determinado problema seja tratado e uma resposta correta produzida, o
modo como os dados so tratados e estruturados assume papel importante
neste contexto. Nas Unidades anteriores foram apresentadas as maneiras
como os comandos de um algoritmo so executados e como as variveis
so definidas. nas variveis que so armazenados os dados e, em
conseqncia, nelas que os comandos agem e os dados so
transformados.
Para que sejam especificadas corretamente as transformaes dos
dados, preciso que sejam definidas as expresses que os manipulam sem
que haja ambigidade nas interpretaes. Deste modo, esta Unidade trata
das expresses algortmicas e suas propriedades.
3.2 Matemtica e preciso da notao

Existe muito em comum entre as expresses algortmicas e as
expresses matemticas que so aprendidas desde os primeiros anos de
estudo. Expresses matemticas so indicadas por operandos e operadores.
Na expresso 2 3 + 7, por exemplo, so indicadas as operaes de
multiplicao e de soma; os operandos da multiplicao so os valores 2 e 3
e os da adio, o resultado da multiplicao (6) e o 7. O resultado, claro,
13.
Outra expresso, como 7 + 2 3, ... a mesma expresso. Na
realidade, uma expresso equivalente. Nesta nova expresso, as
operaes e resultados so os mesmos, mas uma diferena deve ser
notada: a multiplicao, embora colocada aps a adio, calculada antes.
Expresses matemticas possuem, naturalmente, prioridade entre os
operadores, o que tem evidente importncia no que a expresso
representa.
Expresses algortmicas so similares s expresses matemticas.
Possuem operadores, operandos e ordem correta de avaliao. Tambm
tm algumas outras restries, que as tornam adequadas aos algoritmos, e
devem tratar distintamente os vrios tipos dados.
3.3 Expresses em algoritmos

As expresses em algoritmos, do mesmo modo que as matemticas
j conhecidas de todos, tm como caracterstica uma formalidade que evita
ambigidades. Assim, apresentada uma expresso qualquer, as regras
envolvidas determinam em que ordem cada operao deve ser avaliada
para que, ao final, um resultado especfico seja calculado. Esta Unidade
trata da introduo, nos algoritmos, dos diversos tipos de expresses
vlidos para que sejam utilizados nas solues propostas.
jander moreira

3.3.1 Linearidade das expresses, operadores e precedncia

A formalizao, to necessria desde a primeira unidade, comea por
definir as regras bsicas para que as expresses sejam construdas
corretamente:
1) Todas as expresses so lineares, ou seja, so escritas na altura de
uma linha;
2) Os operadores so sempre explcitos e devem ser coerentes com os
tipos de dados envolvidos;
3) As relaes entre os tipos de dados devem ser mantidas de forma
coerente.
O fato de expresses serem lineares implica que no h liberdade de
usar visualmente o espao, como feito na matemtica. A Figura 3-1(a-c)
apresenta algumas expresses matemticas cujos elementos no ficam
todos em uma nica linha. Nos algoritmos, isto uma necessidade, de
forma que modificaes so requeridas para que fiquem na forma linear. A
Figura 3-1(d-f) mostra as mesmas expresses em forma linear.
b
c+d
a+
b
c
d
(a)
(b)
(c)
a/b
a * b /(c + d )
a + b /(c / d )
(d)
(e)
(f)
Figura 3-1. (a-c) Exemplos de expresses matemticas. (d-f) Verses algortmicas

das mesmas expresses.
A segunda regra exige que todos os operadores sejam explcitos.

Portanto, expresses que incluam a multiplicao, que geralmente omitida
na matemtica, como na Figura 3-1(b), devem estar explicitamente
apresentadas, como na verso algortmica mostrada na Figura 3-1(e).
Deve-se notar, em particular, que a multiplicao indicada por um
asterisco.
Tratando dos tipos de dados envolvidos, a terceira regra exige
coerncia entre os valores e resultados. Estes aspectos de coerncia so
tratados nas sees seguintes, para os vrios tipos de expresses que
aparecem em algoritmos: as aritmticas, as literais, as relacionais e as
lgicas.
J na Unidade 2, no Algoritmo 2-3, exemplificada uma expresso
escrita na forma linear e seguindo as orientaes aqui especificadas.
3.3.2 Expresses aritmticas

Os tipos de dados inteiro e real so tratados conjuntamente nas
expresses aritmticas. Este tipo de expresso est diretamente
jander moreira

vinculado ao conceito de expresses matemticas, como as exemplificadas
na seo anterior.
As expresses aritmticas utilizam o conjunto de operadores
apresentado na Figura 3-2. A primeira observao sobre os dois
operadores que usam o mesmo smbolo: o sinal de menos. O primeiro,
junto como %, o operador unrio, usado em expresses como b, e o
segundo o binrio, que exige dois operandos, como em a - b. Outro ponto
a ordem de prioridade, sendo que os de maior prioridade (avaliados
antes) esto na parte superior e os de menor prioridade na parte inferior.
Assim, em uma expresso com os operadores % (mdulo) e *
(multiplicao), o mdulo calculado antes. Alterao na ordem de
precedncia dos operadores feita com o uso de parnteses, que podem
ser usados em qualquer tipo de expresso.
maior
menor
%
/
+
(operador unrio)
*
(operador binrio)
Figura 3-2. Operadores aritmticos.
Ainda na questo sobre a precedncia dos operadores, operadores

que esto na mesma linha na Figura 3-2, isto , que possuem a mesma
precedncia, so avaliados da esquerda para a direita. Por exemplo,
3 * 8 / 2 tem a multiplicao do 3 pelo 8 sendo feita antes da diviso deste
resultado intermedirio por 2. Na expresso anterior, pode-se argumentar
que fazer a diviso antes da multiplicao no alteraria o resultado, o que
verdadeiro neste caso. Embora, em geral, esta ordem parea no fazer
diferena, quando so usadas divises o resultado pode no ser o
pretendido, como no caso da expresso 3 / 8 / 2. Nesta nova situao,
ambas as divises tm a mesma precedncia, mas dividir 3 por 8 para
ento dividir por 2 diferente de dividir 8 por 2, para ento dividir 3 por
este resultado. Confira as contas!
Todos os operadores, exceto o de mdulo (%), podem ser usados
tanto em operandos inteiros quanto reais. Assim, adota-se a regra que,
para dois operandos do mesmo tipo, o resultado segue o mesmo tipo.
Portanto, a soma de dois inteiros resulta em inteiro e a multiplicao de
dois reais resulta em um real. Um destaque deve ser feito diviso, pois a
diviso de dois inteiros resulta em um inteiro, de forma que a expresso
5 / 2 tem valor 2, e no 2,5. Esta uma caracterstica que requer ateno e
deve ser tratada com cuidado, sob a pena de especificar expresses
incorretas.
Quando h mistura de tipos, adota-se a chamada regra da
promoo, que promove o tipo mais simples para o mais completo.
Isto quer dizer que, no caso de operaes que envolvam inteiros e reais,
primeiro o inteiro promovido a real, e ento a operao feita. Por
exemplo, 10,2 * 2 tem o 2 (inteiro) promovido para 2,0 (real); ento a
multiplicao de real por real efetuada, resultando neste caso em 20,4.
Enquanto a expresso 21 / 2 * 2 resulta 20 (lembrando que o inteiro 21
jander moreira

dividido pelo inteiro 2 resulta no tambm inteiro 10), 21 / 2,0 *2 resulta
21,0, pois o 21 promovido a real antes da diviso pelo real 2,0 (com
resultado intermedirio 10,5); ento o inteiro 2 promovido a real, antes
da multiplicao final. Ateno especial deve sempre ser dada a estas
situaes.
Finalmente, o chamado operador modular, indicado pelo smbolo %
e usado exclusivamente para operandos inteiros, resulta no resto de uma
diviso inteira. Por exemplo, 10 % 3 resulta em 1, pois 10 dividido por 3
resulta em 3, com resto 1. Similarmente, 6 % 2 resulta 0, 7 % 2 resulta 1,
254 % 100 resulta 54. Pode-se observar que o resto de diviso por um
valor k est sempre entre os valores 0, 1, 2..., k1.
No somente operaes esto disponveis para as expresses, mas
tambm algumas funes de uso geral, como as apresentadas na Tabela
3-I.
Tabela 3-I. Lista das funes usuais para expresses aritmticas.
Funo
Parmetros
Valor de
retorno
sen(r), cos(r),
tan(r)
real
real
Funes trigonomtricas,
com parmetros em
radianos
asen(r), acos(r),
real
real
Funes trigonomtricas
inversas, retornando o valor
do arco em radianos
ln(r)
real
real
Logaritmo neperiano (base

e)
log(r)
real
real
Logaritmo base 10
exp(r)
real
real
e elevado potncia r
pot(v, r)
real/inteiro,
real
sinal(i)
inteiro
inteiro
Retorna 1 se o valor for

positivo ou 1 se for
negativo; zero se for nulo
trunca(r) ou int(r)
real
inteiro
Retorna somente a parte

inteira do argumento
passado
frac(r)
real
real
Retorna somente a parte

fracionria do argumento
arred(r)
real
inteiro
atan(r)
Descrio
tipo do primeiro Potncia vr

argumento
Retorna o inteiro mais

prximo do valor real
passado
jander moreira

abs(v)
real/inteiro
tipo do primeiro Retorna o valor absoluto

(sem sinal) do argumento,
argumento
mantendo o tipo
especificado no parmetro
resto(r, i)
real, inteiro
inteiro
Retorna o resto da diviso

inteira de r por i
quoc(r, i)
real, inteiro
inteiro
Retorna o quociente da
diviso inteira de r por i
O Algoritmo 3-1 uma proposta de soluo para o seguinte

problema: Uma lanchonete precisa, em um determinado momento,
calcular o total da conta de uma mesa e, dado o valor pago pelos clientes,
calcular o troco. Os dados disponveis, alm do valor pago pelos clientes,
so o valor total consumido em bebidas e o total consumido em alimentos.
Sabe-se tambm que, como padro, tambm includo na conta a gorjeta
do garom, no valor correspondente a 10% do total da conta. preciso
escrever um algoritmo que reporte o valor total da conta, o valor total pago
pelos clientes e o valor do troco..
Algoritmo 3-1
1
{ apresentar, para uma conta de lanchonete, o valor total da conta,
o valor pago e o troco devolvido, dados o total consumido de bebidas
e alimentos, alm de se saber que a porcentagem do garom 10% }
4
5
6
algoritmo
declare totalBebidas, totalAlimentos,
valorPago, troco,
porcentagemGarom: real
9
10
{ obteno dos dados necessrios }
11
leia(totalBebidas, totalAlimentos, valorPago)
12
13
{ clculos necessrios }
14
porcentagemGarom (totalBebidas + totalAlimentos) *
15
16
10/100,0 { 10% }
troco valorPago (totalBebidas + totalAlimentos +
17
porcentagemGarom)
18
19
{ apresentao dos resultados }
20
escreva(Valor da conta:,
21
totalBebidas + totalAlimentos + porcentagemGarom)
22
escreva(Valor pago:, valorPago)
23
escreva(Troco:, troco)
24 fim-algoritmo
Deve-se notar que, no algoritmo, todas as variveis so reais. Um

potencial problema com tipos de dados foi resolvido na linha 15, ao se
calcular o valor de 10%. Caso a expresso fosse escrita apenas 10/100, o
jander moreira

valor recebido pelo garom seria de zero, pois ambos os valores so inteiros
e, portanto, o resultado da diviso daria zero. O uso de um dos operandos
com valor real exige a promoo do outro e o resultado desejado (0,1)
obtido. Tambm podem ser observadas as expresses utilizadas em outros
locais, principalmente com o uso de parnteses.
3.3.3 Expresses literais

Os tipos literais so mais restritos em termos de operaes, pois so
constitudos somente por texto. definida, portanto, apenas uma operao
sobre literais, que a concatenao. Desta forma, dados os literais texto
inicial e texto final, a expresso texto inicial + texto final resulta no
literal texto inicialtexto final. Havendo vrias concatenaes, assume-se
que sejam feitas da esquerda para a direita, embora isso no d diferena
no resultado final: a expresso incio + + fim resulta incio fim,
notando-se que indica um literal contendo um espao em branco
(diferentemente de , que indica um literal vazio, sem nenhum caractere).
Algumas funes sobre literais tambm esto disponveis, com as
mais usuais apresentadas na
Tabela 3-II. Lista das funes usuais para expresses literais
Funo
Parmetros
Valor de
retorno
Descrio
comprLiteral(s)
literal
inteiro
Retorna o comprimento
da cadeia de
caracteres, incluindo os
espaos
posLiteral(s1, s2)
literal,
literal
inteiro
Retorna a primeira
posio onde a cadeia
s1 ocorre na cadeia s2,
sendo que o primeiro
caractere considerado
como posio 0 (zero);
retorna -1 se no ocorrer
nenhuma vez.
subLiteral(s1, n1, n2)
literal,
inteiro,
inteiro
literal
Retorna a sub-cadeia de
s1, comeando na
posio n1 e
comprimento total n2
valLiteral (s)
literal
tipo equivalente
ao valor
numrico
representado
Retorna o valor numrico

de uma cadeia de
caracteres que contm
um nmero vlido; o tipo
resultante depende do
valor representado no
literal
jander moreira

Seja o problema: Dados o primeiro nome e o sobrenome de uma
pessoa, compor o nome em dois formatos: Fulano Tal e Tal, F. (como na
lista telefnica).. O Algoritmo 3-2 ilustra uma possvel soluo para este
problema, ilustrando o uso de expresses literais.
Algoritmo 3-2
1
2
{ dados, separadamente, prenome e sobrenome, escrev-los em dois

formatos: Fulano Tal e Tal, F. }
3
4
algoritmo
declare prenome, sobrenome,
formato1, formato2: literal
7
8
{ obteno dos nomes }
leia(prenome, sobrenome)
10
11
{ composio dos nomes }
12
formato1 prenome + + sobrenome
13
formato2 sobrenome + , + subLiteral(prenome, 1, 1) + .
14
15
{ resultados }
16
escreva(formato1)
17
escreva(formato2)
18 fim-algoritmo
3.3.4 Expresses relacionais

Comparaes de valores permitem ao algoritmo executar aes
diferentes de acordo com os resultados. Operadores relacionais so
operadores de comparao, ou seja, que avaliam a relao entre dois
valores. Todos os operadores relacionais so binrios, isto , com dois
operandos, e sempre resultam em verdadeiro ou falso.
A Tabela 3-III apresenta os operadores relacionais.
Tabela 3-III. Operadores relacionais.
Operador
Funo
<>
>
<
>=
<=
Igual
Diferente
Diferente (smbolo alternativo)
Estritamente maior
Estritamente menor
Maior ou igual
Maior ou igual (smbolo alternativo)
Menor ou igual
Menor ou igual (smbolo alternativo)
jander moreira

As comparaes podem ser realizadas desde que os tipos sejam
equivalentes.
Expresses inteiras e reais podem ser comparadas entre si,
considerando as mesmas regras de promoo descritas para as expresses
aritmticas.
Literais tambm podem ser comparados com outros literais, usando
todos os operadores. No caso do tipo literal, o resultado realizado em
termos textuais, seguindo a ordem alfabtica. Por exemplo, a expresso
abacate > abacaxi
resulta
falso,
pgina = pgina
resulta
verdadeiro e forma forma tambm verdadeiro (pois h um
espao adicional na segunda constante literal).
No caso dos tipos ponteiro e lgico, os nicos operadores vlidos
so os de igualdade e desigualdade.
Combinaes de vrias expresses lgicas so feitas por operadores
lgicos, compondo as expresses lgicas, apresentadas na prxima seo.
Um algoritmo exemplo apresentado na prxima seo, ilustrando o uso de
expresses relacionais e lgicas.
3.3.5 Expresses lgicas

Os valores lgicos so somente verdadeiro e falso. Para estes
valores, so definidas as operaes no, e e ou. A Figura 3-3 mostra estes
operadores e sua ordem de precedncia, a qual, naturalmente, pode ser
quebrada com o uso de parnteses.
maior
no
e
ou
menor
Figura 3-3. Operadores lgicos.
As operaes lgicas seguem de forma bastante prxima o raciocnio

lgico. Assim, o que no verdadeiro falso, e o que no falso
verdadeiro, conforme a tabela verdade contida na Tabela 3-IV.
Tabela 3-IV. Tabela verdade para o operador no.
Operao
Resultado
no falso
verdadeiro
no verdadeiro falso
O operador e exige que ambos os operandos tenham valor
verdadeiro para que o resultado seja verdadeiro. Portanto, todas as
outras combinaes resultam falso. A Tabela 3-V mostra as combinaes e
os resultados.
jander moreira

Tabela 3-V. Tabela verdade para o operador e.
Operao
falso e falso
falso e verdadeiro
verdadeiro e falso
verdadeiro e verdadeiro
Resultado
falso
falso
falso
verdadeiro
A verificao do operador ou permite que o resultado seja

verdadeiro bastando que um dos operandos tambm seja verdadeiro. O
resultado falso somente quando ambos os operadores tiverem valor
falso, como mostrado na Tabela 3-VI.
Tabela 3-VI. Tabela verdade para o operador ou.
Operao
falso ou falso
falso ou verdadeiro
verdadeiro ou falso
verdadeiro ou verdadeiro
Resultado
falso
verdadeiro
verdadeiro
verdadeiro
As expresses lgicas so essenciais nas verificaes de condies ou

situaes durante a execuo de algoritmos. Por exemplo, um algoritmo
pode tomar atitudes diferentes conforme o valor do saldo seja negativo e a
conta no possua limite adicional (cheque especial). Condies mais
complexas, que envolvem vrias situaes simultaneamente tambm
podem ser modeladas nas expresses.
O Algoritmo 3-3 mostra um exemplo de verificaes de algumas
situaes. O problema dado o seguinte: Verificar se um tringulo,
descrito pelo comprimento de cada um de seus lados, eqiltero, issceles
ou escaleno, caso os lados ainda formem um tringulo..
Algoritmo 3-3
1
{ determinar, dados os comprimentos dos lados de um tringulo, se o
tringulo pode ser formado (se existe) e qual o tipo dele (eqiltero,
issceles ou escaleno) }
4
5
6
algoritmo
declare
lado1, lado2, lado3: real
existeTringulo,
Eqiltero, Issceles, Escaleno: lgico
10
11
{ leitura dos comprimentos dos lados }
12
leia(lado1, lado2, lado3)
13
14
{ verificaes necessrias }
15
existeTringulo lado1 < lado2 + lado3 e
16
lado2 < lado1 + lado3 e
jander moreira

17
lado3 < lado1 + lado2
18
Eqiltero existeTringulo e lado1 = lado2 e lado2 = lado3
19
Issceles existeTringulo e no Eqiltero e
20
21
(lado1 = lado2 ou lado2 = lado3 ou lado1 = lado3)

Escaleno existeTringulo e no Eqiltero e no Issceles
22
23
{ resultados }
24
escreva(Tringulo existe?, existeTringulo)
25
escreva( eqiltero?, Eqiltero)
26
escreva( issceles?, Issceles)
27
escreva( escaleno?, Escaleno)
28 fim-algoritmo
Os comandos escreva, nas linhas de 24 a 27, produzem como

resultado as mensagens especificadas, seguido das palavras verdadeiro ou
falso, conforme o valor lgico contido nas variveis.
3.3.6 Ordem global de precedncias de operadores

Quando as expresses misturam expresses aritmticas, relacionais e
lgicas simultaneamente, a precedncia sempre feita avaliando-se
primeiramente as partes aritmticas, seguidas pelas relacionais e,
finalmente, as lgicas, sempre da esquerda para a direita.
7 + 2 * 5 < 20
ou 1 + 2 * 2 10 5
e peter parker
1
2
3
4
5
6
7
8
9
10
Figura 3-4. Ordem de avaliao de uma expresso composta.
A Figura 3-4 apresenta uma expresso e a ordem em que as diversas

partes so avaliadas.
3.3.7 Uso de parnteses nas expresses

Quando se desejar que a ordem natural de precedncia seja
modificada, pares de parnteses so usados. Podem ser empregados tantos
nveis de parnteses quanto forem necessrios, aninhados ou no. Em
jander moreira

algoritmos exclusivamente os parnteses so usados, pois colchetes ([ ]) e
chaves ({ }) possuem significados diferentes.
A Tabela 3-VII apresenta alguns exemplos nos quais o uso dos
parnteses produz alteraes nos resultados, pois alteram a precedncia
natural dos operadores. Especial ateno ainda pode ser dada s linhas 19 e
20 do Algoritmo 3-3, na qual a ausncia dos parnteses alteraria o
resultado, tornando-o incorreto.
Tabela 3-VII. Exemplos de expresses com parnteses.
Expresso
3 * (8 + 14) + 4
-100 * (200 50)/(9
(200 50)/(9 1) *
(-5 14,0)/((2 + 6)
(8 + 7)/2 > 6 + 1
45 > 10 e (torre <
Resultado
70
1)
-100
* 10)
-1875
-1800
-0,2375
falso
pilar ou abc = abc)
verdadeiro
3.3.8 Organizao visual nas expresses

Em todas as expresses devem ser usados espaos entre os
operadores e os operandos, para aumentar a clareza da expresso. Apenas
o operador de diviso pode ser usado sem os espaos, pois no h
comprometimento visual, principalmente quando prximo a parnteses.
considerado uma prtica muito ruim omitir os espaos, portanto
este aspecto ser cobrado na escrita dos algoritmos, juntamente como a
organizao visual geral (j visto na seo 1.4 da Unidade 1).

Expresses algortmicas apresentam uma caracterstica bastante
dbia. Se por um lado parecem ser bastante naturais, a ponto de alguns
pensarem fcil, por outro lado repleta de detalhes, que levam muito
facilmente a erros. Expresses algortmicas no so expresses
matemticas e no esto sujeitas ao mesmo tipo de interpretao. Se, na
matemtica se escreve a > b, a b 0 querendo dizer que a sempre maior
que b e ambos so diferentes de zero, tal expresso em algoritmos no tem
absolutamente nenhum sentido, pois devem ser usadas as regras de
avaliao apresentadas.
Os principais pontos que devem ter ateno especial envolvem o uso
correto dos operadores (que so sempre obrigatrios) e os tipos dos
operandos. Especificar uma expresso de forma incorreta tem implicaes
graves na interpretao do algoritmo e, portanto, no resultado produzido.
Em particular, as promoes e decessos entre reais e inteiros deve ser
tratada com muito cuidado.
A prtica a melhor forma de se obter domnio sobre as expresses
algortmicas. Portanto, estudo e exerccios so fundamentais.
jander moreira

Estratgia de desenvolvimento de algoritmos
Unidade 4 - Estratgia de desenvolvimento de

algoritmos
O que se sabe de algoritmos at o momento bastante limitado para
que problemas um pouco mais complexos sejam resolvidos. Entretanto, os
fundamentos apresentados nas Unidades de 1 a 3 so de extrema
importncia e devem ter sido compreendidos completamente.
Esta Unidade quebra um pouco o fluxo do texto, que vinha
construindo o conhecimento sobre algoritmos, para mostrar um ponto
importante, o qual ser utilizado at o final deste material. Este ponto, que
no somente importante, mas essencial, a filosofia de
desenvolvimento.
Propor um algoritmo no depende somente do conhecimento das
variveis, dos tipos de dados, da estruturao das expresses e do uso dos
comandos, mas tambm do modo que so utilizados. Em outras palavras,
possvel saber como funcionam diodos, transistores, resistores e outros
itens eletrnicos, mas da a fazer um rdio, outra histria.
Esta Unidade trata de como se pensar para que um problema seja
resolvido pela proposio de um algoritmo. Esta metodologia de
desenvolvimento tambm vista sob um enfoque um pouco mais formal.
4.2 Organizao para resolver problemas

Cada um tem um modo de resolver seus problemas, sejam eles quais
forem. Se for preciso arrumar o guarda-roupa, que est entulhado de
roupas e outros objetos que despencam toda vez que uma porta aberta,
cada um tem seu prprio jeito de fazer a arrumao.
Uma pessoa, por exemplo, opta por retirar tudo e espalhar sobre a
cama e outros mveis, agrupando as camisas, as calas e as blusas, j
separando as coisas velhas e outros objetos. Terminada esta fase, para
cada grupo de coisas, pe tudo de volta no guarda-roupa, organizando cada
compartimento e gaveta (arrumando as camisetas, separando as camisas
de mangas curtas e mangas compridas, vestidos, calas jeans e sociais
etc.), um a um.
Outra pessoa opta por remover do guarda-roupa apenas o necessrio
e j partir para a organizao. Separa, por exemplo, as roupas ntimas,
meias e shorts, e j os arruma nas gavetas; separa as calas e faz sua
arrumao nos cabides; junta as blusas nas gavetas de baixo; junta as
roupas de cama na parte de cima. Cada item praticamente terminado
antes que outro seja iniciado.
Todas as alternativas (as duas acima e ainda outras) levam
arrumao pretendida, porm de forma diferente. Cada um pode justificar
sua soluo como melhor que outras, mas isso outra questo.
Em suma, um algoritmo tambm pode ser abordado de forma
diferente e vrias solues distintas podem levar produo de respostas
idnticas, todas resolvendo o problema.
jander moreira

4.3 Estratgia de
algoritmos
abordagem
para
desenvolvimento
de
Para o caso de algoritmos, uma forma (que no a nica) de se

abordar uma proposio de soluo na forma de algoritmo a chamada
abordagem top-down. O termo, que poderia ser traduzido abordagem de
cima para baixo, pode ser entendido como uma abordagem do mais geral
para o mais especfico.
Veja-se a primeira alternativa para a arrumao do guarda-roupa
sugerida na seo anterior (a que sugere tirar tudo e, posteriormente,
arrumar). Ela pode ser descrita pelos seguintes passos, de forma mais
geral:
1) Remova todas as roupas, separando-as sobre a cama segundo
grupos similares (camisetas, camisas, vestidos, roupas de inverno
etc.)
2) Para cada grupo formado, organize-o (por cor, por uso ou outra
forma) e o acondicione no local definitivo (gavetas, cabides).
Deve ser observado que a soluo acima prope uma soluo
coerente para o problema, mesmo j pensando na questo de algoritmos
formais, que indica que o segundo passo somente executado aps o
primeiro ter sido inteiramente completado.
Uma soluo melhor, para ser dada a uma empregada ou ao caula
da famlia que foi condenado a fazer a organizao, deveria ser mais
especfica, detalhando os procedimentos e especificando melhor as aes e
critrios.
4.3.1 Abordagem top-down

Na forma de um algoritmo, que no tem pretenso nenhuma de ser
executado por um computador, a soluo para o problema de arrumao
pode ser observada no Algoritmo 4-1.
Algoritmo 4-1
1
2
{ soluo geral e no computacional para a arrumao de um guarda-roupa

em situao calamitosa }
3
4
5
algoritmo
remova todas as roupas, separando-as sobre a cama segundo grupos
6
7
8
similares
organize cada grupo formado e o acondicione nos locais apropriados
fim-algoritmo
Estabelecida a soluo global, que deve ser completa e coerente, um

detalhamento maior pode ser especificado, reescrevendo-se alguns
comandos do algoritmo. Deve-se observar que, nesta nova verso (e nas
subseqentes), a notao de comentrios far parte da apresentao. O
Algoritmo 4-2 mostra o resultado.
jander moreira

Algoritmo 4-2
1
2

em situao calamitosa VERSO 2 }
3
4
5
6
7
algoritmo
{ remoo de todas as roupas, separando-as sobre a cama
segundo grupos similares }
para cada pea de roupa,
pegue-a do guarda-roupa
coloque-a no grupo correto
10
11
{ organizao de cada grupo formado e acondicionamento
12
nos locais apropriados }
13
para cada grupo de roupas,
14
organize o grupo
15
para cada pea de roupa do grupo,
16
transfira a pea para o local apropriado
17 fim-algoritmo
Mesmo assim, alguns pontos ainda podem precisar de detalhamento,

o que leva a outra verso, expressa pelo Algoritmo 4-3.
Algoritmo 4-3
1
2

em situao calamitosa VERSO 3 }
3
4
5
6
7
algoritmo
{ remoo de todas as roupas, separando-as sobre a cama
segundo grupos similares }
para cada pea de roupa,
pegue-a do guarda-roupa
{ colocao no grupo correto }
10
para cada grupo que j existe,
11
se a pea pertencer ao grupo,
12
coloque-a no grupo,
13
14
{ for similar s demais }
se a pea no foi colocada em nenhum grupo,
{ no existe }
crie um novo grupo com a pea
15
16
{ organizao de cada grupo formado e acondicionamento
17
nos locais apropriados }
18
para cada grupo de roupas,
19
{ organizao do grupo }
20
caso o grupo seja:
21
de camisetas, separe por cor
22
de camisas, calas ou vestidos,
23
separe por tipo { social/esporte }
24
de saias ou blusas, separe por idade { novas/velhas }
25
demais grupos, separe por cor
jander moreira

26
para cada pea de roupa do grupo,
27
{ transferncia da pea para o local apropriado }
28
procure uma gaveta ou cabide disponvel, conforme
29
30
a pea
coloque a pea no local, obedecendo a organizao
31 fim-algoritmo
O Algoritmo 4-3 mostra uma verso bem mais detalhada do

procedimento, aproveitando em cada passo o que foi detalhado nos passos
anteriores. Naturalmente, o detalhamento pode ser refinado o quanto for
necessrio, at que esteja completamente compreensvel por quem vai
execut-lo (mesmo que este algum seja um computador capaz de
comandar um rob dotado de viso e bom-gosto e que seja hbil para
dobrar as roupas sem suj-las de graxa).
Esta estratgia ilustra o procedimento top-down. Inicialmente feito
um algoritmo mais geral, que descreve completamente a soluo, mas sem
todos os detalhes. Esta proposta inicial refinada sucessivamente (e nem
preciso que os detalhamentos sejam feitos na ordem em que aparecem) at
que, na verso final, esteja pronta para a execuo.
4.3.2 Abordagem do problema

Quando se pensa em algoritmos, eles esto no contexto de um
problema, como visto na Unidade 1. comum que, mesmo usando a
tcnica de refinamentos sucessivos (vista em detalhes na prxima
seo), a primeira coisa que o desenvolvedor faz comear a escrever o
algoritmo. Este seu primeiro erro.
H um conjunto de passos que devem ser seguidos para a elaborao
de um algoritmo. So eles:
1) Entender a proposta do problema;
2) Buscar e entender uma soluo no algortmica para o problema;
3) Propor um algoritmo que traduza para uma seqncia de passos a
soluo j encontrada;
4) Testar os vrios aspectos do algoritmo elaborado para verificar se
no h problemas e se realmente produz a soluo esperada;
5) Verificar o algoritmo pronto e considerar se algumas das etapas
podem ser feitas de forma mais eficiente.
Nota-se que elaborar o algoritmo apenas o terceiro passo, e no o
primeiro. Os dois primeiros passos traduzem uma idia de pensar antes no
assunto, antes de resolv-lo.
Deste modo, entender o problema significa verificar o que
solicitado e o que deve ser produzido como resposta. Devem ser levantados
os dados disponveis e, a partir deles, quais dados devem ser produzidos.
Para exemplificar a abordagem como um todo, proposto um problema
relativamente simples: Um professor de fsica trabalha com balstica e, em
um determinado momento, precisa que seja elaborado um algoritmo para
determinar se um projtil colidir ou no com um obstculo (muro ou
jander moreira

prdio) presente em seu caminho. A Figura 4-1 mostra um esquema da
situao, juntamente com alguns dados disponveis. Sabe-se a velocidade
inicial no lanamento e o ngulo, em graus, em relao ao solo. Tem-se
tambm a distncia do objeto do ponto de lanamento, alm de sua altura e
espessura. Deve-se considerar a superfcie da Terra e sem influncia de
outros fatores, como vento.
v0
Figura 4-1. Problema de lanamento de objeto.
Para quem vai desenvolver o algoritmo, o primeiro passo entender

o que se espera como resultado. Neste caso, no interessa o ponto mximo
da trajetria, a distncia da origem que o projtil cai nem sua velocidade
quando passa sobre o objeto. A resposta esperada pelo problema pode vir
em duas sentenas: sim, houve coliso e no, no houve coliso. Este
momento crucial, pois determina todo o desenvolvimento do algoritmo.
O segundo passo se ter uma soluo no algortmica. Para isso,
quem vai escrever o algoritmo no precisa entender de fsica ou saber
qualquer uma das frmulas envolvidas. Esta no sua funo. Por exemplo,
uma apostila de cursinho pode ser consultada ou um especialista (ou
amigo) pode ser ouvido. Neste exemplo, a soluo que se obtm
(independentemente da origem), que somente haver coliso se a altura
do projtil nos limites do objeto for inferior a sua altura (ou seja, nas
distncias d e d + e do ponto de lanamento. Para isso, preciso calcular o
tempo que o projtil leva para atingir os limites do objeto na horizontal e
calcular sua altura nestes momentos. Fisicamente, o tempo at o projtil
estar a uma distncia sh do ponto de lanamento t =
tempos so t d =
d
v0 cos
e t d +e =
sh
. Portanto, os
v0 cos
d +e
. Nestes momentos, a altura
v0 cos
descrita pelo movimento vertical, dado por s v = v0 sin t g
t2
. Novamente,
2
observa-se que esta informao no especialidade de quem escreve o

algoritmo, mas este precisa entender o que as frmulas indicam, mesmo
que no haja qualquer conhecimento sobre o que elas signifiquem
fisicamente. Assim, com estas equaes, possvel calcular a altura do
projtil nos dois momentos crticos e verificar se esto acima ou no do
objeto que precisa ser transposto.
jander moreira

O terceiro passo , finalmente, propor o algoritmo. Uma verso
inicial do algoritmo apresentada como Algoritmo 4-4.
Algoritmo 4-4
1
{ verificao se um projtil, lanado de um ngulo de graus em
relao ao solo colide ou no com um objeto situado em seu caminho,
3
4
sabendo-se a distncia do lanamento e a altura e espessura do objeto;

o resultado produzido verdadeiro se h coliso ou falso caso
contrrio }
6
7
{ A Figura 4-1 deve ser consultada para melhor referncia (apostila

de Construo de Algoritmos, pgina 4-5) }
8
9
10
algoritmo
declaraes
11
12
obtenha o ngulo, v0, a distncia do objeto, sua espessura e altura
13
calcule os momentos em que o projtil passa pelos limites
14
do objeto
15
calcule a altura do projtil nestes dois momentos
16
verifique se em algum destes dois momentos o projtil no
17
18
est acima da altura do objeto

escreva o resultado
19 fim-algoritmo
Refinando o algoritmo para chegar no nvel dos comandos vistos na

Unidade 2, uma nova verso obtida (Algoritmo 4-5).
Algoritmo 4-5
1
{ verificao se um projtil, lanado de um ngulo de graus em
relao ao solo colide ou no com um objeto situado em seu caminho,
sabendo-se a distncia do lanamento e a espessura e altura do objeto;
o resultado produzido verdadeiro se h coliso e falso caso
5
6
7
contrrio }
{ A Figura 4-1 deve ser consultada para melhor referncia (apostila
de Construo de Algoritmos, pgina 4-5) }
8
9
algoritmo
10
{ declaraes }
11
declare
12
ngulo, velocidadeInicial, distncia, espessura, altura,
13
momento1, momento2, alturaProjtil1, alturaProjtil2: real
14
colidiu: lgico
15
16
17
18
{ obteno do ngulo, v0, distncia do objeto,

sua espessura e altura }
leia(ngulo, velocidadeInicial, distncia, espessura, altura)
19
20
21
{ clculo dos momentos em que o projtil

passa pelos limites do objeto }
jander moreira

22
momento1 distncia/(velocidadeInicial * cos(ngulo * 3,1415/180))
23
momento2 (distncia + espessura)/
24
(velocidadeInicial * cos(ngulo * 3,1415/180))

{ 3,1415 aproximao para
25
26
na converso para radianos }
27
28
{ clculo da altura do projtil nestes dois momentos }
29
alturaProjtil1 velocidadeInicial * sen(ngulo * 3,1415/180) *
30
momento1 9,8 * pot(momento1, 2)/2
31
alturaProjtil2 velocidadeInicial * sen(ngulo * 3,1415/180) *
32
momento2 9,8 * pot(momento2, 2)/2
33
34
35
36
{ verificao se em algum desses dois momentos o projtil no

est acima da altura do objeto }
colidiu alturaProjtil1 altura e alturaProjtil2 altura
37
38
{ escrita do resultado }
39
escreva(Houve coliso?, colidiu)
{ escreve V ou F }
40 fim-algoritmo
Escrito o algoritmo, deve-se proceder a sua avaliao se est

correto. Para isso, preciso verificar para algumas situaes se o resultado
produzido o esperado. Esta avaliao feita pelo acompanhamento do
algoritmo passo a passo, realizando seus comandos e verificando se no h
problemas. Para a verso 2 (Algoritmo 4-5), nota-se que, caso uma das
alturas do projtil esteja igual ou menor que a altura do objeto (linha 35), o
operador e somente produz verdadeiro se ambas estiverem acima do
objeto, proporcionando um resultado incorreto. Desta forma, a linha 35
reescrita usando o operador ou.
35
colidiu alturaProjtil1 altura ou alturaProjtil2 altura
Um cuidado especial deve ser tomado nesta fase, pois o algoritmo

parecer funcionar corretamente muito diferente dele realmente realizar
sua tarefa a contento. Muitas vezes, mesmo um algoritmo bem testado
acaba por deixar passar algumas situaes nas quais h falha em sua lgica
de execuo.
Finalmente, verificado que no h mais problemas com os clculos e
os resultados produzidos, o algoritmo pode ser avaliado se pode ser
melhorado. Esta etapa pode ser mesclada em certos momentos com o
desenvolvimento (passo anterior). No exemplo apresentado, o resultado
pode ser considerado satisfatrio. Uma possvel melhoria poderia ser a
reduo do nmero de comandos, evitando o clculo das variveis
momento1 e momento2 pela substituio de suas expresses
diretamente no clculo das duas alturas do projtil. Como pode haver certo
comprometimento da clareza da soluo, optou-se, neste caso, por manter
a verso atual, embora a alterao proposta seja defensvel.
jander moreira

4.3.3 Resoluo de problemas por refinamentos sucessivos

Normalmente o desenvolvimento do algoritmo feito com papel e
lpis, e no em um computador ou editor de textos. Por isso, a abordagem
top-down para a construo dos algoritmos vem associada a uma notao
para indicar os detalhamentos, chamados refinamentos, de modo que no
seja preciso reescrever, a todo momento, todas as linhas das verses
anteriores do algoritmo.
Esta notao apresentada por meio de um novo exemplo de
desenvolvimento. Assim, deve ser considerado o seguinte problema: A
mdia final de um aluno da disciplina Clculo Numrico calculada com
peso 6 para a mdia de provas (considerando 2 provas), peso 2 para a
mdia de trabalhos prticos (4 trabalhos prticos) e peso 2 para o nico
seminrio. As mdias de provas e de trabalhos so mdias aritmticas
simples. preciso escrever um algoritmo para, dadas as notas de provas,
dos trabalhos e do seminrio, calcular a mdia final e determinar se o aluno
foi aprovado (mdia final maior ou igual a 6).
Embora seja um exemplo bastante simples, o objetivo aqui ilustrar
a notao dos refinamentos, os quais passaro a ter maior importncia da
Unidade 5 em diante.
O Algoritmo 4-6 mostra uma soluo para o problema proposto,
delineando a soluo de forma mais geral.
Algoritmo 4-6
1
{ calcular a mdia final e determinar a aprovao (mdia final >= 6),
dadas as notas de 2 provas, 4 trabalhos e um seminrio; as mdias de
provas e de trabalhos so mdias aritmticas simples e a composio
de pesos para a mdia final 6 para mdia de provas, 2 para mdia de
trabalhos e 2 para seminrio }
6
7
8
algoritmo
{ ref declarar variveis }
9
10
{ ref obter todas as notas }
11
{ ref calcular as mdias de provas e de trabalhos }
12
{ ref calcular a mdia final e verificar aprovao }
13
14
{ apresentao dos resultados}
15
escreva(mdiaFinal, aprovado)
16 fim-algoritmo
Pode-se observar que a estrutura de delineamento geral da soluo

a mesma j vista neste texto. A diferena que, ao invs do itlico usado
nas outras verses, usada a notao de comentrios e um indicador ref
para representar uma instruo ou passo que ainda precisa ser detalhada.
Pode ser visto tambm, que nas linhas 14 e 15 optou-se por no usar
refinamentos, pois se julgou desnecessrio.
jander moreira

Os detalhamentos necessrios podem ser feitos, agora, apenas para
os refinamentos especificados. O Algoritmo 4-7 mostra como fica o
refinamento para a linha 10 e o Algoritmo 4-8 para a linha 12.
Algoritmo 4-7
1
refinamento { obter todas as notas }
leia(prova1, prova2) { 2 provas }
leia(trabalho1, trabalho2, trabalho3, trabalho4) { 4 trabalhos }
4
5
leia(seminrio) { 1 seminrio }
fim-refinamento
Algoritmo 4-8
1
2
3
4
refinamento { calcular a mdia final e verificar aprovao }

mdiaFinal 0,6 * mdiaProvas + 0,2 * (mdiaTrabalhos + seminrio)
aprovado mdiaFinal 6,0
fim-refinamento
Esta uma notao formal que permite organizar tanto o raciocnio

quanto a documentao. Todos os elementos que foram indicados para
refinamento devem ser transformados em comentrios quando o algoritmo
final for passado a limpo em sua verso final. Em outras palavras, se a
linha de raciocnio indicou um refinamento necessrio, porque, de alguma
forma, ele importante como um elemento de organizao e merece,
portanto, o comentrio.
Naturalmente, um refinamento pode conter outros itens que sero
refinados e assim por diante, criando uma hierarquia de refinamentos
sucessivos. Um problema complexo se torna, deste modo, uma coleo de
problemas mais simples.
Voltando ao exemplo, a incorporao dos dois refinamentos
realizados (Algoritmo 4-7 e Algoritmo 4-8) deve produzir o Algoritmo 4-9.
Algoritmo 4-9
1
{ calcular a mdia final e determinar a aprovao (mdia final >= 6),
dadas as notas de 2 provas, 4 trabalhos e um seminrio; as mdias de
provas e de trabalhos so mdias aritmticas simples e a composio
de pesos para a mdia final 6 para mdia de provas, 2 para mdia de
trabalhos e 2 para seminrio }
6
7
8
algoritmo
{ ref declarar variveis }
9
10
{ obter todas as notas }
11
leia(prova1, prova2) { 2 provas }
12
leia(trabalho1, trabalho2, trabalho3, trabalho4) { 4 trabalhos }
13
leia(seminrio) { 1 seminrio }
14
15
{ ref calcular as mdias de provas e de trabalhos }
16
17
{ calcular a mdia final e verificar aprovao }
jander moreira

18
mdiaFinal 0,6 * mdiaProvas + 0,2 * (mdiaTrabalhos + seminrio)
19
aprovado mdiaFinal 6,0
20
21
{ apresentao dos resultados}
22
escreva(mdiaFinal, aprovado)
23 fim-algoritmo
Podem ser observadas a insero dos comandos refinados nos locais

apropriados e tambm a remoo da indicao ref, com a manuteno do
comentrio.
Outro ponto importante que os refinamentos no precisam,
necessariamente, ser feitos em ordem e, dentro de cada um deles, as
variveis que forem necessrias vo sendo criadas. claro que se deve
manter a coerncia entre as variveis comuns aos refinamentos, como o
caso da varivel lgica aprovados, que j aparece na verso inicial e
usada coerentemente nos refinamentos.
Nesta linha de raciocnio, o ltimo refinamento que deve ser feito o
das declaraes, pois somente aps terminados todos os outros que se
pode saber todas as variveis que sero necessrias.

A esta altura, comum que surja uma dvida sobre a real
necessidade dos refinamentos. A primeira razo que o exemplo
apresentado e tambm os prximos exemplos na Unidade 5 ainda so
relativamente simples. Mas essencial que esta metodologia, embora
parea enfadonha no incio, seja incorporada ao processo de raciocnio no
desenvolvimento. Infelizmente, embora alguns tenham o dom de resolver
problemas com facilidade, depende de cada um no rejeitar um mtodo que
ser de grande utilidade para a grande maioria.
Desta Unidade, alguns preceitos de grande importncia foram
abordados:
Para fazer um algoritmo, a fase de escrita somente a terceira
etapa; necessrio antes disso compreender o problema e saber
como ele pode ser resolvido (no algoritmicamente);
Ao se escrever um algoritmo, imprescindvel que uma viso geral
coerente de toda a soluo esteja bem definida; esta a chamada
verso inicial ou esboo inicial, a qual pode conter os itens que
devero ser refinados;
Utilizar os refinamentos auxilia no processo de raciocnio sobre a
elaborao da soluo, pois implica em quebrar um problema mais
complexo em outros mais simples e, em conseqncia, mais
facilmente tratados;
A quantidade de refinamentos que sero necessrios depende de
quem est escrevendo o algoritmo; o grau de maturidade e a prtica
tornam diversos problemas mais simples de ser tratados com o
tempo;
jander moreira

A prtica o principal modo para que os conhecimentos

apresentados nesta seo sejam corretamente aplicados e realmente
se tornem to teis quanto seu potencial permite.
jander moreira

Comandos condicionais
Unidade 5 -

A grande maioria dos problemas que so enfrentados na prtica no
possui soluo linear. Quase sempre necessrio fazer algo somente se
uma dada condio ocorrer. Desta forma, esta Unidade trata o caso da
execuo condicional de comandos sob o aspecto formal dos algoritmos.
Esta ferramenta (a execuo condicional) de extrema importncia
e, portanto, deve ser observada com ateno. Juntamente com este novo
tema, os conceitos sobre desenvolvimento estruturado e sobre a
organizao do desenvolvimento, abordados na Unidade 4, sero
retomados.
5.2 Situaes de deciso

Na Unidade 1, ao se fazer a introduo aos algoritmos, foi citado que
um algoritmo (no to formal quanto o que este texto apresenta) pode ser
aquele especificado como instrues para cadastrar um novo contato na
agenda do celular. Este algoritmo poderia ser ilustrado como: pressione
[Menu], selecione [Agenda] e opte por [Novo contato]; preencha o nome e
o telefone; pressione [Ok] para encerrar ou [Off] para cancelar.
As aes condicionais podem ser observadas em vrios momentos
deste procedimento, como na deciso se o telefone cadastrado ser
colocado na parte reservada para o nmero fixo, para o comercial ou para o
mvel; ou ainda, no final, na diferena do resultado caso a incluso seja
efetivada ou cancelada.
Estas decises dependem de certas condies, como: o nmero do
telefone que deve ser cadastrado o fixo ou o celular? no fim das contas,
vale realmente a pena cadastrar este contato? Ou ainda, de outras: o saldo
est positivo? ainda h contas para pagar? a luz do quarto ficou acesa? h
roupa no varal? ser que vai chover?
Tambm nos algoritmos existem condies que alteram o resultado
das aes em funo das situaes que forem ocorrendo.
5.3 Alterao condicional do fluxo de execuo

Os comandos condicionais so as instrues que o algoritmo tem para
verificar uma situao e alterar o fluxo de execuo em funo desta
situao. Como observado nas Unidades anteriores, o fluxo de execuo
sempre seqencial, seguindo a ordem das instrues. Esta regra no se
altera, pois o comando condicional considerado uma nica instruo e, em
seu interior so especificados os conjuntos de instrues que dependem
de condio.
Com vistas versatilidade, os comandos condicionais se apresentam
em dois formatos: o condicional padro e o de seleo mltipla.
O primeiro o comando condicional comum e mais importante
que o de seleo mltipla, pois tem uso mais geral. Tambm possvel
jander moreira

escrever um comando de seleo mltipla usando os condicionais padro,
de modo os de seleo mltipla podem ser considerados suprfluos,
embora sejam bastante prticos em muitas (porm restritas) situaes.
5.3.1 Condicionais simples e completos

O comando condicional completo escrito no formato indicado
abaixo, sendo que especificada uma condio lgica e dois grupos de
comandos.
se expresso_lgica ento
conjunto_de_comandos_caso_verdadeiro
seno
conjunto_de_comandos_caso_falso
fim-se
A lgica de execuo do comando simples: a avaliao da

expresso lgica feita e seu resultado calculado; se for verdadeiro,
somente o primeiro conjunto de comandos executado (especificados no
ento); se o resultado for falso, somente o segundo conjunto de
comandos executado (especificados pelo seno). A delimitao dos
conjuntos de comandos feita do ento at o seno para a parte se
verdadeiro e do seno at o fim-se para a parte se falso.
Por exemplo, o seguinte problema pode ser considerado: A mdia
final de um aluno calculada pela mdia aritmtica simples de duas provas
e sua aprovao depende desta mdia ter valor maior ou igual a 6. Escreva
um algoritmo que, dadas as notas de provas, escreva a mdia final e uma
mensagem que indique se houve ou no aprovao..
A partir da abordagem da Unidade 4, o primeiro passo entender o
problema. Como o caso simples, conclui-se que os dados de entrada so
somente duas notas (assumidas no intervalo de 0 a 10, incluindo os limites)
e o resultado esperado um valor real (a mdia, no mesmo intervalo) e
uma mensagem equivalente a aprovado ou reprovado.
O segundo passo conhecer a soluo no algortmica, que trivial,
pois basta somar as notas e dividir por 2 e, ento, comparar este resultado
com 6.
O terceiro passo , finalmente, a proposio do algoritmo. Cada aluno
deve se perguntar, neste momento, se cedeu tentao de comear a
escrever o algoritmo no primeiro passo!
Considerando a simplicidade do algoritmo, a proposta inicial no
inclui refinamentos, sendo apresentada no Algoritmo 5-1.
Algoritmo 5-1
1
2
{ clculo da mdia final de um aluno, feita pela mdia aritmtica de

duas provas, e escrever mensagem indicando aprovao ou reprovao }
3
4
5
algoritmo
declare notaProva1, notaProva2, mdia: real
6
7
{ leitura das notas }
jander moreira

8
leia(notaProva1, notaProva2)
9
10
{ clculo da mdia }
11
mdia (notaProva1 + notaProva2)/2
12
13
{ resultados }
14
escreva(mdia)
15
se mdia >= 6 ento
16
17
escreva(Aprovado :)...)
seno
18
19
escreva(Reprovado :(...)
fim-se
20 fim-algorimo
O comando condicional se um comando longo e ocupa as linhas de

15 a 19. A apresentao visual do comando importante, principalmente
medida que os problemas se tornarem mais complexos. Sugere-se
fortemente adotar o formato indicado no exemplo, com o alinhamento das
clusulas se, seno e fim-se.
No exemplo, a condio dada pela avaliao da expresso relacional
(se a mdia superior ou igual a 6), que resulta necessariamente em
verdadeiro ou falso. Se o resultado for verdadeiro, o nico comando
aps o seno executado e a mensagem Aprovado escrita; caso
contrrio, a mensagem Reprovado. (Uma confrontao entre este
algoritmo e o Algoritmo 4-9 pode ser feita, principalmente em relao ao
modo como o problema de verificao da aprovao feito.)
Muitas vezes o comando se no precisa da parte do seno, que pode
ser omitida. O formato simples do comando condicional apresentado
abaixo.
se expresso_condicional ento
conjunto_de_comandos_caso_verdadeiro
fim-se
Um exemplo de uso do comando condicional simples ilustrado no

Algoritmo 5-2, que apenas um trecho de um algoritmo do qual as partes
restantes foram omitidas.
Algoritmo 5-2
1
(parte omitida)
2
3
leia(saldo)
se saldo < 0 ento
leia(taxaJuros, nmeroDias)
valorDevedor abs(saldo) * taxaJuros * nmeroDias
saldo saldo valorDevedor
{ s se o saldo for devedor }
fim-se
9
10
(parte omitida)
jander moreira

No exemplo, se o valor do saldo no for devedor, nem a taxa de juros

nem o nmero de dias que a conta ficou negativa so solicitados, alm de
no ser preciso descontar este valor do saldo.
5.3.2 Aninhamento de comandos

Os comandos condicionais so a primeira forma de comandos que
possuem comandos subordinados. Em outras palavras, o condicional um
comando que incorpora outros comandos.
Os mesmos princpios de execuo que valem para o algoritmo so
obedecidos para o conjunto de comandos subordinados, como execuo
seqencial e execuo de um comando somente aps o anterior ter sido
encerrado.
O conjunto de comandos internos a um se pode incluir qualquer
tipo de comando, como atribuies, leituras ou outros comandos
condicionais. No h, portanto, restries. Quando h comandos
condicionais dentro de outros comandos condicionais, dito que os
comandos esto aninhados. Uma vantagem da notao utilizada que no
existe confuso entre o seno de um se com o dos outros.
No Algoritmo 3-3 (pgina 3-9) apresentada uma soluo para
verificar a classificao de um tringulo em funo dos comprimentos de
seus lados. Abaixo, o Algoritmo 5-3 mostra uma forma alternativa de
resolver o mesmo problema.
Algoritmo 5-3
1
{ determinar, dados os comprimentos dos lados de um tringulo, se o
tringulo pode ser formado (se existe) e qual o tipo dele (eqiltero,
issceles ou escaleno) }
4
5
6
algoritmo
declare
lado1, lado2, lado3: real
classificao: literal
9
10
{ leitura dos comprimentos dos lados }
11
leia(lado1, lado2, lado3)
12
13
se lado1 lado2 + lado3 ou lado2 lado1 + lado3 ou { existe? }
14
lado3 lado1 + lado2 ento
15
16
17
escreva(Os lados fornecidos no formam um tringulo)

seno
se lado1 = lado2 e lado2 = lado3 ento
classificao Eqiltero
18
19
20
seno
se lado1 = lado2 ou lado1 = lado3 ou
21
{ issceles? }
lado2 = lado3 ento

classificao Issceles
22
23
{ lados iguais? }
seno
jander moreira

classificao Escaleno
24
25
26
fim-se
fim-se
27
28
{ escrita da classificao }
29
escreva(classificao)
30
fim-se
31 fim-algoritmo
Devem ser observados, inicialmente, os limites de cada comando se,

finalizado cada um com seu respectivo fim-se. A primeira verificao
(linha) checa se os lados podem no compor um tringulo; se no for
possvel, a nica coisa feita escrever a mensagem indicativa, rejeitando a
execuo de todos os demais comandos (que esto no seno). A expresso
verificada na linha 16 resulta em verdadeiro somente se todos os lados
forem iguais e, se este comando chegou a ser executado, ento o tringulo
tem que existir e a verificao coerente. Se o comando se da linha 19 for
executado, sabe-se que o tringulo no eqiltero e, portanto, se houver
dois lados iguais (quaisquer que sejam), ento o tringulo issceles. Caso
esta ltima verificao resulte em falso, ento o tringulo no eqiltero
e nem issceles; portanto no mais necessria outra verificao para
concluir que escaleno, o que permite a atribuio direta indicada na linha
23. Pode-se notar que todos os comandos condicionais utilizados contm
um nico comando tanto na parte do ento quanto do seno, exceto o
iniciado na linha 12 (condio de inexistncia), cujo seno tem dois
comandos: um condicional e um comando de escrita. Este comando de
sada da linha 28 apresenta na tela o valor atribudo varivel
classificao e somente executado, naturalmente, caso o tringulo
exista e aps ser verificado seu tipo.
5.3.3 Comandos de seleo mltipla

Uma forma alternativa de fazer verificaes usando do comando
de seleo mltipla, tambm conhecido por caso.
caso expresso_inteira seja
lista_de_seleo
seno
conjunto_de_comandos_se_no_h_coincidncias
fim-caso
O comando caso funciona exclusivamente com uma expresso

inteira, cujo valor resultante avaliado para ser confrontado com cada item
da lista de seleo. Se no houver coincidncias, os comandos
especificados na parte do seno so executados.
A lista de seleo composta por um ou mais itens, que obedecem
ao formato abaixo.
lista_de_constantes: conjunto_de_comandos
jander moreira

Nesta especificao, a lista de constantes uma lista formada por

constantes inteiras, que sero confrontadas com o resultado da expresso
inteira. Caso haja uma coincidncia (igualdade), o conjunto de comandos
especificado ser executado; se no houver, os comandos sero ignorados.
A exemplificao do comando a melhor forma de entender seu
funcionamento. O Algoritmo 5-4 apresenta um algoritmo que, dada uma
idade, classifica a pessoa segundo algumas faixas etrias.
Algoritmo 5-4
1
{ classificao da faixa etria segundo um critrio arbitrrio }
2
3
4
algoritmo
declare idade: inteiro
5
6
{ leitura da idade }
leia(idade)
8
9
{ classificao }
10
caso idade seja
11
0:
escreva(beb)
12
1..10:
escreva(criana)
13
11..14:
escreva(pr-adolescente)
14
15..18:
escreva(adolescente)
15
16
17
18
19..120: escreva(adulto)
seno
escreva(Idade invlida ou sem classificao definida)
fim-caso
19 fim-algoritmo
A expresso inteira usada no comando caso formada apenas pela

varivel idade, que inteira. Portanto, o valor da varivel ser confrontado
com cada item da lista de seleo (cada linha um item). A primeira
alternativa indica que o valor vai ser comparado com 0; se for igual,
escrita a mensagem beb e o comando se encerra (como o ltimo
comando do algoritmo, este tambm termina). As demais opes usam
indicao de intervalo: 1..10 significa de 1 at 10, ou seja, 1, 2, 3..., 9 e
10. Se houver coincidncia da expresso (idade) com qualquer um destes
valores, ento o comando especificado executado e o caso terminado.
As demais linhas tambm especificam intervalos (de 11 a 14, de 15 a 18 e
de 18 a 120). Finalmente, o comando do seno somente ser executado
quando nenhuma das coincidncias ocorrer (ou seja, se idade tiver valor
menor que zero ou maior que 120).
importante salientar que considerado um erro se um mesmo valor
constante for colocado em mais que um item da lista de seleo, da mesma
forma que um erro usar variveis no lugar das constantes (no h como
garantir que no haja valores iguais em opes diferentes). Tambm no
necessrio que todo um intervalo de valores seja especificado, pois o seno
jander moreira

existe para este caso. Assim, as constantes especificadas podem ser
esparsas.
Como ocorre nos comandos condicionais, tambm na seleo mltipla
a parte do seno optativa, o que indica que, se no houver qualquer
coincidncia, nada ser executado e o comando subseqente ao caso
ganha vez.
Na relao de constantes, alm da constante isolada e do intervalo,
possvel especificar outras combinaes, usando-se a vrgula como
separador. O Algoritmo 5-5 exemplifica algumas possibilidades vlidas,
dadas fora de qualquer contexto, servindo apenas como ilustrao.
Algoritmo 5-5
1
{ ... }
caso valor1 + valor2/3 valor3/2 seja
-100..-1:
2, 3, 5, 7:
escreva(primo menor ou igual a 10)
1, 4, 6, 8..10:
escreva(no primo menor ou igual a 10)
15:
se valor1 > 0 ento
escreva(alguma coisa)
seno
escreva(outra coisa)
10
11
fim-se
20..30:
12
leia(idade)
se idade < 18 ento
13
escreva(Menor de idade)
14
seno
15
escreva(J atingiu a maioridade)
16
17
escreva(alguns valores negativos)
fim-se
16, 40, 80:
18
fim-caso
19
{ ... }
escreva(16, 40 ou 80...)
Embora, primeira vista, o comando parea bastante verstil (e o ,

em alguns casos), sua aplicao bastante limitada. Inicialmente,
possvel especificar apenas expresses inteiras. Outro ponto que, nas
constantes especificadas, somente possvel comparar por igualdade, o que
torna invivel usar o caso para verificar se uma expresso menor que
zero, por exemplo. incoerente, portanto, escrever um item da lista de
seleo no formato > 0: escreva(positivo), pois no faz sentido que um
valor inteiro seja igual a > 0.
5.3.4 Testes de mesa

O acompanhamento de um algoritmo j foi mencionado como a
quarta fase ao se abordar um problema (seo 4.3.2). Neste contexto,
acompanhar significa executar os comandos passo a passo e anotar as
modificaes impostas por eles nas variveis. O nome dado a este
acompanhamento manual teste de mesa.
jander moreira

Como acontece com os algoritmos, tambm para os testes de mesa
h tcnicas que facilitam o acompanhamento da execuo.
A estratgia de teste de mesa indicada nesta seo bastante
simples, porm muito til. Como um algoritmo especifica suas variveis
antecedendo os comandos, sempre possvel saber quais as variveis que
sero usadas. Deste modo, estas variveis podem ser o cabealho de uma
espcie de tabela de valores. Cada vez que um comando implica na
alterao de um valor de uma ou mais variveis, seu valor atual riscado e
o novo valor escrito logo abaixo. Com isso, torna-se bastante simples saber
o valor mais recente (atual) de uma varivel apenas consultando a tabela.
Considerando apenas alguns comandos apresentados no Algoritmo
5-6, a Figura 5-1 mostra histrico do acompanhamento das instrues. No
exemplo, todas as variveis so inteiras.
Algoritmo 5-6
1
{ ... }
valor1 10
valor2 valor1 * 5
valor3 valor1 + valor2/2
se valor3 < valor1 + valor2 ento
escreva(valor3, valor1 + valor2)
fim-se
valor1 valor1 + valor2
valor3 valor3/2
10
escreva(valor1, valor2, valor3)
11
{ ... }
valor1
valor2
valor3
sada
10
50
35
35 60
17
60 50 17
60
Figura 5-1. Teste de mesa para o trecho especificado em Algoritmo 5-6.
A prtica no uso do teste de mesa importante para que pequenos

erros conceituais ou falhas no entendimento de alguns detalhes sejam
detectados e, em conseqncia, corrigidos. Enfatiza-se que todos adotem
como hbito fazer os testes de mesa, mesmo no caso de algoritmos mais
simples.

Esta Unidade apresentou uma das ferramentas de controle do fluxo
de execuo dos algoritmos, os comandos condicionais, sem a qual
praticamente impossvel escrever um algoritmo. O condicional se um
comando simples em sua forma, mas us-lo requer treinamento e um
excelente conhecimento das expresses lgicas.
jander moreira

Fazer exerccios e test-los (com os testes de mesa), avaliando cada
expresso lgica com cuidado auxilia no entendimento do comando e
permite um bom domnio desta importante estrutura.
O comando de seleo mltipla, embora possua suas limitaes,
tambm importante, principalmente por permitir uma soluo simples,
clara e, em geral, elegante.
Finalmente, ressalta-se que os testes de mesa so essenciais para
que o funcionamento dos algoritmos seja plenamente compreendido.
comum que alguns alunos achem os algoritmos um tanto quanto nebulosos.
Se este for o caso, significa que os conceitos no foram compreendidos e
este o momento de tentar recuperar esta deficincia. O exerccio com os
testes de mesa acaba auxiliando bastante neste processo.
jander moreira

Comandos de repetio
Unidade 6 -
Comandos de repetio

Todo problema que pode ter uma soluo algortmica precisa de
entrada, sada, atribuio, condicionais e repeties. S isso. Claro que h
mais algumas coisas para ajudar no processo, mas esta Unidade, com
comandos que permitem repetir um conjunto de aes, encerra o conjunto
de estruturas de controle de fluxo. Ou seja, estes so os ltimos comandos.
Enquanto condicionais permitem que um conjunto de comandos seja
opcionalmente executado, os comandos de repetio so construdos para
habilitar a execuo de um conjunto de comandos diversas vezes.
Assim como no h algoritmos (a no ser os muito simples) que no
usem condicionais, praticamente no h algoritmos (a no ser os simples)
que no usem comandos de repetio.
6.2 Por que fazer de novo?

Situaes repetitivas so mais comuns no cotidiano do que se pode
perceber. Se uma receita de bolo requer que quatro gemas sejam colocadas
na massa, est subentendido que o processo pegue um ovo; quebre sua
casca; separe a clara; coloque a gema na tigela tenha que ser repetido
quatro vezes. Se o pneu do carro furou e preciso colocar o estepe no
lugar, o processo coloque a chave no parafuso; remova o parafuso;
coloque o parafuso em um lugar onde possa ser encontrado depois deve
ser repetido para cada parafuso (trs, quatro ou cinco vezes, geralmente,
dependendo do veculo). Na aula de desenho, os passos pegue uma folha
em branco; faa seu trabalho; avalie o que foi feito; se ficou ruim, jogue
fora devem ser repetidos at que se julgue o trabalho bom e este possa
ser entregue ao professor.
Alm disso, h tipos de repeties diferentes. Uma indica faa isso
tantas vezes e outra instrui faa isso at que tal situao seja alcanada.
Cada uma delas tem lgica diferente e se aplica a uma situao diferente.
Esta Unidade descreve quatro modos distintos de repetir.
6.3 Fluxo de execuo com repetio

Um comando de repetio corresponde a uma nica instruo,
mesmo que tenha vrias instrues internas a ele. Estas instrues
internas so consideradas subordinadas repetio.
O primeiro formato de comando de repetio bastante especfico:
usado quando se sabe quantas vezes o conjunto de comandos vai ser
repetido. algo como faa isso 10 vezes. Este comando denominado
para e tem seu formato geral indicado abaixo.
para identificador expresso_incio at expresso_fim faa
lista_de_comandos_subordinados
fim-para
jander moreira

Comandos de repetio
O identificador tem que se referir necessariamente a uma varivel

inteira, assim como tambm devem ser considerados inteiros os resultados
da expresso do valor de incio e da expresso de valor de fim. Se a
expresso no for inteira, o valor real truncado (i.e., tem sua parte
fracionria desprezada).
O comando se comporta primeiro fazendo a atribuio do valor inicial
varivel, que dentro do para chamada varivel de controle.
(Qualquer varivel inteira pode ser usada, mas somente uma varivel de
controle se estiver sendo usada no lugar do identificador do comando
para.) A seguir, o conjunto de comandos especificado executado uma
vez, sendo que o valor da varivel de controle vlido e pode ser usado.
Terminada a execuo, a varivel de controle incrementada de 1 e os
comandos executados novamente, sendo este processo repetido at que, na
ltima vez, a varivel tenha o valor especificado na expresso final.
Como exemplo, o Algoritmo 6-1 mostra como pode ser produzida
uma lista de converses de graus Celsius para Fahrenheit.
Algoritmo 6-1
1
2
{ algoritmo para gerar uma tabela de converso Celsius -> Fahrenheit

para valores de 0 a 40, de 1 em 1 }
3
4
5
algoritmo
declare celsius: inteiro { sempre inteiro, neste caso }
Fahrenheit: real { real, pois obtido pela converso }
7
8
{ repetio para os valores indicados }
para celsius 0 at 40 faa
10
11
12
fahrenheit celsius * 1,8 + 32

escreva(celsius,
<--->
, fahrenheit)
fim-para
13 fim-algoritmo
Este algoritmo exemplo possui um nico comando: o para que se

inicia na linha 9 e termina na linha 12, com o delimitador fim-para.
Subordinados a esta repetio esto os comandos das linhas 10 e 11. O
comando para se inicia atribuindo 0 varivel celsius e ento executando
os dois comandos internos (calculando o valor convertido e escrevendo
ambos). Escrito o primeiro par da tabela de converso, o valor de celsius
incrementado de um e os comandos internos so repetidos para o valor 1.
Depois h novo incremento e repetio para o valor 2, e depois para 3, para
4, e assim sucessivamente, at que a ltima repetio se d para o valor
40, que o valor final. Aps o para realizar todas as repeties, o
algoritmo termina, pois no h mais comandos. Porm, antes de terminar,
deve-se observar que o valor de celsius aps o para 41, ou seja, o
ltimo incremento sempre feito.
Para especificar melhor o comportamento da repetio com o para,
seguem algumas caractersticas importantes:
jander moreira

Comandos de repetio
1) A repetio do para ocorre sempre de forma a incrementar a varivel
de controle, sendo, portanto, sempre crescente;
2) Caso o valor inicial seja maior que o valor final, os comandos internos
no sero executados nenhuma vez e o valor da varivel de controle
ser simplesmente igual ao valor de incio (no haver incremento,
pois no houve execuo);
3) Se o valor de incio for igual ao valor de fim, os comandos sero
executados uma nica vez e a varivel de controle terminar com
valor incrementado de 1;
4) Alterar o valor da varivel de controle dentro do para considerado
erro de uso do comando;
5) Caso os valores de incio e de fim sejam formado por expresses que
usam variveis, estas expresses sero avaliadas somente uma vez
antes das repeties comearem; portanto, se houver modificao
dos valores das variveis, o nmero de repeties estimado
inicialmente no ser alterado.
valor sada
para valor 1 at 5 faa

escreva(valor)
fim-para
6
inicial 100
inicial valor sada
para valor 1 at 3 faa

escreva(inicial)
100
100
inicial inicial 10
fim-para
escreva(valor, inicial)
90
90
80
80
70
valorBase 15
para valor valorBase/3 at valorBase/2 { 5 a 7 }
valorBase valorBase 1
fim-para
escreva(valorBase)
valorBase valor sada
15
14
13
12
12
Figura 6-1. Exemplos de trechos de algoritmo com o comando para e seus

respectivos testes de mesa.
Pode-se notar que em todas as instncias do comando para a

varivel de controle (valor, em todos os exemplos) acaba com valor igual
jander moreira

Comandos de repetio
ao valor da expresso que indica o valor final acrescido de 1. Outra
observao pertinente que, dados os valores inicial e final, o nmero de
repeties claramente determinado (sempre igual a final inicial + 1). No
ltimo exemplo, ainda, o contedo da varivel valorBase alterado
durante a execuo da repetio, mas isso no modifica o nmero de vezes
que a repetio efetuada (lembrando que os valores de incio e fim so
avaliados uma nica vez, antes do incio do ciclo de repetio).
O comando para um comando bastante poderoso e usado
amplamente como ferramenta para realizar repeties e resolver
problemas. Lembrando-se de suas restries de uso, pode ser aplicado
sempre que se puder determinar, de antemo, quantas vezes o lao de
repetio ser realizado e os valores inicial e final que ter.
Porm, o comando para no pode ser usado em uma srie de
situaes, exatamente aquela em que no se sabe quantas vezes a
repetio ser feita. Um exemplo simples poderia ser dado para o caso de
se registrarem movimentaes (crditos e dbitos) em um saldo e parar
quando o saldo ficar negativo. No possvel saber quantas movimentaes
sero processadas, pois isso depende do saldo e dos valores de cada
movimentao; o saldo pode j estar negativo e nenhuma movimentao
ser feita, apenas uma movimentao j pode deixar o saldo negativo, ou
ento algumas centenas de movimentaes podem ocorrer, at que a
quantidade disponvel da conta se esgote.
Para estas situaes, h outros comandos de repetio. Estes se
apresentam com filosofias de operao levemente diferentes, mas sua
estrutura bsica similar.
O primeiro deles chamado de enquanto e tem sua estrutura
mostrada abaixo.
enquanto expresso_lgica faa
conjunto_de_comandos
fim-enquanto
Sua operao bastante simples: primeiro a condio especificada

avaliada e, sendo o resultado verdadeiro, o conjunto de comando
executado. Ao final de cada repetio, a condio novamente avaliada
para verificar se o conjunto de comandos ser executado novamente ou se
o comando ser encerrado.
Algoritmo 6-2
1
{ algoritmo que apresenta uma saudao para alguns nomes }
2
3
4
algoritmo
declare nome: literal
5
6
{ primeiro nome a ser lido }
leia(nome)
8
9
{ repetio que termina quando o nome for fim }
10
enquanto nome fim faa
jander moreira

Comandos de repetio
11
{ escreve a saudao }
12
escreva(Ol,, nome, , como vai?)
13
14
{ leitura do prximo nome }
15
leia(nome)
16
fim-enquanto
17
18
{ despedida }
19
escreva(No h mais ningum? Ento, tchau!)
20 fim-algoritmo
O Algoritmo 6-2 mostra um algoritmo simples que fica repetidamente

lendo nomes (todos em uma mesma varivel chamada nome, que
reaproveitada, esquecendo os nomes anteriores). Uma saudao simples
para cada nome escrita na tela, a no ser que o nome digitado seja fim,
o que causa o encerramento da repetio e o trmino do algoritmo com a
mensagem final de despedida (linha 19).
A Figura 6-2(a) mostra a execuo do algoritmo se os nomes escritos
forem Otvio, Pedro e Adalberto, seguidos de fim para terminar.
apresentado um teste de mesa comentado, indicando a operao de
processamento do algoritmo.
Outro exemplo tambm apresentado na Figura 6-2(b), que mostra
o comportamento do algoritmo quando fim a primeira (e nica) entrada
para o algoritmo.
nome
sada
Comentrio
Otvio
Ol, Otvio, como vai?
O nome lido na linha 7 e comparado,

na linha 10, com a constante fim;
como so diferentes, os comandos do
enquanto
so
executados:
a
mensagem escrita e um nome lido
novamente (linha 15).
Pedro
Ol, Pedro, como vai?
Pedro foi transferido na linha 15 para

a varivel nome e a primeira
repetio se encerra. O teste da linha
10 feito novamente e novamente
resulta
em
verdadeiro.
Nova
mensagem e nova leitura so feitas
(segunda repetio).
Adalberto
Ol, Adalberto, como vai?
Como Adalberto diferente de fim,

a terceira repetio feita, com
mensagem para Adalberto e leitura do
valor fim.
fim
No h mais ningum? Ento
Ao fim da terceira repetio, a

comparao da linha 10 finalmente
resulta em falso (fim fim) e o
enquanto se encerra, passando ento
para o escreva da linha 19, que o
ltimo comando do algoritmo.
tchau!
(a)
jander moreira

Comandos de repetio
nome
sada
Comentrio
fim
No h mais ningum? Ento
A leitura da linha 7 j coloca o valor

fim na varivel nome. Na linha 10,
feita a comparao do enquanto, que
j resulta em falso. Com isso, os
comandos internos no so executados
e a repetio encerrada. O prximo
comando executado (linha 19) e o
algoritmo termina.
tchau!
(b)
Figura 6-2. Teste de mesa para o Algoritmo 6-2. (O texto traz mais detalhes.)
Os exemplos de execuo ilustram a situao normal, na qual

vrios nomes so digitados e, depois, h o encerramento indicado pela
entrada fim, e uma situao limite, na qual fim indicado logo na
primeira vez. O algoritmo foi escrito para funcionar de forma harmoniosa
para ambas as situaes, evitando que uma mensagem como Ol, fim,
tudo bem? seja escrita.
O comando enquanto , portanto, um comando de repetio que
usado quando no se sabe quantas vezes a repetio ser feita, usando
para isso um teste de trmino superior (isto , no incio do comando).
Esta caracterstica faz com que o comando possa no ter seus comandos
internos executados nenhuma vez, como ilustrado na Figura 6-2(b). Outro
ponto relevante que, ao contrrio do para, no existe uma varivel de
controle. Isto quer dizer que no h restries ou incrementos automticos
envolvidos.
Nem sempre, entretanto, se deseja que a verificao seja feita antes
do conjunto de comandos, pois pode ser necessria a primeira repetio e,
depois, verificar se deve haver ou no outra execuo. Para esta situao
existe o terceiro tipo de comando, que se apresenta com duas alternativas,
ambas mostradas na seqncia.
faa
enquanto expresso_lgica
faa
at condio_lgica
Em cada uma delas h, primeiro, a execuo do conjunto de

comandos. Aps cada vez que houver a execuo, o teste ser feito para
verificar se haver nova repetio ou o encerramento do comando. Como o
comando se apresenta em dois modos diferentes, a primeira verso,
faa/enquanto, tem sua repetio continuada somente quando a
expresso lgica for avaliada como verdadeira. Na verso faa/at, a
repetio continuada somente quando a expresso lgica for avaliada
como falsa.
Como exemplos, o problema da tabela de converso de graus Celsius
para Fahrenheit revisitado, com uma pequena alterao. Escreva um
algoritmo que gere uma tabela de converso de graus Celsius para
jander moreira

Comandos de repetio
Fahrenheit, iniciando em 0 e terminando em 10, com intervalo de 0,5. O
Algoritmo 6-3 e o Algoritmo 6-4 mostram uma possvel soluo, a primeira
usando o faa/enquanto e outra o faa/at.
Algoritmo 6-3
1
2
{ gerao de uma tabela de converso de graus Celsius para Fahrenheit

de 0 a 10 (inclusive), de 0,5 em 0,5. }
3
4
5
algoritmo
declare celsius, fahrenheit: real
6
7
{ gerao da tabela }
celsius 0
faa
{ valor inicial }
10
{ calcula o valor convertido e escreve ambos }
11
12
escreva(celsius, <---> , fahrenheit)
13
14
{ passa para o prximo valor em Celsius }

celsius celsius + 0,5
15
16
enquanto celsius 10
17 fim-algoritmo
Algoritmo 6-4
1
2
{ gerao de uma tabela de converso de graus Celsius para Fahrenheit

de 0 a 10 (inclusive), de 0,5 em 0,5. }
3
4
5
algoritmo
declare celsius, fahrenheit: real
6
7
{ gerao da tabela }
celsius 0
faa
{ valor inicial }
10
{ calcula o valor convertido e escreve ambos }
11
12
escreva(celsius, <---> , fahrenheit)
13
14
15
16
{ passa para o prximo valor em Celsius }

celsius celsius + 0,5
at celsius > 10
17 fim-algoritmo
Em ambos os algoritmos, a condio de trmino gira em torno do

valor da varivel celsius, o qual alterado a cada ciclo da repetio, sendo
feito um acrscimo de 0,5 a cada lao da repetio. No Algoritmo 6-3
feita a verificao usando o menor ou igual, pois deve haver a prxima
execuo durante todo o tempo em que a varivel celsius permanecer
abaixo de 10 ou for igual a este valor. A condio do at a oposta do
anterior, e no Algoritmo 6-4, feita a verificao por maior que 10 (ou
jander moreira

Comandos de repetio
seja, no menor ou igual); neste caso, quando a condio for verdadeira,
o ciclo de repetio encerrado, o que ocorrer quando celsius tiver valor
10,5.
O acompanhamento de ambos os algoritmos com o teste de mesa
muito importante para compreender como cada instruo executada e
como o controle de trmino da repetio considerado.
Por ser importante, a diferena dos comandos enquanto e do
comando faa (em qualquer verso) novamente salientada: o enquanto,
por fazer o teste no incio, pode executar seus comandos internos zero ou
mais vezes; os comandos faa, por sua vez, podem executar os comandos
subordinados uma ou mais vezes, j que o teste feito no final do
comando.
6.3.1 Condies de execuo de repetio: estado anterior, critrio

de trmino, estado posterior
Todos os comandos de repetio so, de certa forma, traioeiros.
muito freqente escrever as repeties e, devido falta de cuidado, haver
uma repetio a mais ou uma a menos. Em outras palavras, uma repetio
que deveria ocorrer 100 vezes pode ser feita 99 ou 101 vezes, o que
certamente ocasionar um erro no resultado esperado para o algoritmo. Em
especial este erro menos comum no uso do para, quando comparado aos
outros comandos de repetio.
Por este tipo de equvoco ser freqente e at provvel de acontecer,
so recomendados alguns cuidados importantes quando repeties forem
usadas.
No caso do para, a recomendao verificar com ateno as
expresses que so usadas para indicar os valores inicial e final da
repetio. O ponto chave lembrar que ambas as expresses so inteiras e
que, se um valor real for usado, deve-se dar ateno especial se se deseja
truncar ou arredondar o resultado. Por exemplo, se a repetio iniciar em 1
e for at o resultado da expresso 188,0/10, a repetio de 1 a 18; se for
de 1 at arred(188,0/10), o valor final ser 19. Essa diferena pode
produzir um resultado incorreto, dependendo da situao.
Assim, para cada repetio devem ser verificados seu estado
anterior, ou seja, o valor da variveis que participam das condies de
trmino da repetio antes dela se iniciar, o critrio de trmino, que at
quando a repetio continua, e o estado posterior, que so os valores
aps o encerramento da repetio.
O comando para tem essa verificao mais simples: a nica varivel
que participa da condio de execuo a varivel de controle e seus
valores inicial e final so fornecidos atravs das expresses. O cuidado deve
ser tomado segundo as recomendaes de converses entre reais e inteiros
indicadas acima. Portanto, o estado anterior a atribuio automtica do
primeiro valor varivel; o critrio de trmino haver repetio a ser feita,
o que depende do valor final; e o estado posterior o valor final acrescido
de 1, caso tenha havido pelo menos uma execuo dos comandos internos,
ou o prprio valor inicial, se nenhuma repetio tiver ocorrido.
jander moreira

Comandos de repetio
Para os demais comandos, preciso ter mais cuidado, visto que no
h varivel de controle. Para estes, necessrio verificar a expresso lgica
usada no comando. Todas as variveis usadas nesta expresso, alm de
algumas outras que contribuem para que seus contedos sejam alterados,
so importantes. O critrio de trmino depende no somente da expresso,
mas tambm de como as variveis so alteradas nos comandos internos.
Por fim, o estado posterior deve ser avaliado para os valores envolvidos na
expresso lgica e para os valores correlatos (i.e., que contribuem para
seus valores).
Observar cada repetio com cuidado evita problemas e, em
conseqncia, incorrees nos algoritmos. A prtica ajuda a avaliar as
situaes que se apresentam e, portanto, o treino e a realizao de
exerccios com ateno so fundamentais para dominar estes conceitos.
6.3.2 Aplicaes prticas de repeties

O princpio de funcionamento das repeties no extremamente
complexo. Porm, conseguir extrair proveito de suas caractersticas para
resolver problemas pode ser um desafio. Nesta seo sero cobertos alguns
dos usos comuns de repeties, atravs de exemplos.
A primeira aplicao , naturalmente, a de repetio de tarefas que
ocorrem vrias vezes, como j foi exemplificado nos algoritmos anteriores.
Outro exemplo: A mdia final de uma disciplina calculada pela mdia
aritmtica simples de trs provas. Escreva um algoritmo que, dado o
nmero de alunos de uma turma e suas notas de provas, calcule para cada
um deles sua mdia final.. Um algoritmo para este problema o Algoritmo
6-5, no qual a varivel i usada somente para contar os alunos.
Algoritmo 6-5
1
2
{ calcular a mdia de trs provas para cada aluno de uma turma, dado o
nmero de alunos e as notas das provas }
3
4
5
algoritmo
declare
i, nmeroAlunos: inteiro
prova1, prova2, prova3, mdia: real
8
9
{ obteno do nmero de alunos }
10
leia(nmeroAlunos)
11
12
{ clculo da mdia para cada aluno }
13
para i 1 at nmeroAlunos faa
14
{ obteno das notas }
15
leia(prova1, prova2, prova3)
16
17
{ clculo e escrita dos resultados }
18
mdia (prova1 + prova2 + prova3)/3
19
20
escreva(mdia)
fim-para
21 fim-algoritmo
jander moreira

Comandos de repetio
Outras aplicaes envolvem tarefas comuns em algoritmos, como por

exemplo, determinar o maior (ou o menor) valor de um conjunto de dados,
realizar somas de vrios valores, calcular a mdia, contar o nmero de
ocorrncias de uma determinada situao, ou ento combinaes entre
elas.
Os primeiros exemplos so de determinao do maior valor em um
conjunto de dados. Naturalmente a determinao do menor valor
bastante similar e ser apenas comentada. Para tanto, o problema o
seguinte: Uma adega possui uma relao de seus vinhos, contendo nome
do produto, seu preo e seu tipo (tinto, branco ou ros). O nmero total de
garrafas no conhecido inicialmente, mas convenciona-se que se o nome
do vinho for fim significa que a relao se encerrou. Escreva um algoritmo
para ler a lista de vinhos e indicar o produto mais caro, dando seu nome,
seu preo e seu tipo. Assuma que no existam dois vinhos com o mesmo
preo * ..
O Algoritmo 6-6 resolve o problema usando uma estratgia simples.
Uma varivel (chamada preoMaior) iniciada com um valor abaixo do
menor preo possvel (que pode at ser R$0,00, se o vinho for de graa).
Para cada vinho, seu preo comparado com o valor armazenado em
preoMaior e, se for maior que este, o novo vinho mais caro registrado.
Alm do preo, tambm so guardados seu nome e tipo, para que sejam
escritos posteriormente.
Algoritmo 6-6
1
{ dados o nome, o preo e o tipo dos vinhos (indicados aqui por T para
tinto, B para branco ou R para ros, descrever o vinho mais caro;
no so considerados vinhos de preos iguais;
fim dos dados indicado por nome = fim }
5
6
algoritmo
declare
nome, nomeMaior,
tipo, tipoMaior: literal
10
preo, preoMaior: real
11
12
{ repetio para leitura dos dados }
13
preoMaior -1
14
faa
{ para forar a troca na primeira verificao }
15
{ dados }
16
leia(nome, preo, tipo)
17
18
{ verificao do maior preo }
19
se preo > preoMaior e nome fim ento
20
nomeMaior nome
21
preoMaior preo
22
tipoMaior tipo
Esta restrio para evitar o problema de dois ou mais vinhos empatados como mais caros.
jander moreira

Comandos de repetio
23
fim-se
24
at nome = fim
25
26
{ apresentao do resultado }
27
se preoMaior = -1 ento
28
29
escreva(Nenhum vinho foi apresentado.)

seno
30
31
escreva(nomeMaior, preoMaior, tipoMaior)

fim-se
32 fim-algoritmo
H ainda duas observaes pertinentes quanto soluo. A primeira

que, caso na primeira informao seja digitado fim para o nome (e
quaisquer valores para preo e tipo), o valor de preoMaior chega ao final
inalterado, o que permite saber que no houve entradas e, portanto, no h
resultados. A outra que, na linha 19, a comparao se o nome do vinho
no fim necessria para que os dados de um vinho chamado fim,
que no existe, no sejam considerados como vlidos ao se achar o mais
caro. Fica como exerccio pensar como alterar o algoritmo para que o vinho
mais barato seja encontrado. Neste caso, qual seria o valor inicial para uma
eventual varivel preoMenor? Para se pensar no assunto, pode-se
assumir que no h nenhum vinho com valor acima de R$200,00.
Em muitas situaes, quando no h limites para o intervalo de
variao da varivel cujo maior valor (ou o menor) se deseja achar, a ttica
de colocar um valor inicial pequeno no funciona. Por exemplo, suponha
que se precise achar a menor temperatura de um conjunto. Caso se opte
por colocar a maior temperatura com valor inicial -1 e todas as
temperaturas que forem entradas estiverem abaixo deste valor, nunca
haver troca e, portanto, o algoritmo falha. Se se optar por usar -100 no
lugar do -1, pode ser que todas as temperaturas sejam abaixo de -100 e o
algoritmo falha de novo. Esta tcnica funciona apenas quando se sabe que
h um limite para os valores. O Algoritmo 6-7 apresenta uma soluo para
o seguinte problema: Dado um conjunto de temperaturas e conhecendo-se
a quantidade de itens de entrada, determinar a menor temperatura,
escrevendo um algoritmo que indique este resultado..
Algoritmo 6-7
1
2
{ determinar a menor temperatura de um conjunto, sabendo-se a quantidade

de valores disponveis }
3
4
5
algoritmo
declare
i, nmeroEntradas: inteiro
temperatura, menorTemperatura: real
8
9
{ obteno da quantidade de itens }
10
leia(nmeroEntradas)
11
12
13
se nmeroEntradas 0 ento
escreva(No h dados; portanto no h menor temperatura)
jander moreira

Comandos de repetio
14
seno
15
{ leitura da primeira temperatura, em separado }
16
leia(temperatura)
17
menorTemperatura temperatura { a primeira a menor }
18
19
{ repetio para leitura das outras temperaturas}
20
para i 2 at nmeroEntradas faa
21
{ leitura}
22
leia(temperatura)
23
24
25
se temperatura < menorTemperatura ento

menorTemperatura temperatura
26
27
fim-se
28
fim-para
29
30
{ resultado }
31
escreva(menorTemperatura)
32
fim-se
33 fim-algoritmo
Nesta ltima soluo, a primeira temperatura lida em separado e,

como a nica at o momento, ela considerada a menor. O comando
para da linha 20 faz a leitura para os itens restantes (notando-se que
comea em 2, e no em 1), comparando-os com o primeiro ou com o menor
at o momento. Neste caso, independentemente das temperaturas que
forem informadas, o resultado correto ser fornecido, no sendo necessrio
conhecer a faixa de variao das temperaturas.
Outra aplicao prtica bastante usual para as repeties contar.
Isso pode ser ilustrado pelo Algoritmo 6-8, que resolve o seguinte
problema: Conhecendo-se a quantidade de pessoas de um grupo e suas
idades, escrever um algoritmo que indique quantas so maiores de idade
(referncia a 18 anos) e qual a porcentagem destes que tm idade acima de
60 anos..
Algoritmo 6-8
1
{ determinar, dadas uma quantidade conhecida de pessoas e suas idades,
quantas so maiores de 18 (maior ou igual) e, dentre estas, a
porcentagem de pessoas acima de 60 anos }
4
5
6
algoritmo
declare
i, nmeroPessoas,
conta18, conta60: inteiro
9
10
{ obteno da quantidade de pessoas }
11
leia(nmeroPessoas)
12
13
{ contagem de maiores de idade e de acima de 60 anos }
jander moreira

Comandos de repetio
14
conta18 0
15
conta60 0
16
para i 1 at nmeroPessoas faa
17
{ leitura da idade }
18
leia(idade)
19
20
{ analisa a idade }
21
se idade 18 ento
22
conta18 conta18 + 1 { conta mais 1 }
23
se idade > 60 ento

conta60 conta60 + 1
24
25
fim-se
26
27
fim-se
fim-para
28
29
{ resultados }
30
se conta18 = 0 ento
31
32
escreva(No h maiores de idade nem sexagenrios)

seno
33
escreva(H, conta18, pessoas maiores de idade)
34
escreva(Destas,, 100,0 * conta60/conta18,
35
36
% tm mais de 60 anos)
fim-se
37 fim-algoritmo
O uso de contadores, normalmente dentro de condicionais, mas no

necessariamente, feito comeando com zero e, quando preciso,
incrementando o valor de 1. Tambm muito freqente ser necessrio, no
final, verificar se houve contagem, pois sempre h o risco de diviso por
zero (como na linha 34, se no houvesse sido feita a verificao).
De forma similar aos contadores, tambm possvel fazer somas e,
em decorrncia delas, calcular mdias. Problema: Uma loja de informtica
possui uma lista de preos de DVDs virgens de vrias marcas, juntamente
com as quantidades em estoque de cada um. Deseja-se saber, a partir da
relao de preos e quantidades, o valor total dos DVDs e o preo mdio da
unidade. Escreva um algoritmo para processar os dados e escrever estes
resultados. Como o nmero de itens no est disponvel, deve-se considerar
que a lista termina quando for digitado o valor zero tanto para preo quanto
para quantidade.. Uma soluo apresentada no Algoritmo 6-9.
Algoritmo 6-9
1
{ dada uma relao de preos e quantidade relativas a mdias de DVD
virgens, calcular o valor total em estoque (em reais) e o preo mdio
da unidade de DVD; o fim dos dados indicado por preo e quantidade
iguais a zero }
5
6
7
algoritmo
declare
jander moreira

Comandos de repetio
9
10
{ valores iniciais dos contadores }
11
nmeroItens 0
12
valorTotal 0
13
somaUnitrios 0
14
15
{ leitura dos dados }
16
leia(preo, quantidade)
17
enquanto preo 0 e quantidade 0 faa
18
{ conta e acumula }
19
nmeroItens nmeroItens + 1
20
valorTotal valorTotal + preo * quantidade
21
somaUnitrios somaUnitrios + preo
22
23
{ obtm o prximo item }
24
leia(preo, quantidade)
25
fim-enquanto
26
27
{ resultados }
28
escreva(Valor total: R$, valorTotal)
29
se nmeroItens = 0 ento
30
31
escreva(No possvel calcular o preo mdio unitrio)

seno
32
escreva(Valor unitrio mdio: R$,
33
34
1,0 * somaUnitrios/nmeroItens)
fim-se
35 fim-algoritmo
Somas tambm usam, geralmente, a ttica de iniciar o acumulador

com zero e, sucessivamente, ir somando a ele os valores que forem
necessrios.
Um problema alternativo que utiliza somas a classe que calcula
valores por aproximao. Um exemplo o fato de o valor do cosseno de um
arco poder ser calculado por uma soma. claro que a soma precisaria ser
infinita para que os resultados fossem iguais, mas o caso mais comum se
contentar
com
uma
aproximao.
Assim,
pode-se
escrever
cos x = 1
x2 x4 x6
+
+ ... e, deste modo, elaborar um algoritmo para, dado
2! 4! 6!
um valor de arco, aproximar seu cosseno. Uma proposta o Algoritmo

6-10.
Algoritmo 6-10
1
2
{ dado o comprimento de um arco, calcular seu cosseno pela soma

cos(x) = x^i/i! para um dado nmero de termos }
3
4
5
6
algoritmo
declare i, termo, baseFatorial, fatorial: inteiro
cosseno, ngulo: real
jander moreira

Comandos de repetio
8
{ leitura do arco e do nmero de termos }
leia(ngulo, nmeroTermos)
{ ngulo em radianos }
10
11
{ clculo da aproximao do cosseno }
12
cosseno 0
13
baseFatorial 1
14
fatorial 1
15
termo 1
16
para i 1 at nmeroTermos faa
{ acumulador do resultado }
17
{ faz o somatrio }
18
se i % 2 = 1 ento
19
20
cosseno cosseno + termo
{ soma termos mpares }
cosseno cosseno termo
{ subtrai termos pares }
seno
21
22
fim-se
23
24
{ calcula o prximo termo }
25
fatorial fatorial * baseFatorial * (baseFatorial + 1)
26
baseFatorial baseFatorial + 2
27
termo pot(x, i + 1)/fatorial
28
fim-para
29
30
{ resultado calculado }
31
escreva(cos(, ngulo, ) = , cosseno)
32 fim-algoritmo
Neste algoritmo alguns pontos podem ser destacados. Inicialmente,

h o cuidado para que o somatrio considere os termos positivos e
negativos, o que feito somando os termos de posies pares e subtraindo
o das mpares. No caso, o resto de uma diviso inteira por 2 sempre zero
para pares e 1 para mpares. Outro detalhe o controle do fatorial, que se
inicia com 1, pois haver sucessivas multiplicaes (e no ajuda multiplicar
por zero), e o controle tambm da base do fatorial. Como a cada passo so
multiplicados dois fatores (2!, 4!, 6!...), as duas multiplicaes so feitas de
uma vez (linha 25).
O ltimo exemplo: Um nmero inteiro maior que zero chamado de
nmero perfeito quando a soma de todos seus divisores (exceto o prprio
nmero) tiver valor igual a ele. Por exemplo, 28 perfeito, pois
1+2+4+7+14 = 28. Escreva um algoritmo que leia um nmero inteiro
qualquer e determine se ele perfeito.. O Algoritmo 6-11 ilustra uma
soluo.
Algoritmo 6-11
1
2
{ dado um nmero inteiro, determinar se um nmero perfeito, ou seja,

se igual soma de seus divisores, exceto ele mesmo }
3
4
5
algoritmo
declare
jander moreira

Comandos de repetio
7
{ leitura do nmero }
leia(valor)
9
10
{ soma dos divisores de valor }
11
soma 0
12
para i 1 at valor/2
13
se valor % i = 0 ento
soma soma + i
14
15
16
{ soma somente se for divisor }
fim-se
fim-para
17
18
{ resultado }
19
se soma = valor e valor 0 ento
20
21
22
23
escreva(valor, um nmero perfeito)

seno
escreva(valor, no um nmero perfeito)
fim-se
24 fim-algoritmo
O truque deste algoritmo somente fazer a soma dos termos que

interessam. No caso, somar os divisores (ou seja, aqueles que dividem
valor e deixam resto zero). Um outro detalhe que o comando para vai
somente at a metade do caminho; isso porque no existem divisores
que sejam maiores que a metade de um dado nmero. Ficam como
exerccio para o leitor determinar a razo da comparao com zero na linha
19 e porque os nmeros negativos so tratados de forma adequada pelo
algoritmo.

As repeties so a alma do processamento de dados. Por meio delas
so indicadas tarefas executadas diversas vezes ou para um grande nmero
de valores.
As diferenas entre os trs tipos de comandos de repetio um
ponto crucial: o para usado quando se sabe o primeiro e o ltimo valor da
repetio, que usa somente inteiros e vai sempre de 1 em 1; o enquanto
um comando mais livre, sem varivel de controle, que testa condies
simples ou complexas, sendo a verificao feita antes da execuo dos
comandos internos; e o par faa/enquanto e faa/at definem repeties
livres como as do enquanto, mas o teste feito sempre depois da
repetio. Entender estas diferenas ajuda a usar o comando mais
adequado a cada situao.
Finalmente, preciso reforar que repeties so utilssimas. Dentre
os exemplos vistos, podem ajudar a localizar o maior ou o menor do
conjunto, somar valores, cont-los e calcular mdias. Outras aplicaes de
repeties incluem busca por valores, determinao da ocorrncia ou no
de uma condio para um conjunto de dados ou fazer clculos especficos,
como determinar o mximo divisor comum entre dois valores inteiros.
jander moreira

Ponteiros
Unidade 7 -
Ponteiros

Esta uma Unidade curta. Seu objetivo dar uma noo geral e
precisa do que so ponteiros. Os ponteiros so um tipo de varivel de
ampla utilizao em algoritmos, mas so considerados como estruturas
avanadas.
Ponteiros so teis para disciplinas como Estruturas de dados e
Organizao e recuperao da informao. Com eles possvel usar
partes da memria sem precisar declarar uma varivel para cada parte
usada e estruturar dados de forma mais complexa (naturalmente mais
difcil, mas com vantagens compensadoras).
Esta Unidade, porm, visa apenas fornecer condies para que os
alunos entendam o que um ponteiro e como podem ser usados para
manipular a memria. o bsico do bsico; por isso o assunto breve.
7.2 Uma questo de organizao

Um aluno aplicado cumpre suas tarefas com afinco. Faz exerccios,
estuda, faz anotaes, escreve textos e ensaios. Para isso, utiliza um
caderno, por exemplo. Este caderno a sua memria de estudos. Se o
volume de coisas feitas no caderno for muito grande e for necessrio
localizar as coisas, vrios recursos podem ser usados para ajudar na
localizao de coisas importantes. Uma alternativa seria comprar uma
coleo de etiquetas que colam e descolam, multicoloridas, e encher o
caderno de orelhas com pequenas anotaes. Outra, seria numerar as
pginas e manter, normalmente a um grande custo, um ndice remissivo
para o contedo. Em ambas, contar com a memria natural sempre til,
tambm.
Organizar os dados importante sempre, desde o uso da organizao
mais simples at a mais elaborada. O esquema de organizao foco
para que sejam localizadas as informaes e para relacion-las umas s
outras.
7.3 Ponteiros e endereos na memria

No modelo de computador, o algoritmo e os dados so armazenados
na memria. A unidade de processamento executa o algoritmo, o qual d
instrues para que os dados sejam transformados de forma a produzir a
resposta pretendida. Esta foi a Unidade 2.
Uma questo importante que no foi detalhada a relao entre uma
varivel e a memria. J se sabe que uma varivel usa uma parte da
memria para guardar um valor; sabe-se tambm que seu tipo determina
como este valor armazenado e interpretado. Outra coisa conhecida que
a posio de memria localizada corretamente, pois dado um nome para
ela, que o identificador.
jander moreira

Ponteiros
7.3.1 Memria e endereamento

Para especificar melhor a relao entre a memria e as variveis,
preciso colocar que, para organizar a memria, existe um esquema de
endereamento. Desta maneira, toda parte da memria tem um
endereo, que sua posio. Portanto, toda varivel tem seu endereo e
quando um algoritmo usa o identificador da varivel, a unidade de
processamento sabe que aquele identificador est associado a um
endereo e, assim, consegue localizar o dado na memria.
Embora existam diversos esquemas de endereamento, usualmente a
memria pode ser pensada como uma coleo finita de unidades (chamadas
de bytes em um computador real) e cada uma delas tem um endereo. Este
endereo usualmente comea em zero e vai at o nmero total de unidades
menos 1. Em uma memria real de 1Gbyte, existem 1.073.741.824 de
unidades, que podem ser identificadas pelos nmeros de 0 at
1.073.741.823, por exemplo. Nem sempre o endereamento feito desta
forma, mas importante que se saiba que sempre h um endereamento.
7.3.2 Acesso memria com ponteiros

Voltando Unidade 2, relembra-se que tanto os dados quanto os
algoritmos esto na memria. Portanto, tudo o que o computador
armazena, que na memria, tem endereo.
Nos algoritmos existe um tipo abstrato de dados que foi
propositalmente ignorado at agora: o tipo ponteiro. Uma varivel do tipo
inteiro guarda valores inteiros, variveis reais guardam reais, as literais
guardam textos e as do tipo lgico guardam verdadeiro ou falso. As
variveis do tipo ponteiro guardam endereos.
O Algoritmo 7-1 mostra um exemplo simples de variveis do tipo
ponteiro.
Algoritmo 7-1
1
2
{ dadas duas variveis, uma inteira e outra literal, escrever os

endereos de memria na qual esto armazenadas }
3
4
5
algoritmo
declare
valorReal: real
valorLiteral: literal
endereoReal: real
{ endereos de variveis reais }
endereoLiteral: literal
{ endereos de variveis literais }
10
11
{ armazenamento dos endereos }
12
endereoReal &valorReal
13
endereoLiteral &valorLiteral
14
15
{ escrita do resultado }
16
escreva(A varivel real est no endereo:, endereoReal)
17
escreva(A varivel literal est no endereo:, endereoLiteral)
18 fim-algoritmo
jander moreira

Ponteiros
Existe um operador unrio & que resulta em um endereo de seu

operando. Este operador permite obter o endereo de praticamente
qualquer coisa que exista em um algoritmo, mas usado normalmente com
variveis. Deste modo, a expresso &valorReal resulta no endereo da
memria na qual a varivel est armazenada. A situao a mesma para a
expresso que retorna o endereo de valorLiteral. bom saber, tambm,
que se uma varivel precisar de muitas unidades de memria (que o caso
das variveis literais, evidentemente), o operador & retorna o endereo da
primeira unidade, ou seja, do comeo da rea de memria.
As variveis do tipo ponteiro so variveis como quaisquer outras,
possuindo um identificador, ocupando sua poro de memria e tendo,
tambm, seu prprio endereo. A expresso &endereoReal resulta na
posio de memria na qual a varivel endereoReal est armazenada.
Uma terminologia comum quando se usam ponteiros o termo
apontar. Como uma varivel ponteiro contm o endereo de outra varivel,
diz-se que ela aponta para a varivel. No Algoritmo 7-1,
endereoLiteral, aps a atribuio da linha , aponta para valorReal.
Uma forma de se pensar nesta terminologia um tanto confusa
lembrando que os termos apontar e endereo tm significado similar
neste contexto. Uma varivel aponta para outra se contiver seu endereo.
Isto tambm significa que a segunda apontada pela primeira.
A grande pergunta, ainda, : para que servem os ponteiros?.
A resposta mais simples vem do fato de se poder mexer no dado
guardado na memria se for conhecido apenas seu endereo. O Algoritmo
7-2 mostra como isso pode ser feito, introduzindo tambm a notao
pertinente.
Algoritmo 7-2
1
{ dada uma varivel, modificar seu contedo usando apenas seu endereo }
2
3
4
algoritmo
declare valor: inteiro
ponteiro: inteiro
{ um inteiro comum }
{ um ponteiro para inteiro }
6
7
{ atribuio de um dado inicial }
valor 100
9
10
{ determinao do endereo da varivel }
11
ponteiro &valor
12
13
{ uso do ponteiro para mexer na memria }
14
ponteiro 200
15
16
{ verificao do valor armazenado em valor }
17
escreva(valor)
{ 200!!! }
18 fim-algoritmo
jander moreira

Ponteiros
O Algoritmo 7-2 usa a varivel ponteiro, que guarda o endereo de
variveis inteiras, para saber onde a varivel valor est na memria. Isso
feito na linha 11.
A instruo na linha 14, por sua vez, pode ser lida da seguinte forma:
atribua posio de memria apontada por ponteiro o valor 200. Mais
simples seria dizer o contedo de ponteiro recebe 200. Por contedo
de entende-se o valor apontado pela varivel. O efeito do comando ,
portanto, armazenar o valor da expresso (200) na posio de memria,
que coincide com a posio de valor. Na prtica, houve a alterao do
contedo armazenado na varivel valor de forma indireta.
Pode-se observar que os ponteiros possuem um tipo relacionado, isto
, apontam para um tipo especfico (ponteiro para inteiro, ponteiro para
real etc.). Assim como uma varivel tem seu tipo para saber o que
armazenado na rea de memria reservada para ela, tambm o ponteiro
deve conhecer este tipo para tambm armazenar dados de maneira
coerente.
Uma das grandes utilidades de ponteiros dar a possibilidade de
modificar os dados armazenados na memria, sabendo-se apenas onde
esto. Com isso vivel alterar indiretamente o valor das variveis e, como
caso prtico, possvel escrever uma nica seqncia de comandos que
cada hora manipula uma varivel diferente, pois em momentos diferentes
pode apontar para localizaes diferentes.
O Algoritmo 7-3 ilustra como um mesmo trecho de cdigo pode, em
momentos diferentes, modificar variveis diferentes.
Algoritmo 7-3
1
2
{ exemplo de modificao de variveis diferentes usando o mesmo conjunto

de comandos }
3
4
5
algoritmo
declare
nmeroPassos,
valor1, valor2: inteiro
Ponteiro: inteiro
9
10
{ atribuies iniciais }
11
valor1 0
12
valor2 0
13
14
{ repetio }
15
leia(nmeroPassos)
16
para i 1 at nmeroPassos faa
17
{ escolha da varivel }
18
se i % 5 = 0 ento
ponteiro &valor1
19
20
21
22
seno
ponteiro &valor2
fim-se
23
jander moreira

Ponteiros
24
{ comandos de manipulao da varivel escolhida }
25
ponteiro ponteiro + i
26
se ponteiro % 2 = 1 ento
ponteiro ponteiro 1
27
28
29
fim-se
fim-para
30
31
{ escritas }
32
escreva(valor1, valor2)
33 fim-algoritmo
Neste exemplo, o condicional da linha 15 determina que sempre que i

for divisvel por 5, ponteiro apontar para valor1; nos casos restantes,
apontar para valor2. Os comandos das linhas de 22 a 25 usam somente a
varivel ponteiro e manipulam a memria que estiver sendo apontada
naquele momento da execuo, ou seja, algumas vezes manipula valor1,
outras vezes valor2.

Ponteiros so, para o iniciante no desenvolvimento de algoritmos (e
de programas), um terreno obscuro e com nevoeiro. Iluminar o caminho
requer ateno e exerccios prticos. Os testes de mesa so tambm aqui
um aliado poderoso para entender o que est envolvido e quais as
conseqncias produzidas pelos comandos.
Os principais pontos desta Unidade esto em saber que ponteiros
armazenam endereos de outras variveis e, por meio destes, permitem
modificar os dados diretamente onde esto.
A utilidade dos ponteiros nos algoritmos, para este curso, bastante
limitada. Em programao, porm, poder ser visto um uso essencial,
principalmente na linguagem C.
jander moreira

Estruturas compostas heterogneas: registros
Unidade 8 registros
Estruturas compostas heterogneas:

Umas das maiores nfases que se d aos algoritmos a organizao.
Desde os comentrios iniciais, com a documentao interna, passando pela
organizao visual adequada e pela escolha de nomes de variveis que
sejam significativos, em todos os lugares h organizao.
Os dados, porm, continuam apenas amontoados de variveis.
claro que pode haver organizao na declarao, mantendo variveis
relacionadas mais prximas, seja por sua funo no algoritmo, seja por tipo
de dados. Isto, porm, muito pouco significativo, embora tenha seu
mrito.
Existem formas mais sofisticadas de organizar os dados e, como ser
visto nas prximas Unidades, so formas muito teis.
Vrios dados correlacionados podem ser mantidos juntos, criando-se
uma nica varivel que junte todos eles. Esta nova varivel pertence a um
grupo chamado variveis compostas heterogneas, ou, simplesmente,
registros.
8.2 Preenchendo fichas

Desejando obter um credirio em uma loja, um cliente gasta um
pouco do seu tempo respondendo vrias coisas ao vendedor, que as vai
anotando em uma longa folha de papel. Entre as coisas anotadas esto o
nome, endereo, bancos em que possui conta e nmero de documentos
pessoais. A ficha ser posteriormente guardada (talvez at em forma
digital) e, se tudo der certo, o cliente levar, alm do produto dos seu
sonhos, um grande carn.
Uma situao semelhante se passa na locadora, que guarda tambm
dados pessoais, como os da loja, alm de uma relao de outras pessoas
que tambm podero locar DVDs em nome de um dado cliente.
Outra situao ocorre naquela biblioteca da cidadezinha do interior,
que, desprovida de computador, tem a ficha catalogrfica de cada livro
preenchida em um carto. Neste, pode-se ler o nome dos autores, do livro,
o nmero do tombo, ano de publicao, o nome do tradutor (se houver),
entre outros dados.
Nas trs situaes acima, os mesmos dados poderiam ser anotados
em papis diferentes. Por exemplo, o vendedor poderia anotar o nome do
cliente em uma folha de papel, seu endereo em outra, CPF e RG em uma
terceira. Na biblioteca, os nomes dos autores estariam em uma gaveta, os
ttulos dos livros e ano de publicao em outra, mas em cartes separados.
Nesta situao, juntar os dados que seria um grande problema.
Cada conjunto de dados s faz sentido se estiver junto. Cada conjunto
forma uma unidade. A ficha uma unidade e cada uma um registro de
uma entidade nica, como um cliente ou um livro.
jander moreira

8.3 Conceito de estruturas compostas de dados

As variveis compostas so uma classe de variveis que permitem
agrupar dados que possuem uma relao natural de proximidade entre si,
caracterizando uma unidade. Ao se fazer este agrupamento de dados
distintos em um nico lugar, cria-se um nico objeto, o qual faz pouco
sentido se for quebrado em partes.
Os registros, ou variveis compostas heterogneas (que um
nome muito longo), so uma nica varivel formada por partes, cada uma
destas partes sendo composta por outros dados. Alm dos registros, h
tambm as variveis compostas homogneas, que sero vistas na
Unidade 10.
A denominao heterognea quer simplesmente dizer que cada
parte da varivel no precisa ter o mesmo tipo. Assim, a varivel composta
pode ser formada por uma parte inteira, outra real e outras 2 ou 3 que
sejam literais. Ou qualquer outra combinao.
8.3.1 Declarao e uso de registros

Um registro pode ser declarado em um algoritmo utilizando o formato
abaixo, no qual a organizao visual ainda mantm sua importncia. Uma
declarao de varivel composta determina a criao de um novo tipo de
dados, personalizado segundo o desenvolvedor do algoritmo.
registro
lista_de_campos
fim-registro
A lista de campos a que define as partes constituintes de um

registro. O termo campo usado para especificar cada uma destas partes e
o formato idntico ao de declaraes de variveis, o que facilita o
entendimento.
Um primeiro exemplo pode ser dado pelo seguinte problema: Um
aluno de geometria analtica precisa determinar, entre dois pontos em R3,
qual o mais prximo origem. Escreva um algoritmo que calcule as
distncias e determine qual o mais prximo..
A soluo deste problema passa por entender o que se pretende e
que a distncia do ponto p = [ p1 , p 2 , p3 ] origem dada pela frmula
d (p) =
p12 + p22 + p32 . Assim, o Algoritmo 8-1 prope uma soluo.
Algoritmo 8-1
1
{ determinar, em R3, qual de dois pontos o mais prximo da origem }
2
3
4
5
6
7
algoritmo
declare
ponto1, ponto2: registro
x, y, z: real
fim-registro
jander moreira

8
distncia1, distncia2: real
9
10
{ leitura das coordenadas dos pontos }
11
leia(ponto1.x, ponto1.y, ponto1.z)
12
leia(ponto2.x, ponto2.y, ponto2.z)
13
14
{ clculo das distncias }
15
distncia1 raiz(pot(ponto1.x, 2) + pot(ponto1.y, 2) +
16
17
pot(ponto1.z, 2))
distncia2 raiz(pot(ponto2.x, 2) + pot(ponto2.y, 2) +
18
pot(ponto2.z, 2))
19
20
{ comparao e resultado }
21
se distncia1 < distncia2 ento
22
23
24
escreva(O primeiro ponto o mais prximo)

seno
se distncia2 < distncia1 ento
25
26
escreva(O segundo ponto o mais prximo)

seno
27
28
29
escreva(Os pontos eqidistam da origem)

fim-se
fim-se
30 fim-algoritmo
As variveis ponto1 e ponto2 so definidas como registros. Cada

uma delas contm trs campos internos, sendo, no caso, todos do tipo real.
Os identificadores x, y e z so usados para indicar as trs coordenadas
cartesianas que cada ponto possui.
A especificao de cada campo feita com o operador de acesso a
campo, que um ponto (.). Por exemplo, enquanto a varivel ponto1
especifica o registro completo, ponto1.x especifica somente o campo x da
varivel ponto1, que tem o tipo real. A Figura 8-1 mostra um esquema
que ilustra a varivel ponto1 e seus campos; para a varivel ponto2 o
esquema, naturalmente, similar.
ponto1
ponto1.x
ponto1.y
ponto1.z
Figura 8-1. Esquema da varivel ponto1, que um registro com trs campos reais,
x, y e z, declarada no Algoritmo 8-1.
Neste caso, o uso do registro no obrigatrio, pois poderiam ter

sido usadas variveis separadas para cada coordenada de cada ponto,
fazendo uso de seis valores reais (x1, y1, z1, x2, y2 e z2, por exemplo).
Porm, a questo da organizao um ponto importante e a legibilidade da
soluo s tem a ganhar com uma boa estruturao dos dados.
jander moreira

O uso de registros traz uma facilidade adicional. Para exemplific-la,
um problema similar ao anterior proposto: Sabendo-se que existe um
conjunto de pontos e que a quantidade de elementos tambm conhecida,
determinar qual deles o mais prximo da origem.. Sua soluo
mostrada pelo Algoritmo 8-2.
Algoritmo 8-2
1
2
{ determinar, em R3, qual de um conjunto de pontos o mais prximo

da origem, sabendo-se o nmero de elementos do conjunto }
3
4
5
algoritmo
declare
ponto,
pontoMaisPrximo: registro
x, y, z: real
fim-registro
10
distncia: real
11
12
{ obteno do nmero de pontos }
13
leia(nmeroPontos)
14
15
se nmeroPontos 0 ento
16
17
18
escreva(No h pontos a serem processados ou valor invlido)

seno
{ leitura das coordenadas do primeiro ponto}
19
leia(ponto.x, ponto.y, ponto.z)
20
pontoMaisPrximo ponto
21
menorDistncia raiz(pot(ponto.x, 2) + pot(ponto.y, 2) +
{ o primeiro o mais prximo }
22
pot(ponto.z, 2))
23
24
{ processa os demais pontos }
25
para i 2 at nmeroPontos faa
26
leia(ponto.x, ponto.y, ponto.z)
27
distncia raiz(pot(ponto.x, 2) + pot(ponto.y, 2) +
28
pot(ponto.z, 2))
29
30
{ comparao }
31
se distncia < menorDistncia ento

menorDistncia distncia
32
pontoMaisPrximo ponto
33
34
35
fim-se
fim-para
36
37
{ resultado }
38
escreva(Ponto mais prximo:, pontoMaisPrximo.x,
39
40
pontoMaisPrximo.y, pontoMaisPrximo.z)
fim-se
41 fim-algoritmo
jander moreira

O ponto de maior destaque so as atribuies existentes nas linhas
20 e 33. Como tanto a varivel, que fica esquerda do smbolo de
atribuio (), quanto a expresso, do lado direito, possuem o mesmo tipo,
a atribuio vlida (ou seja, feita uma cpia do contedo). Portanto,
uma vantagem que existe com os registros que se pode copiar um
registro inteiro para outro, usando um nico comando. Certamente
preciso entender que a cpia completa, isto , uma reproduo fiel do
registro copiado feita, incluindo campos ainda no preenchidos (que ainda
no tiveram atribuio).
A parte ruim que, para a leitura e a escrita, somente so vlidas as
especificaes campo a campo da varivel composta. Por exemplo, um
comando escreva(ponto1) considerado errado. Cada campo deve ser
especificado individualmente, como foi feito nas linhas 19, 26 e 38 do
Algoritmo 8-2.
Da mesma forma, expresses relacionais entre registros devem ser
feitas identificando os campos, no sendo considerado correto comparar
registros inteiros de uma vez. Afinal, qual seria o resultado de
ponto1 < ponto2? Mesmo as comparaes de igualdade ou desigualdade
no so consideradas vlidas (e.g., ponto1 = ponto2).
Outro exemplo pode ser dado pela reescrita do Algoritmo 6-6 (pgina
6-10), sobre o problema dos vinhos, para uma verso com registros, dada
pelo Algoritmo 8-3.
Algoritmo 8-3
1
{ dados o nome, o preo e o tipo dos vinhos (indicados aqui por T para
tinto, B para branco ou R para ros, descrever o vinho mais caro;
no so considerados vinhos de preos iguais;
fim dos dados indicado por nome = fim }
5
6
7
algoritmo
tipo tVinho: registro
nome,
tipo: literal
10
preo: real
11
12
fim-registro
declare
13
vinho, vinhoCaro: tVinho
14
15
{ repetio para leitura dos dados }
16
vinhoCaro.preo -1
17
faa
{ para forar a troca na primeira vez }
18
{ dados }
19
leia(vinho.nome, vinho.preo, vinho.tipo)
20
21
22
se vinho.preo > vinhoCaro.preo e vinho.nome fim ento
23
24
25
vinhoCaro vinho
{ copia tudo }
fim-se
at vinho.nome = fim
jander moreira

26
27
{ apresentao do resultado }
28
se vinhoCaro.preo = -1 ento
29
30
31
32
escreva(Nenhum vinho foi apresentado.)

seno
escreva(vinhoCaro.nome, vinhoCaro.preo, vinhoCaro.tipo)
fim-se
33 fim-algoritmo
A soluo similar apresentada anteriormente, modificada para que

os dados sobre uma dada garrafa de vinho formem uma nica entidade, no
caso o registro.
A novidade apresentada no Algoritmo 8-3 a possibilidade da
definio de novos tipos, o que feito de forma similar a uma declarao
de varivel. As linhas de 9 a 11 mostram como a declarao tipo define um
novo tipo abstrato de dados, personalizado pelo desenvolvedor. No
exemplo, o novo tipo recebe o nome de tVinho (que indica, pelo t, que
um tipo * ).
Na Figura 8-2 podem ser observados alguns exemplos de declaraes
de tipos usando registros. Em especial, pode-se indicar no terceiro exemplo
o uso de registros como campos de outro registro, como o uso de
tTransao e tData. O acesso a campos internos tambm feito com o
operador ., como por exemplo operao.transaoPrincipal.valor, com
operao sendo uma varivel declarada do tipo tOperaoBancria. No
custa lembrar que operao.transaoPrincipal um registro do tipo
tTransao e, portanto, pode ser atribudo diretamente a outra varivel ou
campo com o mesmo tipo.
tipo tDada: registro
dia, ms, ano: inteiro
fim-registro
tipo tAluno: registro
nome: literal
cdigo: inteiro
cidadeNascimento,
cidadeResidncia: literal
rg: literal
fim-registro
tipo tTransao: registro
operao: literal { entrada/sada }
valor: real
fim-registro
tOperaoBancria: registro
saldo: real
limiteEspecial: real
A notao que usa o t para indicar um tipo uma opo de estilo, e no uma regra. A adoo desta
estratgia , portanto, opcional. Ressalta-se, porm, que a diferenciao entre variveis e tipos ajuda
na clareza e permite uma melhor organizao do algoritmo, servindo como auto-documentao.
jander moreira

transaoPrincipal: tTransao
data: tData
fim-registro
declare operao: tOperaoBancria
{ varivel }
Figura 8-2. Exemplos de declaraes de tipos, incluindo o uso de outros registros

como campos.

Os registros so uma forma imprescindvel de organizao dos
algoritmos. Ajudam a organizar e estruturar os dados de modo que a leitura
do algoritmo fica facilitada, pois o cdigo se torna praticamente autodocumentado.
Ainda mais que organizar, os registros tambm permitem facilidades
importantes, como ser observado nas Unidades seguintes.
Um ltimo comentrio: nem sempre preciso que os dados sejam
armazenados em registros; agrup-los uma deciso organizacional, de
forma que extremos para menos (nenhum agrupamento quando seria bom
faz-los) ou para mais (agrupar tanto os dados, que se torna complicado
us-los) podem ser prejudiciais. A prtica e o bom senso ainda so a melhor
regra.
jander moreira

Sub-rotinas
Unidade 9 -
Sub-rotinas

Neste ponto, entre aquilo que ser visto na disciplina, no h mais
novidades em termos de comandos. Atribuio, leitura e escrita,
condicionais e repeties compem, praticamente, todo o quadro de
comandos que esto disponveis para o desenvolvimento dos algoritmos.
Esta Unidade no traz novidades, portanto, em termos de comando,
mas sim de organizao.
O assunto, agora, separar conjuntos de comandos que constituem
uma unidade funcional. A organizao se baseia em resolver subproblemas, ou seja, partes de um problema maior, e separar estes
comandos em uma sub-rotina.
A organizao em sub-rotinas, porm, no um ponto simples, pois
envolve uma grande quantidade de detalhes. Cada um destes detalhes ser
tratado no momento devido.
9.2 Separando para organizar

Um jantar mais formal deve ser feito com cuidados e envolve uma
srie de consideraes. No se pode esquecer de alguns aperitivos na
recepo, como azeitonas, queijo em cubinhos, pat com torradas. Tambm
algumas bebidas. Uma salada tem que estar disponvel e bem apresentada.
Considera-se sobre um prato de entrada e sobre o prato principal, alm da
bebida que os acompanha. Finalmente, e no menos importante, a
sobremesa.
Caso se pretenda pedir a uma pessoa que execute a tarefa de
preparar cada uma destas coisas, que no so poucas, preciso orient-la
bem. necessrio, tambm, passar-lhe as receitas.
Com as orientaes gerais sobre o que fazer, sabe-se o rumo do
jantar. Com as receitas individuais, tem-se o conhecimento para preparar
cada prato.
Na prtica, as orientaes gerais so passadas oralmente ou, ento,
por escrito. Separadamente, ficam as receitas. Cada receita, tambm,
costuma vir em um papel separado ou ter pginas especficas em um
caderno ou livro. complicado pensar que, nas receitas, todos os
ingredientes sejam listados e, a seguir, tenha um conjunto de instrues
que permitam fazer, ao mesmo tempo, a salada, a sopa de entrada, o prato
principal e a sobremesa. Tudo vem separado, organizado.
Separar tambm organizar. E ajuda bastante.
9.3 Conceituao de sub-rotinas e fluxo de execuo

Nos algoritmos, separar para organizar significa redefinir o velho
conhecido fluxo de execuo. At este ponto, o fluxo contnuo, iniciando
pelo primeiro comando e indo seqencialmente at o ltimo.
jander moreira

Sub-rotinas
Porm, de forma parecida organizao de um jantar (e instrues
necessrias para prepar-lo), algumas coisas podem ser indicadas
separadamente. Por exemplo, o prato principal pode ser um mussak, e,
nas instrues gerais, haver somente uma indicao: faa o mussak.
Ser na receita do mussak que estaro listados todos os ingredientes e o
modo de fazer.
O fluxo de execuo segue, assim, as instrues principais (que
equivalem ao algoritmo) e, em um dado momento, suspende esta execuo
para executar uma tarefa especfica, que neste caso a preparao do
prato principal (ou seja, uma sub-rotina). Terminada a tarefa, as instrues
gerais so retomadas no ponto seguinte quele em que foram
temporariamente suspensas.
Nos algoritmos, uma sub-rotina um conjunto completo de
instrues, com uma funo bem definida no contexto do algoritmo. O
algoritmo principal, quando preciso, apenas indica que aquele conjunto de
comandos deve ser executado. Aps esta execuo, o fluxo dos comandos
retomado.
Em geral, as sub-rotinas servem aos seguintes propsitos:
1) Separar conjuntos de comandos de forma a obter uma melhor
organizao da soluo, ajudando na clareza e no entendimento do
algoritmo;
2) Separar conjuntos de comandos que se repitam em vrias partes do
algoritmo, permitindo indicar uma nica vez a soluo e indicar
vrios lugares diferentes em que ela deva ser aplicada;
3) Separar conjuntos de comandos que realizem uma tarefa, simples
ou complexa, de forma completa; deste modo, uma soluo feita
para um problema pode ser usada em outro, minimizando esforos.
Mas para entender como isso acontece, o melhor tomar um
exemplo. Para tanto, pode-se considerar o seguinte problema: Escreva um
algoritmo para ler dois nmeros racionais e escrever o valor de sua soma e
sua multiplicao. Assuma que os valores lidos so vlidos (ou seja, o
denominador nunca nulo) e que ambos os valores sejam diferentes de
zero.. O Algoritmo 9-1 apresenta uma soluo para o problema.
Algoritmo 9-1
1
2
{ a partir de dois nmeros racionais, calcular e apresentar a soma e a

multiplicao de ambos }
3
4
5
algoritmo
tipo tRacional: registro
numerador, denominador: inteiro
fim-registro
8
9
declare
10
nmero1, nmero2, resultado: tRacional
11
valor1, valor2, resto: inteiro
12
13
{ obteno dos nmeros }
jander moreira

Sub-rotinas
14
leia(nmero1.numerador, nmero1.denominador)
15
16
17
{ clculo da soma }
18
resultado.numerador nmero1.numerador * nmero2.denominador +
19
20
nmero1.denominador * nmero2.numerador
resultado.denominador nmero1.denominador * nmero2.denominador
21
22
{ clculo do MDC }
23
valor1 resultado.numerador
24
valor2 resultado.denominador
25
faa
26
resto valor1 % valor2
27
valor1 valor2
valor2 resto
28
29
at resto = 0
{ resultado do MDC fica em valor1 }
30
31
{ simplificao da razo }
32
resultado.numerador resultado.numerador/valor1
33
resultado.denominador resultado.denominador/valor1
34
35
{ escrita da soma }
36
escreva(resultado.numerador, /, resultado.denominador)
37
38
{ clculo do produto }
39
resultado.numerador nmero1.numerador * nmero2.numerador
40
41
42
{ clculo do MDC }
43
valor1 resultado.numerador
44
valor2 resultado.denominador
45
faa
46
47
valor1 valor2
48
49
valor2 resto
at resto = 0
50
51
52
resultado.numerador resultado.numerador/valor1
53
resultado.denominador resultado.denominador/valor1
54
55
{ escrita do produto }
56
57 fim-algoritmo
Este algoritmo calcula a soma e o produto e, para melhor apresentar

os resultados, racionaliza as razes resultantes, de forma que, se o
resultado for 2/6, a escrita ser de 1/3.
jander moreira

Sub-rotinas
O que se pode notar de imediato que, como so necessrias duas
simplificaes, todo um conjunto de comandos deve ser repetido. Uma
forma de simplificar um pouco este cdigo foi usar a mesma varivel para
guardar tanto o resultado da soma quanto o da multiplicao. Deve-se
ainda pensar que, caso fossem solicitadas outras operaes (subtrao e
diviso, por exemplo), novas racionalizaes de fraes teriam que ser
incorporadas.
O ponto principal, aqui, que a racionalizao de uma razo
sempre feita da mesma forma e, assim, poderia ser escrita uma nica vez
e, quando necessrio, teria indicada uma solicitao de sua execuo.
O Algoritmo 9-2 mostra uma verso modificada do Algoritmo 9-1,
incluindo sub-rotinas para a racionalizao de fraes. Esta soluo est,
porm, repleta de particularidades, as quais sero detalhadas no restante
da Unidade.
Algoritmo 9-2
1
2
{ a partir de dois nmeros racionais, calcular e apresentar a soma e a

multiplicao de ambos }
3
4
{ definio do tipo }
tipo tRacional: registro
numerador, denominador: inteiro
fim-registro
8
9
procedimento simplifiqueRacional(var racional: tRacional)
10 { modifica um racional para que fique na forma mais simples }

11
declare valor1, valor2, resto: inteiro
12
13
{ clculo do MDC }
14
valor1 racional.numerador
15
valor2 racional.denominador
16
faa
17
18
valor1 valor2
valor2 resto
19
20
at resto = 0
21
22
23
racional.numerador racional.numerador/valor1
24
racional.denominador racional.denominador/valor1
25 fim-procedimento
26
27 algoritmo
28
declare nmero1, nmero2, resultado: tRacional
29
30
{ obteno dos nmeros }
31
32
33
jander moreira

Sub-rotinas
34
{ clculo da soma }
35
resultado.numerador nmero1.numerador * nmero2.denominador +
36
nmero1.denominador * nmero2.numerador
37
38
simplifiqueRacional(resultado)
39
40
{ escrita da soma }
41
42
43
{ clculo do produto }
44
resultado.numerador nmero1.numerador * nmero2.numerador
45
46
simplifiqueRacional(resultado)
47
48
{ escrita do produto }
49
50 fim-algoritmo
As linhas de 9 a 25 indicam uma sub-rotina na forma de um

procedimento. Cada procedimento tem seu prprio nome, que um
identificador; neste caso, o nome simplifiqueRacional, para deixar clara
sua funo. A sub-rotina define sobre o que trabalhar: uma varivel do
tipo tRacional chamada simplesmente de racional (ainda na linha 9). No
bloco definido pelo par procedimento/fim-procedimento, est tudo o que
necessrio para completar o propsito da sub-rotina: um comentrio de
documentao, todas as variveis necessrias e os comandos que devem
ser executados.
importante notar que o algoritmo continua se iniciando com o
primeiro comando aps a palavra algoritmo, ou seja, comea na linha 31,
aps a declarao das variveis. O procedimento apenas uma declarao
de sub-rotina. Em outras palavras, apenas uma indicao do que deve
ser feito e no que os comandos devam ser executados antes do algoritmo.
Correspondem, portanto, apenas especificao das instrues. Cada subrotina fica, assim, conhecida com antecedncia, mas somente executada
quando houver uma chamada explcita indicando esta ao.
Nas linhas 38 e 46 que se encontram as solicitaes de execuo,
conhecidas como chamadas de procedimento, pontos nos quais feita a
solicitao de execuo do cdigo anteriormente declarado Nelas esto as
indicaes que o simplifiqueRacional tem que ser executado, alm de
informar que as aes devem ser feitas sobre a varivel resultado. Para
esclarecer: a declarao do procedimento feita antes do algoritmo uma
soluo genrica; na chamada do procedimento que se especifica com
clareza sobre qual varivel (ou variveis) efetivamente se dar o
processamento. Mais detalhes ainda sero discutidos; portanto, preciso
um pouco de pacincia do leitor.
Por agora, preciso atentar que as chamadas feitas a
simplifiqueRacional alteraram o fluxo de execuo para o cdigo da subrotina (declarando suas variveis e executando seus comandos) e
retornaram, depois, execuo normal, retomando a execuo seqencial
jander moreira

Sub-rotinas
dos comandos. A chamada funciona como se houvesse sido definido um
novo comando.
E voltando, ainda, hiptese de se precisar incluir tambm uma
subtrao e uma diviso de racionais, as simplificaes seriam resolvidas
apenas por chamar o procedimento novamente aps cada clculo.
Como exerccio, fica para o leitor considerar que outras coisas
existem no Algoritmo 9-2 que sejam tambm repetitivas e, assim, possam
ser transformadas em sub-rotinas.
conveniente, ainda, considerar uma sub-rotina como uma soluo
genrica para um problema especfico (como a simplificao do nmero
racional). Sob este ngulo, as sub-rotinas devem ser completas, isto , ter
explcitas todas as suas necessidades internamente. No Algoritmo 9-2, a
sub-rotina simplifiqueRacional completa, pois tem, em sua definio,
todos os elementos de que precisa: identifica o parmetro sobre o qual a
operao ser realizada, as declaraes de todas as variveis necessrias
para a soluo do problema e todo o cdigo que deve ser executado para
cumprir sua tarefa. Deve-se notar que a sub-rotina quase que independe do
algoritmo principal; ou seja, pode ser usada em qualquer algoritmo que
tenha um tipo tRacional definido como na linha 5. Esta a nica
dependncia externa da sub-rotina: o tipo de seu parmetro.
9.3.1 Procedimentos
Um procedimento uma forma de sub-rotina. Sua forma genrica,
apresentada abaixo, delimita a especificao da sub-rotina.
procedimento identificador(lista_de_parmetros)
{ comentrio de descrio do procedimento }
declaraes_locais
fim-procedimento
O identificador o nome dado sub-rotina, que deve ser no

conflitante com as demais declaraes (como tipos ou variveis). A lista de
parmetros, que pode ser vazia, lista os parmetros formais do
procedimento (detalhados na prxima seo). As declaraes locais
correspondem a quaisquer declaraes (tipos, variveis, sub-rotinas etc.)
que sejam exclusivas sub-rotina.
Para especificar a lista de parmetros, deve-se usar uma lista de
identificadores com seus respectivos tipos, separados por vrgulas. Cada
parmetro deve, portanto, ter um tipo associado a ele.
O conjunto de comandos, finalmente, corresponde lista de
comandos que deve ser executada para completar o propsito da subrotina. Estes comandos manipulam, assim, os parmetros e as declaraes
locais para obter a soluo desejada.
jander moreira

Sub-rotinas
9.3.2 Parmetros formais

Para compreender com preciso o que acontece na chamada de uma
sub-rotina preciso compreender o papel dos parmetros que elas podem
ter. No exemplo do Algoritmo 9-2, o procedimento simplifiqueRacional
tem apenas o parmetro racional do tipo tRacional.
O parmetro tem a funo de permitir uma soluo genrica para o
cdigo da sub-rotina e, no momento da chamada, indicado o real
argumento sobre o qual as aes sero realizadas. Voltando ao exemplo
da racionalizao, racional o parmetro genrico e as linhas 38 e 46
especificam que o que feito com racional, na realidade, feito com
resultado.
Os parmetros podem obedecer duas formas distintas de
comportamento, caracterizando parmetros com passagem por valor ou
passagem por referncia. O exemplo visto utiliza o parmetro passado
por referncia.
Passagem de parmetros por referncia indica que, na subrotina, o parmetro formal uma referncia varivel utilizada no
momento da chamada. O termo referncia quer dizer que o parmetro
efetivamente corresponde varivel real, sendo ambas a mesma coisa. Em
outras palavras, tanto o identificador da varivel (racional, no exemplo)
quanto o do parmetro (resultado) fazem referncia mesma posio de
memria. O efeito disso que modificaes feitas no parmetro formal so
feitas, na verdade, na varivel externa. A principal utilizao de passagem
por referncia poder modificar o valor das variveis dentro de uma subrotina, de modo que as alteraes feitas internamente fiquem refletidas
externamente sub-rotina.
Por outro lado, a passagem de parmetros por valor no faz a
ligao entre o parmetro e a varivel usada na chamada. feita a cpia
do valor da varivel externa para o parmetro, o qual possui sua prpria
rea de memria para armazenamento. A conseqncia disso que, feitas
alteraes pela sub-rotina no valor do parmetro formal, somente a cpia
(o parmetro) afetada, sendo que o valor original do argumento usado na
chamada preservado. Assim, sempre que no houver necessidade de que
um valor alterado em uma sub-rotina seja conhecido externamente a ela, a
passagem por valor deve ser empregada.
Para diferenciar as duas formas de passagem de parmetros, a
palavra reservada var usada para indicar, para cada parmetro
individualmente, que se trata de uma passagem por referncia (com
alterao da varivel externa). Se no houver indicao, ento a passagem
ser por valor.
O Algoritmo 9-3 ilustra as duas formas de passagem de parmetros.
Algoritmo 9-3
1
{ algoritmo simples (e sem funo especfica) que ilustra o formato
e as conseqncias de sub-rotinas com passagem de parmetros por
valor e por referncia }
4
5
procedimento escrevaInteiroEFracionrio(valor: real)
jander moreira

Sub-rotinas
6
{ escreve as partes inteira e fracionria de um valor }
7
8
escreva(Parte inteira:, int(valor))
valor valor int(valor)
10
escreva(Parte fracionria:, valor)
11 fim-procedimento
12
13 procedimento transformeEmPositivo(var valor: real)
14 { transforma o valor de um nmero real em positivo }
15
16
se valor < 0 ento

valor -valor
17
18
{ transforma em positivo }
fim-se
19 fim-procedimento
20
21 algoritmo
22
declare nmero: real
23
24
{ o valor especial 999 indica o trmino }
25
faa
26
leia(nmero)
27
28
escrevaInteiroEFracionrio(nmero)
29
30
escreva(O mdulo :)
31
transformeEmPositivo(nmero)
32
33
escreva(nmero)
enquanto nmero 999
34 fim-algoritmo
O procedimento escrevaInteiroEFracionrio possui um parmetro

formal, com passagem por valor. No cdigo desta sub-rotina usado um
artifcio simples para se obter a parte fracionria do nmero, sendo este
valor armazenado na prpria varivel que corresponde ao parmetro. Como
a alterao feita em uma cpia do contedo, no h qualquer efeito da
atribuio da linha 9 sobre a varivel nmero, usada na chamada de
procedimento.
O
modificador
var,
na
declarao
do
procedimento
transformeEmPositivo (linha 13), por sua vez, proporciona um
comportamento diverso para a atribuio que feita internamente ao
procedimento. Como o parmetro uma referncia direta varivel usada
na chamada do procedimento (neste caso, a varivel nmero), a
modificao no valor do parmetro valor implica a modificao da varivel
nmero, j que ambas se referem diretamente mesma posio de
memria. No h como modificar uma sem modificar a outra.
Em termos gerais, usa-se o termo parmetros de entrada para
aqueles que carregam informaes para o interior da sub-rotina.
Parmetros de sada, por seu turno, referem-se aos parmetros que
transferem dados para o exterior da sub-rotina. A passagem por valor
jander moreira

Sub-rotinas
usada para parmetros de entrada. Parmetros de sada exigem a
passagem por referncia. Deve-se notar, ainda, que no exemplo do
Algoritmo 9-3, o parmetro formal valor de transformeEmPositivo usado
tanto quanto parmetro de entrada (quando leva por referncia um valor
externo que usado na sub-rotina) quanto de sada (ao fazer que a
alterao feita internamente tenha abrangncia fora do escopo do
procedimento).
Algumas
vezes,
parmetros
passados
por
referncia
so
exclusivamente de sada. Isto pode ser identificado quando o valor
armazenado na varivel antes da chamada da sub-rotina no interfere com
o resultado produzido por ela. Portanto, somente h a sada de dados, e
no a entrada.
A declarao da lista de parmetros feita, como visto, nos
parnteses que seguem o identificador da sub-rotina. Todos os parmetros
devem ter seu tipo especificado, assim como a forma de passagem (por
valor ou por referncia). possvel, caso alguns parmetros consecutivos
compartilhem tanto o tipo quanto a forma de passagem, especificar uma
nica vez o tipo e a forma. A Tabela 9-I mostra alguns exemplos genricos
de declaraes de parmetros, algumas separando os tipos para cada
argumento, outras os agrupando (quando compartilharem modo de
passagem e tipo).
Tabela 9-I. Exemplos de declaraes de parmetros.
Exemplo de lista de parmetros
Comentrio
p1, p2: inteiro
Dois parmetros inteiros, por valor.
p1: inteiro, p2: inteiro
Dois parmetros inteiros por valor (idntica

ao exemplo anterior).
p1: real, p2: inteiro, p2: real
Trs parmetros, sendo o primeiro e o

ltimo reais e o segundo inteiro, todos por
valor
p1, p2, p3: tTipo
Trs parmetros do tipo tTipo, por valor.
var p1, p2: literal
Dois
parmetros
referncia.
var p1: literal, p2: literal
Um parmetro literal por referncia (o

primeiro) e outro, tambm literal, por valor.
p1: literal, var p2: literal
Dois parmetros literais, o primeiro por valor

e o segundo por referncia.
p1: real, var p2: real, p3: real
Trs parmetros, todos reais, sendo o

primeiro e terceiro por valor e somente o
segundo por referncia.
literais,
ambos
por
9.3.3 Regras de escopo de declaraes

Ao longo dos exemplos de algoritmos apresentados nesta Unidade,
possvel observar que as declaraes so feitas em vrios locais diferentes
dentro do algoritmo. E o termo declaraes, aqui, no se refere somente a
declaraes de variveis, mas tambm a declaraes de tipo e de subrotinas.
O Algoritmo 9-2 ser usado para exemplificar estes locais de
declarao. Nele existem variveis que pertencem somente parte principal
jander moreira

Sub-rotinas
do algoritmo e no fazem sentido nem so usadas fora dele, que so
declaradas internamente ao par algoritmo/fim-algoritmo. Estas
declaraes ocorrem na linha 28. Outras variveis pertencem apenas ao
procedimento simplifiqueRacional, correspondendo ao parmetro da linha
9 e s variveis declaradas na linha 11. Alm das variveis, existem a
declarao do tipo tRacional (linhas 5 a 7) e a declarao da sub-rotina
que correspondem ao procedimento como um todo (com incio na linha 9 e
concluso na linha 25).
As declaraes feitas internamente, como os parmetros e as
variveis internas a uma sub-rotina, alm daquelas que pertencem
exclusivamente parte principal do algoritmo, so conhecidas como
declaraes locais (linhas 9, 11 e 28 do Algoritmo 9-2, como exemplo).
As demais declaraes, feitas fora deste escopo * local so as declaraes
globais (que so as declaraes do tipo e do procedimento).
No caso do Algoritmo 9-3, os parmetros dos dois procedimentos
(ambos identificados por valor) tm escopo local, como o caso da
varivel nmero, que local parte principal do algoritmo. Alm disso, so
globais as declaraes dos prprios procedimentos.
Algumas regras de escopo devem ser definidas para que no
existam ambigidades de interpretao quando da execuo de um
comando em qualquer parte do algoritmo.
Definem-se, assim, as seguintes regras:
1. Qualquer declarao somente vlida e visvel aps ter sido feita e
se torna invlida depois de encerrado seu escopo.
2. Declaraes locais tm como escopo somente a sub-rotina dentro da
qual foram declaradas, assim como declaraes locais parte
principal do algoritmo somente so vlidas e visveis neste trecho
especfico.
3. Parmetros formais de sub-rotinas obedecem mesma regra de
escopo das declaraes locais da sub-rotina.
4. Declaraes globais so vlidas e visveis do ponto onde foram feitas
at o final do algoritmo.
5. Identificadores com o mesmo nome podem ser usados, desde que
pertenam a escopos diferentes.
6. Quando um mesmo identificador definido para escopos diferentes e
ambos possuem escopo em um dado local, o identificador vlido
sempre o do escopo mais local.
A Figura 9-1 apresenta um algoritmo simplificado com vrias
declaraes, todas vlidas. Existem seis declaraes globais: o tipo tTipo,
as variveis umInteiro, valor e outroInteiro, alm dos procedimentos
meuProcedimento e seuProcedimento. Estes dois ltimos (os
procedimentos)
definem
dois
novos
escopos
locais.
Para
meuProcedimento, h os parmetros v1 (inteiro) e v2 (real), mais uma
varivel local denominada umInteiro. O escopo local definido para
seuProcedimento declara os parmetros umInteiro e valor (ambos
*
Escopo, no contexto deste texto, pode ter seu significado entendido como rea de abrangncia.
jander moreira

Sub-rotinas
inteiros) e duas variveis locais do tipo tTipo, identificadas por v1 e v2.
H, finalmente, um terceiro escopo local, definido para a parte principal do
algoritmo, na qual se declara a varivel valor (do tipo tTipo).
A declarao de tTipo vlida para todo o algoritmo, tanto que
utilizada internamente a seuProcedimento e tambm na parte principal do
algoritmo.
{ exemplos de abrangncia de escopo de declaraes }
tipo tTipo: registro
a, b, c: inteiro
fim-registro
tTipo, umInteiro, valor
declare
umInteiro: inteiro
valor: real
procedimento meuProcedimento(var v1: inteiro, var v2: real)
declare umInteiro: inteiro
v1, v2,
umInteiro
meuProcedimento
fim-procedimento { meuProcedimento }
declare outroInteiro: inteiro
outroInteiro
procedimento seuProcedimento(umInteiro: inteiro, valor: inteiro)

umInteiro,
declare v1, v2: tTipo
valor,
fim-procedimento { seuProcedimento }
v1, v2
{ parte principal }
algoritmo
declare valor: tTipo
seuProcedimento
valor
fim-algoritmo
Figura 9-1. Exemplo de escopo de declaraes.
As variveis umInteiro e valor valem para todo o algoritmo, assim

como tTipo. Porm, o identificador umInteiro substitudo pela varivel
local na sub-rotina meuProcedimento e pelo parmetro, em
seuProcedimento. Em cada escopo, passa a valer a declarao local, o
que interrompe o acesso varivel global at o final de cada procedimento.
Fora destes locais, a declarao global que vale. O mesmo ocorre pela
substituio da varivel global valor dentro de seuProcedimento (onde
sobreposta pelo parmetro) e dentro da parte principal do algoritmo
(substituda por outra varivel, agora do tipo tTipo).
A declarao da varivel outroInteiro tambm global, porm
somente vlida a partir de sua declarao; ou seja, no est definida para a
sub-rotina meuProcedimento.
Finalmente, ainda importante destacar que os procedimentos
tambm tm seus escopos. Assim, meuProcedimento pode ser usado
dentro de seuProcedimento e na parte principal do algoritmo. A subrotina seuProcedimento, por sua vez, global e pode ser usada na parte
principal, porm no vlida dentro de meuProcedimento, uma vez que,
a esta altura, ainda no foi declarada.
jander moreira

Sub-rotinas
9.3.4 Funes
Outro tipo de sub-rotina so as funes. Um procedimento substitui
um comando, como se um novo comando fosse criado. As funes
substituem um valor.
Na Unidade 3 foram apresentadas vrias funes pr-definidas * . Esta
seo apresenta uma forma de se escrever uma sub-rotina que pode ser
usada como uma nova funo. Para tanto, usado o par funo/fimfuno para indicar o novo cdigo. O formato apresentado na seqncia.
funo identificador(lista_de_parmetros): tipo_da_funo

{ comentrio de descrio da funo }
declaraes_locais
fim-funo
Para exemplificar, o Algoritmo 9-4 ilustra as novas funes

menorInteiro, menorReal e mdulo.
A funo menorInteiro resulta no menor entre dois valores inteiros;
havendo igualdade, o valor comum o resultado. menorReal funciona de
modo similar, mas usa parmetros e prov o resultado do tipo real.
Finalmente, mdulo uma funo que retorna o valor positivo de um
argumento (no caso, um real). claro que j existe a funo abs, mas
mdulo um exemplo de como ela poderia ter sido implementada.
Algoritmo 9-4
1
{ exemplificao de sub-rotinas na forma de funo e seu uso }
2
3
funo menorInteiro(valor1: inteiro, valor2: inteiro): inteiro
{ retorna o menor entre valor1 e valor2; se iguais retorna um deles }
5
6
se valor1 < valor2 ento
retorne valor1
seno
retorne valor2
10
fim-se
11 fim-funo
12
13 funo menorReal(valor1: real, valor2: real): real
14 { retorna o menor entre valor1 e valor2; se iguais, retorna um deles }
15
16
se valor1 < valor2 ento
17
18
19
retorne valor1
seno
retorne valor2
Ver Tabela 3-I, sobre operaes aritmticas e Tabela 3-II, sobre operaes literais.
jander moreira

Sub-rotinas
20
fim-se
21 fim-funo
22
23 funo mdulo(valor: real): real
24 { retorna o valor absoluto do valor }
25
26
se valor < 0 ento

valor -valor
27
28
fim-se
29
retorne valor
30 fim-funo
31
32 { parte principal }
33 algoritmo
34
declare
35
primeiroInt, segundoInt: inteiro
36
primeiroReal, segundoReal: real
37
38
{ entrada de dados }
39
leia(primeiroInt, segundoInt, primeiroReal, segundoReal)
40
41
{ algumas sadas e manipulaes }
42
escreva(O menor inteiro entre, primeiroInt, e,
43
segundoInt, , menor(primeiroInt, aegundoInt))
44
45
se menorReal(primeiroReal, segundoReal) primeiroReal ento
46
47
escreva(segundoReal, menor que, primeiroReal)

fim-se
48
49
se mdulo(primeiroReal) = primeiroReal e primeiroReal 0 ento
50
51
52
53
escreva(O valor, primeiroReal, positivo)

seno
escreva(O valor, primeiroReal, no positivo)
fim-se
54
55
escreva(Considerando-se o mdulo, tem-se que o menor entre,
56
primeiroReal, e, segundoReal, ,
57
menorReal(mdulo(primeiroReal), mdulo(segundoReal))
58 fim-algoritmo
Os principais pontos que diferenciam um procedimento de uma

funo so:
Uma funo deve ter um tipo explcito de retorno, o qual indicado
em sua declarao.
O resultado (o valor final) de uma funo determinado pela
execuo do comando retorne.
O comando retorne somente faz sentido no interior de uma funo e
tem como argumento uma expresso qualquer, cujo valor final deve
jander moreira

Sub-rotinas
coincidir com o tipo de retorno da funo. Outro ponto importante que sua
execuo encerra a sub-rotina, em qualquer posio que esteja.
Por fim, regras de escopo e passagem de parmetros so idnticas
tanto para procedimentos quanto para funes. Por exemplo, uma funo,
alm de retornar um valor, como seu papel, pode ainda modificar os
argumentos que forem passados por referncia.

Uma das ferramentas mais importantes no desenvolvimento de
algoritmos so as sub-rotinas. Estas permitem organizar os algoritmos de
diversas maneiras, tanto pela reduo de cdigo repetido quanto pela
organizao em si.
Diferenciar procedimentos de funes tambm importante. Uma
forma simples de se pensar sobre o assunto ver procedimentos como
definies de novos comandos, enquanto as funes so usadas apenas
como resultados em expresses.
Estruturados adequadamente, os algoritmos podem ter seus
refinamentos transformados em sub-rotinas durante seu desenvolvimento
ou estas podem ser inseridas quando o cdigo final for avaliado para
verificar se h espao para melhorias. A prtica faz com que, j no
desenvolvimento, muitas partes da soluo sejam diretamente estruturadas
como sub-rotinas.
Muita ateno deve ser dada a este tpico dentro da disciplina. Como
ser notado, todo desenvolvimento, a partir de agora, j incorporar
procedimentos e funes como soluo para a proposta de algoritmos.
jander moreira

Estruturas compostas homogneas: arranjos
Unidade 10 - Estruturas compostas homogneas:

arranjos
bastante comum a situao em que um conjunto de dados de
entrada processado para gerar uma sada (resultado). isso que foi
apresentado at agora. H situaes, entretanto, em que o conjunto de
dados no pode ser esquecido medida que o processamento for
ocorrendo.
Em algoritmos, bastante comum o caso em que, feito um
processamento, preciso voltar ao conjunto de dados para checar uma
situao ou refazer um clculo.
As
variveis
compostas
homogneas
so
uma
forma
importantssima de organizao de dados (ou estruturao de dados) que
tm como funo guardar vrios dados do mesmo tipo e permitir fcil
acesso a cada item em particular.
10.2 Lembrar , muitas vezes, importante

Pode-se considerar, inicialmente, a seguinte proposio para um
algoritmo: Ao final de uma competio esportiva se dispe, para cada pas,
do nmero de medalhas de ouro, de prata e de bronze conquistadas
durante a competio. Deseja-se saber qual pas obteve o melhor
desempenho e qual obteve o pior. Deve-se considerar que no houve
empates.. Para solucionar, basta fazer uma repetio obtendo os dados
pas a pas, comparando se a situao de cada nova entrada melhor que o
melhor pas at o momento ou pior que o lanterninha registrado; se for
necessrio, substituir o melhor ou o pior, prosseguindo a repetio. Ao final,
escrever os dados armazenados para o melhor e para o pior desempenhos.
Porm, considere a mesma proposta, mas sem a restrio de que no
haja empates. O problema muda consideravelmente. A soluo, agora, no
mais armazenar o melhor e o pior. Pode haver dois pases empatados na
primeira posio e outros quatro empatados em ltimo. A resposta, ento,
deve ser uma lista dos pases em primeiro lugar no ranking e uma lista dos
ltimos classificados. Na realidade, pode ser que haja um empate e que
todos obtenham o mesmo nmero de medalhas e todos empatem em
primeiro (improvvel, mas possvel). Uma soluo para o algoritmo, nesta
nova situao, (de novo) verificar as condies de medalhas que definem
o primeiro e o ltimo colocados; depois, a lista de todos os pases deve ser
repassada, listando todos aqueles que coincidem com o status de melhor de
todos, fazendo um procedimento similar para verificar os que se encontram
na situao de pior desempenho. Nesta soluo, preciso se lembrar de
vrios dos dados (nome do pas, nmero de cada tipo de medalha), para
confrontar no final.
jander moreira

10.3 Estruturao dos dados

As variveis compostas homogneas formam uma classe de
organizao de dados similar s variveis compostas heterogneas (ou
registros, vistos na Unidade 8), pois tm como funo usar uma nica
varivel para armazenar vrios dados individuais. As semelhanas terminam
a.
Para simplificar, o termo usado para identificar este novo tipo de
varivel ser arranjo * .
Assim, um arranjo uma nica varivel, a qual formada por um
conjunto homogneo (isto , do mesmo tipo) de valores. Para identificar
cada valor usado um nmero inteiro, que corresponde posio do valor
em relao aos demais. Este nmero, apropriadamente, chamado de
ndice.
Portanto, pode-se pensar em um arranjo com capacidade de
armazenar, por exemplo, 10 nomes. O arranjo formado um arranjo de
literais. Cada nome individual identificado por seu ndice, para o qual se
estabelece, como conveno, que a numerao se inicia em zero. H, desta
forma, um literal na posio zero, outro na posio um, seguindo assim at
a ltima posio, que tem ndice 9.
As diversas linguagens de programao existentes apresentam
variaes no modo como os ndices so numerados. Algumas marcariam
ndices de 1 a 10, para o exemplo acima, outras permitiriam marcaes
menos intuitivas, como de -5 a 4. O ponto principal, em que a grande
maioria das linguagens concorda, que o ndice um valor inteiro e que os
valores so sempre consecutivos (ou seja, no pulam nenhum valor).
Para os algoritmos usados no contexto desta disciplina, todo arranjo
de k elementos ter cada um deles identificado pelos ndices de 0 a k 1,
sem excees.
10.3.1
Declarao e uso de arranjos unidimensionais
Para declarar um arranjo unidimensional em um algoritmo,

simplesmente usada uma indicao do nmero de elementos que a varivel
composta armazenar, o que feito por um valor inteiro entre colchetes
posicionado imediatamente aps o identificador. Com esta indicao se
distingue uma varivel simples de uma varivel composta.
O Algoritmo 10-1 ilustra o uso de uma varivel composta,
denominada valor, usada para armazenar 20 valores inteiros distintos. Na
linha 7 feita a declarao de duas variveis do tipo inteiro: uma varivel
simples, i, e outra composta homognea, valor, com 20 posies (ilustrado
na Figura 10-1).
Enquanto o identificador valor usado para a varivel completa
(com todos seus 20 valores), cada inteiro individual identificado por seu
ndice, do zero ao 19. A indicao do ndice tambm utiliza os colchetes logo
aps o identificador. Deste modo, valor[0] o primeiro valor do conjunto,
seguido por valor[1], por valor[2] e terminando em valor[19]. Como o
*
Outra nomenclatura bastante comum para arranjos o termo ingls array.
jander moreira

algoritmo utiliza as 20 posies, usada uma varivel auxiliar (i) para
determinar qual a posio em uso. Assim, na linha 12, em cada execuo
dentro do comando para, uma posio diferente do arranjo utilizada.
Como as posies de um arranjo so independentes, a linha 20, ao
utilizar ndices diferentes, revisita cada valor lido individualmente,
comparando-o em relao mdia calculada.
Algoritmo 10-1
1
2
{ calcular, para um conjunto de 20 valores inteiros, quantos destes

so maiores ou iguais mdia do conjunto }
3
4
algoritmo
{ declarao de variveis }
Declare
soma, contador, i,
valor[20]: inteiro { i: um inteiro; valor: 20 inteiros }
mdia: real
10
11
{ obteno dos dados e clculo da mdia }
12
soma 0
13
para i 0 at 19 faa
14
leia(valor[i])
15
soma soma + valor[i]
16
fim-para
17
mdia soma/20.0
18
19
{ contagem de quantos valores so maiores ou iguais mdia }
20
contador 0
21
para i 0 at 19 faa
22
se valor[i] mdia ento

contador contador + 1
23
24
fim-se
25
fim-para
26
27
{ resultado }
28
escreva(H, contador, iten(s) maiore(s) que a mdia, mdia)
29 fim-algoritmo
valor
10
11
12
13
14
15
16
17
18
19
Figura 10-1. Ilustrao do arranjo valor do Algoritmo 10-1.
Uma declarao de um arranjo feita para um tamanho fixo de

elementos. Em outras palavras, j na declarao se deve conhecer quantas
posies existiro e este tamanho no poder ser modificado. Embora
muitas vezes desejvel, no se podem usar variveis para especificar o
jander moreira

nmero de posies que um arranjo ter, pois isso daria um carter
dinmico em relao ao tamanho da varivel.
Como qualquer outra varivel, um arranjo, logo ao ser criado, contm
em suas vrias posies valores indefinidos (lixo). semelhana das
outras variveis, tambm s faz sentido usar o contedo armazenado se j
houver sido feita uma leitura ou uma atribuio quela posio.
Para exemplificar, considere-se uma declarao de dados como a
abaixo.
declare lista[5]: inteiro
O trecho de algoritmo seguinte ilustra o preenchimento do arranjo

com valores, obedecendo uma regra, que a de que cada posio contenha
o dobro do valor da posio imediatamente anterior, acrescido de 1
unidade.
lista[0] 1
{ primeiro da lista }
para i 1 at 4
{ demais posies }
lista[i] lista[i 1] * 2 + 1
fim-para
A Tabela 10-I apresenta a situao do arranjo lista nos vrios

momentos em que um de seus valores internos modificado. A primeira
coluna da tabela mostra o contedo de cada uma das cinco posies
existentes no arranjo, sendo a de ndice zero indicada do lado esquerdo.
Tabela 10-I. Ilustrao passo a passo dos valores de um arranjo para atribuies
sucessivas.
contedo
Comentrio
Contedo da varivel logo aps sua declarao.

interrogao indica que o valor desconhecido.
Valores aps a primeira atribuio, anterior ao para.
Valores aps a primeira atribuio dentro da repetio do

comando para, quando i igual a 1.
Valores aps a atribuio, quando i igual a 2.
15
Valores aps a atribuio, quando i igual a 3.
15
31
Valores aps a ltima atribuio do para, quando i igual a

4.
Um comentrio final que os arranjos unidimensionais tambm so

freqentemente chamados de vetores, em uma associao com os vetores
utilizados em Geometria Analtica. O termo vetor usado mesmo quando os
valores armazenados no so reais, sendo comum encontrar um vetor de
inteiros ou um vetor de valores lgicos.
jander moreira

10.3.2
Aplicaes prticas de arranjos unidimensionais
Vetores so de uso amplo para a proposta de soluo de problemas.

Neste tpico so apresentados alguns exemplos que ilustram sua utilidade
em aplicaes e como sua manipulao pode ser feita.
Uma primeira proposta: Escreva um algoritmo para listar o melhor
aluno em uma turma com 40 estudantes. Esto disponveis as notas de trs
provas, todas com o mesmo peso, alm do nome de cada aluno..
Para sua soluo, observa-se que necessrio calcular a mdia para
cada aluno e selecionar a maior nota, alm do nome do aluno. Porm,
havendo dois alunos com a mesma mdia, apenas um seria listado. Como
pode haver empate, uma proposta seria armazenar todos os nomes e todas
as mdias calculadas e, aps se obter a melhor mdia, listar todos os
alunos que a possuem. O Algoritmo 10-2 ilustra esta opo de resoluo.
Algoritmo 10-2
1
{ listar o(s) melhor(es) aluno(s) de uma turma com 40 alunos, dadas
as notas de trs provas e sabendo-se que todas possuem o mesmo peso
no clculo da mdia }
4
5
6
algoritmo
{ declaraes }
constante nmeroAlunos: inteiro = 40
declare
i: inteiro
10
notaProva1, notaProva2, notaProva3, melhorMdia: real
11
nomeAluno[nmeroAlunos]: literal
12
mdia[nmeroAlunos]: real
13
14
{ obteno dos dados, clculo das mdias e seleo da melhor }
15
melhorMdia -1
16
para i 0 at nmeroAlunos - 1 faa
{ fora substituio logo para o primeiro aluno }
17
leia(nomeAluno[i], notaProva1, notaProva2, notaProva3)
18
mdia[i] (notaProva1 + notaProva2 + notaProva3)/3
19
20
se mdia[i] > melhorMdia ento

melhorMdia mdia[i]
21
22
23
fim-se
fim-para
24
25
26
escreva(Melhor nota final:, melhorMdia)
27
28
se mdia[i] = melhorMdia ento
29
30
31
escreva(Nome do aluno:, nomeAluno[i])

fim-se
fim-para
32 fim-algoritmo
jander moreira

Neste algoritmo de soluo, deve-se observar que h uma

correspondncia entre as posies do arranjo de nomes, nomeAluno, e do
arranjo de mdias, mdia. Para um dado ndice k, nomeAluno[k] obteve
a mdia de provas mdia[k]. Outro ponto de destaque o uso da
declarao de constante na linha 7, que ajuda a organizar o algoritmo. Caso
a proposta do nmero de alunos se modifique de 40 para 100, esta a
nica linha que deve ser modificada para adequar o algoritmo (alm de
alterar o comentrio da documentao, claro).
Uma outra proposta de problema: Escreva um algoritmo para listar o
melhor aluno em uma turma de estudantes. Esto disponveis o nmero
total de alunos, as notas de trs provas de cada um, todas com o mesmo
peso, alm dos nomes de cada um. Deve-se considerar que haja, no
mximo, 150 alunos em uma turma..
Com a modificao da proposta, a soluo, embora siga uma linha
semelhante, requer algumas modificaes. A primeira a questo de que o
nmero de estudantes varivel. Como no possvel criar arranjos de
tamanhos variveis, vale-se da informao de que o nmero mximo 150
alunos. A soluo, assim, pode criar um arranjo de 150 posies para
nomes e para mdias, mas somente o nmero de posies necessrias so
utilizadas (o que corresponde ao nmero de alunos da turma). As demais
posies existem, mas so simplesmente ignoradas durante a execuo.
Algoritmo 10-3
1
{ listar o(s) melhor(es) aluno(s) de uma turma de alunos, dadas
as notas de trs provas (sabendo-se que todas possuem o mesmo peso
no clculo da mdia) e tendo-se o nmero total de alunos }
4
5
6
algoritmo
{ declaraes }
constante mximoAlunos: inteiro = 150
declare
i: inteiro
10
notaProva1, notaProva2, notaProva3, melhorMdia: real
11
nomeAluno[mximoAlunos]: literal
12
mdia[mximoAlunos]: real
13
14
{ obteno do nmero de alunos }
15
leia(nmeroAlunos)
16
17
se nmeroAlunos > mximoAlunos ento
18
19
escreva(Nmero mximo de alunos , mximoAlunos)

seno
20
{ obteno dos dados, clculo das mdias e seleo da melhor }
21
melhorMdia -1
22
{ fora substituio }
23
leia(nomeAluno[i], notaProva1, notaProva2, notaProva3)
24
mdia[i] (notaProva1 + notaProva2 + notaProva3)/3
jander moreira

25
26
se mdia[i] > melhorMdia ento

melhorMdia mdia[i]
27
28
29
30
fim-se
fim-para
fim-se
31
32
33
escreva(Melhor nota final:, melhorMdia)
34
35
se mdia[i] = melhorMdia ento
36
37
38
escreva(Nome do aluno:, nomeAluno[i])

fim-se
fim-para
39 fim-algoritmo
A soluo apresentada no Algoritmo 10-3 incorpora uma tcnica

comum no uso de arranjos. feito o dimensionamento para um valor
mximo considerado razovel para a soluo (o nmero mximo de alunos,
no exemplo acima) e o uso feito somente para o necessrio. Claramente
h a introduo de um desperdcio de memria, pois h a reserva de espao
para vrios dados sem que esta rea seja efetivamente usada. um preo
a se pagar, entretanto. A prtica no desenvolvimento e as particularidades
do problema que est sendo tratado ajudam em estimativas que podem ser
consideradas razoveis para os tamanhos de arranjos que podem ser
alocados * .
De modo a ilustrar outra situao diferenciada, um novo problema
proposto: Um professor de matemtica deseja exemplificar para seus
alunos o conceito de unio de conjuntos. Para isso, quer que seja
desenvolvido um programa simples de computador que permita que os
alunos entrem os dados de dois conjuntos (valores reais) e visualizem o
resultado da unio. Escreva um algoritmo para a implementao de tal
programa..
O desenvolvimento desta soluo passa por lembrar que conjuntos
podem possuir de zero a infinitos elementos e que o caso do infinito seria
um impedimento para o programa. Uma segunda conversa com o professor
de matemtica traz a luz de que conjuntos com at 50 elementos so mais
que satisfatrios para seu trabalho com os alunos.
O algoritmo precisa usar dois conjuntos e gerar um terceiro. Como
cada conjunto precisa guardar at 50 elementos e tambm deve saber
quantos destes so efetivamente usados, opta-se por usar um registro para
estruturar cada conjunto. Este registro mantm um inteiro para guardar o
nmero de elementos no conjunto (de zero a 50, no caso) e um arranjo de
reais, que armazenam os valores em si.
Quando um algoritmo for implementado em uma linguagem de programao, a memria real do

equipamento e as limitaes do sistema operacional tambm sero fatores determinantes para os
tamanhos de arranjos.
jander moreira

Esta soluo algortmica parece ter muitos detalhes e, assim, opta-se
por organizar a soluo usando sub-rotinas. Outro fato que justifica subrotinas a necessidade de repetio de cdigo, como o caso da leitura
dos conjuntos, que deve ser feita para os dois conjuntos iniciais.
A soluo final para o problema da unio de conjuntos apresentada
no Algoritmo 10-4.
Algoritmo 10-4
1
{ exemplificao de teoria de conjuntos para a operao de unio,
usando a leitura de dois conjuntos de valores reais e mostrando o
resultado da unio }
4
5
constante mximoElementos: inteiro = 50
{ nmero mximo de elementos
no conjunto }
7
8
tipo tConjunto: registro
nmeroElementos: inteiro
10
elementos[mximoElementos]: real
11
fim-registro
12
13 procedimento insereConjunto(elemento: real, var conjunto: tConjunto,
14
var sucesso: lgico)
15 { insere um novo elemento no conjunto, retornando sucesso=verdadeiro

16
se a insero ocorrer; retorna falso se no houver espao ou se o
17
elemento for repetido }
18
declare
19
i: inteiro
20
achou: lgico
21
22
{ ajusta o resultado padro }
23
sucesso falso
24
25
se conjunto.nmeroElementos < mximoElementos ento
26
{ verifica se o elemento j est no conjunto }
27
i 0
28
achou falso
29
enquanto no achou e i < conjunto.nmeroElementos faa

achou elemento = conjunto.elemento[i]
30
31
fim-se
32
33
se no achou ento
34
{ insere o novo elemento no conjunto }
35
conjunto.elemento[conjunto.nmeroElementos] elemento
36
conjunto.nmeroElementos conjunto.nmeroElementos + 1
37
sucesso verdadeiro
38
39
40
fim-se
fim-se
41 fim-procedimento
jander moreira

42
43 procedimento leiaConjunto(var conjunto: tConjunto)
44 { leitura dos elementos de um conjunto, evitando as repeties }
45
declare
46
nmeroElementos: inteiro
47
elemento: real
48
inseroOk: lgico
49
50
{ criao de um conjunto inicialmente vazio }
51
conjunto.nmeroElementos 0
52
53
{ obteno do nmero de elementos do conjunto (com limitao) }
54
faa
55
leia(nmeroElementos)
56
se nmeroElementos > mximoElementos ento
57
escreva(O limite de zero a , mximoElementos)
58
59
fim-se
enquanto nmeroElementos < 0 ou nmeroElementos > mximoElementos
60
61
{ entrada de cada elemento }
62
enquanto conjunto.nmeroElementos < nmeroElementos faa
63
leia(elemento)
64
65
insereConjunto(elemento, conjunto, inseroOk)
66
se no inseroOk ento
67
escreva(O elemento j existe; digite outro.)
68
69
fim-se
fim-enquanto
70 fim-procedimento
71
72 procedimento escrevaConjunto(conjunto: tConjunto)
73 { escrita dos elementos de um conjunto }
74
declare i: inteiro
75
76
se conjunto.nmeroElementos = 0 ento
77
78
79
escreva (Conjunto vazio)

seno
para i 0 at conjunto.nmeroElementos - 1 faa
80
81
82
escreva(conjunto.elemento[i])
fim-para
fim-se
83 fim-procedimento
84
85 procedimento unaConjuntos(var resultado: tConjunto,
86
conjunto1, conjunto2: tConjunto)
87 { cria o conjunto resultado a partir da unio dos conjuntos 1 e 2 }

88
declare
89
i: inteiro
90
inseroOk: lgico
91
jander moreira

92
{ cria resultado inicialmente igual ao primeiro conjunto }
93
resultado conjunto1
94
95
{ insere os elementos do conjunto 2 no resultado, sem repeties }
96
inseroOk verdadeiro
97
i 0
98
enquanto i < conjunto2.nmeroElementos e inseroOk faa
99
insereConjunto(conjunto2.elemento[i], resultado, inseroOk)
100
i i + 1
101
fim-para
102
103
se no inseroOk ento
104
escreva(No houve espao para a unio; o resultado,
105
106
no contm todos os elementos)

fim-se
107 fim-procedimento
108
109 { parte principal }
110 algoritmo
111
declare conjunto1, conjunto2, conjuntoUnio: tConjunto
112
113
{ entrada de dados }
114
leiaConjunto(conjunto1)
115
leiaConjunto(conjunto2)
116
117
{ unio }
118
unaConjuntos(conjuntoUnio, conjunto1, conjunto2)
119
120
{ resultado }
121
escreva(Resultado da unio de)
122
escrevaConjunto(conjunto1)
123
escreva(e)
124
escrevaConjunto(conjunto2)
125
escreva(contm os elementos)
126
escrevaConjunto(conjuntoUnio)
127 fim-algoritmo
Seguem alguns comentrios pertinentes sobre o Algoritmo 10-4. Na

parte principal feita a leitura de cada um dos conjuntos, seguida da unio
e da apresentao dos resultados (que inclui ambos os conjuntos e o
conjunto resultante da unio).
O procedimento leiaConjunto pega um registro do tipo tConjunto
passado por referncia. Faz primeiro a leitura do nmero de elementos que
sero
digitados,
garantindo
que
estejam
no
intervalo
[0, mximoElementos]. O conjunto ajustado para que seja vazio (ou
seja, com nmero de elementos igual a zero) e cada elemento lido
inserido no conjunto, atualizando o campo nmeroElementos, que
controla a quantidade de elementos vlidos. Um procedimento especfico
para colocar um novo elemento no conjunto (insereConjunto) tem a
jander moreira

funo de acrescentar um item ao arranjo, desde que haja espao e que o
elemento ainda no exista. O sucesso ou no da insero indicado por um
parmetro de sada (sucesso).
A sub-rotina escrevaConjunto faz simplesmente a apresentao dos
dados do conjunto.
Para que a unio seja realizada, feita uma cpia de um dos
conjuntos e, a esta cpia, so acrescentados, um a um, os elementos do
segundo conjunto. O procedimento insereConjunto usado novamente,
pois j verifica se h repeties, alm de checar por espao disponvel.
Em relao a aplicaes de arranjos, o prprio Algoritmo 10-4 ilustra
algumas delas. Podem ser citadas:
Utilizao de registros como um dos campos de registro, criando uma
estrutura mais autnoma e completa, j que representa, com seus
vrios campos, uma nica entidade.
Uso de arranjo como repositrio de elementos, incluindo um
procedimento de incluso de um novo elemento.
Pesquisa por um elemento em um arranjo, verificando sua existncia.
Outros tipos de uso incluem usar o arranjo para manter os dados em
ordem crescente, possibilitar a remoo de um elemento do arranjo (com
consecutivo decremento no contador de nmero de elementos).
O Algoritmo 10-5 apresenta outra verso para o procedimento
insereConjunto do Algoritmo 10-4, o qual mantm os elementos do
conjunto organizado de forma crescente. J o Algoritmo 10-6 ilustra um
procedimento para, dado um elemento, remov-lo do conjunto.
Algoritmo 10-5
1
procedimento insereConjunto(elemento: real, var conjunto: tConjunto,
2
3
var sucesso: lgico)

{ insere novo elemento no arranjo, mantendo ordem crescente nos
elementos; sucesso retorna falso se no h espao ou se h repetio,
e verdadeiro caso contrrio }
6
7
declare
i, posio: inteiro
8
9
{ valor padro para sucesso }
10
sucesso falso
11
12
se conjunto.nmeroElementos < mximoElementos ento
13
{ busca se j existe }
14
posio 0
15
enquanto posio < conjunto.nmeroElementos e
16
17
18
conjunto.elementos[posio] < elemento faa

posio posio + 1
fim-enquanto
19
20
se posio conjunto.nmeroElementos ou
jander moreira

21
conjunto.elementos[posio] elemento ento
22
{ faz o deslocamento dos itens maiores que o novo }
23
i conjunto.nmeroElementos 1
24
enquanto i posio faa

conjunto.elementos[i + 1] conjunto.elementos[i]
25
i i - 1
26
27
fim-enquanto
28
29
{ insere no arranjo }
30
conjunto.elementos[posio] elemento
31
conjunto.nmeroElementos conjunto.nmeroElementos + 1
32
sucesso verdadeiro
33
34
35
fim-se
fim-se
36 fim-algoritmo
Algoritmo 10-6
1
procedimento removerConjunto(elemento: real, var conjunto: tConjunto,
2
3
4
5
var sucesso: lgico)

{ busca e remove um dado elemento do conjunto retornando sucesso como
verdadeiro; se o item no existir, sucesso retorna falso }
declare i: inteiro
6
7
{ localiza o elemento }
i 0
enquanto i < conjunto.nmeroElementos e
10
elemento conjunto.elementos[i] faa

i i + 1
11
12
fim-enquanto
13
14
{ verifica presena ou ausncia do elemento }
15
se i conjunto.nmeroElementos ou
16
elemento = conjunto.elementos[i] ento

sucesso falso
17
18
seno
19
{ remove o item }
20
enquanto i < conjunto.nmeroElementos e
21
i < mximoElementos - 1 faa
22
conjunto.elementos[i] conjunto.elementos[i + 1]
23
i i + 1
24
fim-enquanto
25
conjunto.nmeroElementos conjunto.nmeroElementos - 1
26
27
28
sucesso verdadeiro
fim-se
29 fim-procedimento
jander moreira

10.3.3
Declarao e uso de arranjos bidimensionais
Uma estrutura bastante comum em matemtica so as matrizes.

Uma matriz um arranjo de duas dimenses (linhas e colunas) de
elementos, todos do mesmo tipo. Em algoritmos possvel usar arranjos
bidimensionais, tambm conhecidos genericamente como matrizes
(independentemente do tipo de dado dos elementos).
A declarao de arranjos bidimensionais feita com a especificao
de mais uma dimenso, o que representado por mais um valor includo
entre colchetes. Assim, um novo par de colchetes deve ser acrescentado.
So apresentados, abaixo, alguns exemplos de matrizes.
declare
idade[10][20]: inteiro
notas[50][3]: real
nomes[2][5]: literal
{ matriz 10 linhas por 20 colunas }

{ matriz 50 x 3 }
{ matriz 2 x 5 }
Como padro, adota-se a primeira dimenso para simbolizar as linhas

e a segunda para as colunas. Deste modo, idade[2][5] o valor
armazenado na terceira linha, sexta coluna. Novamente, os ndices se
iniciam em zero, terminando no valor da dimenso menos 1. No exemplo
acima, a matriz notas possui 150 elementos reais, com ndices variando de
notas[0][0] a notas[49][2].
10.3.4
Aplicaes prticas de arranjos bidimensionais
O exemplo inicial de aplicao a representao de matrizes de

nmeros reais, usadas em matemtica. No Algoritmo 10-7 apresentada
uma soluo para exemplificar o uso das matrizes, com os procedimentos
bsicos de leitura e escrita e algumas funes (trao e verificao se a
matriz quadrada). Na parte principal lido um grupo de matrizes
diferentes e alguns dados so apresentados.
Algoritmo 10-7
1
{ exemplo de utilizao de algumas operaes sobre matrizes matemticas }
2
3
constante
mximoLinhas: inteiro = 100
mximoColunas: inteiro = 100
6
7
tipo tMatriz: registro
nmeroLinhas, nmeroColunas: inteiro
dados[mximoLinhas][mximoColunas]: real
10
fim-registro
11
12 procedimento leiaMatriz(var matriz: tMatriz)
13 { obteno dos dados da matriz, incluindo as dimenses }
14
declare i, j: inteiro
15
16
{ obteno das dimenses }
jander moreira

17
faa
18
19
leia(matriz.nmeroLinhas, matriz, nmeroColunas)

enquanto matriz.nmeroLinhas < 0 ou
20
matriz.nmeroLinhas > mximoLinhas ou
21
matriz.nmeroColunas < 0 ou
22
matriz.nmeroColunas > mximoColunas
23
24
{ leiura dos dados }
25
para i 0 at matriz.nmeroLinhas 1 faa

para j 0 at matriz.nmeroColunas 1 faa
26
27
leia(matriz.dados[i][j])
28
29
fim-para
fim-para
30 fim-procedimento
31
32 procedimento escrevaMatriz(matriz: tMatriz)
33 { escrita dos dados armazenados na matriz }
34
declare i, j: inteiro
35
36
{ sada }
37
se matriz.nmeroLinhas 0 ou matriz.nmeroColunas 0 ento
38
39
escreva(Matriz invlida)
seno
40
{ apresentao da matriz }
41
para i 0 at matriz.nmeroLinhas 1 faa

para j 0 at matriz.nmeroColunas 1 faa
42
43
escreva(matriz.dados[i][j])
44
fim-para
45
46
fim-para
fim-se
47 fim-procedimento
48
49 funo Quadrada(matriz: tMatriz): lgico
50 { verifica se uma matriz quadrada }
51
52
retorne matriz.NmeroLinhas = matriz.nmeroColunas
53 fim-funo
54
55 funo traoMatriz(matriz: tMatriz): real
56 { calcula o trao da matriz; se no for quadrada, retorna 0 }
57
declare
58
i: inteiro
59
soma: real
60
61
{ soma os elementos da diagonal principal }
62
soma 0
63
se Quadrada(matriz) ento
64
65
66
para i 0 at matriz.nmeroLinhas faa

soma soma + matriz.dados[i][i]
fim-para
jander moreira

67
fim-se
68
69
{ resultado }
70
retorne soma
71 fim-funo
72
73 procedimento multipliqueMatriz(var resultado: tMatriz,
74
matriz1, matriz2: tMatriz)
75 { calcula a multiplicao de duas matrizes; se as dimenses no forem

76
77
compatveis, retorna uma matriz invlida (0 x 0) }

declare
78
79
{ verificao das dimenses }
80
se matriz1.nmeroColunas matriz1.nmeroLinhas ento
81
{ no possvel multiplicar }
82
resultado.nmeroLinhas 0
resultado.nmeroColunas 0
83
84
seno
85
{ calcula a multiplicao }
86
resultado.nmeroLinhas matriz1.nmeroLinhas
87
resultado.nmeroColunas matriz2.nmeroColunas
88
para i 0 at resultado.nmeroLinhas - 1 faa

para j 0 at resultado.nmeroColunas 1 faa
89
90
resultado.dados[i][j] 0
91
para k 0 at matriz1.nmeroColunas 1 faa

resultado.dados[i][j] resultado.dados[i][j] +
92
93
matriz1.dados[i][k] * matriz2.dados[k][j]
94
fim-para
95
96
97
{ usa como acumulador }
fim-para
fim-para
fim-se
98 fim-procedimento
99
100 funo temDiagonalZero(matriz: tMatriz): lgico
101 { retorna verdadeiro se todos os elementos da diagonal principal
102
forem nulos; se no forem nulos ou a matriz no for quadrada,
103
retorna falso }
104
declare
105
tudoCerto: lgico
106
i: inteiro
107
108
{ verificao }
109
tudoCerto Quadrada(matriz)
110
i 0
111
enquanto i < matriz.nmeroLinhas e tudoCerto faa
112
113
114
tudoCerto matriz.dados[i][i] = 0
i i + 1
fim-enquanto
115
116
retorne tudoCerto
jander moreira

117 fim-funo
118
119 algoritmo
120
declare
121
nmeroLeituras: inteiro
122
trao, maiorTrao: real
123
matriz, matrizSelecionada: tMatriz
124
125
{ iniciao }
126
maiorTrao -1E20
{ quase menos infinito }
127
128
{ leitura dos dados }
129
leia(nmeroLeituras)
130
para i 1 at nmeroLeituras faa
131
{ leitura dos dados da matriz }
132
leiaMatriz(matriz)
133
134
{ seleo da matriz de maior trao }
135
trao traoMatriz(matriz)
136
se trao > maiorTrao ento

maiorTrao trao
137
matrizSelecionada matriz
138
139
fim-se
140
141
{ alguns dados sobre a matriz digitada }
142
escreva(O trao , trao)
143
se no Quadrada(matriz) ento
144
escreva(A matriz no quadrada)
145
seno
146
escreva(A matriz quadrada)
147
se temDiagonalZero(matriz) ento
148
escreva(Todos os valores da diagonal so zero)
149
seno
150
escreva(Algum valor na diagonal no nulo)
151
fim-se
152
153
fim-se
fim-para
154
155
{ mais uma informao }
156
{ obs.: assume-se que nenhum trao resulte em 10-20 }
157
se maiorTrao = -1E20 ento
158
159
160
escreva(Nenhuma matriz digitada foi quadrada)

seno
escreva(O maior trao entre as matrizes foi, maiorTrao)
161
escreva(Matriz de maior trao:)
162
escrevaMatriz(matrizSelecionada)
163
fim-se
164 fim-algoritmo
jander moreira

Alm das matrizes de nmeros reais, so teis tambm matrizes com
outros tipos, pois podem representar adequadamente uma informao
importante para que o algoritmo resolva um determinado problema. Por
exemplo, uma matriz de valores lgicos pode representar um tabuleiro do
jogo de Batalha Naval, sendo que falso indica gua e verdadeiro
representa uma parte de uma embarcao em uma determinada
coordenada.
10.3.5
Arranjos multidimensionais
A extenso da dimensionalidade de um arranjo direta.

Acrescentando-se mais dimenses, ou seja, especificando mais ndices,
podem ser declarados arranjos de trs dimenses ou mais. Us-los pode ou
no ser adequado para representar algumas informaes.

Os arranjos, de qualquer dimenso, so ferramentas essenciais para
o desenvolvimento de algoritmos. Muitos dados tm que existir durante
grande parte do algoritmo e, portanto, devem ter todos seus valores
preservados para consulta em diversos momentos distintos. possvel
calcular a soma de duas matrizes de reais (soma elemento a elemento) sem
usar arranjos bidimensionais. Para isso, basta que sejam lidos os elementos
das matrizes intercaladamente, j apresentando o resultado (lem-se os
elementos a00 e o b00, calculando-se o resultado c00; ento so lidos a01 e o
b01, calculando-se c01, e assim sucessivamente). No , porm, uma forma
nem elegante nem prtica de resolver o problema. Mas uma soluo
possvel. O clculo da multiplicao das matrizes (codificada no Algoritmo
10-7), por sua vez, impossvel de ser feito sem que ambas as matrizes
estejam disponveis em vrios momentos, pois os dados so consultados
diversas vezes, sendo preciso estarem mo.
Um hbito que muitos desenvolvedores de cdigo adquirem, porm,
o de usar arranjos quase que indiscriminadamente, declarando vetores e
matrizes mesmo quando no so necessrios. Como um exemplo desta
situao, pense no problema bsico de calcular a mdia de um conjunto de
temperaturas, para o qual a soluo pode ler um vetor de temperaturas e
varr-lo para calcular a mdia dos valores. Nesta situao, cada valor de
temperatura necessrio uma nica vez e, assim, bastaria que uma nica
varivel (e no um arranjo inteiro) fosse empregada.
preciso sempre lembrar que arranjos tendem a consumir um
recurso importante, que a memria. Uma matriz 10x10, por exemplo,
possui 100 elementos; uma 100x100 j passa a armazenar 10.000 itens.
Uma matriz de trs dimenses 100x100x100, por sua vez, define
1.000.000. Quando o algoritmo for implementado em uma linguagem de
programao em um computador real, estas limitaes passam a ser
crticas. Como um caso prtico, pode-se considerar que um nmero real
simples, em uma linguagem de programao, utiliza 4 bytes. Isso leva uma
matriz 100x100 a consumir 40.000 bytes. Para realizar uma multiplicao
de matrizes usando o procedimento multipliqueMatriz do Algoritmo 10-7,
a parte principal do algoritmo deve usar trs matrizes (duas para leitura dos
jander moreira

dados e uma para armazenamento do resultado); ao ser feita a chamada da
sub-rotina, duas matrizes so criadas (a passagem por valor e feita uma
cpia dos dados), mas o resultado no requer outra matriz (a rea de
memria compartilhada, pois chamada por referncia). No saldo final,
so necessrias cinco matrizes, o que d um total de 200.000 bytes
somente para armazenar os elementos das diversas matrizes. Um exerccio
para o leitor refazer os clculos para um arranjo tridimensional
100x100x100.
Para resumir, possvel sempre lanar mo de um recurso
importante como arranjos, mas nunca se deve deixar de verificar sua real
necessidade e de se ter noo que o consumo de memria pode ser muito
elevado. Use com moderao.
jander moreira

Estruturas compostas mistas: homogneas e heterogneas
Unidade 11 - Estruturas compostas mistas:

homogneas e heterogneas
A organizao de dados em agrupamentos feita de dois modos em
algoritmos: na forma de registros (heterogneos) e na forma de arranjos
(homogneos).
Em muitas situaes um desenvolvedor cria uma matriz para guardar
dados reais e, em um determinado momento, pesa algo como bem que
esta ltima coluna poderia ser de valores lgicos, e no de reais. Para
estas (e outras situaes) um arranjo de dados homogneos no resolve o
problema, mas vivel pensar em uma estrutura heterognea.
Deste modo, passa a ser interessante a utilizao de um arranjo de
registros, que o tema desta ltima Unidade da disciplina.
11.2 Listas mais sofisticadas

A utilizao de conjuntos de dados que precisam ser mantidos em
memria durante parte do tempo de execuo de um algoritmo uma
necessidade real.
Pode-se considerar o seguinte problema: Uma adega mantm dados
sobre vinhos, que incluem nome do produto, nome do fabricante, nome do
distribuidor, tipo de vinho (tinto, branco ou ros), ano da safra, ano do
envasamento, preo da garrafa e nmero de unidades vendidas em um
dado perodo. Deseja-se, a partir destes dados, determinar o vinho de
maior sada em valor (nmero de unidades multiplicada pelo valor) e a
mdia, em valor, da sada geral de vinhos (mdia dos produtos de
quantidade por valor unitrio). Precisa-se, tambm, ao final, dos dados de
todos os vinhos que estejam abaixo desta mdia, para que a gerncia
decida sobre a continuidade das compras..
possvel, na proposio de uma soluo algortmica, criar um vetor
para cada informao (um vetor de nomes, um vetor de produtores, um
vetor de preos e assim por diante). A partir destes vetores, calcular o
vinho de maior sada, calcular a mdia e listar os dados desejados dos
vinhos abaixo da mdia.
Uma soluo mais elegante (no necessariamente computacional)
ter todos os dados tabulados, fazer os clculos necessrios e gerar os
dados. Para o algoritmo, o conceito reside em ter um nico vetor de dados,
sendo que cada posio corresponde a um vinho, ou seja, a um registro no
qual todos os dados daquele vinho estejam armazenados.
11.3 Declarao e uso de arranjos de registros

O uso de tipos a forma mais elegante, bem documentada e clara de
usar declaraes para arranjos de registros.
Como exemplificao para sua utilizao, apresentada uma soluo
para o problema dos vinhos da seo anterior. Como restries ao problema
jander moreira

se estabelece que o nmero mximo de itens na lista seja de 300 tipos
diferentes e que se saiba o nmero de itens existente.
Algoritmo 11-1
1
2
3
4
{ obter, para uma relao de dados sobre vinhos, o vinho de maior venda
e a lista de todos os vinhos que tenham venda abaixo da mdia geral do
grupo }
constante mximoElementos: inteiro = 300
5
6
tipo tVinho: registro
nome,
nomeFabricante,
nomeDistribuidor,
10
tipo: literal
11
anoSafra,
12
anoEnvasamento: inteiro
13
preo: real
14
unidades: inteiro
15
16
fim-registro
tListaVinhos[mximoElementos]: tVinhos
{ arranjo de registros }
17
18 procedimento leiaVinho(var vinho: tVinho)
19 { leitura de um registro de vinho }
20
21
leia(vinho.nome, vinho.nomeFabricante, vinho.nomeDistribuidor,
22
vinho.tipo, vinho.anoSafra, vinho.anoEnvasamento,
23
vinho.preo, vinho.unidades)
24 fim-procedimento
25
26 procedimento escrevaVinho(vinho: tVinho)
27 { leitura de um registro de vinho }
28
29
escreva(vinho.nome, vinho.nomeFabricante, vinho.nomeDistribuidor,
30
vinho.tipo, vinho.anoSafra, vinho.anoEnvasamento,
31
vinho.preo, vinho.unidades)
32 fim-procedimento
33
34 funo calculeVendas(vinho: tVinho): real
35 { retorna o produto do preo pelo nmero de unidades vendidas }
36
37
retorne vinho.unidades * vinho.preo
38 fim-funo
39
40 { parte principal do algoritmo }
41 algoritmo
42
43
declare
i, nmeroItens: inteiro
44
somaVendas, maiorVenda, mdiaVinhos: real
45
vinho: tListaVinhos
46
jander moreira

47
{ leitura da relao de dados e clculo da mdia e da maior venda }
48
leia(nmeroItens)
49
somaVendas 0
50
maiorVenda -1
51
para i 0 at nmeroItens 1 faa
52
{ assume-se maior ou igual a 1 }
leiaVinho(vinho[i])
53
54
somaVendas somaVendas + calculeVendas(vinho[i])
55
se calculeVendas(vinho[i]) > maiorVenda ento

maiorVenda calculeVendas(vinho[i])
56
57
fim-se
58
fim-para
59
mdiaVendas somaVendas/nmeroItens
60
61
{ apresentao da melhor venda }
62
63
se calculeVendas(vinho[i]) = maiorVenda ento
64
65
66
escrevaVinho(vinho[i])
fim-se
fim-para
67
68
{ apresentao dos vinhos abaixo da mdia calculada }
69
70
se calculeVendas(vinho[i]) < mdiaVinhos ento
71
72
73
escrevaVinho(vinho[i])
fim-se
fim-para
74 fim-algoritmo
Para esta soluo pode-se visualizar o arranjo de registros como

sendo uma tabela, na qual cada linha uma posio do arranjo,
organizando-se os campos como colunas. A Figura 11-1 mostra uma
representao visual do arranjo (mostrado verticalmente, com suas
posies identificadas pelos ndices), com os diversos dados de cada
campo * .
Os enlogos devem perdoar os dados ficcionais desta tabela de vinhos.
jander moreira

0
1
2
3
4
5
6
7
8
9
10
11
nome
nomeFrabricante nomeDistribuidor tipo anoSafra anoEnvasamento preo unidades
Cabernet
Salton
Perrichet
R
2000
2002
48,23
45
Chiraz
Guy Salmona
Os Cascos
T
2004
2006
87,04
10
Merlot
Miolo
Perrichet
T
2006
2007
28,90
123
Chiraz
Benjamin Romeo
VERCOOP
B
2005
2006
31,33
54
Chiraz
Benjamin Romeo
VERCOOP
B
1998
1999
48,22
22
Merlot
Salton
Anadil
T
2002
2002
102,50
23
Cabernet
Salton
Os Cascos
R
1956
1956
299,90
2
Chiraz
Benjamin Romeo
Anadil
B
2006
2006
87,34
34
Merlot
Guy Salmona
Perrichet
B
2006
2007
59,28
76
Cabernet
Salton
Perrichet
T
1997
2001
29,90
33
Cabernet
Miolo
Os Cascos
T
2006
2007
12,09
76
Merlot
Salton
VERCOOP
T
1937
1938
853,22
1
registro
campo
Figura 11-1. Ilustrao de um arranjo de registros como uma tabela.
Um ponto importante do uso de arranjos de servio o modo de

acesso aos dados. O arranjo uma nica varivel e corresponde a uma
coleo ordenada (e indexada) de elementos do mesmo tipo (como o tipo
tListaVinhos, no Algoritmo 11-1). Cada um de seus elementos
corresponde a um registro do tipo tVinho. Assim, ao se declarar a varivel
vinho na linha 45, o identificador vinho passa a ser todo o arranjo. A
especificao vinho[i] (linha 52, por exemplo), corresponde a um nico
registro e tem o tipo tVinho. Como, ainda na linha 52, vinho[i] um
registro, pode ser passado como argumento (por referncia, no caso) para
o procedimento leiaVinho, que aceita como parmetro exatamente um
registro do tipo tVinho, como se especifica na linha 18. Um cuidado em
especial deve ser tomado aqui para distinguir o parmetro vinho (do tipo
tVinho), que parte do procedimento leiaVinho da varivel vinho, da
parte principal do algoritmo, que um arranjo de 300 posies do tipo
tListaVinhos; os escopos so diferentes.
Pode-se, ainda, enfatizar que na parte principal do algoritmo seria
vlido escrever vinho[i].nome, j que vinho[i] um registro e nome
um de seus campos. Assim, a linha 70 teria exatamente o mesmo
significado se fosse escrita como abaixo, apenas substituindo a chamada da
funo pelo clculo que esta efetivamente faz.
se vinho[i].unidades * vinho[i].preo < mdiaVinhos ento
Ainda, preciso ateno para diferenciar o que seria vinho[i].nome

de vinho.nome[i]. No primeiro caso, vinho um arranjo de registros,
vinho[i] o registro de ndice i e, finalmente, vinho[i].nome o literal
contido neste campo para a posio i do arranjo. Na segunda especificao,
vinho.nome[i], vinho tem que ser um registro, para o qual um dos
campos nome, sendo nome um arranjo, no qual se escolhe a posio i.
Portanto, nesta segunda situao, existe um arranjo dentro do registro, e
no um arranjo de registros, como se est discutindo nesta Unidade.
jander moreira


Arranjos de registros formam uma das estruturas de dados que
melhor permite organizar dados de certa complexidade em colees de
elementos iguais. Permitem que esta organizao traga clareza para o que
os dados representam e como deve ser feito o acesso a cada campo.
claro que, no lugar de um arranjo de registros, seria vivel ter
vrios arranjos separados, um para cada campo. Porm, haveria a
introduo de um grau de desorganizao (ou sub-organizao), pois
dados que constituem unidades seriam representados por variveis
completamente separadas. Alm disso, seria inviabilizada a possibilidade de
leitura de todos os dados, como feito no exemplo usado nesta unidade.
Seria preciso, para o procedimento de leitura, passar como argumento cada
dado separadamente, como na linha seguinte.
leia(nome[i], nomeFabricante[i], nomeDistribuidor[i], tipo[i],
anoSafra[i], anoEnvasamento[i], preo[i], unidades[i])
Da mesma forma, cada parmetro teria que ser passado

separadamente para outros procedimentos ou funes, uma vez que no
existiria a unidade proporcionada pelo registro.
Recomenda-se fortemente, assim, o emprego de arranjos (ou at
matrizes, se for o caso) de registros no lugar de vrios arranjos (ou
matrizes) separadamente.
jander moreira

Construção de Algoritmos - Apostila

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Construção de Algoritmos - Apostila

Hochgeladen von

Copyright:

Verfügbare Formate

Construo de

Delimitaes necessrias aos algoritmos formais ..................... 1-2

Ordem de execuo ............................................................ 1-2

Definio para algoritmos .................................................... 1-4

Apresentao visual dos algoritmos...................................... 1-4

Unidade 2 - Conceitos bsicos para o desenvolvimento de

Tipos abstratos de dados ..................................................... 2-2

Modelo de computador ........................................................ 2-3

Formalizao da notao de algoritmos.................................. 2-4

Entrada, sada e atribuio................................................... 2-5

Regras para a formao de identificadores ............................. 2-9

Consideraes finais ........................................................ 2-10

Unidade 3 - Expresses algortmicas........................................ 3-1

Linearidade das expresses, operadores e precedncia ............ 3-2

Expresses aritmticas ........................................................ 3-2

Expresses literais .............................................................. 3-6

Expresses relacionais......................................................... 3-7

Expresses lgicas .............................................................. 3-8

Ordem global de precedncias de operadores ....................... 3-10

Uso de parnteses nas expresses ...................................... 3-10

Organizao visual nas expresses...................................... 3-11

Consideraes finais ........................................................ 3-11

Unidade 4 - Estratgia de desenvolvimento de algoritmos ....... 4-1

Abordagem top-down .......................................................... 4-2

Abordagem do problema...................................................... 4-4

Resoluo de problemas por refinamentos sucessivos .............. 4-8

Consideraes finais ........................................................ 4-10

Unidade 5 - Comandos condicionais ......................................... 5-1

Condicionais simples e completos.......................................... 5-2

Aninhamento de comandos .................................................. 5-4

Comandos de seleo mltipla .............................................. 5-5

Testes de mesa .................................................................. 5-7

Consideraes finais .......................................................... 5-8

Unidade 6 - Comandos de repetio ......................................... 6-1

Aplicaes prticas de repeties .......................................... 6-9

Consideraes finais ........................................................ 6-16

Unidade 7 - Ponteiros............................................................... 7-1

Memria e endereamento ................................................... 7-2

Acesso memria com ponteiros .......................................... 7-2

Consideraes finais .......................................................... 7-5

Unidade 8 - Estruturas compostas heterogneas: registros ..... 8-1

Declarao e uso de registros ............................................... 8-2

Consideraes finais .......................................................... 8-7

Unidade 9 - Sub-rotinas ........................................................... 9-1

Procedimentos ................................................................... 9-6

Parmetros formais............................................................. 9-7

Regras de escopo de declaraes .......................................... 9-9

Funes .......................................................................... 9-12

Construo de algoritmos iii

Consideraes finais ........................................................ 9-14

Unidade 10 - Estruturas compostas homogneas: arranjos...... 10-1

Declarao e uso de arranjos unidimensionais....................... 10-2

Aplicaes prticas de arranjos unidimensionais .................... 10-5

Declarao e uso de arranjos bidimensionais .......................10-13

Aplicaes prticas de arranjos bidimensionais.....................10-13

Arranjos multidimensionais ...............................................10-17

10.4 Consideraes finais ...................................................... 10-17

Construo de algoritmos 1-1

Conceitos bsicos sobre algoritmos

1.1 Primeiras palavras

1.2 Algoritmos no cotidiano

Construo de algoritmos 1-2

1.3 Conceitos bsicos de algoritmos e sua lgica