Algoritmos - Final

Ricardo Reis Pereira
Jerffeson Teixeira de Souza

Jeandro de Mesquita Bezerra
Algoritmos e Programao
1 Edio
2009
Copyright 2009. Todos os direitos reservados desta edio SECRETARIA DE EDUCAO A DISTNCIA
(SEAD/UECE). Nenhuma parte deste material poder ser reproduzida, transmitida e gravada, por qualquer
meio eletrnico, por fotocpia e outros, sem a prvia autorizao, por escrito, dos autores.
INFORMAES TCNICAS
Autores
Ricardo Reis Pereira
Jerffeson Teixeira de Souza
Jeandro de Mesquita Bezerra
Design instrucional
Antonio Germano Magalhes Junior
Igor Lima Rodrigues
Pedro Luiz Furquim Jeangros
Projeto grfico
Pedro Luiz Furquim Jeangros
Igor Lima Rodrigues
Marcos Paulo Rodrigues Nobre
Ilustrao
Diagramao
Francisco Jos da Silva Saraiva
Capa
PRESIDENTE DA REPBLICA
Luiz Incio Lula da Silva
MINISTRO DA EDUCAO
Fernando Haddad
SECRETRIO DE EDUCAO A DISTNCIA
Carlos Eduardo Bielschowsky
DIRETOR DO DEPARTAMENTO DE POLTICAS EM EDUCAO A DISTNCIA DPEAD
Hlio Chaves Filho
SISTEMA UNIVERSIDADE ABERTA DO BRASIL
Celso Costa
GOVERNO DO ESTADO DO CEAR
GOVERNADOR
Cid Ferreira Gomes
UNIVERSIDADE ESTADUAL DO CEAR
REITOR
Francisco de Assis Moura Araripe
VICE-REITOR
Antnio de Oliveira Gomes Neto
PR-REITORA DE GRADUAO
Josefa Lineuda da Costa Murta
SECRETARIA DE EDUCAO A DISTNCIA - SEaD
COORDENADOR DA SECRETARIA DE EDUCAO A DISTNCIA
Antnio Germano Magalhes Jnior
COORDENADOR GERAL UAB/UECE
Francisco Fbio Castelo Branco
COORDENADORA ADJUNTA UAB/UECE
Josete de Oliveira Castelo Branco Sales
COORDENADOR DO CURSO DE LICENCIATURA EM INFORMTICA
Jorge Luiz de Castro e Silva
COORDENADOR DE TUTORIA E DOCNCIA DA LICENCIATURA EM INFORMTICA
Andr Ribeiro Cardoso
Fundamentos .....................................................................................................................7
1. FUNDAMENTOS................................................................................................................9
1.1. A IDIA DE ALGORITMO ..........................................................................................9
1.2.CONSTRUO DE ALGORITMOS .............................................................................11
1.3.EXECUO DE ALGORITMOS ...................................................................................13
2. ENTRADA E SADA ............................................................................................................14
2.1. DISPOSITIVOS DE E/S ................................................................................................14
2.2. ENTRADA PADRO...................................................................................................14
2.3. SADA PADRO .........................................................................................................14
3. VARIVEIS ..........................................................................................................................15
3.1. A MEMRIA PRINCIPAL E AS VARIVEIS ..................................................................15
3.2. OS TIPOS DE VARIVEIS ...........................................................................................17
3.3. A DECLARAO DE VARIVEIS ................................................................................20
3.4. ENTRADA E SADA COM VARIVEIS ........................................................................20
Elementos Construtivos ......................................................................................................25

1. OPERADORES ....................................................................................................................27
1.1. A ATRIBUIO ..........................................................................................................28
1.2. OPERADORES ARITMTICOS....................................................................................30
1.3. OPERADORES RELACIONAIS ....................................................................................30
1.4. OPERADORES LGICOS...........................................................................................31
1.5. EXPRESSES ..............................................................................................................32
2. ESTRUTURAS DE CONTROLE ...........................................................................................34
2.1. DECISO ...................................................................................................................35
2.2. REPETIO ................................................................................................................43
Variveis Indexadas ............................................................................................................55

1. MATRIZES ..........................................................................................................................57
1.1. INTRODUO A MATRIZES E VETORES...................................................................57
1.2. MATRIZES NA MEMRIA ..........................................................................................58
1.3. DECLARAO, INICIALIZAO E USO DE VETORES ..............................................58
1.4. AS CADEIAS DE CARACTERES...................................................................................61
1.5. VETORES DINMICOS .............................................................................................64
1.6. USANDO MAIS DE UMA DIMENSO ......................................................................68
Programao Modular .......................................................................................................71

1. MODULARIZAO ...........................................................................................................73
1.1. O QUE MODULARIZAR?........................................................................................73
1.2. FUNES, PROCEDIMENTOS, PROCESSOS E CONTROLE .....................................73
1.3. ESCOPO DE VARIVEIS .............................................................................................76
1.4. PASSANDO ARGUMENTOS POR VALOR E POR REFERNCIA ................................78
1.5. PASSANDO VETORES COMO ARGUMENTOS .........................................................79
1.6. RECURSIVIDADE .......................................................................................................81
Fundamentos
UNIDADE
O objetivo desta unidade apresentar o conceito de algoritmos e suas
formas bsicas de representao: texto, uxograma e pseudocdigo. Outros
fatores importantes so: entradas e sada, seguidas de outros fundamentos
como variveis.
1. FUNDAMENTOS
1.1. A IDIA DE ALGORITMO
Para realizar uma viagem primordial fazer o seu planejamento. De
onde se partir e qual o destino? Que meios de transporte sero usados, qual
o custo e tempo que cada um leva? So necessrias novas roupas? Se mais de
um lugar foi visitado no percurso quanto tempo se ficar e o que se visitar
em cada um deles? Onde se ficar em cada lugar, em um hotel, uma pousada
ou um albergue? Tendo-se essas informaes (entre outras) pode-se coloclas em papel para estimar o custo total e ver a viabilidade da viagem. Mas
se imprevistos acontecerem? Uma lista de planos alternativos poder evitar
muitas dores de cabea.
Partir de uma receita para se preparar alguma coisa rotina comum
em culinria. Quem escreve tais receitas lista o que necessrio, tanto em
ingredientes quanto em utenslios alm, claro, nas etapas que devem ser
seguidas. Seguir a risca, entretanto, pode s vezes ser invivel por que algum
ingrediente poder no estar disponvel (um alternativo poder ser usado). A
boa receita deve prever as faltas potenciais para sua realizao e documentlas
Montar um novo equipamento, que acabou de chegar pelos correios
numa grande caixa, pode no ser uma tarefa muito fcil principalmente
quando as instrues de montagem no so bem documentadas ou fracamente
ilustradas. Boas instrues vm em passos escritos em blocos separados e ao
lado de gravuras legveis e de fcil compreenso. Em muitos casos o fabricante
fornece, para auxiliar seus clientes, uma listagem das ferramentas apropriadas
(quando necessrias). Bicicletas, mveis e alguns brinquedos ilustram bem esta
situao.
Pessoas que tem pouco tempo a perder precisam de uma agenda (e s
vezes tambm uma secretria) para darem conta de todas as suas obrigaes. As
tarefas ou compromissos so listados por data e hora. Imprevistos obviamente
podem acontecer e desta forma requerem decises tais como cancelamento
de algumas etapas ou remarcao para outro dia. Executivos e homens de
negcio conhecem bem a necessidade do agendamento.
As situaes descritas ilustram a idia de algoritmo. Um algoritmo um
conjunto de passos finitos que devem ser seguidos para que certo objetivo seja
alcanado. Algoritmos tm natureza terica e correspondem a planejamentos
estruturados (e preferencialmente otimizados) de algo que se deseja realizar,
como fazer uma viagem, preparar um prato especial, montar uma bicicleta
ou solucionar as pendncias de uma empresa. Para cumprir um algoritmo
decises precisam ser tomadas, aes precisam ser realizadas e recursos
restritos precisam ser gerenciados. O processo de realizao de um algoritmo
conhecido como execuo do algoritmo.
ALGORITMOS E PROGRAMAO
O planejamento de uma viagem impresso em papel seu algoritmo ao

passo que a viagem em si sua execuo. Os recursos so dinheiro, transportes,
hotis, roupas, guias e etc. As decises ocorrem em diversos nveis do processo,
como por exemplo, a seqncia de visitas das obras de arte num certo museu.
A receita de um bolo numa sesso culinria de revista um algoritmo.
Os recursos para sua execuo so ingredientes, utenslios em geral, forno, etc.
A execuo o trabalho do cozinheiro. Decises diversas podem ser tomadas
neste processo como a simples complementao de um ingrediente por um
alternativo ou o aumento do tempo em forno devido o bolo no ter alcanado
o aspecto ou textura desejados.
As instrues de montagem de uma bicicleta exemplificam outro
algoritmo. Neste caso os recursos so peas, ferramentas e etc. A execuo
o trabalho do montador. Um exemplo comum de deciso deste processo
abandonar certa etapa somente quando h certeza da fixao mecnica das
partes daquela etapa.
Cada data em uma agenda representa um algoritmo para aquela data.
A execuo o cumprimento de todos os compromissos durante o dia.
Dependendo do portador da agenda os recursos podem variar (carro, dinheiro,
roupas apropriadas, computador porttil, secretria, escritrio, celular e etc.).
O trabalho de um executivo praticamente tomar decises para cumprimento
de seu agendamento.
Um algoritmo computacional aquele construdo baseado nas
capacidades e recursos disponveis de um computador. Os recursos disponveis
em computadores modernos so representados por seu hardware, ou seja, a
CPU, a memria principal, a memria de armazenamento e os perifricos de
entrada/sada. Dificilmente estes recursos so acessados diretamente porque
um software especial, o sistema operacional, gerencia o uso deles de forma a
equilibrar a demanda dos softwares em execuo.
Um algoritmo computacional requer a definio de uma linguagem para
que possa ser expresso. Essa linguagem consiste em um conjunto relativamente
pequeno de regras pr-estabelecidas, denominadas sintaxe da linguagem,
que devem ser mantidas em todo o corpo construtivo de um algoritmo
computacional. O texto em questo visa apresentar uma sintaxe simples para
a criao de algoritmos computacionais baseada em outras metodologias de
criao de algoritmos que investigamos nos ltimos anos. Daqui para frente
trataremos algoritmos computacionais simplesmente por algoritmos.
Um algoritmo necessita ser transformado em um programa para que
possa ser executado por um computador. Essa transformao consiste numa
traduo do algoritmo para uma linguagem de programao. Uma linguagem
de programao , como uma metodologia de ensino de algoritmos, um
conjunto de regras. Entretanto a sintaxe de tais linguagens mais complexa e
rgida e requer estudo mais aprofundado (Sebesta, 2007).
Denomina-se compilador a um software capaz de reconhecer um
arquivo de texto contendo um programa escrito numa dada linguagem de
10
programao e traduzi-lo num cdigo em linguagem de mquina para que

possa ser finalmente executado pelo computador. Se um algoritmo expresso
numa linguagem X hipottica, ento precisa de um compilador X para ser
reconhecido e traduzido (processo de compilao). Um compilador hipottico
Y, por exemplo, no reconhece cdigos escritos na linguagem X. A compilao
no a nica metodologia prtica para execuo de um programa. O leitor
ainda pode investigar a interpretao pura e interpretao hbrida em
(Sebesta, 2007). A metodologia preferencial neste texto a compilao.
H inmeras linguagens de programao projetadas para fins diversos que
vo entre criao de sistemas operacionais a desenvolvimento de aplicaes
Web. Bom domnio sobre construo de algoritmos pr-requisito necessrio
para o ingresso no estudo de uma linguagem de programao.
1.2. CONSTRUO DE ALGORITMOS

H muitas formas de se representar um algoritmo. As mais comuns
so por texto livre, por fluxogramas e por pseudocdigos. Num algoritmo
em texto livre a idia expressa utilizando-se todos os recursos existentes
numa linguagem natural especfica (portugus, ingls, etc.). Um exemplo
comum desta abordagem so as receitas de bolo normalmente apresentadas
em dois pargrafos: aquele com a lista de ingredientes e outro descrevendo a
preparao passo a passo. A lista de ingredientes corresponde fase declarativa
do algoritmo, ou seja, a parte que antecede o prprio algoritmo e visa buscar
os recursos necessrios a sua realizao.
Algoritmos representados por fluxogramas utilizam obviamente a
estratgia grfica para se expressarem. Cada uma das etapas (ou grupo de
etapas) representada por um elemento geomtrico (retngulo, crculo, etc.).
Todos os elementos constituintes so ento conectados logicamente por
arestas orientadas (setas). Efetuar cada uma das aes requeridas nos elementos
geomtricos na seqencia das setas corresponde execuo do algoritmo.
O fluxograma a seguir ilustra um algoritmo simples para fazer uma viagem a
cidade de Fortaleza (os retngulos representam aes e os losangos decises).
11
PALAVRAS
RESERVADAS:
Em programao de computadores, uma palavra reservada uma palavra que, em

algumas linguagens de programao, no pode ser utilizada como um identificador
por ser reservada para uso
da gramtica da linguagem.
A construo de algoritmos via pseudocdigos a preferencial deste

texto. Nesta representao so usados recursos de linguagem natural, mas
com quantidade bastante reduzida de vocbulos e estruturas para melhor
assimilao. Os vocbulos desta metodologia so divididos em duas categorias:
de aplicao pr-determinada, chamadas palavras reservadas e de definio
customizada (durante criao do algoritmo), mas com regras pr-estabelecidas.
Palavras reservadas podem ser comandos ou elementos de estruturas. Os
comandos so invocaes de tarefas especficas nos algoritmos, por exemplo,
um comando de impresso deve imprimir uma mensagem de texto. A invocao
de um comando conhecida como chamada do comando. Os elementos de
estruturas associam-se nas estruturas de controle para efetuar decises ou
repeties (dependendo do contexto). Importantes comandos e estruturas de
controle sero estudados ao decorrer deste texto.
Por exemplo, na linguagem

de
programao
PASCAL,
um programador no pode
utilizar uma varivel com o
nome read pois esta palavra
reservada para a leitura de
variveis. Ela uma "palavra
As regras de sintaxe de um algoritmo tratam-se das restries prestabelecidas para possibilitar a criao de pseudocdigos. Neste texto so
definidas vrias regras de sintaxe e mantidas at o final. bom lembrar que tais
regras no so universais, mas que em qualquer apresentao de metodologia
algortmica, um conjunto de regras de sintaxe se mostrar necessrio para
garantir conciso e clareza dos algoritmos.
chave", e por ser de uso restrito, tambm uma "palavra

reservada".
A palavra semntica ser esporadicamente utilizada para se referir ao

significado lgico dos elementos ou estruturas que constituem um algoritmo.
Isso importante porque muitas construes feitas no so intuitivas e a
compreenso s ser possvel se houver prvio conhecimento do que elas se
propem a fazer.
Algoritmos em pseudocdigo apresentam-se como um texto contendo
diversas linhas de cdigo. Uma mesma linha pode conter um ou mais
comandos ou ainda estruturas de controle. Vrias linhas de cdigo podem
estar encapsuladas por um conceito lgico denominado bloco. O cdigo de
um bloco possui dessa forma incio e fim e representa um sub-processo do
processo geral de execuo do algoritmo. Veja o exemplo esquemtico:
//bloco de instrues
instruo 1
instruo 2
instruo 3
Um mesmo algoritmo pode conter diversos blocos seriados ou blocos

dentro de outros blocos. Se um bloco est dentro de outro dizemos que h
aninhamento de blocos. O aninhamento construdo por indentao, ou
seja, colocando-se recuos no texto-cdigo para produzir uma hierarquia. Veja
o exemplo esquemtico:
//bloco 1
instruo 1-1
instruo 1-2
// bloco 2 indentado
instruo 2-1
instruo 2-2
instruo 2-3
instruo 1-3
12
Neste exemplo o bloco 2 parte integrante do bloco 1, mas tem

significado lgico independente dentro deste bloco e desta forma indentado.
Vrios nveis de indentao so permitidos num mesmo pseudocdigo. Mais
tarde ser estudado como a indentao auxilia fortemente na legibilidade de
algoritmos.
Blocos tambm permitem a criao de mdulos. Mdulos so blocos
do pseudocdigo com aes a executarem atravs de uma chamada, ou seja,
so comandos personalizados. Um mesmo algoritmo pode possuir diversos
mdulos onde um deles, exatamente aquele onde a execuo principia,
chamado bloco principal ou funo principal. At o estudo dos mdulos, os
pseudocdigos apresentados neste texto sero constitudos apenas do bloco
principal.
O par de barras //, utilizado nos exemplos esquemticos anteriores,
marca a linha como comentrio de forma que a mensagem que ele precede
possui apenas valor informativo.
1.3. EXECUO DE ALGORITMOS

Executar um algoritmo significa executar seqencialmente cada uma das
linhas que formam o bloco principal onde pode haver dezenas ou mesmo
centenas de linhas. No necessariamente todas as linhas sero processadas.
Podero ocorrer as seguintes possibilidades: (i) algumas linhas podero ser
saltadas; (ii) um grupo de linhas poder ser diversas vezes repetido (iii) um
comando ou mdulo poder ser chamado principiando o processamento de
linhas de outro bloco processamento; (iv) a execuo encerrada porque a
ltima linha foi executada ou porque foi suspenso explicitamente.
O salto e a repetio em algoritmos sero estudados mais adiantes. Para
suspender um algoritmo antes da ltima linha utilizaremos o comando pare,
como segue.
instruo
instruo
pare
instruo
instruo
1
2
3
4
Neste exemplo a execuo de pare implica suspenso imediata de

processamento (sem realizao das duas ltimas linhas).
Linhas so elementos construtivos de textos e normalmente tem
significado impreciso em algoritmos. Ao invs de linhas consideraremos
o conceito de instrues. Uma instruo corresponde a cada poro do
pseudocdigo tomada para execuo. Comumente h uma instruo por
linha (o que torna linhas e instrues sinnimas), entretanto h instrues
montadas normalmente utilizando mais de uma linha. No restante deste texto
abordaremos algoritmos como listagens de instrues e no mais de linhas.
13
2. ENTRADA E SADA
2.1. DISPOSITIVOS DE E/S
Dispositivos de entrada e sada, ou simplesmente E/S, so todos e
quaisquer hardwares responsveis pelo fornecimento ou leitura de informaes
do/para o computador. A forma mais tradicional de entrada de dados ainda
a alfanumrica e feita atravs de teclados. Devido sua grande importncia,
definiremos neste texto os teclados como sendo a entrada padro dos
programas. Similarmente a mais tradicional sada de dados visual e ocorre
via monitores (naturalmente associados s placas de vdeo). Definiremos a
associao monitor/placa de vdeo como sendo a sada padro.
2.2. ENTRADA PADRO

Como definimos anteriormente, o teclado o dispositivo padro de
entrada. Todas as informaes fornecidas por teclado so alfanumricas, ou seja,
letras, nmeros e alguns smbolos. O processo de entrada de dados atravs de
teclados funciona da seguinte forma: Cada tecla pressionada gera um caractere
que armazenado num buffer mantido por algum software em execuo (e
que obviamente detm temporariamente o controle sobre o teclado). Quando
uma tecla de confirmao por fim pressionada (normalmente ENTER em
teclados convencionais), ocorre a transferncia da informao contida no buffer
(esvaziamento de buffer) para seu destino final. Muitas vezes essa transferncia
demanda algum processamento adicional: isso ocorre porque toda informao
recebida de fato textual e assim o computador precisa identificar e
transformar parte deste texto em outro tipo de informao. Por exemplo, se
um usurio digita produto 25, custo 9.78, de fato 22 caracteres, incluindo
vazios, que sero recebidos; entretanto se algum processamento adicional
estiver associado, ento o inteiro 25 e o real 9.78 podero ser extrados.
A sintaxe que evoca a entrada padro ser construda com a palavra
reservada, leia, como no exemplo:
leia x
Observe que todos os detalhes funcionais do dispositivo fsico so

ocultados e simplificados num nico comando imperativo (neste caso, leia).
Mais detalhes sobre entrada de dados com leia sero vistos mais adiante.
2.3. SADA PADRO

Como j definido, a associao placa de vdeo/monitor a sada
padro. Em computadores mais antigos os monitores eram capazes apenas
de mostrar texto: a resoluo da tela restringia-se a um plano cartesiano de
poucas colunas por poucas linhas onde em cada clula desta grade invisvel
14
era possvel escrever um caractere apenas. Quando a tela enchia os caracteres

comeavam a rolar para cima num aparente efeito de paginao. Cada
programa posto em execuo tinha a tela como alvo de sua sada (ou em outros
casos a impressora) de forma que fcil, neste contexto, associar o monitor
como um todo sada visual de um programa. Nos dias atuais o conceito
de sada tornou-se sofisticado: o sistema operacional normalmente consegue
manter diversas janelas grficas cada uma delas associada a um programa em
execuo. Cada uma destas janelas gerencia de forma independente entrada
e sada do programa a que esto ligadas. Quando uma janela contm o foco
(como usualmente se diz), significa que esta janela est frente de todas as
outras (em termos de visibilidade) e ainda que qualquer entrada via teclado
ser recebida por ela.
Devido natureza grfica das janelas flutuantes nos sistemas operacionais
modernos, existem cada vez mais formas poderosas de interagir com o
aplicativo. De fato atualmente investem-se bastante em interfaces cada vez
mais inteligentes que facilitem a interao do usurio com o computador.
Neste estudo de algoritmos no sero considerados detalhes sobre
as modernas interfaces grficas de sada. Ao invs disso consideraremos
todas as sadas do algoritmo sendo escritas para uma janela hipottica cujo
comportamento idntico ao dos antigos monitores, ou seja, trata-se de um
continer alfanumrico para onde so enviadas mensagens de texto: se a janela
enche um efeito de paginao se procede empurrando os caracteres para cima
de forma que sempre o ltimo contedo impresso ficar disponvel na parte
inferior da janela.
A sintaxe que evoca o envio de dados para a sada padro construda
aqui com a palavra reservada, escreva, como no exemplo:
escreva ol mundo!!
Este exemplo ilustra o uso mais simples de escreva: a impresso de

mensagens. Uma mensagem simplesmente um agregado de caracteres entre
aspas simples. Uma mensagem aparecer na sada padro tal como foi escrita
no pseudocdigo. Mais adiante sintaxe adicional de escreva ser apresentada
para impresso de outros tipos de informao.
3. VARIVEIS
3.1. A MEMRIA PRINCIPAL E AS VARIVEIS
A memria principal a memria voltil do computador, ou seja, s
armazenar alguma informao enquanto corrente eltrica cruzar seus circuitos
(A memria projetada para manter informaes, mesmo com o equipamento
desligado, a memria secundria, como por exemplo, os discos rgidos). Na
memria principal sero colocados os programas para que sejam executados.
Estes por sua vez precisaro de memria adicional para realizar suas tarefas.
Nos computadores modernos muitos programas podem estar em execuo ao
15
mesmo tempo e assim concorrerem pela mesma memria livre no momento

em que suas atividades requererem mais espao.
A problemtica geral sobre o gerenciamento de memria em
computadores a seguinte: como impedir que programas distintos no sejam
gravados na mesma rea de memria e ainda, como impedir que eles concorram
pela mesma regio livre de memria no momento em que requerem espao
adicional? De fato esta responsabilidade do sistema operacional atravs do
gerenciador de memria. Os projetistas de um sistema operacional devem
prever que os programas, que rodaro sobre ele, faro tais exigncias em
relao memria principal. Tal delegao de controle da memria ao sistema
operacional implica no seguinte fato: qualquer demanda por memria ser
resolvida mediante requisio formal ao sistema operacional mantendo-o
sempre no controle da memria principal. Uma analogia deste comportamento
o funcionamento de alguns espaos para estacionamento de carros: o
cliente faz a solicitao formal por uma vaga entrada do estabelecimento. O
funcionrio na guarita (que trabalha como o gerenciador de memria) registra
a entrada do cliente e marca como usada a vaga que ele preencher. Quando
ele volta e recolhe seu carro, espao liberado e o funcionrio atualiza o status
daquela vaga como livre. Se um cliente qualquer requer uma vaga no h risco
de ser indicado a um lugar j ocupado.
Na memria secundria os dados so gerenciados atravs de blocos de
bytes chamados arquivos que se encontram em diretrios (pastas) estruturadas
numa grande rvore de diretrios. Essa metodologia transparente aos usurios
de computadores os quais contam com as possibilidades de adicionar e remover
arquivos e pastas. E na memria principal, como ocorre o gerenciamento? Cada
processo (programa) consiste num conjunto de instrues gravadas numa parte
da memria que foi requisitada ao sistema. O sistema busca por essa memria
e a marca como ocupada numa tabela de controle. Quando o processo se
encerra (fim da execuo do programa) seu espao liberado removendo-se a
marca da tabela: esta rea agora est apta ao uso por outros processos.
E quando cada processo requer por memria adicional? Neste caso
instrues do prprio programa fazem a requisio de memria ao sistema
operacional. Os programas devem dizer quanto precisam e o sistema responde
marcando reas livres de memria que assumiro e mantero o status de
ocupadas enquanto estiverem sobre a tutela daquele processo que as requereu.
E como os programas gerenciaro internamente cada bloco de memria
requisitado? Para tanto existe um mecanismo denominado vinculao:
ele consiste em ligar uma entidade abstrata interna definida no cdigo do
programa (pelo programador) a uma parte finita da memria. Tais entidades
so denominadas variveis do programa e a regio a que so vinculadas de
clulas de memria.
Um programa pode requerer quantas clulas de memria adicional
precisar atravs do uso de variveis. Cada varivel conter seu prprio nome
e seu escopo (este conceito ser abordado mais adiante). Devido ao carter
formal de requisio de memria as variveis precisam ser referenciadas no
programa antes de serem utilizadas. Esse referenciamento denominado
declarao de variveis.
16
Variveis podem ser primitivas ou derivadas. As variveis primitivas

tratam da representao de dados elementares como nmeros e caracteres.
Existem categorias distintas de variveis primitivas as quais se diferenciam
basicamente pelo tipo de dados que se propem a armazenar e pela faixa de
representao destes dados. Variveis derivadas (como os vetores) so aquelas
constitudas por mais de um elemento primitivo e sero estudadas mais adiante.
3.2. OS TIPOS DE VARIVEIS

So quatro os principais tipos primitivos de variveis: Inteiros, Reais,
Caracteres e Lgicos. A seguir fazemos a descrio de cada um.
3.2.1. TIPOS NUMRICOS: INTEIROS E REAIS

muito comum em programao de computadores o uso de valores
numricos. Eles dividem-se basicamente em dois grandes grupos: o dos
inteiros e o dos reais. Freqentemente h confuso entre o conceito de
inteiros e reais em computao e em matemtica. Nesta ltima tais definies
correspondem a conjuntos com quantidade infinita de nmeros alm do fato
de o conjunto dos inteiros ser contido no dos reais. Em computao valores
inteiros e reais tambm representam conjuntos de nmeros, mas neste caso de
quantidade finita de elementos. Alm do mais a idia de inteiros contido nos
reais no se aplica com exatido neste caso. Analisaremos estes dois aspectos
nos pargrafos seguintes.
Por que h finitos inteiros e reais nos tipos numricos dos computadores?
A resposta simples: cada clula de memria possui uma quantidade finita
de bits. Assim cada nmero em base decimal representado em circuito por
um layout de um grupamento de bits (base binria) previamente vinculado a
uma varivel. De fato o que se faz pr-estabelecer uma quantidade fixa de
bytes para variveis de um dado tipo e verificar que faixa de valores pode ser
representada. Por exemplo, com 1-byte podem-se montar at no mximo 256
combinaes de zeros e uns que podero tanto representar nmeros inteiros
entre -128 e 127 (denominados inteiros de 1-byte com sinal) quanto de 0 a 255
(inteiros de 1-byte sem sinal). Para mais detalhes sobre bases numricas e suas
transformaes o leitor pode consultar (FERNANDEZ; FEDELI, 2003).
3.2.2. TIPO CARACTERE

A maior parte da informao em formato eletrnico contido nos
computadores em todo mundo textual, ou seja, formada de caracteres
das diversas linguagens naturais (portugus, ingls, francs, alemo etc.).
obviamente importante desenvolver mtodos computacionais seguros que
permitam o armazenamento e recuperao deste tipo de informao.
17
Como uma mquina intrinsecamente numrica pode armazenar texto?

Na realidade qualquer informao registrada e recuperada por computadores
ser binria, e ainda, aps um tratamento de converso, por exemplo, binrio
para decimal, estas seqncias de bits se apresentaro como nmeros inteiros.
Ento onde entram os caracteres? Estes so mantidos por tabelas existentes
em vrias categorias de softwares como editores de textos ou mesmo o
prprio sistema operacional. Nestas tabelas h duas colunas relacionadas: na
primeira encontram-se nmeros normalmente inteiros sem sinal; na segunda
um conjunto de grafemas de uma ou mais lnguas naturais: so os caracteres.
Nestas tabelas existe um nico inteiro para cada caractere e vice-versa.
As tabelas de caracteres podem ter tamanhos variados de acordo com a
quantidade de bits dedicados a representao dos valores inteiros da primeira
coluna. Com 1-byte, por exemplo, tem-se 8-bits e logo nmeros entre 0 e 255:
assim com 1-byte 256 caracteres distintos podem ser representados.
Uma das mais comuns tabelas de caracteres utiliza 7-bits e denomina-se
ASCII (American Standard Code for Information Interchange, que em portugus
significa "Cdigo Padro Americano para o Intercmbio de Informao). Este
padro tem uso difundido em todo o mundo e aceito praticamente por
todos os softwares de edio de texto. Neste texto os algoritmos tomaro seus
caracteres do padro ASCII. A representao em pseudocdigo ora aparecer
como nmero (que neste caso est na faixa 0 a 27-1, ou seja, 0 a 127) ora
aparecer como o caractere propriamente dito (grafema). Neste ltimo caso
os grafemas correspondentes sero escritos sempre entre aspas simples ( ). A
seguir ilustramos parcialmente a tabela ASCII fazendo pares do valor numrico
com o caractere (entre aspas simples) equivalente:
Na prtica muitos editores de texto simples salvam e recuperam seus

arquivos de texto pela leitura byte a byte considerando cada um destes como
um caractere ASCII: o oitavo bit obviamente no representativo. Por englobar
apenas 128 grafemas (27), ele pouco representativo no que diz respeito s
inmeras lnguas naturais e seus diversificados caracteres. A representao
de letras acentuadas, por exemplo, em lngua portuguesa no suportada
18
convenientemente em tal sistema. Por isso muito comum encontrar fontes

de dados em formato eletrnico (na internet, por exemplo) com erros de
acentuao. Um sistema mais universal e mais complexo, o UNICODE, substitui
progressivamente o ASCII na representao de caracteres.
E como funcionam os tipos caracteres em programao? Cada varivel
declarada como caractere num programa armazena de fato um nmero
inteiro. Na maioria das implementaes de linguagens de programao, as
clulas de memria vinculadas so de 1-byte (isso tem mudado para 2-bytes
em linguagens mais atuais com o UNICODE). Ento quando se recorrem s
tabelas de caracteres? Isso acontece na impresso. A impresso o momento
onde informao enviada para um dispositivo (hardware) de sada como uma
impressora, um disco ou a tela. Cada hardware reage de forma diferente ao
recebimento de dados para impresso: a impressora deposita tinta em papel,
no disco arquivos so criados ou tm alterados seus contedos; e na tela so
impressos momentaneamente imagens para leitura. Em todas essas aes a
informao textual recebe arte final pela recorrncia s tabelas de caracteres.
Mais adiante sero estudadas as cadeias de caracteres: elas
correspondem a junes (concatenaes) de dois ou mais caracteres e so de
fato as entidades representativas dos textos.
3.2.3. TIPO LGICO

Uma varivel lgica quando ela possui apenas dois valores possveis:
genericamente Verdadeiro e Falso, ou ainda 0 e 1. Tais notaes provm da
lgebra booleana e por essa razo este tipo de dados comumente denominado
tambm tipo booleano.
Em termos de memria 1-bit seria necessrio para representar variveis
lgicas. Entretanto o que se v na prtica o uso de 1-byte. Isso se deve
ao modelo de endereamento das mquinas modernas efetuado byte a byte
(o endereamento bit a bit seria custoso e ineficiente). O uso de um byte
completo por booleanos resolvido da seguinte forma: uma varivel lgica
ser Falsa se todos os oito bits forem zeros, do contrrio ser Verdadeira.
Em algumas linguagens de programao h uma relao direta entre
variveis inteiras de 1-byte e variveis lgicas. Se x uma varivel lgica, por
exemplo, ao receber um valor inteiro, caso seja nulo (todos os bits iguais a 0)
ento a x ser atribudo de fato o valor Falso; caso contrrio a x ser atribudo
Verdadeiro. Analogicamente se y inteiro e a y atribudo Falso, tal varivel
receber 0; do contrrio se a y for atribudo Verdadeiro, tal varivel receber 1.
19
3.3. A DECLARAO DE VARIVEIS

A primeira parte de um algoritmo computacional normalmente a
declarativa, ou seja, nela so definidas as variveis que sero utilizadas no
restante do cdigo. Considere o exemplo a seguir:
declare
i: inteiro
x, y: real
b: lgico
c: caractere
//instrues do bloco de cdigo
Este pseudocdigo ilustra como funciona a declarao de cinco variveis:

uma inteira, chamada i, duas reais, chamadas x e y; uma lgica, chamada b; e
uma de tipo caractere chamada c. A sesso de declarao de variveis possui
a seguinte sintaxe fixa: a palavra chave declare marcando o incio da sesso e
logo abaixo a lista de variveis indentada em um nvel para representar o bloco
de variveis. Cada linha desta lista constituda por um subgrupo de uma ou
mais variveis de mesmo tipo; caso haja mais de uma varivel por subgrupo,
elas sero separadas por vrgulas (como ocorreu a x e y). Cada subgrupo de
variveis encerrar em dois pontos (:) seguido pelo tipo base do subgrupo. Os
tipos primitivos base tero os nomes inteiro, real, caractere e lgico (cada
qual referindo-se aos tipos j apresentados).
O nome das variveis normalmente aparece como um nico caractere:
entretanto isso no obrigatrio. Nomes completos so legais e as regras para
cri-los so as seguintes: no so usadas palavras reservadas (como declare,
pare, etc.); no so usados caracteres especiais na grafia (como *, # ou &); no
so usados espaos em branco em um mesmo nome; nmeros so permitidos
desde que no estejam no comeo do nome (exemplo, x88 vlido, mas 5w
no ); uso de underline (_) legal. Exemplos:
declare
alpha, beta: inteiro
dia _ de _ sol: lgico
x200, y _ 90, hx: real
ch _ base _ 5: caractere
Aps a sesso declarativa de variveis segue o bloco principal do algoritmo.

Variveis declaradas e no utilizadas neste bloco devero ser removidas.
3.4. ENTRADA E SADA COM VARIVEIS

Depois de declaradas cada varivel funcionar como uma caixa onde
se podem colocar valores e de onde tambm se podem l-los. importante
observar que tais caixas suportam um valor de cada vez e que desta forma a idia
de empilhamento de mais de um valor naquele mesmo espao inconcebvel.
Outra idia inconcebvel a de caixa vazia: sempre haver uma informao
disponvel numa varivel, mesmo logo aps sua declarao. Normalmente
20
esta informao no tem sentido algum no contexto da codificao sendo

meramente projeo do contedo digital presente naquela clula de memria
no momento da declarao.
A entrada de variveis feita com o comando leia ao passo que a sada
pelo comando escreva. Vejamos o exemplo a seguir:
declare
x: inteiro
leia x
escreva valor fornecido =, x
Neste exemplo leia provoca uma parada provisria da execuo o

que significa uma espera de entrada de informaes via dispositivo padro
(teclado neste caso). Quando o usurio digita alguma coisa a execuo ainda
no prossegue porque uma confirmao necessria (como a tecla ENTER).
Uma vez confirmada, esta informao transmitida e processada pela CPU,
neste caso para se tornar um valor numrico inteiro. Novamente outra
transmisso ocorre desta vez da CPU com destino final a memria principal,
mais exatamente a clula vinculada varivel x. At segunda ordem, ou at a
finalizao da execuo, a varivel x conter o valor fornecido pelo usurio.
A prxima instruo executada uma chamada a escreva. Ela no
provoca espera, pelo contrrio, envia sada padro (neste caso a tela) contedo
textual. Neste exemplo a informao escrita tem duas partes separadas por
uma vrgula: a primeira uma mensagem de texto que ser enviada para a
tela tal como foi escrita; a segunda uma referncia a clula x e neste caso a
CPU necessita recorrer memria principal, buscar pelo contedo numrico
em x, transformar este contedo em texto e por fim envi-lo sada padro.
De fato apenas uma mensagem de texto enviada sada padro: se duas
ou mais partes separadas por vrgulas esto presentes o processamento em
srie individual ser feito, vrias componentes textuais geradas e por fim
concatenadas numa nica a qual ser enviada. O termo concatenao surge
comumente em computao representando a fuso de informao numa s,
normalmente textual.
As vrgulas possuem papel importante tanto em leia como em escreva.
Para o comando leia a vrgula permite leitura de vrios valores em uma nica
chamada do comando. Veja o exemplo a seguir:
declare
x, y: inteiro
leia x, y
escreva A soma vale =, x+y
A linha de instruo contendo leia neste exemplo exatamente

equivalente a duas chamadas ao comando, uma para x e outra para y, em
linhas distintas, como em:
leia x
leia y
21
Se na execuo o usurio fornecer um valor e pressionar ENTER a

execuo no prosseguir, pois leia aguarda por um segundo valor. Enquanto
este no for digitado, confirmaes com ENTER sero incapazes de permitir
o prosseguimento. Em outras palavras: apesar de uma nica chamada a leia,
cada varivel em sua lista (que so separadas por vrgulas) necessitar de sua
prpria confirmao. possvel digitar todos os valores pretendidos s variveis
e confirmar a entrada com um nico ENTER? Sim. Neste caso todas as entradas
devem ser digitadas numa nica linha e separadas entre si por espaos. A seguir
temos a sada obtida em tela para as duas abordagens descritas (<ENTER>
apenas representa a tecla de confirmao sendo pressionada):
25 <ENTER>
32 <ENTER>
A soma vale = 57
A soma vale = 57
Confirmaes uma a uma
25 32 <ENTER>
Confirmao nica
A ltima linha impressa nos esquemas acima ilustra a flexibilidade do

comando escreva. Ao passo que leia pode apenas manipular listas de variveis,
escreva pode manipular listas contendo mensagens, variveis ou mesmo
expresses. A expresso x+y do exemplo demanda da CPU processamento
adicional que efetua a soma dos contedos das clulas x e y antes da converso
em texto e da concatenao. Mais detalhes sobre as expresses sero vistos
mais adiante.
O exemplo a seguir ilustra a leitura de um nmero e a exibio se seu
quadrado:
declare
n: inteiro
leia n
escreva n, ao quadrado vale , n*n
Neste pseudocdigo o comando escreva concatena o valor de n, uma

mensagem de texto e o valor da expresso, n*n (produto de n por n). Um
exemplo de execuo segue:
6 <ENTER>
6 ao quadrado vale 36
Caracteres podem ser lidos normalmente por leia e escritos normalmente

por escreva. Entretanto alguns cuidados devem ser tomados. Se uma instruo
como, leia c, com c caractere, executada, muitos caracteres podero ser
escritos pelo usurio antes da confirmao: neste caso c s receber o primeiro
caractere e os demais sero desconsiderados. Se uma instruo como, escreva
c, com c caractere executada, ser impresso um caractere contido em c, mas
sem as aspas simples.
Valores lgicos no podem ser lidos ou escritos diretamente com leia e
escreva. Mais adiante analisaremos exemplos que, entretanto, permitem aos
usurios modificarem ou inspecionarem variveis deste tipo.
22
Se o comando leia aguarda por valores numricos e, por exemplo, texto

digitado, ento uma converso apropriada no poder ser feita pela CPU e
ocorrer um erro em tempo de execuo. Nesta abordagem sobre algoritmos,
quando um erro ocorre necessariamente a execuo suspensa.
Nesta unidade foi apresentado o conceito de algoritmo e suas formas

bsicas de representao: texto, fluxograma e pseudocdigo. Mostra tambm
as possibilidades de execuo que um algoritmo pode ter. Lembrando que as
mesmas devem seguir uma sequncia, mas que nem sempre todas podem
ser processadas. Outros fatores importantes para algoritmos so: entrada e
sada. O conceito de varivel e os tipos podem ser: inteiro, real, caractere e
booleano. A primeira parte do programa a declarativa a qual define os tipos
de variveis tambm contemplaram esta unidade.
1. Definir algoritmo utilizando suas prprias palavras.

2. Formule em forma de fluxograma trs algoritmos que descrevem
tarefas de seu dia-a-dia.
3. Discutir sintaxe e semntica em uma metodologia de construo de
algoritmos.
4. O que so pseudocdigos e que aspectos de sintaxe esto envolvidos?
5. Qual a importncia da indentao na construo de pseudocdigos?
6. Outras metodologias de construo de algoritmos utilizam blocos
do tipo incio-fim para promover o encapsulamento de cdigo. Pesquise e
responda por que a indentao neste caso no necessria e qual o papel dela
quando utilizada.
7. Pesquise e responda: qual a diferena entre uma instruo de cdigo
e uma instruo de mquina?
8. Conceituar entrada e sada padro e discutir as questes de
simplificao de hardware associadas a elas.
9. Quais as principais diferenas entre o gerenciamento de memria
secundria e primria?
10. Que so variveis e qual a relao entre elas, a memria principal e
o sistema operacional?
11. Quais so e o que representam os tipos primitivos de variveis?
12. Construir pequeno algoritmo que leia trs valores da entrada padro
reais e escreva na sada padro a mdia aritmtica entre eles.
23
SEBESTA, Robert W. Concepts of Languagues Programming. 8th edition. University

of Colorado. Addison-Wesley 2007. 752p. ISBN-10: 032149362.
FERNANDEZ, M; Corts, M. Introduo Computao. 1 Edio. Fortaleza. RDS
Editora, 2009.
O link do light-bot traz um

jogo muito interessante para
o incio da aprendizagem em
programao. O nome do
jogo Light-bot o qual consiste de um rob capaz de
http://equipe.nce.ufrj.br/adriano/c/apostila/algoritmos.htm
http://armorgames.com/play/2205/light-bot
executar tarefas (sequncia

de passos) com o objetivo
de chegar ao quadrado azul
e acend-lo. Ao carregar a
pgina do jogo, voc deve clicar em play e logo em seguida clicar em new game para
iniciar. Vamos l ! Voc ver
que a prtica aliada aos algoritmos que voc desenvolver
para chegar ao quadrado azul
o ajudaro na aprendizagem
de programao.
24
Elementos Construtivos
UNIDADE
O objetivo desta unidade apresentar os elementos essenciais para a
construo de algoritmos.
1. OPERADORES
Variveis so vinculaes com a memria real do computador e
funcionam como meros armazenadores temporrios de informao digital.
Entretanto, para a construo de algoritmos funcionais, deve ser possvel
tambm operar entre si tais variveis. Operar neste contexto pode significar
tanto alterar o contedo de uma varivel quanto associar duas ou mais destas
numa expresso vlida para se obter um novo valor (por exemplo, x+y envolve
duas variveis numa operao de soma cujo resultado um novo valor).
Operadores so objetos de construo de algoritmos, de simbologia
prpria e semntica bem definida, destinados s operaes com ou entre
variveis. Por exemplo, na expresso, a+b, o smbolo + um operador e sua
semntica a execuo da soma entre os valores nas variveis a e b.
Operadores podem ser unrios ou binrios, ou seja, podem ou operar
um ou dois operandos respectivamente. O exemplo mais comum de operador
unrio o de mudana de sinal. A sintaxe -x, onde o sinal de menos o
operador, x a varivel e o valor retornado o valor na varivel (numrica)
com sinal invertido. Outro exemplo de operador unrio valor absoluto.
A sintaxe |x|, onde as duas barras verticais representam o operador, x
a varivel e o valor retornado o mdulo do valor na varivel (numrica).
Operadores aritmticos so exemplos de operadores binrios. Na expresso,
a*b, o asterisco denota um operador binrio operando as variveis a e b e cuja
semntica a multiplicao numrica. Nesta expresso o valor retornando o
produto entre o contedo existente nessas variveis.
Operadores podem ser infixos, prfixos ou psfixos. Esta classificao
refere-se posio relativa dos operadores nas expresses em que aparecem.
Por exemplo, em, a+b, o operador de adio, +, infixo, ou seja, disposto
entre seus operandos. Na expresso de mudana de sinal, -a, o operador
pr-fixo, ou seja, disposto antes do operando. Na expresso de clculo de
um fatorial, x!, o operador ps-fixo, ou seja, disposto depois do operando.
Usualmente a maioria dos operadores binrios usada infixamente e dos unrios
pr-fixamente. H situaes em que operadores tradicionalmente infixos so
utilizados como pr ou ps-fixao. Em notao polonesa inversa (PEREIRA;
2006), por exemplo, a expresso, AB+, legal e denota a soma das variveis
A e B com operador de adio ps-fixado. Esta notao conveniente aos
computadores no que diz respeito a avaliao de expresses (teis no projeto
de compiladores, por exemplo).
Notao Polonesa Inversa,

tambm conhecida como notao ps-fixada, foi inventada pelo filsofo e cientista
da computao australiano
Charles Hamblin em meados
dos anos 1950. Ela deriva
da notao polonesa cujos
Operadores so funes, ou seja, ao invs da notao apresentada at

ento uma dada operao pode ser expressa utilizando uma funo nomeada
com seus operandos entre parnteses e separados por vrgula. Assim, por
exemplo, a expresso, SOMA(A, B), tem exatamente o mesmo efeito de, A+B.
Na notao funcional o smbolo + substitudo pela funo SOMA(). Em outras
sintaxes propostas para algoritmos, ou mesmo em linguagens de programao,
operadores so introduzidos apenas pela notao funcional. Se um operador
no possui smbolo que permita prefixao, in-fixao ou ps-fixao, ento
a notao funcional nica opo. Exemplos: logaritmo natural LN(), funo
exponencial EXP(), funes trigonomtricas (SEN(), COS() e etc.) entre outras.
operadores so prefixos dos

operandos. Como exemplo
a expresso, A+B, escrita
como +AB. A notao polonesa foi introduzida em 1920
pelo matemtico polons Jan
ukasiewicz. (Da o nome
sugerido de notao Zciweisakul).
27
1.1. A ATRIBUIO
O operador de atribuio o elemento de construo de algoritmos
que expressa mais genuinamente a essncia da mquina de von Neuman
(FERNANDEZ; 2009). Este operador o responsvel pela modificao do
contedo das clulas de memria (variveis) alocadas. Cada atribuio
corresponde a uma ao da CPU que envia dados de seus registradores para
uma clula de memria alvo e cujo valor s se modificar novamente por outra
atribuio.
A Arquitetura de von Neuman (de John von Neuman),
uma arquitetura de computador que se caracteriza pela
possibilidade de uma mquina digital armazenar seus
programas no mesmo espao
de memria que os dados,
podendo
assim
manipular
tais programas. A mquina

proposta por Von Neumann
rene os seguintes componentes: (i) uma memria, (ii)
Atribuies podem ser explcitas ou implcitas. Numa atribuio

explcita o operador utilizado para indicar que o lado direito da expresso
alvo do lado esquerdo, ou seja, uma varivel do lado esquerdo ter seu valor
modificado para o valor avaliado no lado direito. Veja o exemplo a seguir.
declare
a: inteiro
x, y: real
c: caractere
a120
x3.253
ya+x+23
cw
escreva b, y, c
uma unidade aritmtica e

lgica (ULA), (iii) uma unidade central de processamento
(UCP), composta por diversos
registradores, e (iv) uma Unidade de Controle (UC).
No pseudocdigo acima s variveis a e x so atribudos valores

numricos diretamente; varivel y atribudo o resultado da avaliao prvia
da expresso, a+x+23 (a soma calculada primeiramente para ento y ser
modificado); varivel c diretamente atribudo o cdigo ASCII de caractere
w; por fim na ltima instruo, escreva converte para texto, concatena e
imprime b, y e c.
Se uma varivel lgica, a atribuio explicita em cdigo dos valores
Verdadeiro e Falso feita mediante as palavras chave V e F respectivamente.
Exemplo:
declare
a, b: lgico
aV
bF
De uma forma geral o lado direito de uma atribuio primeiramente

resolvido para ento o resultado encontrado ser redirecionado para clula de
memria vinculada a varivel do lado esquerdo desta atribuio. Esta forma de
processamento permite que a seguinte expresso seja legal:
xx+y
Em casos como este a varivel que aparece em ambos os lados da

atribuio possui um valor antes e outro depois da atribuio e comumente
chamados de valor antigo e valor novo da varivel respectivamente.
28
O processamento ocorre da seguinte forma: o contedo das clulas x

e y so copiados para registradores distintos da CPU; em seguida a unidade
lgica aritmtica desta efetua a soma e a coloca num terceiro registrador; por
fim o valor da soma transmitido para a clula de memria vinculada a x onde
ocorrer sobreposio de valor. Este ltimo passo corresponde a atribuio
propriamente dita.
Atribuies implcitas ocorrem quando o comando leia invocado. O
mesmo mecanismo de envio de uma informao para uma clula de memria
alvo acontece, porm, a origem da informao a entrada padro. Veja o
exemplo:
declare
x, y: inteiro
leia x
yx+10
escreva Resposta: , y
Neste pseudocdigo a varivel x tem atribuio implcita ao passo que y

tem atribuio explcita, ou seja, o contedo na clula vinculada a x muda por
ao de leia ao passo que aquela vinculada a y muda por ao do operador
aps resoluo da expresso, x+10. Funcionalmente a execuo deste
algoritmo implica na leitura de um valor dado pelo usurio e sua impresso
acrescentada de 10. Veja o esquema de execuo a seguir:
34 <ENTER>
Resposta: 44
Em alguns casos o operador pode participar diretamente na entrada

de dados fornecidos pelo usurio. o que acontece com o comando tecla.
Quando uma expresso de atribuio contendo tecla encontrada o
processamento suspenso provisoriamente aguardando entrada do usurio,
da mesma forma que acontece com leia. Entretanto neste caso basta um nico
pressionar de tecla para continuar o processamento. A tecla pressionada neste
intere atribuda a varivel do lado esquerdo da atribuio. Por esta razo tal
varivel deve ser de tipo caractere. Veja o exemplo a seguir:
declare
ch: caractere
ch tecla
escreva tecla pressionada: , ch
Neste pseudocdigo a execuo da linha, ch tecla, implica suspenso

provisria da execuo. Quando o usurio pressionar uma tecla seu valor ASCII
repassado para a varivel ch (caractere) a qual manter este valor at uma
nova atribuio. A mensagem final impressa a concatenao da mensagem
entre aspas e o grafema do caractere da tecla pressionada.
29
1.2. OPERADORES ARITMTICOS

conveniente padronizar o comportamento dos operadores aritmticos
em qualquer estudo de algoritmos. Na tabela a seguir so apresentados os
smbolos e a descrio adotados neste texto.
Operadores
+
*
/
div
mod
abs
Descrio
Soma de valores numricos
Subtrao de valores numricos
Multiplicao de valores Numricos
Diviso entre valores reais
Diviso entre valores inteiros
Resto de diviso entre valores inteiros
Mdulo de valor numrico
Todos os operadores, com exceo de abs, so usualmente binrios e

infixos O operador abs unrio e com notao funcional. Por exemplo, a
expresso, abs(x), representa o mdulo do valor em x. Os operadores, +, e,
, possuem tambm verses unrias e pr-fixas como nas expresses, +x-3
(nfase de sinal), e, a+b (inverso de sinal).
O operador / utilizado para dividir dois valores reais retornando
um valor real de sada. Se algum dos operandos for inteiro ento este ser
primeiramente convertido em real antes da diviso. Na expresso, ab/c, se b
e/ou c so inteiros, ento eles so primeiramente convertidos em reais, depois
divididos e o resultado da diviso atribudo a varivel a. Se a uma varivel
real, o valor integral da diviso atribudo, por exemplo, se b contm 7 e c
contm 2, ento a receber 3.5. Entretanto, se a uma varivel inteira ocorrer
truncamento, ou seja, o real oriundo da avaliao da expresso do lado direito
da atribuio perder a parte fracionria e o valor inteiro restante atribudo
a. Neste caso o valor 3.5 truncado para 3 para ento haver atribuio.
As expresses, ab div c, e, ab mod c, s sero legais se b e c forem
variveis inteiras. Se a for real, o inteiro oriundo da operao no lado direito
ser convertido em real para ento ocorrer a atribuio.
1.3. OPERADORES RELACIONAIS

Operadores relacionais so operadores binrios e infixos cujo resultado
da expresso que constituem sempre um valor lgico, ou seja, Verdadeiro
ou Falso. A tabela a seguir lista smbolos e nomes dos operadores relacionais
utilizados neste estudo de algoritmos:
30
Operadores
=
>
<
Nomes
Igual a
Maior que
Menor que
Maior ou igual a
Menor ou igual a
Diferente de
A seguir alguns exemplos de expresses relacionais legais, ou seja, cada

uma delas quando avaliada ser Verdadeira ou Falsa.
a >
400
a+b
x+y
100
y
c
< a+b
Nos dois ltimos casos acima o operador relacional contm em um dos

lados (ou em ambos) expresses aritmticas. Esta sintaxe perfeitamente legal
e ser analisada logo adiante.
1.4. OPERADORES LGICOS

Operadores lgicos so aqueles que operam valores lgicos e retornam
valores lgicos. Utilizando a notao mais usual da lgebra booleana, montamos
a listagem dos operadores lgicos, juntamente com seus nomes conforme
tabela a seguir.
lgebra booleana (ou lge-
Operadores
Nomes
Conjuno
Disjuno
Disjuno Exclusiva
Negao
bra de Boole) trata das estruturas algbricas construdas a partir das operaes
lgicas E, OU e NO, bem
como das operaes soma,
produto e complemento em
teoria de conjuntos. comu-
Os operadores de conjuno, disjuno e disjuno exclusiva so todos

binrios e infixos ao passo que o de negao unrio e pr-fixo. A seguir
algumas expresses lgicas legais:
mente aplicada em computao para operar nmeros

binrios. Recebeu o nome
de George Boole, matemti-
X Y
B (A B)
(A B C) (A C)
co ingls, que foi o primeiro

a defini-la como parte de um
sistema de lgica em meados
do sculo XIX.
Nos exemplos acima so utilizados apenas variveis e operadores lgicos.

As variveis poderiam ser substitudas, por exemplo, por expresses relacionais.
O resultado da avaliao destas expresses tambm um valor lgico.
Como cada varivel do tipo lgico s assume dois valores, Falso ou
Verdadeiro (F ou V) possvel listar todas as possibilidades de resposta de uma
expresso lgica (em contrapartida s expresses numricas com inmeras
31
possibilidades). Tais listagens so conhecidas como Tabelas-Verdade. A seguir

so listadas as tabelas verdades para as expresses lgicas elementares (que
possuem apenas um operador).
A
AB
AB
AB
F
V
V
F
F
V
F
F
V
F
V
V
F
V
1.5. EXPRESSES
Expresses podem ser constitudas pela associao de diversas variveis
de tipos no necessariamente compatveis, mas que se arranjem de forma lgica
e avalivel. Uma vez definidas tais expresses, a avaliao implica num processo
sistemtico que finaliza num valor final cujo tipo depender da expresso.
Por exemplo, na expresso, x+1 > y-p*p, resolvem-se primeiramente as
expresses aritmticas em cada lado do operador relacional para depois fazer
a comparao que resultar num valor lgico. Este procedimento de escolha
de quem operar primeiro numa expresso segue na verdade dois conjuntos
de regras de operadores. So eles o de precedncia de operadores e de
associatividade de operadores. Os analisaremos a seguir.
1.5.1. PRECEDNCIA DE OPERADORES

Nas primeiras lies sobre matemtica ensina-se que numa expresso
numrica primeiramente devem-se fazer as divises e multiplicaes para
por fim fazer as adies e subtraes. Ensina-se tambm que se existem
componentes entre parnteses elas so prioritrias na ordem de resoluo.
Sem tais regras uma expresso como, 2+4*7, seria ambgua, ou seja, com
duas possibilidades de resposta dependo de qual operao fosse realizada em
primeiro lugar. Esta predefinio de quem opera primeiramente numa famlia
de operadores comumente chamada de precedncia de operadores.
A ordem convencional de precedncia dos operadores aritmticos, do
de maior para o de menor, a seguinte:
(maior precedncia)
(menor precedncia)
32
abs
+, (unrios)
*, /, mod, div
+, - (binrios)
A precedncia convencional dos operadores lgicos a seguinte:

(maior precedncia)
(menor precedncia)
Por exemplo, na expresso, ABC, o booleano C primeiro invertido,

depois a conjuno entre este valor e B feita; por fim a disjuno exclusiva
fecha o processo de avaliao e um valor final lgico obtido.
Convencionalmente no existe precedncia entre operadores relacionais,
o que ser mais bem compreendido na sesso seguinte.
1.5.2. ASSOCIATIVIDADE DE OPERADORES

Permitir a associatividade de operadores significa permitir que dois
operadores de uma mesma famlia (aritmtico, relacional ou lgico) e de
mesma precedncia apaream adjacentes em uma mesma expresso sem
afetar operabilidade. Por exemplo, na expresso, A+B-C, quem deve ser feita
primeira? Adio ou subtrao? A forma usual de resolver a associatividade
definindo um sentido fixo de avaliao; por exemplo, da direita para a esquerda
(no exemplo anterior a subtrao seria ento feita primeiro).
A associatividade nem sempre possvel. Para que dois operadores
possam ser associados o tipo da sada do operador deve ser do mesmo tipo
dos operandos, do contrrio ocorrer inconsistncia. Por exemplo, a avaliao
da expresso, A+B-C, da esquerda para a direita, possui o seguinte esquema:
A+B-C
<nmero>+<nmero>-<nmero>
<nmero>+<nmero>
<nmero>
Cada reduo na resoluo acima transforma um par de nmeros num

novo nmero que entra na etapa seguinte da avaliao. De uma forma geral,
operadores aritmticos so sempre associveis. O mesmo no acontece na
expresso, A>B>C, onde A, B e C so inteiros. O processo de avaliao desta
expresso, da esquerda para direita, interrompido por uma inconsistncia,
como se v a seguir:
A>B>C
<nmero> > <nmero> > <nmero>
<nmero> > <lgico>
//inconsistncia! No pode continuar
Este exemplo demonstra a ausncia de associatividade entre operadores

relacionais e conseqentemente a inexistncia de precedncia entre eles. A
associatividade entre operadores lgicos funciona similarmente aos operadores
aritmticos.
33
1.5.3. EXPRESSES BOOLEANAS

Expresses booleanas so expresses cujo valor da avaliao um
lgico, ou seja, Verdadeiro ou Falso. Expresses booleanas podem conter
componentes aritmticas, relacionais, ou mesmo lgicas. A seqncia de
avaliao por ordem de natureza de componentes a seguinte:
(1).
(2).
(3).
Componentes aritmticas;
Componentes relacionais;
Componentes lgicas
Se existem parnteses nas expresses ento o contedo entre eles deve

ser avaliado primeiro obedecendo naturalmente, neste escopo, a seqncia
anterior. Considere o exemplo a seguir:
x+y>50 w<100+r wy-5
A seqncia esquemtica de avaliao desta expresso a
seguinte:
x+y > 50
<nmero>
<lgico>
<lgico>
<lgico>
w < 100+r w y-5

> <nmero> <nmero> < <nmero> <nmero> <nmero>
<lgico> <lgico>
<lgico>
Caso a disjuno exclusiva deva ser avaliada antes da conjuno, ento

o uso apropriado de parnteses transforma a expresso em:
(x+y>50 w<100+r) wy-5
Cujo esquema de avaliao agora :

(x+y > 50 w < 100+r) w y-5
(<nmero> > <nmero> <nmero> < <nmero>) <nmero> <nmero>
(<lgico> <lgico>) <lgico>
//prioridade de parnteses
<lgico> <lgico>
<lgico>
2. ESTRUTURAS DE CONTROLE
Existem dois mecanismos construtivos que qualquer mtodo de
elaborao de algoritmos deve possuir: deciso e repetio. O conjunto
de componentes de cdigo que se associam para representar um processo
de deciso ou de repetio denominado estrutura de controle. Sem tais
estruturas no seria possvel a construo de algoritmos.
34
2.1. DECISO
Um processo de deciso consiste na escolha entre dois ou mais blocos
de pseudocdigo para execuo. Apenas um, entre os blocos existentes,
selecionado e assim tem seu contedo executado.
Uma deciso o resultado da avaliao de uma expresso booleana.
Adiante so estudados diferentes tipos de estruturas de deciso.
2.1.1. DECISO UNIDIRECIONAL

A deciso unidirecional aquela que envolve apenas um bloco de
cdigo. Se a expresso de controle da deciso avaliada como verdadeira,
ento o cdigo do nico bloco executado. Do contrrio, se a expresso
resulta em falso, ocorre um desvio para a prxima instruo fora do bloco
(caso exista).
A sintaxe bsica da deciso unidirecional :
se (...) ento
...
Onde a primeira reticncia entre parnteses refere-se expresso

booleana de controle, enquanto a segunda refere-se ao bloco de pseudocdigo.
Para marcar o bloco utiliza-se pelo menos um nvel de indentao no cdigo
de execuo condicional. Diz-se que instrues de um bloco de deciso so
encapsuladas pela estrutura de deciso. Veja o exemplo:
declare
x: inteiro
leia x
se (x>0) ento
escreva x
escreva o valor positivo!
As ltimas trs linhas deste algoritmo constituem um processo de deciso.

A linha com se mantm a expresso booleana de controle, x>0. Logo abaixo,
indentadas em um nvel para formar um bloco, duas instrues de impresso
so encapsuladas pela estrutura. A execuo do algoritmo inicialmente requer
um valor inteiro atravs da varivel x. Se este valor positivo as duas impresses
so executadas em seqncia (primeiro a do valor em x e depois a mensagem
de texto). Se o valor em x negativo ou nulo nada impresso na sada padro
e a execuo se encerra (no h mais instrues aps processo de deciso).
35
Outro exemplo:
declare
a: inteiro
leia a
se (a mod 2 = 0) ento
escreva o nmero par
escreva m da execuo!
Neste algoritmo o nico processo de deciso presente contm duas

linhas (em negrito) e o bloco encapsulado apenas uma linha (ver a indentao).
Se a expresso booleana de controle, a mod 2=0 (resto da diviso do valor
em a por 2 igual a zero?), avaliada como verdadeira, ento a mensagem
o nmero par impressa. Do contrrio ela no o ser. A impresso da
mensagem fim da execuo! no pertence ao processo de deciso (ver
indentao) e logo ocorre incondicionalmente.
2.1.2. DECISO BIDIRECIONAL

Na deciso bidirecional dois blocos de pseudocdigo competem para
que um deles, e apenas um, seja executado. Caso a expresso booleana
de controle seja avaliada como Verdadeira, ento o primeiro bloco de
pseudocdigo ser executado, do contrrio o segundo bloco que o ser.
A sintaxe bsica da deciso bidirecional :
se (...) ento
...
seno
...
Onde a primeira reticncia entre parnteses refere-se expresso

booleana de controle, a segunda refere-se ao primeiro bloco de pseudocdigo
e a terceira reticncia refere-se ao segundo bloco de pseudocdigo. Veja o
exemplo:
declare
num, x: inteiro
leia num
se (num mod 2 = 0) ento
x num div 2
escreva x
seno
x (num+1) div 2
escreva x + 1
As linhas com as palavras-chave se e seno so colocadas no mesmo

nvel de indentao para acusar que fazem parte da mesma estrutura. Os
blocos encapsulados so dispostos um nvel de indentao acima estando o
primeiro antes e o segundo aps o seno. Se a expresso booleana de controle,
num mod 2=0, avaliada como verdadeira ento x recebe o resultado na
36
expresso, num div 2, e tem em seguida o valor impresso. Do contrrio x

recebe o resultado da expresso, (num+1) div 2, e o valor, x+1, que
impresso. Apenas uma atribuio explcita e uma impresso ocorrem.
Outro exemplo:
declare
n: inteiro
leia n
se (n mod 2 = 0) ento
escreva nmero par!
seno
escreva nmero mpar!
Cada um dos blocos no algoritmo anterior constitudo por uma nica

linha de instruo.
Estudo de caso Existncia de Tringulo: Consideremos agora o
algoritmo que determina se um tringulo existe ou no. H duas maneiras de
abordar o problema: (I) pode-se testar se cada um dos lados menor que a
soma dos outros dois e (II) pode-se testar se um lado qualquer menor que
soma dos outros dois e maior que o mdulo da subtrao entre os mesmos. O
algoritmo para (I) ser:
declare
a, b, c: inteiro
leia a, b, c
se (a<b+c b<a+c c<a+b) ento
escreva O trimgulo existe!
seno
escreva O tringulo no existe!
A nica diferena para o caso (II) est na expresso booleana de deciso

que deve se tornar:
a<b+c a>abs(b-c)
O caso (I) ilustra o uso das expresses booleanas e a importncia dos

operadores lgicos quando expresses relacionais precisam ser conectadas.
O caso (II) reafirma o caso (I) e ilustra o uso do operador mdulo, abs, em
componentes aritmticas de expresses booleanas.
2.1.3. DECISO MLTIPLA

Em algoritmos, a deciso mltipla um processo de deciso que envolve
muitas entradas, ou seja, entre vrias rotas possveis de cdigo ser escolhida
uma, e apenas uma, para ser executada. Devido natureza binria das
expresses booleanas, elas no se aplicam em processos da deciso mltipla.
Ao invs disso utilizada uma expresso aritmtica com valor resultante inteiro
(usualmente expresses de controle aparecem como uma nica varivel de
tipo inteiro conhecida como varivel de controle). Espera-se naturalmente
37
da expresso de controle que o valor proveniente da avaliao esteja numa

faixa finita de valores inteiros. Cada um destes valores deve conduzir ao seu
prprio bloco de cdigo. Se a avaliao resulta um valor fora da faixa ento
nenhum bloco executado e o processo de deciso encerrado. Blocos em
decises mltiplas precisam de um rtulo para indicar onde principiam. O
rtulo deve conter o valor inteiro esperado pela avaliao da expresso de
controle que induza a execuo do bloco que rotula. A estrutura de deciso
mltipla, conhecida como caso...seja..., possui a seguinte sintaxe geral:
caso <varvel ou expresso de controle> seja
<rtulo 1>: <bloco 1>
...
<rtulo n>: <bloco n>
Cada rtulo da estrutura acima possui o prprio bloco e separado

dele pela marca, : (dois pontos). Todos os rtulos so dispostos um nvel de
indentao acima no nvel onde esta a palavra chave seja. Blocos dispem-se
um nvel de indentao acima daquele onde esto os rtulos.
Em sntese, aps a avaliao da expresso (ou varivel) de controle
um valor inteiro obtido, o rtulo com este valor selecionado e por fim o
bloco executado. Quando a execuo encerra, ocorre um desvio para fora da
estrutura para que outros blocos no sejam executados.
O exemplo a seguir ilustra a estrutura caso...seja:
declare
n: inteiro
leia n
caso (n) seja
1: escreva Ol mundo!
2: escreva Hello world!
3: escreva Hallo Welt!
A execuo deste pseudocdigo implica impresso de uma entre trs

mensagens (caso o valor em n seja 1, 2 ou 3) ou em finalizao sem impresso
alguma (caso outros valores sejam fornecidos). Nunca duas mensagens so
simultaneamente impressas.
A estrutura caso..seja pode ser estendida na sintaxe seguinte:
caso <varvel ou expresso de controle> seja
...
<rtulo n>: <bloco n>
seno
<bloco n+1>
A palavra chave seno funciona neste contexto como um rtulo

alternativo a todos os valores no rotulados anteriormente. Ou seja, se a
avaliao da varivel ou expresso de controle resulta um valor fora da faixa
dos rtulos, ento o bloco n+1 ser executado. Neste contexto sempre algum
38
bloco executado. Uma prtica bastante comum o uso da sesso seno para
imprimir mensagens de erro. Veja o exemplo:
declare
n: inteiro
leia n
caso (n) seja
1: escreva
2: escreva
3: escreva
seno
escreva
Ol mundo!
Hello world!
Hallo Welt!
Opo invlida!!
Se for fornecido a varivel n um valor diferente de 1, 2 e 3 ento a

mensagem de erro Opo invlida!! ser impressa. O exemplo a seguir contm
blocos, numa estrutura caso..seja, com mais de uma linha de instruo:
declare
ch: caractere
raio, base, altura, lado: inteiro
escreva pressione: C para cculo, T para tringulo, Q para
quadrado
ch tecla
caso ch seja
C: escreva Valor do raio:
leia raio
escreva rea = , 3.14159235*raio*raio
T: escreva Valores da base e da altura:
leia base, altura
escreva rea = , base*altura/2
Q: escreva Valor do lado:
leia lado
escreva rea = , lado*lado
seno
escreva Opo invlida!!
Este algoritmo efetua clculo da rea de trs categorias de figuras

geomtricas: crculo, tringulo ou quadrado. De acordo com a tecla pressionada
a execuo direcionada para um rtulo apropriado. Cada bloco possui
mensagem de entrada, leitura de variveis e apresentao de resultados (rea
da figura). A varivel de controle de tipo caractere e como caracteres so
tipos especiais de inteiros ento podem ser usados em estruturas caso...seja.
O uso de uma deciso com se..ento..seno em um bloco de caso...
seja perfeitamente legal e bastante usual. No exemplo seguinte simula-se
uma calculadora cujos operandos so fornecidos primeiro e a operao (soma,
subtrao, multiplicao ou diviso) depois com um pressionar de tecla:
39
declare
op: caractere
x, y: inteiro
escreva fornecer valores:
leia x, y
escreva forcecer opo : + - * /
op tecla
caso op seja
+: escreva Soma: , x+y
-: escreva Subtrao: , x-y
*: escreva Multiplicao: , x*y
/: se (b0) ento
escreva x/y
seno
escreva diviso por zero!
seno escreva Opo invlida!!
Se a tecla com o caractere / for pressionada ento a operao de

diviso selecionada. Isso inicia um processo de deciso com se..ento..ento
que trata a possibilidade de diviso por zero. A mensagem diviso por zero!
impressa quando o valor em b nulo. A mensagem Opo invlida!!
impressa quando uma tecla operacional invlida pressionada.
2.1.4. ANINHAMENTO DE DECISES

A estrutura se...ento(...seno) permite o aninhamento, ou seja, a
possibilidade de construo de outras estruturas se...ento(...seno) dentro
de seus blocos. Este encapsulamento de decises pode se estender em
muitos nveis dependendo das unicamente das necessidades de expresso do
algoritmo. A seguir um exemplo esquemtico:
se (...) ento
// bloco
se (...) ento
// bloco
seno
se (...) ento
// bloco
seno
se (...) ento
// bloco
seno
// bloco
Estudo de Caso IMC: A sigla IMC significa ndice de massa corprea.

Trata-se de um nmero calculado pela razo entre o peso em kg (na verdade a
massa!) e o quadrado da altura (em metros) de uma pessoa. O IMC determina
se esta pessoa est em um dos estados seguintes: magra (o IMC menor que
20), gorda (o IMC maior que 25) ou em bom peso (o IMC est no intervalo
fechado de 20 a 25). O pseudocdigo seguinte resolve o problema do IMC:
40
declare
peso, altura, imc: real
escreva Fornecer peso e altura:
leia peso, altura
imc peso /(altura*altura)
se (imc<20) ento
escreva Voc est magro!
seno
se (imc>25) ento
escreva Voc est gordo!
seno
escreva Voc est num bom peso!
A execuo deste algoritmo ocorre da seguinte forma: o primeiro se

divide seu caminho entre os valores de IMC que so menores que 20 e os que
no so. Caso seja menor que 20 a mensagem, Voc est magro!, impressa e
a execuo finaliza. Caso seja maior ou igual a 20 um novo processo decisrio
aninhado iniciado com se testando se o IMC maior que 25. Caso seja
Verdadeira a mensagem, Voc est gordo!, ser impressa, do contrrio o
contedo encapsulado pelo ltimo seno ser executado. Neste caso o
valor de IMC certamente maior ou igual a 20, por causa do primeiro se,
mas menor ou igual a 25, por causa do segundo se. Assim a impresso da
mensagem, Voc est num bom peso, sempre ocorrer no intervalo fechado
de IMC entre 20 e 25 (como esperado) dispensando o uso de outro se para o
ltimo bloco.
O aninhamento de decises permite a programao da deciso mltipla
de forma diferenciada daquela montada com caso..seja. Nesta estrutura as
tomadas de deciso so necessariamente pontuais, isto , um valor especfico
para cada rtulo de entrada. Com o aninhamento cada deciso fica atrelada
a um intervalo de valores. Estes intervalos compem o domnio de todas as
entradas possveis. Assim, por exemplo, com o aninhamento possvel construir
deciso mltipla utilizando valores reais como no caso do IMC.
Estudo de Caso Menor De Trs Nmeros: Consideremos o problema
de determinao do menor de trs nmeros. O algoritmo seguinte efetua esta
tarefa para trs inteiros fornecidos via entrada padro:
declare
A, B, C, menor: inteiro
leia A, B, C
se (A<B A<C) ento
menor A
seno
se (B<C) ento
menor B
seno
menor C
escreva Menor valor = , menor
41
A idia do algoritmo anterior a seguinte: dados valores s variveis A, B

e C, se o valor em A menor que em B e tambm menor que em C, ento ele
o menor dos trs e o problema fica resolvido. Caso contrrio ento o menor
entre os trs estar obviamente em B ou C. Assim se o valor em B menor
que em C, B contm o menor, do contrrio, C que contm. Uma das trs
atribuies ocorrer devido aos testes de deciso e colocar na varivel menor
a soluo.
Estudo de Caso Equao do Segundo Grau: Uma equao do segundo
grau tem forma, ax2 + bx + c = 0, onde a, b e c so coeficientes constantes e
x a varivel independente. Tais equaes possuem razes reais se o coeficiente
a no nulo e ainda se maior ou igual a zero, onde, = b2 - 4ac. O
algoritmo seguinte resolve o problema de determinao das razes de uma
equao de segundo grau cujos coeficientes so fornecidos via entrada padro:
declare
a, b, c, delta, x0, x1: real
escreva Fornea coecientes da equao:
leia a, b, c
se (a0) ento
delta b*b 4*a*c
se (delta0) ento
x0 (-b + raiz(delta))/(2*a)
x1 (-b - raiz(delta))/(2*a)
escreva Razes: , x0, x1
seno
escreva Razes Complexas!
seno
escreva A equao no de segundo grau!
Neste algoritmo o primeiro processo de deciso verifica nulidade do

coeficiente em a. Se o valor em a nulo a mensagem A equao no de
segundo grau! impressa e o algoritmo se encerra. Caso no seja nulo significa
que se trata de uma equao de segundo grau e que o primeiro bloco indentado
ser executado. Este bloco inicia com o calculo do delta da equao o qual
colocado na varivel delta. Com este valor um novo processo de deciso
iniciado (aninhamento de deciso) o qual trata da existncia de razes reais.
Se o valor em delta maior ou igual a zero ento as razes so calculadas (a
funo raiz() calcula a raiz quadrada de um valor real), impressas e o processo
finalizado. Do contrrio a mensagem Razes Complexes! impressa e o
algoritmo se encerra.
Estudo de Caso Tipo de Tringulo em Relao aos Lados: Um
tringulo pode possuir os trs lados idnticos (eqiltero), dois lados idnticos e
o terceiro diferente (issceles) e os trs lados diferentes (escaleno). O algoritmo
seguinte resolve o problema de determinao do tipo de um tringulo cujos
lados so fornecidos via entrada padro:
42
declare
a, b, c: inteiro
leia a, b, c
se (a<b+c b<a+c c<a+b) ento
se (a=b a=c) ento
escreva Eqiltero!
seno
se (a=b a=c b=c) ento
escreva Issceles!
seno
escreva Escaleno!
seno
escreva O tringulo no existe!
Este algoritmo possui trs nveis de indentao de decises aninhadas.

O primeiro avalia a existncia do tringulo exibindo a mensagem O tringulo
no existe! caso os lados (lidos atravs das variveis a, b e c na entrada padro)
no formem um tringulo vlido. Se o tringulo existe o processo de deciso
do segundo nvel de indentao decide entre tringulos eqilteros e no
eqilteros. Caso seja, a mensagem Equiltero! impressa e o algoritmo
se encerra. Caso no, outro processo de deciso se inicia no terceiro nvel
de indentao o qual decidir se o tringulo no-equiltero issceles ou
escaleno. Para ser issceles basta haver igualdade de pelo menos um par
de lados (por isso a expresso booleana, a=b a=c b=c). Neste caso a
mensagem Issceles! impressa e o algoritmo finaliza. Do contrrio (nenhum
par de lados se iguala) a mensagem Escaleno! impressa e o algoritmo se
encerra.
2.2. REPETIO
As estruturas de deciso permitem a modelagem de apenas parte dos
problemas resolvidos por algoritmos. As estruturas de controle de repetio
estendem largamente esta capacidade de modelagem. Elas fornecem meios de
repetio de execuo de blocos de cdigos especficos. A associao entre
capacidades de deciso e repetio constitui prtica comum na construo de
algoritmos.
Uma estrutura de controle de repetio encapsula apenas um bloco de
cdigo e o repete mediante um critrio que notavelmente muda durante o
processo (Naturalmente este bloco pode conter internamente outros blocos
com nvel de indentao acima e que tambm tero execuo repetida). Cada
repetio conhecida como iterao. Estruturas de repetio so comumente
chamadas de laos ou loops. A seguir so estudadas as principais estruturas de
laos utilizadas na construo de algoritmos.
2.2.1. LAOS CONTROLADOS POR CONTADOR

Um lao controlado por contador quando uma varivel auxiliar, chamada
contador, usualmente de tipo inteiro, responsvel pela contabilizao das
iteraes. A estrutura de controle para lao com contador , para...at...faa,
e possui a seguinte sintaxe geral:
43
para <contador> <limite inferior> at <limite superio> faa

<bloco>
Esta estrutura efetua a repetio sistemtica do cdigo presente no bloco

encapsulado posto nas linhas logo abaixo do cabealho da estrutura e indentado
um nvel acima deste. A execuo deste lao se faz pela progresso aritmtica
do contador desde o limite inferior ate o limite superior. Esta progresso
automtica e acrescenta uma unidade ao contador ao final de cada iterao.
Conseqentemente em cada iterao todo o bloco encapsulado executa com
o mesmo valor de contador que ter uma unidade a mais na iterao seguinte.
Quando o lao encerra o ltimo valor atribudo a varivel de contagem o do
limite superior. O operador constituinte desta estrutura enfatizando que
em cada iterao do lao ocorre uma atribuio (ao contador). O exemplo a
seguir ilustra o uso desta estrutura:
declare
i: inteiro
para i 1 at 100 faa
escreva i
A execuo deste algoritmo imprime os nmeros de 1 a 100 na sada

padro. O bloco da estrutura formado por uma nica linha de instruo. Um
outro exemplo:
declare
i, x: inteiro
para i 1 at 50 faa
x 2*i
escreva x
A execuo deste algoritmo imprime na sada padro os nmeros pares

entre 2 e 100. Em cada iterao o valor em x recalculado em funo do valor
do contador i.
Uma alternativa sinttica ao lao com contador, e que melhora o
desempenho de muitos algoritmos, o uso do passo. Por definio o passo
um valor inteiro que deve ser somado ao contador quando encerrar uma
iterao de lao e iniciar outra. O passo nos laos mostrados anteriormente
valem 1. A sinttica bsica do lao com contador e passo a seguinte:
para <contador> <limite inferior>, <limite superio>, <passo> faa
<bloco de pseudocdigo>
As mudanas nesta nova verso em relao a anterior foram: removeuse a palavra chave at e no seu lugar colocou-se uma vrgula; aps o limite
superior marcou-se uma nova vrgula seguindo-a com o valor do passo; por
fim a palavra chave faa. O exemplo dos nmeros pares pode ser reescrito da
seguinte forma:
44
declare
i: inteiro
para i 2, 100, 2 faa
escreva i
Neste algoritmo o contador i inicia com valor 2 e em cada iterao

incrementado de 2 (passo) at atingir 100.
Note que dependendo do passo o contador pode passar por cima do
limite superior. Quando isso acontece o lao encerra naturalmente quando o
contador atinge o primeiro valor acima do limite superior, mas sem process-lo.
Exemplo:
declare
i: inteiro
para i 7, 30, 3 faa
escreva i,
Este lao imprimir:

7 10 13 16 19 22 25 28
O valor 31 no ser impresso porque extrapola o limite superior do lao.

Quando o valor do passo negativo possvel montar laos com
contador decrescente porque neste caso ocorre sucessivamente a subtrao
ao invs da adio. Exemplo:
declare
i: inteiro
para i 20, 0, -1 faa
escreva i,
Este ltimo lao imprimir na sada padro os nmeros de 0 a 20 em

ordem decrescente e separados por um espao.
Estudo de Caso Fatorial: O fatorial de um nmero inteiro igual ao
produto entre ele e todos os seus anteriores positivos maiores que zero. O
algoritmo seguinte resolve o problema do fatorial:
declare
n, i, fat: inteiro
leia n
fat 1
para i 1 at n faa
fat fat*i
escreva fat
O funcionamento deste algoritmo explicado a seguir. A varivel n

implicitamente modificada pelo comando leia e mantm seu valor at o fim da
execuo. A varivel fat inicializada com o elemento neutro da multiplicao,
1. Em cada iterao do lao para o valor em fat multiplicado pelo valor
45
no contador i e o resultado atribudo prpria varivel fat. Assim, em cada

iterao, fat ir conter o fatorial do valor corrente no contador i. Como o
contador de estende at o valor em n, ento o ltimo valor atribudo a fat o
fatorial do valor em n.
Este processo de constante atualizao de uma varivel em um lao por
operaes de multiplicao denominado de acumulao por produto e
arqutipo de diversos outros algoritmos. A varivel modificada normalmente
inicializada com o elemento neutro da multiplicao para no afetar o resultado
gerado no processo iterativo.
Estudo de Caso Potncia com Expoente Inteiro: Seja a potncia, be,
com base b real e expoente e inteiro. O algoritmo seguinte resolve o problema
de clculo de tais potncias dados base e expoente na entrada padro:
declare
i, b, e, pot: inteiro
leia b, e
pot 1
para i 1 at e faa
pot pot*b
escreva pot
Este algoritmo constitui outro exemplo de acumulao por produto. Sua

nica diferena para o algoritmo de clculo de fatorial o valor pelo qual
a varivel de acumulao, neste caso pot, multiplicada. Para o fatorial tal
valor varia e igual ao valor no contador. No clculo de potncia, este valor
constante e igual a base (na varivel b).
Estudo de Caso Somatrio Seletivo: Quantos nmeros menores que
um milho so divisveis por sete e no so divisveis por trs? Ilustramos dois
algoritmos para resoluo deste problema. Primeiro algoritmo:
declare
n, cnt: inteiro
cnt 0
para n 1 at 1000000 faa
se (n mod 7 = 0 n mod 3 0) ento
cnt cnt + 1
escreva Total: , cnt
Neste algoritmo o lao de contador em n efetua um milho de iteraes.

Este lao encapsula a estrutura de deciso se (um nvel de indentao logo
acima de para). Em cada iterao, se o resto da diviso do valor em n por sete
nulo (ou seja, divisvel por 7) e o resto da diviso por 3 for diferente de nulo
(ou seja, no divisvel por 3), ento o valor na varivel cnt incrementado em
uma unidade (atribuio colocada um nvel de indentao acima da estrutura
de deciso). Como antes do lao cnt foi iniciada em zero (elemento nutro da
adio), ento aps finalizao do lao cnt conter o valor procurado.
Este processo de constante atualizao de uma varivel em um lao por
operaes de adio denominado de acumulao por soma e arqutipo
de diversos outros algoritmos. A varivel modificada normalmente inicializada
46
com o elemento neutro da adio para no afetar o resultado gerado no

processo iterativo.
A segunda forma de resolver o mesmo problema tem melhor desempenho
que a primeira. O algoritmo proposto o seguinte:
declare
n, cnt: inteiro
cnt 0
para n 0, 1000000, 7 faa
se (n mod 3 0) ento
cnt cnt + 1
escreva Total: , cnt
Neste algoritmo o lao possui passo igual a 7 e limite inferior igual a 0. Isso
faz com que o contador assuma apenas valores divisveis por 7 e obviamente
reduza o nmero de iteraes a um stimo do total no algoritmo anterior.
Como o valor do contador j divisvel por 7 em todas as iteraes, ento
o aumento do valor em cnt fica condicionado apenas a no divisibilidade do
valor em n por 3. Por essa razo a expresso booleana se reduz a um nico
teste relacional.
2.2.2. LAOS CONTROLADOS POR TESTE

Cada iterao de um lao est associada a um teste que ser responsvel
pela finalizao ou continuao deste. Nos laos com contador este teste
est embutido na prpria estrutura: ele consiste em verificar se o contador
j alcanou ou ultrapassou o limite superior. H, entretanto laos onde tais
testes so explcitos e aparecem como expresses booleanas. H dois tipos
importantes de laos com teste: de pr-teste e de ps-teste. Analisaremos cada
um deles nas linhas seguintes.
Laos de pr-teste so aqueles que no comeo de cada iterao realizam
um teste para determinar sua continuidade. A estrutura de controle para prteste , enquanto...faa, e possui sintaxe geral como segue:
enquanto <expresso booleana> faa
<bloco>
A semntica funcional desta estrutura descrita a seguir. O bloco

encapsulado repetido diversas vezes (iteraes). Antes de cada iterao a
expresso booleana entrada avaliada. Se seu valor for Verdadeiro significa
que a prxima iterao dever ocorrer do contrrio o lao dever encerrar-se.
Nenhuma instruo do bloco executada se na primeira avaliao o resultado
for Falso. Segue um exemplo:
47
declare
x: inteiro
x 0
enquanto (x<20) faa
escreva x,
x x + 2
Neste algoritmo, enquanto a expresso, x<20, for Verdadeira as duas

instrues encapsuladas sero executadas. importante observar que a varivel
n funciona como contador, apesar de no ser integrante da estrutura. Por essa
razo o valor nesta varivel precisa ser explicitamente inicializado fora do lao
(x0, na terceira linha) e modificado manualmente dentro do lao (xx+2, na
ltima linha). A sada deste algoritmo a seguinte:
0 2 4 6 8 10 12 14 16 18
O valor 20 no impresso porque no satisfaz a expresso booleana (20

igual a 20 e no menor).
Observe que, ao contrrio do que ocorre nos laos por contador,
possvel mudar o local onde a varivel de controle se modifica. Se, por
exemplo, as duas linhas do bloco encapsuladas por enquanto no algoritmo
anterior fossem trocadas de posio o cdigo ainda seria vlido, mas a sada
impressa se modificaria para:
2 4 6 8 10 12 14 16 18 20
Esta sada deixa de imprimir o 0 e imprime 20 simplesmente porque as

impresses agora vem depois da modificao da varivel x..
Laos de ps-teste so aqueles que ao final de cada iterao realizam
um teste para determinar sua continuidade. A estrutura de controle para psteste , repita...at, e possui sintaxe geral como segue:
repita
<bloco>
at <expresso booleana>
A semntica funcional desta estrutura descrita a seguir. O bloco

encapsulado repetido diversas vezes (iteraes). Aps o final de cada iterao
a expresso booleana sada avaliada. Se seu valor for Falso significa que
a prxima iterao dever ocorrer do contrrio o lao dever encerrar-se.
O bloco encapsulado executado pelo menor uma vez independente da
expresso booleana. Ao passo que a estrutura enquanto...faa executa cdigo
enquanto algo verdade, repita..at executa cdigo at que algo seja verdade.
Segue um exemplo:
48
declare
x: inteiro
x 0
repita
escreva x,
x x + 2
at (x>20)
O funcionamento deste algoritmo e similar ao ltimo algoritmo com

pr-teste apresentado. Como o teste fica na sada, o valor em x sempre
impresso na primeira iterao (mesmo que fosse maior que 20). O lao s
interrompido quando o valor em x atinge 22 (o qual no impresso).A sada
deste algoritmo :
0 2 4 6 8 10 12 14 16 18 20
2.2.3. ANINHAMENTO DE LAOS

Aninhar laos significa encapsular laos dentro de outros. Se um lao A
encapsulado por um lao B ento para cada iterao de B o lao A efetuar
sistematicamente todas suas possveis iteraes naquele contexto. Por exemplo:
declare
i, j: inteiro
para i 1 at 10 faa
para j 1 at 10 faa
escreva i+j
Os dois laos no algoritmo anterior so construdos para executar 10 vezes

cada. O primeiro tem contador em i e o segundo contador em j. Entretanto o
primeiro lado encapsula o segundo lao (posto um nvel de indentao acima).
Isso faz com que cada iterao do primeiro lao execute todas as 10 iteraes
do segundo lao e conseqentemente execute 100 vezes a instruo escreva
(posta um nvel de indentao acima do segundo lao).
Os limites dos contadores dos laos podem ser expressos como funo
de qualquer varivel inteira do programa (exceto o prprio contador). Isso
inclui tambm os contadores de laos hierarquicamente acima em um dado
aninhamento. Veja o exemplo:
declare
i, j, cnt: inteiro
cnt 0
para i 1 at 10 faa
para j i at 10 faa
cnt cnt + 1
escreva cnt
Neste algoritmo o segundo lao aninhado no primeiro. O limite inferior

do segundo lao (de contador j) o valor corrente do contador do primeiro
lao, i. proporo que o primeiro lao avana o nmero de iteraes do
segundo lao diminui como indica a tabela a seguir:
49
Valor de i
Nmero de iteraes do segundo lao 10
4 5 6 7
7 6 5 4
8 9 10
3 2 1
O algoritmo utiliza acumulao por soma para guardar na varivel cnt o

total de iteraes. Este valor tambm pode ser calculado pela somatria dos
valores na segunda linha da tabela anterior, ou seja, 10+9+8+7...+1 = 55. Este
ser o valor impresso na sada padro.
No h restries sobre os tipos de estruturas de repetio aninhadas.
Assim, por exemplo, laos de contagem podem estar aninhados a laos de
teste ou vice-versa. Tambm no h restries sobre aninhamento entre
estruturas de deciso e de repetio. De fato a associao coerente de todas
estas estruturas que possibilita a criao de algoritmos aplicveis.
2.2.4. QUEBRA E CONTINUAO DE LAOS

Um lao controlado por teste denominado lao infinito quando a
expresso booleana de controle sempre avaliada como Verdadeira (no caso
de enquanto...faa) ou sempre como Falsa (no caso de repita...at). Laos
infinitos so aplicados em situaes onde o critrio de parada no se encaixa
na entrada (ou na sada) do lao. Quando instrues internas ao bloco de
lao promovem sua suspenso forada (sem uso da expresso booleana de
controle) diz-se que houve quebra de lao. Uma quebra de lao construda
utilizando o comando pare. Veja o exemplo:
declare
ch: caractere
enquanto (V) faa
ch tecla
caso (ch) seja
x: escreva ol mundo!!
y: escreva hello world!
z: escreva hallo Welt!!
seno pare
No algoritmo anterior o lao construdo com enquanto infinito

devido expresso de controle ter sido substituda por um V (Verdadeiro).
Em cada iterao uma tecla solicitada pelo comando tecla e seu caractere
armazenado na varivel ch. Caso o valor em ch seja x, y ou z ento uma de
trs mensagens enviada a sada padro e o lao inicia novamente com nova
solicitao de tecla. Se a tecla pressionada no nenhuma das trs ento o
pare do bloco rotulado seno executado suspendendo o lao.
As regras de funcionamento do comando pare so as seguintes:
Se pare for executado fora de laos, mesmo encapsulado por

alguma estrutura de deciso, ocorrer suspenso da execuo do algoritmo
como um todo.
50

Se pare for executado dentro de um lao sem aninhamento com
outros laos, mesmo que esteja encapsulado por alguma estrutura de deciso,
apenas tal lao ser suspenso, mas o algoritmo no necessariamente.
Se pare for executado em um aninhamento de laos,

mesmo havendo aninhamento de estruturas de deciso, apenas o lao
hierarquicamente mais prximo a este comando ser suspenso, mas o algoritmo
no necessariamente.
Estudo de Caso Nmeros Primos: Um nmero primo aquele que
divisvel apenas por um e por ele mesmo. Como um nmero no divisvel
pelos que o sucedem razovel acreditar que um dado inteiro n, que se quer
testar se primo ou no, deva ser dividido pelos nmeros no intervalo fechado
[2, n-1] sendo primo se todas estas divises obtiverem resto no nulo e no
primo se pelo menos uma for nula (encontrada uma diviso com resto nulo
o nmero no mais primo e as demais divises, se ainda restarem, tornamse desnecessrias). Matematicamente, entretanto, tantas divises no so
necessrias Um intervalo suficiente de testes pode ser reduzido para [2, d] tal
que d2 n.
Com base no critrio anunciado acima foi construdo um algoritmo
capaz de escrever, na sada padro, todos os nmeros primos menores que
cinco mil. Segue:
declare
n, d: inteiro
b: lgico
pata n 2 at 5000 faa
b V
d 2
enquanto (d*d n) faa
se (n mod d = 0) ento
b F
pare
d d+1
se (b) ento
escreva n,
O lao para neste algoritmo submete em cada iterao o valor de seu

contador n a um teste para verificar se ele ou no valor primo. O teste possui
quatro etapas:
(I)
Atribuio varivel b do valor Verdadeiro indicando a primeira
hiptese sobre a natureza do valor em n (ou seja, primo at que se prove o
contrrio).
(II)
A varivel d recebe valor 2 indicando o incio do intervalo de
valores pelos quais o valor em n deve ser dividido.
(III)
O lao enquanto testa a divisibilidade de n pelos valores no
intervalo [2,3,..,d,..,D], com D2n, interrompendo o lao quando o primeiro
resto igual a zero encontrado. Se esta interrupo acontece o valor em b muda
para Falso (foi provado o contrrio: o numero no primo) e o lao enquanto
suspenso por um pare (no h mais sentido testar outras divisibilidades).
51
(IV)
O valor em b verificado para ver se o valor corrente no
contador n primo. Se for (ver expresso booleana formada apenas por b) ele
impresso na sada padro.
Neste ltimo exemplo, utilizando-se limite inferior igual a 3 e passo igual
a 2 no lao para, testam-se apenas valores mpares (o nico primo par 2)
aumentando-se a velocidade do algoritmo.
Nesta unidade foram apresentados elementos essenciais para a

construo de algoritmos. Os operadores so objetos de semntica bem
definida e que so classificados como: lgicos, relacionais e aritmticos.
Em seguida, abordamos elementos construtivos: estruturas de deciso e de
repetio que so fundamentais para a construo de algoritmos. Finalizando
a unidade ilustramos seis estudos de casos que utilizam todos os elementos
abordados na unidade.
Contamos que voc j esteja
fera no jogo sugerido no final da unidade I e que agora
com os conceitos aprendidos
nesta unidade voc consiga
progredir e utilizar as estruturas de deciso e repetio
abordadas aqui.
52
1. Faa um algoritmo para calcular o quadrado de um nmero.

2. Faa um algoritmo para calcular a mdia das notas de uma turma de
20 alunos.
3. Construir um algoritmo que receba trs valores inteiros quaisquer e os
imprima em ordem crescente.
4. Faa um algoritmo para calcular o fatorial de um nmero N inteiro
dado.
5. Faa um algoritmo que, dados nmeros de zero at um mximo,
mostre a soma de todos os no-primos, subtrada da soma dos primos.
6. Faa um algoritmo que determine se um nmero divisvel ou no
por outro.
7. Construir algoritmos para o calculo do nmero de dgitos dos valores:
(a) 100! (b) 21000
8. Considere uma moeda que contenha cdulas de 50,00, 10,00, 5,00
e 1,00. Considere ainda que caixas eletrnicos de um banco operem com
todos os tipos de notas disponveis, mantendo um estoque de cdulas para
cada valor. Os clientes deste banco utilizam os caixas eletrnicos para efetuar
retiradas de uma certa quantia. Escreva um algoritmo que, dado o valor
da retirada desejada pelo cliente, determine o nmero de cada uma das
notas necessrio para totalizar esse valor, de modo a minimizar a quantidade
de cdulas entregues.
9. Faa um algoritmo para calcular a soma de todos os nmeros inteiros
menores que 100 e que no sejam divisveis por 3.
10. O reverso de um nmero natural o novo nmero obtido pela
inverso de seus dgitos, ex: o reverso de 127 721. Escreva algoritmo que
receba um nmero natural e escreva seu reverso.
PEREIRA, SILVIO DO LAGO. Estruturas de Dados Fundamentais: Conceitos e Aplicaes. 9 Edio. Editora rica 2006. ISBN: 8571943702 .
FERNANDEZ, M; Corts, M. Introduo Computao. 1 Edio. Fortaleza. RDS
Editora, 2009.
http://armorgames.com/play/2205/light-bot
53
Variveis Indexadas
UNIDADE
O objetivo desta unidade apresentar a estrutura matriz, a qual utilizada
para manipulao de variveis com capacidade de armazenar na memria
mais de um valor ao mesmo tempo. Para manipular as variveis utiliza-se o
mecanismo de indexao.
1. MATRIZES
1.1. INTRODUO A MATRIZES E VETORES
Uma varivel escalar uma entidade abstrata que se refere a uma
clula de memria e que possui um tipo relacionado, uma faixa restrita de
representao e a capacidade de armazenar um nico valor. H, entretanto, a
possibilidade de definir variveis com capacidade de guardar mais de um valor
ao mesmo tempo. Tais variveis so denominadas matrizes.
Naturalmente os valores armazenados por matrizes no compartilham
a mesma clula de memria: de fato mais de uma clula estar presente na
definio de matrizes. Cada uma destas clulas funciona como uma varivel
escalar independente o que faz das matrizes aglomerados de variveis escalares.
Todas essas variveis constituintes so do mesmo tipo de forma que podemos
ter, por exemplo, matrizes de inteiros, lgicos ou de reais, mas nunca a mistura
deles. Denomina-se tipo base o tipo de dados comum a todos os aglomerados
da matriz.
Uma varivel matriz, assim como todas as demais, possui apenas um
nome. Ento como manipular cada uma das variveis escalares (clulas) que
a constitui? O mecanismo para se referenciar cada uma das clulas de uma
matriz denominado indexao. Assim, por exemplo, se M uma matriz dos
primeiros dez mpares ento M[1] = 1, M[2] = 3, M[3] = 5 e assim por diante:
aqui os colchetes retratam hospedeiros dos ndices que neste caso vo de um
a dez acessando independentemente cada valor em M. O vetor M ainda pode
ser descrito desta forma: M[k]=2k-1, com o ndice k no intervalo {1..10}.
Matrizes podem contar com um ou mais ndices. Cada ndice de uma
matriz est associado a uma dimenso da matriz. Assim matrizes unidimensionais
precisam de um ndice, bidimensionais de dois e assim por diante. As matrizes
na matemtica se confundem com as matrizes bidimensionais aqui descritas.
Matrizes unidimensionais so comumente denominadas de vetores.
Os vetores representam a forma de matriz mais comumente empregada em
algoritmos.
O total de aglomerados de um vetor representa o comprimento do
vetor. O tamanho de um vetor a memria total que ele ocupa, ou seja,
seu comprimento multiplicado pelo tamanho em bytes do tipo base. Assim,
por exemplo, se H um vetor formado de 5 inteiros de 2-bytes, ento o
comprimento de H 5, seu tipo base inteiro, e seu tamanho vale 10-bytes.
57
1.2. MATRIZES NA MEMRIA

Como esto dispostas as matrizes na memria? Se pensarmos em termos
de vetores coerente imaginar que as clulas constituintes so dispostas
vizinhas umas as outras: de fato exatamente isso o que acontece. Quando
um vetor precisa ser alocado, ento a memria requisitada dever ser um
bloco uniforme de bytes com o tamanho total do vetor. Encontrado o bloco
ele ento marcado como usado e vinculado a varivel vetor no programa.
Seja, por exemplo, um vetor formado de 50 clulas de inteiros de 2-bytes
vinculado varivel X. Assim, aps alocao, um bloco de 100 bytes estar
vinculado a X e as 50 clulas podero ser acessadas independentemente por
X[1], X[2], X[3],..., X[50]. O nico endereo real disponvel o do incio do
bloco de memria (chamaremos ). E o de cada clula? Como funciona uma
chamada a X[k], com k inteiro e entre 1 e 50? A resposta simples: atravs de
aritmtica elementar, ou seja, manipular X[k] significa manipular diretamente o
contedo no endereo de memria +(k-1)2.
O acesso a clulas individuais via vetores o mais eficaz se comparada a
outras formas de armazenamento linear (como listas encadeadas).
E as matrizes de mais de uma dimenso? Tambm tem clulas contiguas
em memria? A resposta sim. Quando mais de uma dimenso est envolvida a
memria total utilizada ser o produto entre o tamanho do tipo base e todos os
comprimentos das dimenses. Por exemplo, seja Q uma matriz bidimensional
33 de inteiros como segue:
|12
|1
|11
-7
-9
78
14|
-5|
25|
Se Q composto por inteiros de 2-bytes ento o bloco de memria

alocado ter 18 bytes. O aspecto em memria (mais comumente adotado)
para o exemplo anterior :
12
14
11
78
25
1.3. DECLARAO, INICIALIZAO E USO DE VETORES

A sintaxe geral para declarao de vetores a seguinte:
declare
<varivel>[comprimento]: <tipo>
Segue um exemplo:
58
declare
M[20], i: inteiro
para i 1 at 20 faa
M[i] i*i
Neste cdigo duas variveis so declaradas: um inteiro i e um vetor

de inteiros M. A varivel M comporta vinte valores inteiros e utilizada para
armazenar, por ao de um lao, os quadrados dos nmeros de um a vinte.
Vale observar que o contador i do lao funciona tanto como ndice do vetor
quanto como componente de expresso.
H duas aplicaes para o par de colchetes. A primeira declarativa, ou
seja, eles abrigam o comprimento do vetor declarado conforme se verifica na
definio da sintaxe geral. A segunda evocativa, ou seja, o contedo entre
os colchetes um valor de ndice entre 1 e seu comprimento (definido na
declarao) e possibilita o acesso a uma clula especfica do vetor. Tal acesso
permite tanto leitura quanto modificao do que est na clula indexada.
Consideremos o exemplo seguinte:
declare
M[10], i, imax: inteiro
para i 1 at 10 faa
leia M[i]
imax 1
para i 2 at 10 faa
se (M[i] > M[imax]) ento
imax i
escreva M[imax]
Este algoritmo solicita dez valores do usurio e imprime como sada o

maior entre eles. O primeiro lao o responsvel pela entrada de dados. Em
cada iterao o comando leia modifica uma clula distinta do vetor M de
modo a preench-lo convenientemente. O restante do cdigo um processo
de busca. Tal busca comea com a hiptese de que o maior valor est na
primeira posio (assim imax recebe 1). As demais posies so testadas
progressivamente pelo lao para: cada vez que uma clula verificada possui
valor maior que aquele de ndice imax, ento imax recebe o valor do contador.
Quando o lao encerra imax possui a posio contendo o maior valor e assim
M[imax] impresso. No h aninhamento de laos neste exemplo e por essa
razo os dois laos esto no mesmo nvel de indentao.
Apesar de no estar disponvel na maioria das linguagens de programao
introduzimos nessa abordagem uma opo de inicializao de vetores
diretamente do cdigo. A sintaxe geral a seguinte:
declare
<varivel _ 1>[c1]: <tipo>
//...
<varivel _ 1> {<valo1 _ 1>, <valo1 _ 2>, <valo1 _ 3>,..., <valo1 _ c1>}
//...
59
Um exemplo de aplicao:
declare
M[10], i, imax: inteiro
M {12, -9, 33, 8, -23, 17, 6, -5, 31, 2}
imax 1
para i 2 at 10 faa
se (M[i] > M[imax]) ento
imax i
escreva M[imax]
Nesta sintaxe de inicializao de vetores, o par de colchetes no

necessrio, as chaves (que envolvem os elementos) so obrigatrias e ainda
deve haver vrgulas entre os elementos. A execuo deste algoritmo imprime
33 na sada padro.
Estudo de Caso Dois maiores Valores de um Vetor. O algoritmo
seguinte encontra num vetor dado os dois maiores valores que ele contm.
declare
M[10], i, im1, im2: inteiro
M {-12, 9, 30, 18, 13, 7, -6, 5, 31, 1}
im1 1
im2 2
se (M[im1] < M[im2]) ento
i im1
im1 im2
im2 i
para i 3 at 10 faa
se (M[i] > M[im1]) ento
im2 im1
im1 i
seno
se (M[i] > M[im2])
im2 i
escreva M[im1], e , M[im2]
Este algoritmo modifica im1 e im2 para conterem respectivamente, no

final do processo, os ndices do maior e do segundo maior valor em M. A
primeira hiptese feita no algoritmo a de que o maior valor est na posio
1 e o segundo maior est na posio 2.(atribuies, im11 e im22). No
passo seguinte a estrutura de deciso, se, verifica e possivelmente corrige esta
hiptese (troca de valores) considerando apenas os dois primeiros valores em
M. As demais posies do vetor (3 a 10) so verificadas no lao para e tratadas
da seguinte forma: quando contiverem um valor maior que o maior at ento
(em im1) ento a nova posio do segundo maior valor passa a ser a em im1
(im2im1) e a nova posio do maior valor passa a ser a do contador (im1i);
mas se o valor em i no for maior que aquele em im2, ento ainda poder ser
maior que aquele em im2 e neste caso faz-se, im2i. As variveis im1 e im2
valem no final respectivamente 9 e 3 e a mensagem impressa 31 e 30.
Estudo de Caso Ordenao de Vetores. O algoritmo seguinte
implementa a ordenao de vetores pelo mtodo da seleo:
60
declare
M[10], i, j, t, x: inteiro
M {-12, 9, 30, 18, 13, 7, -6, 5, 31, 1}
//Ordenao por seleo:
para i 1 at 9 faa
t i
para j i+1 at 10 faa
se (M[j] < M[t]) ento
t j
x M[t]
M[t] M[i]
M[i] x
// Impresso:
para i 1 at 10 faa
escreva M[i]
A ordenao por seleo construda pelo aninhamento de dois laos.

O lao externo percorre o vetor da primeira penltima posio. O lao
interno busca pela posio, entre a posio corrente do lao externo e o fim
do vetor, contendo o menor valor. Esta busca usa a varivel t e principia com
a hiptese de que o menor valor tem posio em i (assim, ti). A execuo
do lao interno (e conseqentemente de seus testes de deciso) modifica t
(possivelmente) para conter o ndice do menor valor entre o valor em i e 10
(observe que este lao inicia em i+1 para excluir a hiptese inicial). As ltimas
trs linhas do lao externo (a indentao mostra que elas no fazem parte
do lao interno) fazem a troca entre o elemento na posio em t e aquele na
posio em i, ou seja, na posio em i fica o menor elemento do intervalo
[i corrente, 10]. O lao externo provoca 9 processos de busca que acabam por
ordenar o vetor. O ltimo elemento do vetor no considerado no lao externo
porque no h elementos sua frente para que ocorram trocas. O lao final
imprime a seqencia seguinte na sada padro:
-12
-6
13
18
30
31
1.4. AS CADEIAS DE CARACTERES

Se um vetor constitudo por caracteres ento ele denominado uma
cadeia de caracteres ou simplesmente string. Cadeias de caracteres so
utilizadas para representar mensagens ou mesmo textos completos. H duas
caractersticas importantes das strings que as destacam em relao aos vetores
em geral. A primeira o conceito de comprimento de cadeia e a segunda so
as formas peculiares que elas possuem de inicializao, atribuio, escrita e
leitura.
O comprimento de uma cadeia de caracteres a quantidade de
caracteres medida do primeiro caractere at o caractere que precede a primeira
ocorrncia do caractere nulo. (aquele cujo ASCII zero). Denotaremos este
caractere neste texto por . Esta estratgia responsvel pela capacidade que
strings tm de armazenar mensagens de tamanho varivel, ou pelo menos com
tamanho mnimo (zero) e mximo (comprimento do vetor menos um). Para
entender melhor esta questo consideremos um vetor de comprimento 20
61
onde se queira armazenar a mensagem Hoje vamos viajar. O aspecto dos

caracteres no vetor segue:
O total de caracteres da mensagem 17, incluindo espaos. Disp-la

no vetor demanda 18 caracteres porque o nulo posto logo em seguida. Os 2
finais so ignorados, por exemplo, num processo de impresso. O comprimento
desta cadeia exatamente 17 e poder se estender at no mximo 19 por
causa do nulo.
Pelo menos um caractere nulo dever estar presente num vetor de
caracteres: o final da cadeia ocorrer sempre no caractere que antecede a
primeira apario de .
Outras situaes para o vetor anterior:
Respectivamente essas strings tem comprimentos 19, 4, 0 e 2.

Para inicializar uma cadeia de caracteres pode-se utilizar a sintaxe
apresentada anteriormente. Exemplo:
declare
S[10]: caractere
S {a, , c, a, s, a, }
Neste exemplo cada caractere foi colocado em sua respectiva posio

no vetor, incluindo o nulo. Para guardar a mensagem a casa, entretanto, so
necessrios apenas 7 caracteres (incluindo ). A lgica simples: no excedendo
o comprimento do vetor, qualquer disposio de caracteres terminada em nulo
vivel. Caso seja inferior ao comprimento do vetor, o restante, apesar de
ainda disponvel, simplesmente ignorvel.
Como j mencionado, as cadeias de caracteres possuem inicializao
peculiar. Ao invs de usar chaves, vrgulas e caracteres soltos, convencionaremos
que as cadeias podero ser inicializadas por atribuio direta de uma mensagem.
Veja como fica o exemplo anterior:
declare
S[10]: caractere
S a casa
Neste caso no aparece explicitamente o nulo, mas convencionamos

que a inicializao por esta forma efetua automaticamente sua insero.
62
Exclusivamente para as cadeias de caracteres, os comandos leia e

escreva funcionam anlogos s suas verses para variveis escalares. Exemplo:
declare
S[100]: caractere
leia S
escreva S
Neste algoritmo o usurio fornece uma cadeia via entrada padro e depois
ela simplesmente reimpressa na sada padro. Esta uma forma conveniente
de entrada para leia haja vista que pouco processamento adicional necessrio
(no esquea que a entrada padro gera uma cadeia de caracteres). Cada
caractere digitado convenientemente colocado no vetor. A confirmao de
entrada (ENTER no teclado) concatena adicionalmente o nulo cadeia.
Se o comando escreva deve imprimir uma cadeia de caracteres, ento
ele far impresso caractere por caractere at que um nulo (no impresso)
encontrado. Exemplo:
declare
S[100]: caractere
S ol mundo!
escreva S
Apesar do vetor S comportar at 100 caracteres, a cadeia de caracteres

que ele armazena possui comprimento 10: assim apenas estes caracteres
sero impressos por escreva. O comportamento de escreva, com cadeias de
caracteres, reproduzido com utilizao de um lao:
declare
S[100]: caractere
i: inteiro
leia S
i 1
enquanto (S[i] ) faa
escreva S[i]
i i + 1
Neste algoritmo a cadeia impressa caractere a caractere sendo um

caractere por iterao de lao. Cada um dos caracteres denotado pela
expresso S[i] como convm a qualquer vetor. Se o nulo encontrado, ento
o lao para (no impresso). Outra aplicao de leitura caractere a caractere
de uma cadeia mostrada a seguir:
declare
S[100]: caractere
t, i: inteiro
leia S
t 0
enquanto (S[t+1] ) faa
t t+1
para i t, 1, -1 faa
escreva S[i]
63
Este algoritmo recebe uma cadeia via entrada padro e a escreve de trs
para frente. A idia medir primeiramente o comprimento da cadeia usando
a varivel t cujo valor inicial zero. Com o fim do primeiro lao (enquanto) t
conter o comprimento da cadeia e um lao por contagem (para) poder fazer
o trajeto reverso do vetor a fim de imprimi-lo de trs para frente.
1.5. VETORES DINMICOS

Todas as declaraes de vetores nas sesses anteriores possuam
vinculao esttica de espao em memria, ou seja, o tamanho que o
vetor possuir em tempo de execuo precisa ser definido no cdigo pelo
programador. O efeito direto disso a inflexibilidade, ou seja, se mais memria
for necessria no ser possvel expandir o vetor durante a execuo.
Para resolver esta limitao, introduzimos os comandos alocar e limpar.
Eles interagem diretamente com o gerenciador de memria requisitando e
devolvendo respectivamente quantidades de memria. Cada solicitao de
memria com alocar est associada a uma devoluo com limpar. Memria
no devolvida mantm o status de ocupada no podendo ser usada por outros
processos. Em mquinas reais, a ocorrncia desse quadro causa queda de
desempenho ou mesmo parada do sistema (crash).
Denominamos vetor dinmico ao vetor com capacidade de definir seu
comprimento em tempo de execuo. A sintaxe geral de um vetor dinmico
a seguinte:
declare
<vetor>[]: <tipo base>
A diferena para vetores estticos a ausncia de um comprimento

entre os colchetes. Exemplos:
declare
X[]: inteiro
VET[]: inteiro
Para alocar e limpar memria de um vetor dinmico utiliza-se

respectivamente os comandos alocar e limpar. A sintaxe bsica segue:
alocar <vetor>[<comprimento>]
...
limpar <vetor>
O exemplo a seguir ilustra o uso de vetores dinmicos:
64
declare
X[], n, i: inteiro
leia n
alocar X[n]
para i 1 at n faa
X[i] 2*i-1
limpar X
No exemplo acima o vetor dinmico X tem seu comprimento alocado

com um valor de comprimento, n, fornecido via entrada padro. Aps a
alocao o vetor carregado com a mxima quantidade de nmeros mpares
que suporta e finalmente desalocado ao final.
Estudo de Caso Nmeros Pandigitais: um nmero natural
denominado pandigital se seus algarismos forem todos distintos entre si. O
algoritmo seguinte determina se um valor fornecido pelo usurio ou no
pandigital:
declare
Q[], t, n, i, j: inteiro
b: lgico
leia n
// PARTE I
t 0
j n
enquanto (j>0) faa
t t + 1
j j div 10
// PARTE II
alocar Q[t]
// PARTE III
j n
para i t, 1, -1 faa
Q[i] j div 10
j j div 10
// PARTE IV
b V
para i 1 at t-1 faa
para j i+1 at t faa
se (Q[i] = Q[j]) ento
b F
pare
se ( b) ento
pare
// PARTE V
se (b) ento
escreva o nmero pandigital!
seno
escreva o nmero NO pandigital!
limpar Q
O algoritmo anterior seccionado em seis partes explicadas a seguir.

(I)
O comprimento em dgitos do valor em n medido. Isso feito
pelo lao enquanto que, utilizando uma cpia de n, neste caso em j, efetua
sucessivas divises por dez. Obviamente este lao se encerra quando um total
de iteraes igual ao nmero de dgitos do valor em n realizado (o que
65
conduz j a zero e logo ao encerramento do lao). Haja vista que t anulado

fora do lao e incrementa em um em cada iterao deste, ento o valor final
de t o comprimento em dgitos do valor em n.
(II)
O vetor Q tem seu espao alocado. A estratgia dedicar uma
clula para cada dgito do valor em n.
(III)
Os dgitos do valor em n so dispostos no vetor Q. Para realizar
tal tarefa, novamente uma cpia de n feita em j que mais uma vez, por cclicas
operaes de diviso por dez, reduzido zero. O lao no mais por teste e
sim de contagem com t iteraes (isso provoca o mesmo efeito). Antes de cada
diviso, o valor j mod 10 colocado na posio i de Q. Esta operao consiste
exatamente em ler o ltimo digito do inteiro em j. Como o valor em j reduz em
cada iterao, ento j mod 10 retorna sistematicamente cada ltimo dgito do
nmero. Assim tais dgitos so tomados de trs para frente justificando o lao
de contagem decrescente (observe que nele o contador i inicia com o valor em
t e decresce at 1 causando acesso de trs para frente no vetor). Com o fim do
lao o vetor Q conter os dgitos do atual valor em n na seqncia correta (para
simples verificao de pandigitalidade isso no faz diferena, mas ilustramos
aqui por ser til em outros problemas).
(IV)
testado se o vetor Q de dgitos possui ou no elementos
repetidos. Os dois laos aninhados efetuam sistemticas comparaes entre
elementos sendo suspensos (ambos) se alguma igualdade encontrada. A
varivel b, inicialmente marcada como Verdadeira, indica a hiptese inicial de
que h repeties. Se uma igualdade encontrada tal varivel recebe Falso. As
chamadas a pare que suspendem os laos esto associadas ao valor em b. A
expresso b representa negao do valor em b e necessria para testar se
o lao externo (de contador i) deve ser ou no suspenso.
(V)
Uma mensagem apropriada impressa na sada padro de
acordo com o ltimo valor em b. O vetor Q desalocado.
Estudo de Caso Transformao em Hexadecimal: a base hexadecimal
conta com 16 distintos algarismos para representao de valores numricos.
Os dez primeiros coincidem com aqueles da base decimal ao passo que os
seis restantes so denotados pelas cinco primeiras letras do alfabeto. Como
h letras e nmeros envolvidos, ento hexadecimais so preferencialmente
representados como cadeias de caracteres.
Para transformar um decimal em hexadecimal deve-se submet-lo a
sucessivas divises pela base 16. Os restos destas divises so progressivamente
tomados e seus correspondentes caracteres colocados na string resposta. Se
o resto de diviso est entre 0 e 9 ento os caracteres correspondentes so
respectivamente 0 a 9. Se o resto est entre 10 e 15 ento os caracteres so
respectivamente A a F. Os caracteres devem ser postos na string resposta
de trs para frente porque os caracteres constituintes so obtidos na ordem
inversa.
66
Para resolver o problema descrito o sugerido o algoritmo a seguir:

declare
H[], B[17]: caractere
t, n: inteiro
b: lgico
// PARTE I
B 0123456789ABCDEF
leia n
// PARTE II
t 0
j n
enquanto (j>0) faa
t t + 1
j j div 16
m
// PARTE III
alocar H[t+1]
H[t+1]
// PARTE IV
j t
enquanto (n>0) faa
H[j] B[ 1 + (n mod 16)
n n div 16
j j - 1
// PARTE V
escreva H
limpar H
Este algoritmo divide-se em cinco partes descritas a seguir:

(I)
Define-se o vetor mscara B e um inteiro solicitado ao usurio
via n para que seja convertido para o formato hexadecimal.
(II)
O comprimento em dgitos (na base 16) do valor em n
calculado. Para tanto o valor em j (que iniciado com uma cpia de n)
sucessivamente dividido por 16, no lao enquanto, at ser anulado. Em cada
iterao t (previamente anulado) incrementado em um. Ao final, o valor em
t a quantidade de dgitos do valor em n na base 16.
(III)
Memria alocada no vetor dinmico de caracteres, H. O valor
de comprimento t+1 deve-se a necessidade do caractere nulo.
(IV)
O lao enquanto dispe, no vetor H, cada caractere em sua
posio apropriada. Esta posio apropriada controlada pela varivel j que
inicia com o valor em t e decai at 1 no lao (preenchimento reverso). J os
caracteres, que sero postos em H, so extrados da cadeia B mediante uso
da expresso, 1 + n mod 16. Como o valor em n decai em cada iterao (n
n div 16) ento o valor da expresso, n mod 16, representa cada ltimo
algarismo (na base 16) extrado do que resta em n e conseqentemente o
valor da expresso, 1 + n mod 16, exatamente o ndice em B que contm o
caractere correspondente.
(V)
A string impressa e depois removida da memria.
67
1.6. USANDO MAIS DE UMA DIMENSO

A sintaxe geral para declarao de matrizes com mais de uma dimenso
a seguinte:
declare
<varivel>[comprimento _ 1, comprimento _ 2,...,comprimento _ n]: <tipo>
Segue um exemplo:
declare
X[3,3]: real
i, j: inteiro
para i 1 at 3 faa
para j 1 at 3 faa
leia X[i, j]
No exemplo acima uma matriz quadrada de ordem 3 definida e lida

com o auxlio de dois laos aninhados. O comando leia executado exatamente
um total de nove vezes.
Para criar uma matriz dinmica adotaremos a seguinte sinttica: a
declarao ser idntica a de um vetor dinmico, entretanto no momento da
alocao sero especificados os comprimentos das dimenses separados por
vrgulas. O uso dessas matrizes idntico ao de uma esttica. Veja o exemplo:
declare
W[], n, i, j: integer
leia n
alocar W[n,n]
para i 1 at n faa
para j 1 at n faa
leia W[i, j]
limpar W
No exemplo acima W uma matriz cuja declarao idntica a de

um vetor dinmico. Somente na alocao so definidas as dimenses. O uso
ps-alocao idntico ao de uma matriz comum. Para limpar esta matriz
dinmica a sintaxe a mesma dos vetores dinmicos.
Devido a natureza linear da memria alocada, uma matriz poder ser
tratada como vetor mesmo que tenha mais de uma dimenso. Para ilustrar isso
consideremos o exemplo a seguir:
declare
VET[], m, n, i, j: integer
leia m, n
alocar VET[m,n]
para i 1 at m faa
para j 1 at n faa
VET[i,j] i*j
para i 1 at m*n faa
escreva VET[i]
limpar VET
68
Apesar de VET ser dinamicamente definida como uma matriz de m

colunas e n linhas e de seus valores serem carregados com o uso de dois
ndices (pelo aninhamento de dois laos), isso no impede que um nico lao
trate esta varivel como um vetor cujo nico ndice est no intervalo fechado
[1; m*n]. Se o usurio fornecer 3 e 2 como entrada para este algoritmo a sada
ser:
3 2 <ENTER>
1 2 2 4 3 6
Nesta unidade foi apresentada a estrutura de matriz a qual utilizada

para manipulao de variveis com capacidade de armazenar na memria
mais de um valor ao mesmo tempo. Matrizes unidimensionais so comumente
denominadas de vetores. Os vetores representam a forma de matriz mais
comumente empregada em algoritmos.
1. Construa algoritmo que receba um vetor de inteiros e imprima

como sada o maior e o menor valor contidos nele.
2. Construa algoritmo que busque num vetor os dois maiores valores
contidos.
3. Construa um algoritmo que receba um vetor de comprimento
conhecido e altere seus valores de forma a ficarem em ordem inversa.
4. Construir algoritmo que carregue em um vetor de comprimento n os
primeiros n valores primos.
5. Rotao o procedimento de deslocamento dos itens de um
vetor para casas vizinhas. Numa rotao a direita todos os itens migram
para posies logo a frente, exceto o ltimo que vai para a posio 1,
ex: se v = {1,2,3,4}, uma rotao a direita modifica v para {4,1,2,3}. De
forma anloga uma rotao a esquerda de v geraria {2,3,4,1}. Construir
algoritmos para os dois processos de rotao.
6. Construa um algoritmo que calcule a mdia dos nmeros menores
que 5000 que sejam divisveis por 7 mas no sejam divisveis por 3.
7. Construa um algoritmo que receba uma lista de nmeros inteiros
e rearranje seus elementos de forma a ficarem em ordem crescente
8. Uma cadeia de caracteres dito palndromo se a seqncia dos
caracteres da cadeia de esquerda para direita igual seqncia de caracteres
da direita para esquerda. Exemplos: ARARA, RADAR, AKASAKA, ANA. Faa
um algoritmo que reconhea se uma cadeia de caracteres palndromo.
9. O nmero 585 palndromo nas bases 10 e base 2 (1001001001).
Construir algoritmo que determine a soma de todos os nmeros com esta
propriedade que sejam menores que um milho.
69

http://www.academicearth.org/lectures/array
http://www.academicearth.org/lectures/multi-dimensional-arrays
70
Programao Modular
UNIDADE
O objetivo desta unidade apresentar o conceito de programao modular,
isto , como dividir um programa em subprogramas.
1. MODULARIZAO
1.1. O QUE MODULARIZAR?
H dois importantes nveis de abstrao em computao: abstrao de
dados e abstrao de processos. A abstrao de dados explora como diferentes
tipos de informaes podem ser representados e ainda quais as restries de
operabilidade entre eles. A abstrao de processos trata da simplificao do
processo de execuo de uma dada aplicao pela diviso deste em partes
menores (sub-processos) que podem ser testadas separadamente.
A modularizao est estreitamente ligada abstrao de processos.
Modularizar significa dividir um programa em subprogramas cujos
funcionamentos podem ser testados separadamente. Os subprogramas so
nada mais que abstraes com alguma sintaxe adicional (em nvel de cdigo).
1.2. FUNES, PROCEDIMENTOS, PROCESSOS E CONTROLE

Modularizar algoritmos significa separar o pseudocdigo em funes. As
funes, mdulos ou subprogramas, como so conhecidos, podem aparecer em
grande quantidade em um mesmo algoritmo, mas apenas uma destas funes
tem papel de acionador, ou seja, sempre a partir dela se iniciar a execuo.
a chamada funo principal. Todas as demais funes so secundrias.
Cada funo tem um nome e, num mesmo algoritmo, todas as funes
devem ter nomes distintos entre si. Alm do nome uma funo pode conter
parmetros. Parmetros, ou argumentos, so variveis especiais que agem
como entrada de dados para estas funes. A sintaxe geral de uma funo a
seguinte:
<nome _ da _ funo> (<arg _ 1>: <tipo _ 1>, <arg _ 2>: <tipo _ 2>, ...,
<arg _ n>: <tipo _ n>)
//declarao de variveis da funo
//instrues da funo
Na sintaxe de funes os argumentos so arranjados em uma lista de

variveis com seus respectivos tipos e ainda separados por vrgula. Apesar de
no existir a palavra declarar, os argumentos de entrada so, por definio,
variveis ali declaradas. A primeira linha da funo (composta por seu nome
e seus argumentos entre parnteses) chamada de cabealho da funo. O
corpo da funo todo o cdigo abaixo do cabealho e cuja indentao pelo
menos um nvel acima (relao de encapsulamento de cdigo em funes). O
corpo de uma funo pode possuir uma sesso declarativa (variveis da funo)
e possui obrigatoriamente (logo abaixo) a sesso de cdigo (bloco de cdigo).
Se um grupo de argumentos de entrada tiver mesmo tipo eles podem ser
declarados com a seguinte sintaxe:
73
<nome _ da _ funo> (<arg _ 1>,<arg _ 2>,<arg _ 3>,...,<arg _ n>: <tipo>)

// corpo da funo
Para que seja executada, uma funo precisa ser chamada. Uma
chamada de funo realizada pela invocao de seu nome juntamente com
valores para seus parmetros. Para executar uma dada funo secundria,
ela deve ser chamada de dentro da funo principal ou ento de dentro de
outra funo secundria. Cada funo de um algoritmo deve ser chamada pelo
menos uma vez em algum lugar daquele algoritmo. Se uma dada funo nunca
chamada ela pode ser removida do projeto. A execuo de uma aplicao
nada mais que a execuo de sua funo principal.
Quando uma aplicao inicia sua execuo diz-se que a funo principal
recebe o controle de fluxo ou simplesmente que recebe o controle. Se a
funo principal chama uma funo secundria ento esta funo receber o
controle do fluxo enquanto estiver executando e o devolver a funo principal
quando sua execuo se encerrar. De modo geral quando uma funo A, seja
ela principal ou no, chama outra funo B ocorre repassagem provisria
do controle de fluxo de A para B e depois seu retorno para A quando B se
encerra. Sistematicamente o controle migra de funo para funo durante
toda execuo. Em algum momento cada uma das funes do projeto manter
o controle. Se uma mesma funo for chamada vrias vezes ela manter o
controle em momentos diferentes. Apenas uma, entre as vrias funes, se
existirem, ter o controle durante a execuo da aplicao. (Uma aplicao
dever conter pelo menos a funo principal).
Funes podem retornar valores. O retorno (ou sada) de uma funo
pode ser, por exemplo, um nmero, um caractere ou um booleano. A ao
de retorno de uma funo sumria, ou seja, quando invocada a funo
automaticamente se encerra devolvendo o controle funo chamadora. Para
provocar o retorno usa-se a palavra chave retorne seguida do valor que se
deve retornar. Veja o exemplo a seguir:
soma (x, y: inteiro)
declare
s: inteiro
s x + y
retorne s
principal()
declare
a, b, c: inteiro
leia a, b
c soma(a,b)
escreva c
Neste exemplo h duas funes: a principal (que sempre denotaremos

pelo nome principal) e a funo secundria soma(). A funo secundria possui
dois parmetros, x e y e sua chamada feita na funo principal passado como
argumentos os valores nas variveis a e b. O uso da atribuio, c soma(a, b),
entra em concordncia com o retorne da funo soma(), ou seja, s possvel
atribuir a c algum valor porque este valor existe e o retorno da funo em
74
questo. As variveis x e y so denominadas argumentos formais da funo

soma() ao passo que a e b so denominadas de argumentos reais da mesma
funo.
Os argumentos reais de uma funo podem ser tanto constantes como
variveis. J os argumentos formais aparecem no prprio corpo construtivo da
funo e so representados apenas por variveis. Para cada argumento real
deve haver um formal equivalente. A ordem em de disposio dos argumentos
formais deve ser mantida pelos argumentos reais, por exemplo, se uma dada
funo possui trs argumentos cujos tipos so respectivamente inteiro, real e
booleano, ento os argumentos reais repassados no momento da chamada
devem tambm estar listados nesta ordem de tipo, ou seja, inteiro, real e
booleano.
Consideremos outro exemplo:
e _ primo (n: inteiro)
declare
d: inteiro
d 2
enquanto (d*d n) faa
se (n mod d = 0) ento
retorne F
d d + 1
retorne V
principal()
declare
k: inteiro
para k 1 at 200 faa
se ( e _ primo(k) ) ento
escreva k
A funo e_primo() acima uma verso modularizada do algoritmo

apresentado no estudo de caso Nmeros Primos. O objetivo desta funo
receber um inteiro e retornar um booleano onde retorno Verdadeiro significa
que a entrada um valor primo e retorno Falso significa o inverso. Se durante
os testes de divisibilidade internos ao lao enquanto algum dos restos for nulo,
ento no haver mais sentido continuar testando outras divises porque o
nmero j no mais primo. A estratgia do estudo de caso anterior fora o
uso de um pare e uma varivel booleana auxiliar. Neste novo contexto se
invoca apenas um, retorne F, porque este comando fora o encerramento
da funo independente de onde ele aparea dentro da funo. Como um F
(Falso) segue o retorne ento a funo retorna convenientemente para valores
no primos. Caso o valor seja primo o lao se encerrar normalmente e a
instruo, retorne F, jamais ser executada. Em contrapartida a continuao
da execuo encontrar a linha, retorne V, que forar o encerramento e
retorno Verdadeiro: de fato apenas valores primos causaro o alcance desta
linha de instruo. A funo principal faz uso intenso da funo e_primo()
testando quais nmeros entre 1 e 200 so ou no primos. Caso sejam, eles
so impressos. A expresso booleana do se a prpria chamada da funo
e_primo() haja vista que o retorno dela um valor booleano e desta forma no
desobedece a sintaxe da estrutura.
75
H funes que no precisam retornar. Elas so denominadas de

procedimentos. Veja o exemplo a seguir:
print _ primo (t: inteiro)
declare
i: inteiro
para i 1 at t faa
se ( e _ primo(i) ) ento
escreva(i)
O procedimento anterior deve ser parte integrante do algoritmo

apresentado anteriormente, pois faz uso da funo e_primo(). Este
procedimento simplesmente imprime na sada padro todos os primos entre 1
e o valor no argumento de entrada t. Obviamente o contedo impresso pode
ser interpretado como sada da funo. Entretanto, por conveno, diremos
que uma funo possui sada se ela gerar alguma informao que puder ser
repassada adiante por uma ao conjunta de um retorne e um operador de
atribuio. A funo principal a seguir imprime os primos menores que 100
pela chamada de print_primos().
principal ()
print _ primos(100)
Como print_primos() no possui sada no h nenhuma atribuio

atrelada chamada desta funo.
1.3. ESCOPO DE VARIVEIS

O escopo de uma varivel definido como o lugar no algoritmo onde
esta varivel pode ser manipulada. De forma geral o escopo de todas as
variveis mostradas at este ponto exatamente o corpo das funes onde so
definidas. Assim uma varivel, definida dentro de uma dada funo, no ser
visvel dentro de outras funes. Exemplo:
func _ 1 ()
declare
x: inteiro
x 100
func _ 2 ()
escreva x // erro: x no foi de nido neste escopo
A varivel x no foi definida no escopo da funo func_2() e desta forma

no pode ser impressa. Analogicamente duas variveis em escopos diferentes
podem ter o mesmo nome e no estarem relacionadas (posies distintas em
memria). Exemplo:
76
func _ 1 ()
declarar
x: inteiro
y: booleano
// corpo da funo func _ 1()
func _ 2 ()
declarar
x: real
y: booleano
// corpo da funo func _ 2()
Neste exemplo as variveis x e y esto em escopos diferentes. Em cada

escopo x tem um tipo diferente, mas y mantm o mesmo tipo (booleano). Tais
variveis s possuem em comum o nome. Operar x e y em func_1() no afeta
x e y em func_2() e vice=versa.
Os parmetros ou argumentos de uma funo so as nicas variveis que
podem ser alteradas a partir de outro escopo. Por exemplo, se x argumento
formal da funo f() ento x est no escopo de f(); entretanto ao fazer uma
chamada de f(), uma constante ou varivel fora do escopo de f() ter que
agir como argumento real para carregar x. Argumentos formais so portas de
entrada para as funes e devem se comportar desta forma.
Tanto os argumentos formais quanto as variveis declaradas internamente
a uma funo esto no escopo desta funo e so comumente chamadas de
variveis locais. Todas as variveis apresentadas nos exemplos at aqui so
variveis locais. Uma varivel no local denominada varivel global. Uma
varivel global aquela visvel a todas as funes de um projeto de algoritmo.
Para criar variveis globais uma seo de declarao externa a todas as funes
deve ser criada como no exemplo seguinte:
declare
x: inteiro
proc ()
escrever x
principal()
x 23
proc()
O projeto acima possui uma varivel global, x, um procedimento proc()

sem entrada (o par de parentes vazio mantido aqui para indicar que se trata de
um mdulo) e a funo principal. O mdulo proc() pode escrever x porque ela
global ao passo que principal() tambm pode mudar x com uma atribuio
direta pela mesma razo. Visto que proc() chamado em principal() ento o
valor 23 ser impresso na sada padro.
Caso exista alguma varivel local em alguma funo que tenha mesmo
nome de uma varivel global a ambigidade ser tratada de forma anloga
maioria das linguagens de programao: valer a varivel local e no ser
possvel o acesso a varivel global. Veja o exemplo:
77
declare
x: inteiro
proc ()
declare
x: inteiro
x 23
principal()
x 35
proc()
escreva x
O valor impresso na sada padro ser 35 porque a varivel x mudada

com a execuo de proc() no a verso global. Se a declarao de x em
proc() fosse removida o valor impresso na sada padro seria 23.
1.4. PASSANDO ARGUMENTOS POR VALOR E POR REFERNCIA

As regras de escopo permitem que argumentos formais sejam modificados
para os valores de seus respectivos argumentos reais no momento da chamada
da funo. De fato cada argumento formal recebe uma cpia do contedo de
seu argumento real equivalente. Este modelo conhecido como passagem
de argumento por valor. Utilizando tal modelo, o argumento formal no
tem qualquer influncia sobre o argumento real o que em alguns casos no
interessante. Suponhamos, por exemplo, uma funo inc() que contenha
apenas um argumento e cujo objetivo aumentar em uma unidade o valor no
argumento real. Antes de escrever o cdigo para a funo inc() codifiquemos
uma funo principal que teste inc(), como segue:
principal()
declare
j: inteiro
j 5
inc(j)
escreva j // deve imprimir 6
O comportamento esperado no cdigo acima a impresso do valor 6

na sada padro. Entretanto, pelo modelo da passagem por valor tal funo no
pode ser escrita. Vejamos uma tentativa para inc():
inc(k: inteiro)
k k + 1
Caso esta funo seja utilizada o valor impresso na sada padro ser 5
e no 6 simplesmente por que quem incremente em uma unidade k e no j.
Como k e j no se relacionam a funo no se comporta como desejado.
Para resolver o problema apresentamos outro modelo de passagem de
argumento conhecido como passagem por referncia. Uma referncia por
definio um apelido de varivel que pode ser manipulada como se fosse
a prpria varivel que ela apelidou. Por exemplo, se r uma referncia da
78
varivel x ento uma atribuio a r ser de fato uma atribuio para x. Na

passagem por referncia alguns ou todos os argumentos formais de uma funo
so transformados em referncias: assim quando os argumentos reais so
repassados no ocorre cpia alguma e sim a definio de apelidos em outro
escopo! Uma vez de posse de tais referncias a funo pode mudar variveis
fora de seu escopo.
Para transformar um argumento formal numa referncia basta preceder
a declarao da varivel com a palavra chave ref. Assim a funo inc() pode ser
agora corretamente escrita:
inc(ref k: inteiro)
k k + 1
principal()
declare
j: inteiro
j 5
inc(j)
escreva j
Nesta nova verso k deixa de ser uma varivel de tipo inteiro e tornase uma referncia para valor inteiro. Assim quando j repassado como
argumento, ento k torna-se provisoriamente uma referncia para ele. A adio
de uma unidade referencia k na funo inc() afeta de fato a varivel j. O valor
impresso na funo principal ento 6.
1.5. PASSANDO VETORES COMO ARGUMENTOS

Algumas linguagens de programao no permitem que vetores sejam
repassados por valor. Isso acontece porque no possvel garantir que o
vetor repassado sempre tenha o mesmo comprimento do vetor argumento de
entrada. Mesmo que seja possvel impedir a execuo de uma funo quando
se tentar repassar a ela um vetor de comprimento invlido, isso implicaria em
restries de uso desta funo. A sada utilizada nestas linguagens o uso de
referncias. Adotaremos estas mesmas regras nos algoritmos que seguem.
Para utilizar referncias na repassagem de vetores seguiremos a seguinte
sintaxe geral:
<nome _ da _ funo>(ref <arg>[]: <tipo>)
//corpo da funo
Apesar de um par de colchetes vazios, o argumento no se trata de um

vetor dinmico. A associao entre ref e [ ] no argumento de entrada (e apenas
a) significa vetor repassado por referncia.
Quando repassado por referncia um vetor torna-se modificvel no
escopo da funo. Entretanto a funo aparentemente perde uma informao
importante: o comprimento do vetor. Para resolver o problema utilizaremos
79
uma importante funo chamada comp() que recebe como argumento um

vetor, ou referencia de vetor, e retorna seu comprimento. Exemplo:
soma(ref M[]: inteiro)
declare
i, res: inteiro
res 0
para i 1 at comp(M) faa
res res + M[i]
retorne res
A funo soma() recebe um vetor de valores inteiros e retorna a

somatria de seus elementos. A varivel res um acumulador que recebe
zero no princpio e depois muda em cada iterao do lao at conter a soma
de todos os elementos. A funo comp() retorna o comprimento do vetor
recebendo-o como argumento (sem colchetes).
Estudo de Caso Nmeros Pandigitais. A modularizao do problema
dos pandigitais fornece uma soluo mais natural como indica o algoritmo
seguinte. Nesta nova abordagem procura-se determinar quantos nmeros
pandigitais existem abaixo de um milho.
ndig(num: inteiro)
declare
s: inteiro
s 0
enquanto (num>0) faa
s s + 1
num num div 10
retorne s
carregar(ref R[], num: inteiro)
declarar
i: inteiro
para i comp(R), 1, -1 faa
R[i] num div 10
num num div 10
e _ pandig(ref R[]: inteiro)
declare
i, j: inteiro
para i 1 at comp(R)-1 faa
para j i+1 at comp(R) faa
se (R[i] = R[j]) ento
retorne F
retorne V
principal()
declare
cnt, Q[], t, n: inteiro
cnt 0
para n 0 at 1000000 faa
alocar Q[ ndig(n) ]
carregar(Q, n)
se ( e _ pandig(Q) ) ento
cnt cnt + 1
limpar Q
escreva cnt
80
O algoritmo acima possui trs funes secundrias e a funo principal.

Na funo principal o lao para testa cada valor que o contador n assume.
Cada teste consiste em: (I) alocar dinamicamente o vetor Q com comprimento
igual quantidade de dgitos do atual valor de n; (II) carregar Q com os dgitos
de n e; (III) testar se o vetor Q possui elementos repetidos; caso seja o contador
cnt (iniciado com zero fora do lao) incrementado em uma unidade. Quando
o lao se encerra o valor em cnt o total de pandigitais menores que um
milho.
As quantidades de dgitos de n em cada iterao so calculadas por
chamadas a ndig() cujo modelo de passagem de seu nico argumento por
valor (por isso a inexistncia de uma varivel auxiliar j como no estudo de caso
anterior sobre pandigitais).
O procedimento carregar() distribui os dgitos do valor em num (segundo
argumento) dentro do vetor referenciado por R (primeiro argumento). Quando
invocada dentro do lao para na funo principal, esta funo configura Q para
conter os dgitos do atual valor em n.
A funo e_pandig() testa se um dado vetor referenciado por seu nico
argumento de entrada, R (referncia a vetor em outro escopo), possui repetio
de elementos. Quando isso acontece o par de laos aninhado so encerrados
por um, retorne F; do contrrio a instruo, retorne V, alcanada. Assim,
apenas nmeros pandigitais distribudos no vetor referenciado por R, faro
e_pandig() retornar Verdadeiro. Como a sada desta funo um booleano
ento ela usada como expresso de deciso no se da funo principal.
1.6. RECURSIVIDADE
Recursividade a tcnica que permite a uma funo (ou procedimento)
fazer, no corpo de seu cdigo, uma chamada a si prpria. Para ilustrar a
recursividade apresentamos a seguir duas verses de funes para clculo de
fatorial: uma no-recursiva (iterativa) e outra recursiva.
//verso iterativa
fat(n: inteiro)
declare
res: inteiro
enquanto (n>0) faa
res res * n
n n - 1
retorne res
// verso recursiva
fat(n: inteiro)
se (n<2) ento
retorne 1
seno
retorne n*fat(n-1)
81
A verso no recursiva no trs novidades, mas ilustra a potencialidade

dos laos para resolver problemas como o clculo de fatoriais. Na verso
recursiva o lao desaparece, pelo menos aparentemente. O processamento da
verso recursiva da funo fatorial descrito a seguir. Quando uma chamada
explcita a fat() feita seu argumento formal recebe o valor do qual se deseja
calcular o fatorial. Caso este seja menor que 2 a funo se encerra retornando
1. Caso no seja, ela tenta retornar o produto, n*fat(n-1). Como a expresso de
retorno contm a prpria funo, ento uma nova chamada a fat() realizada.
Enquanto esta nova chamada no for resolvida a chamada anterior no poder
retornar. Assim a primeira chamada fica a espera do retorno da segunda
chamada. Essa por sua vez pode desencadear o mesmo processo e ter-se- um
primeiro aguardando por um segundo e esse por sua vez por um terceiro. O
processo s no se torna infinito porque existe a deciso bidirecional, se, que
desvia para retorno 1 sempre que valores menores que 2 forem repassados.
Em suma a recurso cria vrios nveis de espera que so resolvidos de
trs para frente no momento em que uma delas no recorre mais a recurso. A
presena de um mecanismo de parada como o descrito no exemplo do fatorial
(uso de se) impede naturalmente o problema de lao recursivo infinito.
Um outro exemplo clssico que demonstra o uso da recurso o
problema conhecido como Torre de Hanoi. Nesse problema, deseja-se mover
um conjunto de n discos, de tamanhos diferentes, de uma torre para outra,
na presena de uma terceira torre auxiliar, respeitando-se algumas restries,
entre as quais:
I.
Somente um disco pode ser movido por vez;
II.
Em nenhum momento, um disco de tamanho maior pode estar
acima de um de tamanho menos.
Inicialmente, como mostra a figura XX, todos os discos encontramse empilhados em uma das torres, digamos, A, em ordem decrescente de
tamanho. A partir de movimentos vlidos, ou seja, movimentos que respeitem
as restries acima, deseja-se empilhar todos esse discos em uma outra torre,
digamos, B. Para isso, pode-se usar a torre extra, C, como auxiliar.
Intuitivamente, vamos discutir de que forma esse problema pode ser

resolvido. Para mover todos os discos da torre A para a torre B, sabemos que
precisamos inicialmente colocar o disco maior (nesse caso, o disco branco)
na base de B, visto que a restrio II exige que os discos maiores fiquem na
base das torres. No entanto, para movermos o disco maior de A, precisamos
remover todos os discos que esto acima dele (discos cinza e preto). Como
82
vamos mover esse disco maior para B, essa torre no poder conter nenhum
outro disco. Sendo assim, precisamos mover todos os discos de A, com exceo
do maior, da torre A para a torre C, para podermos posteriormente mover o
disco maior de A para B. Depois disso, basta mover os discos que esto em
C para B. Veja que, para movermos os discos de A para C, estamos resolvendo
o mesmo problema original da Torre de Hanoi, dessa vez tendo como origem
a torre A e como destino a torre C, e desconsiderando o disco maior. Logo,
podemos usar essa caracterstica pra gerar uma soluo recursiva, como se
segue:
hanoi(n: inteiro, A, B, C: <tipo _ torre>)
se (n>0) ento
hanoi(n 1, A, C, B);
move disco de A para B
hanoi(n 1, C, B, A);
O algoritmo recursivo acima apresenta um procedimento, chamado

hanoi(), que move os discos, de acordo as restries apresentadas anteriormente.
Esse procedimento move n discos, da torre A para a torre B, usando a torre
C como auxiliar. Como na descrio intuitiva mostrada acima, o algoritmo
recursivo da Torre de Hanoi resolve esse problema em trs etapas: movendo,
recursivamente, n-1 discos da torre A para C, usando B como auxiliar; movendo
o disco restante de A para B e movendo, tambm recursivamente, os n-1 discos
da torre C para a torre B.
Abaixo segue um diagrama com a aplicao do algoritmo recursivo
mostrado acima para o problema da Torre de Hanoi com 3 discos. Nesse
exemplo, para movermos os discos da torre A para B, primeiro precisamos
mover o disco branco (nessa caso, o maior) para B. Mas antes disso, vamos
mover os dois discos acima dele (cinza e preto) para C. Para isso, usaremos
agora a torre B como auxiliar para executar o mesmo algoritmo recursivo.
Logo, precisaremos mover o disco cinza para C. Mas antes temos que mover
o disco preto para a torre auxiliar B. Fazendo isso, como mostrado no passo 2,
podemos mover o disco cinza para C e o disco preto tambm para C (passos
3 e 4). Pronto, j temos o disco cinza livre para movermos para B (passo 5).
Repetindo-se o procedimento, temos como mover os discos de C para B
(passos 6 8).
Analogamente, o mesmo procedimento recursivo pode ser usado para
resolver o problema com mais de 3 discos.
83
A recurso se apresenta como tcnica de projeto de algoritmos com

muitas aplicaes. Notadamente, a recurso tem sido usada como estratgia
na gerao de solues para o problema da pesquisa, como o caso do
algoritmo de busca binria, para o problema de ordenao, com os algoritmos
quicksort e intercalao, em problemas de grafos, e muitos outros problemas
computacionais.
Nesta unidade foi apresentado o conceito de modularizao. Este termo

muito utilizado na programao, aliado ao mtodo de dividir para conquistar,
o qual permite dividir um problema em partes menores. Modularizar significa
dividir um programa em subprogramas cujos funcionamentos podem ser
testados separadamente. As funes, mdulos ou subprogramas, como so
conhecidos, podem aparecer em grande quantidade em um mesmo algoritmo,
mas apenas uma destas funes tem papel de acionador, ou seja, sempre a
partir dela se iniciar a execuo. a chamada funo principal. Todas as
demais funes so secundrias. Finalizando a unidade abordado o conceito
de recursividade: tcnica que permite a uma funo fazer, no corpo de seu
cdigo, uma chamada a si prpria.
84
1. Faa uma funo que recebe um nmero inteiro por parmetro e

retorna verdadeiro se ele for par e falso se for mpar.
2. Escreva um procedimento de nome tipo_triangulo que receba 3
parmetros representando os lados de um tringulo e imprima o tipo dele
(eqiltero, issceles ou escaleno).
3. Escreva um algoritmo em pseudocdigo para receber o tamanho dos
3 lados de um tringulo e usar o procedimento tipo_triangulo para exibir o tipo
dele.
4. Escreva um algoritmo para receber 10 nmeros reais e armazen-los
em um vetor. Depois disso, mostre o somatrio dos nmeros, atravs do uso da
funo somatorio, que no recebe parmetro nenhum, acessa o vetor definido
globalmente e retorna o somatrio dos elementos do vetor.

http://www.lsd.ic.unicamp.br/projetos/e-lane/introPascal/aula9.html
http://www.inf.pucrs.br/~pinho/LaproI/Funcoes/AulaDeFuncoes.htm
85

Algoritmos - Final

Hochgeladen von

Dokumentinformationen

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

Algoritmos - Final

Hochgeladen von

Copyright:

Verfügbare Formate

Ricardo Reis Pereira

Jerffeson Teixeira de Souza

Elementos Construtivos ......................................................................................................25

Variveis Indexadas ............................................................................................................55

Programao Modular .......................................................................................................71

O planejamento de uma viagem impresso em papel seu algoritmo ao

programao e traduzi-lo num cdigo em linguagem de mquina para que

1.2. CONSTRUO DE ALGORITMOS

Em programao de computadores, uma palavra reservada uma palavra que, em

A construo de algoritmos via pseudocdigos a preferencial deste

Por exemplo, na linguagem

chave", e por ser de uso restrito, tambm uma "palavra

A palavra semntica ser esporadicamente utilizada para se referir ao

Um mesmo algoritmo pode conter diversos blocos seriados ou blocos

Neste exemplo o bloco 2 parte integrante do bloco 1, mas tem

1.3. EXECUO DE ALGORITMOS

Neste exemplo a execuo de pare implica suspenso imediata de

2.2. ENTRADA PADRO

Observe que todos os detalhes funcionais do dispositivo fsico so

2.3. SADA PADRO

era possvel escrever um caractere apenas. Quando a tela enchia os caracteres

Este exemplo ilustra o uso mais simples de escreva: a impresso de

mesmo tempo e assim concorrerem pela mesma memria livre no momento

Variveis podem ser primitivas ou derivadas. As variveis primitivas

3.2. OS TIPOS DE VARIVEIS

3.2.1. TIPOS NUMRICOS: INTEIROS E REAIS

3.2.2. TIPO CARACTERE

Como uma mquina intrinsecamente numrica pode armazenar texto?

Na prtica muitos editores de texto simples salvam e recuperam seus

convenientemente em tal sistema. Por isso muito comum encontrar fontes

3.2.3. TIPO LGICO

3.3. A DECLARAO DE VARIVEIS

Este pseudocdigo ilustra como funciona a declarao de cinco variveis:

Aps a sesso declarativa de variveis segue o bloco principal do algoritmo.

3.4. ENTRADA E SADA COM VARIVEIS

esta informao no tem sentido algum no contexto da codificao sendo

Neste exemplo leia provoca uma parada provisria da execuo o

A linha de instruo contendo leia neste exemplo exatamente

Se na execuo o usurio fornecer um valor e pressionar ENTER a

A ltima linha impressa nos esquemas acima ilustra a flexibilidade do

Neste pseudocdigo o comando escreva concatena o valor de n, uma

Caracteres podem ser lidos normalmente por leia e escritos normalmente

Se o comando leia aguarda por valores numricos e, por exemplo, texto

Nesta unidade foi apresentado o conceito de algoritmo e suas formas

1. Definir algoritmo utilizando suas prprias palavras.

SEBESTA, Robert W. Concepts of Languagues Programming. 8th edition. University

O link do light-bot traz um

executar tarefas (sequncia

Notao Polonesa Inversa,

Operadores so funes, ou seja, ao invs da notao apresentada at

operadores so prefixos dos

tais programas. A mquina

Atribuies podem ser explcitas ou implcitas. Numa atribuio

uma unidade aritmtica e

No pseudocdigo acima s variveis a e x so atribudos valores

De uma forma geral o lado direito de uma atribuio primeiramente

Em casos como este a varivel que aparece em ambos os lados da

O processamento ocorre da seguinte forma: o contedo das clulas x

Neste pseudocdigo a varivel x tem atribuio implcita ao passo que y

Em alguns casos o operador pode participar diretamente na entrada

Neste pseudocdigo a execuo da linha, ch tecla, implica suspenso

1.2. OPERADORES ARITMTICOS

Todos os operadores, com exceo de abs, so usualmente binrios e

1.3. OPERADORES RELACIONAIS