TÉCNICO/A DE

MULTIMÉDIA
ALGORITMIA
- manual de formação -

Projeto financiado por:

 A Regibio é uma empresa de consultoria e formação profissional,
acreditada pela Direcção Geral do Emprego e das Relações do
Trabalho, processo nº 3377, possui ainda certificação e
homologação por parte do Instituto de Emprego e Formação
Profissional, Ministério da Agricultura – Direcção Regional de
Agricultura e do Instituto da Mobilidade e dos Transportes
Terrestres. A sua equipa de profissionais conta com mais de
uma década de experiencia no desenvolvimento, organização e
gestão de sistemas de formação. Em 2006, a convite do
Instituto para a Qualidade da Formação (IQF), fez parte do
grupo de empresas piloto, que testou, o então, novo modelo de
acreditação (que ainda vigora). É membro da Associação
Nacional das Entidades Formadoras, ocupando um lugar de

QUEM SOMOS Direcção.

Apoiando-se num crescimento sustentado, desenvolve as suas
actividades em todo o espaço Nacional, com maior incidência na
Região Norte e Centro, tendo actualmente delegações em
FICHA TÉCNICA Bragança, Porto e Oliveira do Hospital.
É missão da Regibio cumprir com rigor os contratos assumidos,
Título:
excedendo as expectativas dos seus clientes, valorizando os
MANUAL DE FORMAÇÃO seus colaboradores e contribuindo para a aquisição e

ALGORITMIA consolidação de competências dos seus formandos, através da

apresentação de projectos de formação, nas suas vertentes de
formação co-financiada e não financiada, intervindo em todos os
Domínio de Formação: momentos do processo formativo.

0134 - ALGORITMIA Na sua actuação, a Regibio disponibiliza recursos humanos e

físicos que sustentam a organização, execução e gestão de
acções de formação profissional, numa óptica de prestação de
Curso: serviços técnicos, logísticos e administrativos. Promove ainda a

TÉCNICO/A DE MULTIMÉDIA – adopção de soluções de racionalização dos processos de

Nível 4 trabalho, suportados em sistemas e tecnologias de informação e

comunicação.

Edição:

REGIBIO – FORMAÇÃO E
CONSULTADORIA, LDA

Organização de Conteúdos:

ISABEL CAMÕES

Versão: 2/2012
 ALGORITMIA

ÍNDICE

Índice
ÍNDICE .......................................................................................................................... 3
Objectivo ...................................................................................................................... 5
Introdução ................................................................................................................... 7
Gerações de linguagens de programação ................................................................. 10
Noção de Algoritmo .................................................................................................... 12
Definição de algoritmo ............................................................................................... 17
Identificação de algoritmos ....................................................................................... 20
Desenvolvimento de algoritmos ................................................................................ 22
Noção de fluxograma ................................................................................................ 29
Transposição de algoritmos para fluxogramas ......................................................... 33
Desenvolvimento de fluxogramas ............................................................................. 34
Selecção de algoritmos por situação ......................................................................... 35
Estruturas básicas de controlo .................................................................................. 36
Tipos de dados ........................................................................................................... 46
Operações elementares ............................................................................................. 50
Operadores e suas prioridades .................................................................................. 52
Variáveis e Expressões ............................................................................................... 56
Conceito de memória................................................................................................. 58
Pseudo Código ........................................................................................................... 59 3
Plano de testes e Traçagem ....................................................................................... 62
 ALGORITMIA

Gramática de Linguagem ........................................................................................... 64

Noções e uso de BNF ................................................................................................. 64
Noções e uso de UML ................................................................................................ 65
Conceito de abstracção ............................................................................................. 67
Utilização de abstracção ............................................................................................ 76
Conceito e uso de objectos em programação ........................................................... 76
Programação por objectivos...................................................................................... 78

4
 ALGORITMIA

Objectivo

Este manual é um instrumento pedagógico para suporte ao módulo de Algoritmia, o

qual é parte integrante do curso de formação de Técnico/a de Multimédia.
Neste documento expõem-se os conhecimentos necessários à prossecução dos
objectivos do módulo.
Tem ainda como objectivo uniformizar os conceitos e a linguagem entre todos os
intervenientes neste módulo de aprendizagem.

5
ALGORITMIA

6
 ALGORITMIA

Introdução

Desde sempre que o Homem processa informação. Começou por fazê-lo de forma
manual, mas a evolução exigiu um maior processamento de informação num menor
espaço de tempo.
Surge então, na década de 60 do Séc. XX o termo Informática, como resultado da
aglutinação dos termos informação e automática.

Informática = Informação + Automática

A Informática define-se como sendo um ramo do saber que estuda os métodos e as

técnicas utilizadas para tratamento automático da informação.
Este tratamento da informação requer elementos, dados (palavras, frases, imagens)
que possam ser processados pelo computador, por forma a gerar resultados e,
consequentemente, conhecimento.

Dados Informação Conhecimento

Os dados, também apelidados de informações elementares, por si só, são pouco

úteis. Mas, depois de devidamente trabalhados (processados), geram informação, a
qual leva ao conhecimento.
O processamento da informação da forma automática é conseguido pela utilização
de um computador.
Um computador é um conjunto de circuitos eléctricos e electrónicos (Hardware),
capazes de executar, de modo automático, uma determinada tarefa, por execução
e obediência a um programa (Software) armazenado internamente na máquina.

7
 ALGORITMIA

Para o desenvolvimento dos programas, foram (e continuam a ser) criadas e

desenvolvidas linguagens de programação. De difícil aprendizagem e utilização, no
início, em apenas alguns “iluminados” conseguiam criar alguns procedimentos mais
ou menos elaborados que, aos olhos dos comuns mortais, os tornavam seres que
qualidade superior. Com a evolução das linguagens de programação, estas
aproximam-se cada vez mais da nossa linguagem natural, o que torna o trabalho do
programador muito mais fácil e rápido, o que se traduz num aumento da eficácia e
da eficiência.
As linguagens de programação aparecem associadas a editores e a ambiente de
desenvolvimento, como por exemplo o NetBeans, o Visual Studio, entre outros,
ferramentas estas que tornam mais fácil a escrita e detecção de erros, quer ao nível
sintaxe quer ao nível da correcção escrita.

Figura 1 – Ambiente de desenvolvimento NetBeans

Mas não foi apenas isso que aconteceu. A própria filosofia associada à lógica da
programação, que durante anos se centrou na estruturação (Programação
estruturada) foi abalada pelo aparecimento de ferramentas que permitem ao 8
 ALGORITMIA

utilizador comum aceder à programação por objectos, através da utilização de

agradáveis interfaces.

Importa aqui dar uma noção do conceito de programação. Programar é executar

um acto de representação do raciocínio e que passar daí para a representação do
conhecimento é um passo, tendo sempre presente os nossos processos mentais. De
uma forma muito simplista, programar é não mais do que obrigar a máquina a fazer
aquilo que nós queremos.

De salientar o facto de que, e apesar da evolução das linguagens de programação, o

sistema físico do computador (Hardware) continua a trabalhar com o sistema
binário (0’s e 1’s) – representação interna de forma discreta por sequências de bits.
Cada palavra é representada por um conjunto de bits. Um byte é um conjunto de 8
bits e representa um caracter.
Com redução dos custos de Hardware, surge a massificação da utilização dos
computadores e a necessidade de desenvolver novos programas para todas as
áreas de conhecimento e utilização. Surgiram muitos programadores, cada qual
com a sua metodologia de programação. Isto levou a uma certa confusão
generalizada, pois havia várias pessoas a desenvolver as mesmas aplicações, não
existiam regras para programar, o que fazia com que o programa ficasse “ligado”
ao programador que o desenvolveu, pois só ele sabia o raciocínio utilizado.
Surge então o conceito de “Engenharia de Software”.

9
 ALGORITMIA

Gerações de linguagens de programação

Regista-se de seguida uma breve referência à evolução do Software, na perspectiva

das Linguagens de Programação.

O primeiro computador ENIAC era caracterizado por:

 A informação de entrada e de saída ser codificada em cartões perfurados;

 O programa ser realizado em hardware, isto é, através do estabelecimento

de ligações adequadas.

Em 1946 surge o conceito de programa armazenado. O programa e os dados são

introduzidos codificados em cartões perfurados e armazenados na memória do
computador. Conseguiu-se assim aumentar a versatilidade e a flexibilidade do
computador, conceito que ainda se mantém actual nos dias de hoje.

Os programas eram escritos numa linguagem de programação composta por

conjuntos de símbolos binários, designada por linguagem máquina.

Desde então que tem havido evolução, sempre no sentido de facilitar a tarefa do
programador, distanciando-o o mais possível do nível físico.

O passo seguinte deu-se com a utilização de siglas, em vez de símbolos binários,

chegando-se assim à programação em Assembly.

Em 1957 surge uma linguagem de programação independente das máquinas, a

linguagem Fortran.

Desde então têm surgido centenas de linguagens de programação, integradas em

diferentes paradigmas. Exemplos: COBOL, RPG, ALGOL, PASCAL, PL1, C, …

As linguagens de programação têm evoluído de modo a lidar com a crescente

complexidade do desenvolvimento de software.

 Década de 1950-60: Programação não estruturada (COBOL, FORTRAN,

10
BASIC)
 ALGORITMIA

 Década de 1970: Programação procedimental estruturada (PASCAL, C)

 Década de 1980: Programação Modular e abstracção de tipos de dados

(MODULA II e ADA)

 Década de 1990: Programação orientada a objectos (C++, Java, C#)

 …

11
 ALGORITMIA

Noção de Algoritmo

Com a diminuição dos custos do Hardware, surge o desenvolvimento massivo de

Software (programas informáticos), inicialmente com custos de desenvolvimento
muito elevados e com muito fraca fiabilidade (onde cada um desenvolvia e lançava
no mercado aplicações pouco confiáveis).
Era então necessário transformar a tarefa de construir/desenvolver Software numa
actividade com rigor comparável ao utilizado nas diversas áreas de engenharia. É
assim que surge a disciplina de “Engenharia de Software”, a qual tem como
objectivo a produção de Software de modo eficiente em termos de custo e
fiabilidade. Permite a aplicação prática de conhecimentos científicos na:

- especificação
- análise
- projecto (design)
- programação/implementação
- e manutenção de Software.

De um modo esquemático:

12
 ALGORITMIA

Figura 2 – Sequência lógica de resolução de problemas

A fase de especificação diz respeito à identificação do problema que se pretende

resolver. É necessário identificar as necessidades que existem, qual é o problema
que existe e para o qual se pretende dar resposta.
A fase de análise consiste em efectuar uma leitura atenta do problema e ver de que
forma este pode ser resolvido. O que precisamos saber, dados e elementos, como
os devemos processar, de que forma vamos gerar o resultado pretendido.
Os dados que precisamos saber especificam as entradas, dando-nos a indicação do
tipo de informação que irá ser tratada de modo a ser obtido um resultado final. Os
resultados que são pretendidos obter dão-nos informação não apenas acerca do
produto desejado, mas também acerca do modo como esse resultado deve
aparecer (aparência do produto, em termos gráficos, etc.).
13
A fase de análise é de extrema importância, pois é nesta fase que tem que se
 ALGORITMIA

perceber de uma forma muito completa tudo o que é pretendido.

Figura 3 – Elementos essenciais da análise

Exemplo:
Dado o custo unitário de um dado produto, variando a percentagem de
lucro, determinar o preço de venda, com IVA incluído, e a respectiva margem de
lucro.
Análise
Entradas
C – Custo unitário
M – Percentagem de lucro

Saídas
P – Preço de venda
H – Margem de lucro 14
 ALGORITMIA

V – Valor do Imposto
T – Taxa de IVA

Definição do problema
Calcular o preço de venda ao público e a margem de lucro.

Descrição do problema
Apresentar de forma visível e legível, no ecrã ou na impressora, o valor do
preço de venda relacionado com o custo e a margem de lucro.

É na fase de projecto que será estruturado o raciocínio a seguir na implementação

do programa, isto é, de que forma vou processar os dados (entrada) para obter o
resultado (saída).
Na fase de programação/implementação será já desenvolvido o programa numa
linguagem de programação. Esta fase requer testes de funcionamento para
validação do programa.
Depois de devidamente implementado, o programa requer actualizações e
manutenção, pois pode surgir a necessidade de implementação de novas
funcionalidades, correcção de valores assumidos por defeito, etc.

Neste módulo, vamos focar a nossa atenção na fase de projecto/design (algoritmo),

usando como base a metodologia da programação estruturada.
É nesta fase de desenho que se faz a decomposição do problema. Isto consiste em
identificar os módulos (funções) a serem executados bem como definir a lógica de
controlo entre eles. Este método de decomposição deve ser um método
descendente (top-down) composto pelas fases:

15
decompor o problema em subproblemas
 ALGORITMIA

para cada subproblema

se (o subproblema é simples)
então
programar a função
(descrever o respectivo algoritmo em pseudo código e
codificar segundo metodologia da programação estruturada)
senão
continuar a decompor o subproblema em subproblemas

Segue um exemplo muito simples desde raciocínio.

Algoritmo “SomaDeDoisValores”

Ler primeira parcela

Ler segunda parcela
Somar parcelas
Escrever resultado

Figura 4 – Exemplo de algoritmo

Verifica-se assim o desenho e programação procedimental e estruturada, onde se

executa o/a:

- desenho modular
- refinamento gradual (top-down)
- programação estruturada

16
 ALGORITMIA

Obtemos o conceito de programa:

Programa = Algoritmo + Estrutura de Dados

Programar é, então, conceber algoritmos, que serão posteriormente expressos

numa qualquer linguagem de programação.

Definição de algoritmo

Todos os dias, nas nossas tarefas, executamos algoritmos, desde que realizamos a tarefa
mais simples, em que o fazemos e nem nos apercebemos, até à tarefa mais elaborada, em
que temos que pensar um pouco na sequência lógica para a sua execução.
Como exemplo de uma tarefa simples temos a de barrar um pão com manteiga, em que:
Abrir o pão
Barrar a manteiga
Fechar o pão
Se formos para uma tarefa mais elaborada, tipo ir aos correios, à padaria, à biblioteca e ao
multibanco, já temos que pensar mais um pouco.
Começar pela padaria, pois é a que abre mais cedo
Passar na Biblioteca, que fica a caminho dos correios
Seguir para os correios, para levantar encomenda à cobrança
Finalmente, passar pelo multibanco
No entanto, ao verificar que não dispomos de dinheiro para a padaria e para os
correios, será necessário refazer o raciocínio:
Começar pelo multibanco, para levantar dinheiro
Passar pela padaria, qua já está aberta
Seguir pela Biblioteca, que fica a caminho dos correios
Ir aos correios, para levantar encomenda à cobrança 17
 ALGORITMIA

(Nota: tal como já foi abordado, cada um destes problemas pode, e deve, ser
decomposto em subproblemas.)

Este tipo de raciocínio, em que todos os passos são cuidadosamente previstos e

descritos numa determinada sequência, não é mais do que um algoritmo.
Um algoritmo descreve-se então como sendo um conjunto finito e bem definido de
instruções que descreve os passos lógicos para a realização de uma tarefa, num
espaço finito de tempo.
Um algoritmo correcto é aquele que, perante uma entrada válida, produz uma saída
única e correcta. Nem sempre isto acontece, o que implica que se reveja e refaça
parte, ou até mesmo a totalidade do algoritmo (refinamento top-down).
Um algoritmo deve ser eficaz na resolução do problema e eficiente de modo a
resolver o problema com o melhor desempenho.

18
 ALGORITMIA

Figura 5 - Passos da programação

Propriedades do algoritmo:
- Deve permitir comunicação com o exterior – em geral através da entrada de dados
e da saída de resultados
- Deve ser finito – alcançar a solução em tempo finito
- Deve ser bem definido – sem ambiguidades

A sequência lógica no desenvolvimento de um algoritmo é:

- Solicitar/ler dados de entrada;
- Executar processamento dos dados;
- Apresentar o resultado obtido.

19
 ALGORITMIA

Figura 6 – Sequência de processamento

Em resumo, um algoritmo define um processo. Esse processo é especificado em

termos de instruções simples. Cada passo do processo tem que ser implementado
através de uma instrução ou por algum outro algoritmo.

Na escrita do algoritmo devemos ter sempre em consideração que:

- Devemos realizar uma descrição passo a passo, usando uma linguagem

natural
- Cada operação deve ser constituída por um passo ou conjunto sequenciado
de passos, que levem a um resultado concreto e diferente de qualquer outro
- Só se pode executar uma operação de cada vez

Identificação de algoritmos

Os algoritmos podem ser descritos segundo 3 formas:

 Descrição narrativa – consiste na descrição, em texto corrente, dos passos a
seguir na execução da tarefa pretendida.

Exemplo:
Escreva um algoritmo que faça a multiplicação de dois números.

Resolução:

Ler os dois números;

Multiplicar o primeiro pelo segundo; 20
Mostrar o resultado.
 ALGORITMIA

 Fluxograma – consiste na representação gráfica da sequência lógica, a qual

mostra a sequência operacional do desenvolvimento da tarefa.

Exemplo:
Escreva um algoritmo para análise do não funcionamento de uma
lâmpada.

Resolução:

Figura 7 – Exemplo de fluxograma

 Descrição em pseudo código – consiste na descrição dos passos a seguir na

execução da tarefa pretendida, mas obedecendo a uma sintaxe mais
próxima da programação.

21
 ALGORITMIA

Exemplo:

Desenvolva o algoritmo para um programa que faz a soma de dois

valores

Resolução:

variável:
SOMA,A,B: inteiro;
inicio
Escreva("Digite um numero");
Leia(A);
escreva("digite outro numero");
leia(B);
SOMA ← A + B;
escreva(SOMA);
fim.
fim.

Figura 8 – Exemplo de algoritmo em pseudo código

Desenvolvimento de algoritmos

Conhecidas as variáveis, o modo como estas vão ser processadas, e os resultados

pretendidos, temos que descrever o algoritmo que nos permitirá dar solução ao
problema.
Não esquecer que o computador não é mais do que uma máquina que se limita a
executar repetidamente o que lhe é ordenado. Não podemos esperar que resolva o
problema, mas apenas que execute os passos que são indicados para a sua
resolução.
Temos que indicar todos os passos de uma forma sucessiva, sequencial, passos
esses que correspondem às instruções que se darão depois à máquina para que esta 22
 ALGORITMIA

execute o programa.
Mais uma vez se alerta para o facto de que, para problemas de grande
complexidade, não é simples nem lógico desenvolver apenas um algoritmo sem
primeiro pensar se existem vantagens na decomposição do problema em
problemas mais simples. Problemas mais simples originam algoritmos mais simples,
mais fáceis de trabalhar e de corrigir em caso de erro.

Exercício 1:
Desenvolver um algoritmo, usando descrição narrativa, sobre como beber
um copo de água.

Solução:
Pegar no copo
Colocar o copo debaixo da torneira
Encher o copo
Levar copo à boca
Beber a água
Pousar o copo

Como se pode observar, são seis as acções básicas que compõem o algoritmo. Se
quiséssemos porém “dizer” a um computador que “enchesse o copo”, ele não
saberia atribuir significados próprios a conceitos complexos. Na realidade, encher
um copo não é uma tarefa elementar, bem pelo contrário, implica uma série de
raciocínios sucessivos sobre um determinado estado de um objecto, até ter de se
tomar uma decisão. Senão vejamos:
Estando a água a cair da torneira para dentro do copo, vamos observando o nível de 23
água e a cada instante vamo-nos interrogando: está cheio ou não? E só quando a
 ALGORITMIA

resposta é afirmativa é que decidimos executar duas operações sucessivas:

Retirar o copo
Fechar a torneira

Percebendo que cada uma das seis acções básicas que constituem o algoritmo deve
ser constituída por procedimentos elementares, teríamos provavelmente como
resultado uma coisa do seguinte tipo:
inicio
se existe copo
então
pegar no copo
se copo não estiver debaixo da torneira
então
colocar copo debaixo da torneira
se copo debaixo da torneira
então
abrir a torneira
se o copo não estiver cheio
então
manter copo debaixo da torneira
senão
fechar a torneira
levar o copo à boca
beber
pousar o copo
senão
fica-se com sede
fim

Começam aqui a surgir algumas palavras, as quais foram propositadamente

utilizadas, e que correspondem a palavras reservadas ao domínio da programação:

Se Então Senão
Inicio Fim 24
 ALGORITMIA

Mais tarde iremos ver que estas palavras são utilizadas por várias linguagens de
programação, sempre na sua forma original e natural, em Inglês:

If Then Else
Begin End

Repare-se que estas palavras são utilizadas para declarar a execução de passos
simples e elementares e que permitem seguir diferentes acções consoante a
situação que se verifica e a decisão tomada em função disso.

Se (condição se verificar)
Então
Acções a executar
Senão
Acções a executar

Facilmente se chega à conclusão de que a resolução de qualquer tipo de problema

(também denominado de processo) é sempre constituída por decisões e pela
execução de procedimentos elementares.

Repare-se ainda na forma de representação do algoritmo. As acções encontram-se

descritas de forma indentada (espaços deixados antes de se iniciar e escrita de cada
linha) consoante a condição em que vão ser executadas.

Exemplo:
Se tiver dinheiro
compro chocolates
25
vou almoçar
 ALGORITMIA

vou à praia

Nesta representação, só se executam estas três acções se se tiver dinheiro.

Se tiver dinheiro
compro chocolates
vou almoçar
vou à praia

Nesta outra representação, isso já não se verifica. Só se compram chocolates se

houver dinheiro, mas as acções de almoçar e comprar o bilhete serão sempre
executadas, quer se tenha ou não dinheiro.

Esta forma de escrever o algoritmo facilita bastante a quem o faz pois, à medida
que vai descrevendo o problema, consegue saber o que vai ser executado, quando
e sob que condição. Se escrever tudo alinhado, torna a leitura mais difícil.
Então, tão importante como a escrita de um algoritmo é a sua leitura.
Torna-se muito pouco eficiente ter um algoritmo aparentemente muito bem escrito,
se depois quem o for codificar na linguagem de programação não o conseguir ler
(ou tiver dificuldades acrescidas para o fazer).

Exemplo de um algoritmo mal codificado:

Inicio
ler primeiro numero
ler segundo numero
ler terceiro numero 26
se primeiro maior do que o segundo
 ALGORITMIA

então
se primeiro maior do que terceiro
então
escrever (o maior numero é o primeiro)
senão
escrever (o maior numero é o terceiro)
senão
fimse
se segundo maior do que terceiro
então
escrever (o maior numero é o segundo)
senão
escrever (o maior numero é o terceiro)
fimse
fimse
fim
Exemplo de um algoritmo escrito de forma correcta, a qual facilita a sua leitura:

Inicio
ler primeiro numero
ler segundo numero
ler terceiro numero
se primeiro maior do que o segundo
então
se primeiro maior do que terceiro
então
escrever (o maior numero é o primeiro) 27
senão
 ALGORITMIA

escrever (o maior numero é o terceiro)

fimse
senão
se segundo maior do que terceiro
então
escrever (o maior numero é o segundo)
senão
escrever (o maior numero é o terceiro)
fimse
fimse
fim

28
 ALGORITMIA

Noção de fluxograma

Uma outra forma de representar algoritmos é pela utilização de Fluxogramas. Um

Fluxograma, ou diagrama de fluxo, é um diagrama que representa
esquematicamente um processo.
É uma forma de representação gráfica que esquematiza a sequência de execução
do processo, através da representação da transição da informação entre os vários
elementos que o compõem, ou seja, é um gráfico que demonstra a sequência
operacional do desenvolvimento do processo, o qual permite identificar facilmente
a sequência de operações a serem executadas.

Se o problema em análise não for demasiado complexo, esta é a melhor forma de o

representar, uma vez que facilita a sua leitura e interpretação.

Início

Dados Actividade

Decisão

Fim

Figura 9 – Exemplo de fluxograma

29
 ALGORITMIA

O fluxograma é sempre composto por um início, um sentido de leitura, ou fluxo, e

um fim.

Diz-se que o fluxograma é o instrumento fundamental da programação porque, de

uma forma geral, é a partir do diagrama de fluxo (ou fluxograma) que o
programador executa a codificação na linguagem de programação desejada.

É um tipo de representação que utiliza um conjunto de símbolos já conhecidos e

frequentemente utilizados. Cada símbolo está sempre associado a uma
determinada operação.

Símbolos principais:

Símbolo de início de fim de processo

Símbolo de entrada (e saída) de dados

Símbolo de saída de dados

Símbolo de processo

30
 ALGORITMIA

Símbolo de decisão

Indicadores de direcção do fluxo

Linha conectora entre símbolos

Conector de páginas

Chamada a uma sub rotina ou a um processo

Existem outros símbolos, considerados de símbolos secundários, tais como saída de

resultados para o monitor, para a impressora, entrada de dados pelo teclado, por
ficheiro, comentários, etc.

Segue-se a análise de um exemplo simples de aplicação deste tipo de símbolos na

representação de algoritmos.

31
 ALGORITMIA

Início

Ler Nome,
horas,
valor_hora

Salario_iliquido = horas * valor_hora

Salario_liquido = iliquido – (10% * iliquido)

Escrever Nome, horas,

ilíquido, liquido

Fim

Figura 10 – Exemplo de processo em fluxograma

Vejamos com algum detalhe o fluxograma apresentado.

Toda a solução algorítmica começa com um símbolo terminal contendo e palavra
Início e termina com outro símbolo terminal contendo a palavra Fim. Estes símbolos
designam, respectivamente, o início e o fim do algoritmo.
Outro elemento gráfico utilizado é o de entrada e saída de dados. Representa a
32
interacção que existe entre a aplicação e o utilizador (ou exterior). Simboliza a
 ALGORITMIA

entrada de dados, a qual pode ocorrer por via teclado, ou por leitura de um ficheiro,
etc., e a saída de dados, que pode ser via impressora, ou para o ecrã ou até mesmo
para um ficheiro.

As linhas de fluxo ligam os elementos do algoritmo e contêm uma seta, a qual indica
o sentido do fluxo de controlo lógico na solução.

O símbolo de processo indica qual a operação a executar, encontrando-se esta

descrita dentro do símbolo. Note-se que os processos, ou operações, devem ser
descritos pela mesma ordem que se pretende sejam executados.

Transposição de algoritmos para fluxogramas

É possível descrever um algoritmo usando descrição narrativa ou então pela

representação gráfica, através de um fluxograma.

Seguindo o exemplo já utilizado na descrição narrativa, faz-se a transposição para

fluxograma.

33
 ALGORITMIA

inicio

Ler primeiro numero

Ler segundo numero
Ler terceiro numero

Primeiro > segundo >

sim não
segundo? terceiro?

Primeiro > não

terceiro?
sim não sim

Escrever “o
Escrever “o
maior é o
maior é o
terceiro”
primeiro” Escrever “o Escrever “o
maior é o maior é o
segundo” terceiro”

fim

Figura 11 – Exemplo de Fluxograma

Desenvolvimento de fluxogramas

O raciocínio a seguir é sempre o mesmo. O que varia é apenas a representação

desse mesmo raciocínio.

Começa-se por determinar o tipo de operação a executar (leitura, calculo, decisão,

34
etc.) e implementar a operação sequencialmente no fluxograma, seguindo para tal
 ALGORITMIA

o símbolo associado à operação a executar.

Selecção de algoritmos por situação

A linha de raciocínio a seguir na elaboração de um algoritmo é sempre a mesma.

Devem observar-se sempre as regras e as boas práticas no desenvolvimento do
algoritmo.

A forma de representação do algoritmo, segundo uma descrição narrativa,

fluxograma ou pseudo código, depende da complexidade do problema em análise,
pois existem problemas cuja representação em fluxograma se torna bastante
complexa. O objectivo é sempre o de facilitar a sua leitura ao programador, que terá
que ler e interpretar o algoritmo para o transpor para uma linguagem de
programação.

De notar que deve dar-se sempre preferência à descrição do algoritmo em pseudo

código, pelo facto de ser a descrição que mais se aproxima da linguagem de
programação, tanto ao nível da linguagem (termos utilizados) bem como da
organização da informação.

35
 ALGORITMIA

Estruturas básicas de controlo

Qualquer programa contendo apenas um só ponto de entrada e um só ponto de

saída, pode ser escrito utilizando exclusivamente três estruturas básicas de
controlo:

- Sequência – permite a ordenação em série de instruções;

- Selecção/Decisão – permite a selecção em alternância de um ou outro
conjunto de acções por avaliação de uma condição;
- Repetição – permite a execução condicional em circuito fechado,
denominado de ciclo, de um grupo de instruções. A condição é testada em
cada iteração (repetição da instrução) para decidir se abandona ou não o
ciclo.

O programa deve obedecer às seguintes características:

- Possuir um só ponto de entrada e um só ponto de saída do programa;

- Existirem caminhos, desde a entrada até à saída, que possam ser seguidos e
que passam por todos os pontos do programa;
- Todas as instruções serem executáveis e não existir ciclos infinitos;

Descrição das estruturas de controlo de fluxo:

Sequência:

A estrutura sequencial executa as operações, uma em sequência da outra, havendo

a obrigatoriedade de executar todas as operações. As operações são executadas
sequencialmente, pela ordem em que são descritas. Nenhuma operação pode ficar
por executar.

instrução;
instrução;
instrução; 36
 ALGORITMIA

instrução1

instrução2

instrução3

Figura 12 – Fluxograma para instruções de sequência

Exemplo:

ler valor_x;
ler valor_y;
soma = valor_x + valor_y;
escrever (“Resultado = “, soma);

O utilizador terá que introduzir dois valores, os quais serão somados, e cujo
resultado da soma será apresentado no ecrã.

Decisão/Selecção:

Esta estrutura realiza um ou outro conjunto de operações, dependendo do

cumprimento ou não de uma determinada condição. 37
 ALGORITMIA

se (condição)
então
instrução/ões;
senão
instrução/ões;
fimse

condição
sim não

instrução1 instrução2

Figura 13 – Fluxograma para estrutura de decisão/selecção

Caso a condição seja verdadeira, a instrução (ou instruções) contidas no bloco

“então” é (são) executada(s). É o caminho assinalado com o SIM.

O bloco “senão” existe apenas no caso de se pretender executar instruções

alternativas caso a condição não seja verdadeira, isto é, seja falsa. É o caminho
assinalado com o não. Assim, não é obrigatória a existência do bloco “senão”. Se
seguirmos o raciocínio “se determinada condição for verdade, executa isto…”, a
estrutura será composta apenas pelo “se … então … fimse” (if … then).

Exemplo:
38
ler numero;
 ALGORITMIA

se (numero => 0)
então
escrever (“Numero é positivo”);
fimse

O utilizador insere um número e, se este for positivo, será apresentada a mensagem

ao utilizador. Se o número for negativo, nenhuma operação é executada e o
programa termina.

condição
sim

não

instrução1

Figura 14 – Fluxograma da estrutura se … então …

Caso se pretenda executar determinada instrução caso a condição seja verdadeira e

outa instrução alternativa caso seja falsa, então terá que ser utilizada a estrutura
“se … então … senão … fimse” (if … then … else).

Exemplo:

se (numero => 0)
então
escrever (“Número é positivo”);
senão
escrever (“Número não é positivo ”); 39
fimse
 ALGORITMIA

O utilizador insere um número e, se este for positivo, será apresentada ao utilizador

a mensagem “Número é positivo”. Caso o número seja negativo, será apresentada a
mensagem “Número é negativo”.

Repetição:

Muitas das operações têm um caracter repetitivo, como acontece quando se

aplicam operações idênticas a conjuntos homogéneos de dados.

Quando tal acontece, basta indicar uma vez a sequência de operações a executar e
repeti-la tantas vezes quantas as necessárias.

Estas estruturas, que repetem uma sequência de operações, sempre pela mesma
ordem, um determinado número de vezes, são designadas de anel (ou loop). A
acção de repetir as operações recebe o nome de iteração ou ciclo.

Ao descrever uma estrutura de repetição é importante definir:

- O conjunto de operações que compõem o anel;

- O número de vezes que o anel deve ser repetido

Existem diferentes estruturas de repetição, as quais devem ser utilizadas consoante

o objectivo pretendido, uma vez que cada uma difere das restantes:

Estrutura enquanto (while)

Esta estrutura caracteriza-se pela execução repetitiva de um processo enquanto se

verificar que a condição possui o valor lógico Verdade. Quando a condição se tornar
Falsa, o processamento deste bloco termina.

enquanto (condição a verificar)

fazer
instrução; 40
fimenquanto
 ALGORITMIA

condição

sim

instrução
nao

Figura 15 – Fluxograma estrutura enquanto (…) fazer

Esta estrutura permite executar uma instrução, ou um bloco de instruções,

enquanto a condição de verificar. Note-se que o bloco de instruções pode nunca ser
executado, caso a condição nunca seja verdadeira. Será necessário incluir nas
instruções dentro deste bloco, a instrução, ou instruções, que possam fazer variar a
condição. No caso de a condição ser verdadeira e nunca passar a falsa, o ciclo será
executado indefinidamente, nunca mais prosseguindo na execução do programa.
Diz-se que se trata de um ciclo infinito, o qual gera um erro de programação.

Exemplo:

ler numero;
enquanto (numero =>0)
fazer
escrever (“Número é positivo”);
ler numero;
fimenquanto

O utilizador vai inserindo números positivos de forma sucessiva. A cada número

41
introduzido surge a mensagem “Número é positivo”. Assim que o utilizador inserir
 ALGORITMIA

um número negativo, a execução da estrutura de repetição termina.

Estrutura repete (do … while)

repete
instrução/ões;
enquanto (condição a verificar)

instrução
sim

condição

não

Figura 16 – Fluxograma para estrutura repete (…) enquanto (…)

Esta estrutura segue as definições da anterior, diferindo apenas no facto de que a

instrução é executada sempre, e no mínimo, uma vez pois a condição é verificada
apenas depois de executada a instrução. Do mesmo modo, ter o cuidado de não cair
na definição de um ciclo infinito.

Exemplo:

repete
escrever (“insira um número positivo”);
ler numero;
enquanto (numero =>0); 42
 ALGORITMIA

Aparece uma mensagem no ecrã solicitando a introdução de um número positivo.

Esta instrução será repetida enquanto o utilizador inserir valores positivos. Assim
que for introduzido um valor negativo, o bloco termina a sua execução.

Estrutura para (for)

Esta estrutura deve ser utilizada quando é conhecido à partida o número de

iterações (ou ciclos) a executar.

É na própria estrutura que se definem o valor inicial, o valor final, e como esse valor
vai variar. A validação da condição é verificada no início de cada iteração pelo que,
as operações contidas na estrutura poderão nunca ser executadas.

para (condição_inicial; condição_final, incremento)

fazer
instrução;
fimpara

sim

não

instrução

Figura 17 – Fluxograma para estrutura para (…)

Esta estrutura permite executar determinado bloco de instruções entre duas

condições que se verifiquem, através da definição de um incremento, o qual 43
permite avançar de uma condição inicial até uma condição final. Mais uma vez se
 ALGORITMIA

reforça que o bloco de operações pode nunca ser executado, quando se utiliza esta
estrutura.

Exemplo:

para (numero = 1; numero <=5; numero ++)

fazer
escrever (“O próximo valor é “, numero);
fimpara

Esta estrutura de repetição vai imprimir no ecrã as seguintes mensagens:

O próximo valor é 1
O próximo valor é 2
O próximo valor é 3
O próximo valor é 4
O próximo valor é 5

Existe ainda uma outra estrutura bastante útil, a qual permite evoluir por diferentes
processos em função da situação que se verifique.

Estrutura caso (case):

caso (varivável)
opção1:
instrução;
opção2:
instrução;
opção3:
instrução;
outro:
instrução;
fimcaso

Exemplo:
44
caso (mês)
 ALGORITMIA

1,3,5,7,8,10,12:
dias_mes =31;
2:
dias_mes =28;
4,6,9,11:
dias_mes=30;
outro:
escrever (“mês incorrecto”);
fimcaso

mes

dias_mes=31 dias_mes=28 dias_mes=30 Mês incorrecto

Figura 18 – Fluxograma da estrutura case

45
 ALGORITMIA

Tipos de dados

Na codificação do problema, e mesmo antes, aquando da sua análise, torna-se

necessário determinar que tipos de dados serão processados.
A definição do tipo de dados condiciona o tipo de operações que podem ser
realizadas sobre esses mesmos dados.
Como já foi visto anteriormente, importa conseguir decompor o problema em sub
problemas mais simples, descrevendo-os sob a forma de operações simples e
elementares. É então necessário conhecer quais as operações a realizar o sobre que
dados serão realizadas.

Temos então vários tipos de dados e vários tipos de operações, sendo que
diferentes tipos de dados suportam diferentes tipos de operações.
Os dados podem ser caracterizados como sendo alfanuméricos, numéricos ou
lógicos.

Os dados alfanuméricos, também denominados de strings ou cadeia de caracteres,

podem ser de comprimento fixo ou variável. No caso de ter comprimento fixo, o
seu tamanho mantém-se inalterado, ou seja, o número de caracteres que contém é
sempre o mesmo. O tamanho máximo de uma cadeia de caracteres é de 32767
caracteres. Note-se que algarismos serão considerados como texto, pelo que não
suportam operações de cálculo aritmético.
Como tipos de dados alfanuméricos existem o tipo char – um caractere, e o tipo
string – cadeia de caracteres.
Define-se como:
char letra;
char [255] morada; 46
string nome;
 ALGORITMIA

Os dados numéricos podem ser números inteiros ou números reais. Existem vários
tamanhos de dados a ter em consideração:
Inteiros ( 2 Bytes): são números inteiros, com o respectivo sinal. Suportam valores
entre -32768 e 32767.

Inteiros Longos (4 Bytes): são números inteiros, com o respectivo sinal. Suportam
valores entre -2147483648 e 2147483647.

Reais: permitem representar uma gama mais extensa de valores, tal como
potências, raízes, fracções, etc. Também estes números têm limites definidos.

Relativamente aos dados lógicos, a linha de raciocínio utilizada é simples e resume-

se a duas alternativas bem definidas: Verdadeiro ou Falso. As linguagens de
programação consideram esta variável como sendo lógica, isto é, a operação ou é
verdadeira ou é falsa. Nunca as duas em simultâneo.

Importante: O tipo de dados define o tipo de valores e o tipo de operações que a

variável suporta.

Convém fazer referência ao conceito de constante e tipos de constantes que mais

frequentemente se utilizam. As constantes são tipos de dados, as quais seguem a
lógica do tipo de dados atrás referida, que são pré-definidas pelo utilizador e que
não sofrem qualquer alteração ao longo da resolução do problema e,
consequentemente, durante a execução do programa. Podemos então ter
constantes alfanuméricas, numérias ou lógicas.
As constantes utilizam-se quando se trabalha com dados fixos, inalteráveis em todo 47
o problema. Como exemplo temos um valor de uma constante matemática (por
 ALGORITMIA

exemplo o π = 3.14) ou a taxa do I.V.A (23%), que são valores que perduram no
tempo. Caso o valor sofra alteração, basta alterar o valor na definição da constante,
não sendo necessário proceder à alteração do valor em todas as utilizações da
variável (o que seria necessário caso utilize o valor directamente nas expressões em
vez da utilização de uma variável de valor constante).

const int = 2;
int const = 2;
#define TRUE 1
#define FALSE 0

Existem ainda as estruturas de dados, que identificam o modo como os dados estão
organizados e como são acedidos e alterados. Como exemplos temos variáveis
simples, arrays, matrizes, listas, filas, árvores, grafos, etc.

Figura 19 – Exemplo da estrutura Array (ou vector)

48
Figura 20 – Exemplo da estrutura Matriz
ALGORITMIA

Figura 21 – Exemplo da estrutura Grafo

49
 ALGORITMIA

Operações elementares

As operações elementares da programação dividem-se em:

- Atribuição
- Entrada
- Saída

A operação de atribuição consiste na operação de atribuir um valor a uma variável,

tipo:
a = 5; a <- 5;
b = “Maria”; b <- “Maria”;
c = num1 + num2; c <- num1 + num2;
O valor atribuído à variável pode ser uma constante ou uma expressão.
Como já foi visto, esta operação permite armazenar/associar um valor a uma
variável.
Note-se que, ao atribuir um valor a uma variável, este sobrepõe-se a qualquer outro
que pudesse lá estar armazenado, perdendo-se esse mesmo valor.
Por exemplo:
a = 5:
a = 3 * 2;
A variável acima, que inicialmente armazenava o valor 5, passou a conter o valor 6.
Ao utilizar-se esta variável, o valor nela contido é 6 e não 5.

A entrada de dados está normalmente associada a um periférico de entrada, por

exemplo o teclado, mas pode ser de outro tipo. Consegue-se assim atribuir os
valores às variáveis. Sempre que necessário, o computador pede o valor para o
atribuir a uma dada variável. O computador LÊ o valor.
Ler (a);
50
Esta instrução faz com que o computador solicite ao utilizador o valor a atribuir à
 ALGORITMIA

variável “a”;

Do mesmo modo, a saída de dados está normalmente associada a um periférico de

saída, por exemplo o monitor, mas pode ser de outro tipo. Consegue-se assim obter
os valores que foram obtidos para as variáveis definidas e depois de resolvido o
problema. O computador escreve o resultado.
Escrever (a);
Esta instrução faz com que o computador apresente o valor da variável “a” naquele
instante;

51
 ALGORITMIA

Operadores e suas prioridades

Os operadores encontram-se divididos em 5 grupos:

Aritméticos
Relacionais
Lógicos
Funcionais
Operadores de cadeias de caracteres

Os operadores aritméticos são os que normalmente se utilizam para a realização

das operações aritméticas normais. No entanto, é necessário atentar à hierarquia
das operações, pois algumas operações são realizadas antes de outras, a menos que
se diga algo em contrário, utilizando os parênteses. Segue-se, por ordem
decrescente, a prioridade dos operadores:

Exponenciação ^
Negação ~
Multiplicação *
Divisão /
Divisão inteira DIV
Resto da divisão MOD
Adição +
Subtracção -
Módulo ABS

Para alterar esta hierarquia, utilizar os parenteses. Não esquecer que a hierarquia se
mantém dentro destes. 52
 ALGORITMIA

Os operadores relacionais estabelecem uma relação entre dois operandos,

comparando-os e produzindo um resultado que é um resultado lógico, ou
verdadeiro (V) ou falso (F).

Operador Função Exemplo

= Igual a 3=3
> Maior que 5>4
< Menor que 3<5
>= Maior ou igual a 7 >= 3
<= Menor ou igual a 3 <= 7
<> Diferente 8 <> 9

Os operadores lógicos estabelecem uma relação lógica entre dois operandos

booleanos (Verdadeiro ou Falso), apresentando como resultado um valor também
lógico que só pode ser Verdadeiro ou Falso. Onde se considera V ou F, poder-se-á
considerar 1 ou 0, respectivamente.

A tabela seguinte indica o modo de representação destes operadores:

Operador Símbolo Exemplo
and  ab
or  ab
negação ~ ~a

53
 ALGORITMIA

A tabela seguinte indica o modo de utilização destes operadores:

Valores de X e Y Valor resultante da operação lógica
Valor de X Valor de Y NOT X X AND Y X OR Y
V V F V V
V F F F V
F V V F V
F F V F F

Os operadores funcionais chamam uma operação pré-determinada para que esta se

execute sobre um operando, produzindo um resultado. Como exemplo de
operadores funcionais temos os operadores trigonométricos, o cálculo de raízes
quadradas ou logaritmos. Note-se que, neste caso, as prioridades por vezes estão
associadas à linguagem de programação ou às definições feitas pelo utilizador. São
exemplos de operadores funcionais:
SQR Raiz quadrada
SIN função seno
COS função coseno
LOG função logaritmo

Os operadores de cadeias de caracteres actuam sobre cadeias de caracteres, quer

estas sejam simples ou complexas. Os dois tipos de operadores mais significativos
são o de concatenação e o de comparação.
O operador de concatenação permite unir cadeias de caracteres, obtendo como
resultado uma só cadeia. O operador normalmente usado para esta é o sinal +.
Exemplo:
“Ma” + “ria” = “Maria”
Os operadores de comparação são idênticos aos relacionais e produzem o mesmo 54
 ALGORITMIA

tipo de resultado.

55
 ALGORITMIA

Variáveis e Expressões

Uma variável define-se como sendo um nome dado a um objecto. Tal objecto pode
ser um número em particular ou uma cadeia de caracteres. Podemos ter variáveis
simples, que se referem a objectos simples, ou variáveis estruturadas, que se
referem a grupos de objectos.
Exemplo de uma variável simples:
Int idade;
Exemplo de uma variável estruturada:
Int [10] nota;

Como já deu para perceber, uma variável é, por definição, uma entidade que assume
diferentes valores em diferentes instantes de tempo.
Não esquecer que é sempre necessário definir o tipo de dados que a variável
assume e que, por vezes, é necessário inicializar a variável (atribuir-lhe um valor
inicial).

No início de cada programa procede-se à definição e inicialização das variáveis. É

então muito importante não esquecer que:
- Uma variável é reconhecida pelo seu nome, não podendo coexistir duas
variáveis com o mesmo nome, com significados diferentes, no mesmo
programa;
- Cada variável só pode receber um determinado tipo de dados, não podendo
esta característica ser alterada ao longo do programa;
- Cada variável assume apenas um valor em cada instante.

As expressões não são mais do que operações executadas sobre dados ou variáveis. 56
Exemplo:
 ALGORITMIA

32 + 5*c – 2*d +(r/6)^f

Variáveis c d r f
Operadores + * - / ^
A hierarquia define-se pela utilização dos parênteses

Da mesma forma, podem utilizar-se expressões para cadeias de caracteres.

Exemplo:
“Manuel” > “Maria” é uma expressão que utiliza um operador de cadeia
alfanumérica para fazer a comparação que possui o valor lógico Verdadeiro (V).

57
 ALGORITMIA

Conceito de memória

Como visto, os dados são armazenados em variáveis. Estas variáveis são

armazenadas pelo programa numa posição de memória e possui os seguintes
elementos:

- Nome
- Endereço
- Valor (conteúdo)

A estrutura de dados permite:

- Organizar os dados em variáveis Ex: inteiro idade;

- Atribuir um valor a uma variável Ex: idade = 25;
- Aceder ao valor dessa variável Ex: ler idade;
- Outras operações Ex: idade = idade + 1;

58
 ALGORITMIA

Pseudo Código

Para além da representação da informação sob a forma de descrição narrativa ou

sob a forma de fluxograma, existe ainda a possibilidade de representar a
informação em pseudo código.

Pseudo código é uma forma genérica de escrever um algoritmo, utilizando uma

linguagem igualmente simples, tal como na descrição narrativa, mas já muito
aproximada da linguagem de programação. Não pode ser executada num sistema
real, isto é, no computador, pois trata-se de pseudo código e como tal não utiliza a
sintaxe de nenhuma linguagem de programação. Se o fizesse deixaria de ser pseudo
e seria já código.

Começa-se por definir as variáveis com as quais se vai trabalhar e associar o tipo de
dados a cada variável. Podemos ter várias variáveis, cada uma delas com um, e um
só tipo de dados associado.

Tal como já foi visto, a cada tipo de dados estão associadas operações e operadores
que permitem manipular esses mesmos dados.

O tipo de dados INTEIRO admite as operações aritméticas:

+ Adição
- Subtracção
* Multiplicação
/ Divisão inteira (quociente)
% Resto da divisão inteira

O tipo de dados REAL admite as operações aritméticas:

+ Adição
- Subtracção
* Multiplicação
/ Divisão (quociente) 59
 ALGORITMIA

Com os operandos e os operadores constroem-se as expressões.

Operador de atribuição <-

Operadores aritméticos + - * / DIV(/) MOD(%)

Operadores relacionais < > <= >= = !=

Operadores lógicos AND OR NOT

Os operadores aritméticos trabalham com operandos que são números ou

expressões numéricas. Aceita os operadores aritméticos.

Os operadores lógicos, ou booleanos, trabalham com operandos que são

proposições (exemplo “7>5” ou “Hoje choveu”). Tais proposições são verdadeiras
(1 ou V) os falsas (0 ou F). Utiliza os operadores lógicos e são determinados pelas
tabelas de verdade.

Exemplo:

Expressões lógicas
N>0 N<100 NOT(N>0) (N>0)AND(N<100) (N>0)OR(N<100)
Se n = 45 V V F V V
Se n =-5 F V V F V
Se n = 105 V F F F V

As expressões lógicas são:

N>0

(N>0) AND (N<100)

(N>0) OR (N<100)

As expressões lógicas negadas são: 60

 ALGORITMIA

N <= 0
(N<=0) OR (N >=100)
(N<=0) AND (N>=100)

Note-se que a negação do AND é o OR, e que a negação do OR é o AND.

A estrutura do algoritmo em pseudo código é:
ED
Definição das variáveis e do seu tipo
ALG
Inicio
instrução;
instrução;
…
Fim

Exemplo: Determinar a área de um triângulo

ED
var real base, altura, area
ALG
Inicio
ler (base, altura);
area <- base * altura /2;
escrever (“Área do triangulo= “, area);
Fim

61
 ALGORITMIA

Plano de testes e Traçagem

Uma operação fundamental a executar é a verificação dos algoritmos, para

validação do correcto funcionamento do algoritmo. Tal verificação é efectuada
através da realização de traçagens.

Figura 22 - Exemplo de traçagem

A traçagem consiste em atribuir valores às diferentes variáveis e executar, no papel,

o desenvolvimento do algoritmo por forma a validar o seu desempenho e verificar
se o algoritmo efectivamente executa as tarefas que são pretendidas, de forma a
gerar uma resolução correcta para o problema proposto. Devem ser efectuadas
várias traçagens, com diferentes valores, por forma a testar o desempenho do
algoritmo perante diferentes cenários.
Habitualmente, a traçagem faz-se da seguinte forma: cria-se um mapa com várias
colunas ou, de uma forma mais correcta, com vários grupos de colunas. Primeiro,
colocam-se todas as variáveis no cabeçalho, em colunas separadas. A seguir,
colocam-se todas as condições (expressões, condições lógicas, etc.), uma por
coluna e, finalmente, as saídas pretendidas.
62
 ALGORITMIA

Começa-se a executar o algoritmo e escreve-se em cada linha as atribuições que vão

sendo efectuadas, até se atingir o fim do algoritmo, verificando-se então se a
solução obtida na resolução do algoritmo e, consequentemente, do problema, é a
solução pretendida.
Em caso afirmativo, temos o algoritmo bem implementado. Em caso de insucesso,
surge a necessidade de refazer o algoritmo, pois o mesmo está incorrecto.

63
 ALGORITMIA

Gramática de Linguagem

A noção de gramática teve origem no estudo da linguagem natural. Tentativas

foram feitas no sentido de definir quais as diferenças válidas para esta linguagem,
com o objectivo de encontrar formas estruturais de as representar.

No entanto, uma linguagem natural é muito extensa e complexa, e por isso difícil de
definir na sua totalidade. Ainda não existe nenhuma gramática formal
completamente definida, mas progressos importantes foram feitos.

No caso das linguagens de programação, torna-se mais fácil, pois são linguagens
mais simples e a sua representação segue a mesma análise sintáctica da linguagem
natural.

Para que seja possível especificar a sintaxe de uma linguagem de programação,

torna-se necessário:

 Criar um método que especifique meios de construir programas

sintacticamente correctos;

 Um método para analisar um programa e verificar se ele está

sintacticamente correcto;

Noções e uso de BNF

Como exemplo, temos a linguagem ALGOL-60, a qual foi descrita usando uma
gramática livre do contexto de computação: a notação BNF – Backus Naur Form.

Exemplo em notação BNF:

<instrução> ::= <instrução-simples> | <instrução-composta>
<instrução-simples> ::= <instrução-atribuição> | <instrução-for> | … 64
 ALGORITMIA

…
<instrução-for> ::= for <cabeçalho-for> <instrução>
<cabeçalho-for> ::= (<expressão>;<condição>;<expressão>)
…

Noções e uso de UML

O UML – Unified Modeling Language – é um formalismo de representação de

sistemas computacionais, através de diagramas.
Ajuda a capturar a visão inicial de um sistema, comunicá-la e mantê-la durante o
projecto e criação do sistema.
Trata-se da utilização de elementos gráficos que, combinados segundo
determinadas regras, formam diagramas. O objectivo dos diagramas é apresentar
várias vistas de um sistema. O conjunto dos diagramas de um sistema, designados
por modelo UML do sistema, descreve o que o sistema deve realizar e não como
deve ser implementado.
Existem vários diagramas UML, contudo vamos apenas descrever o diagrama de
classes.

Um sistema computacional para representar e interactuar com o mundo necessita

de simular e manipular várias entidades e aceder às suas características. A
organização das várias entidades envolvidas leva às categorias a que cada entidade
naturalmente pertence. Essas categorias designam-se por classes.

O diagrama de classes mostra classes, interfaces e suas relações.

Exemplo: Numa escola, existem pessoas: professores, alunos e funcionários. Todos 65

possuem características comuns entre si, tal como o nome, a idade e a morada.
 ALGORITMIA

Mas cada um destes grupos possui características diferentes.

Então podemos agrupar as características comuns numa classe, e criar classes
distintas, para cada grupo, com as características próprias de cada grupo.

Escola

Pessoa
-Nome
-Idade
-Morada

Professor Aluno Funcionário

-Formação -Turma -Categoria
-Disciplinas -Nº Aluno -Responsabilidade
-Vencimento -Reprovações -Vencimento

Figura 23 – Diagrama de classes

66
 ALGORITMIA

Conceito de abstracção

Definição de abstracção – consiste em extrair de um conteúdo o que dele possa ter

de mais interessante.

A descrição de problemas reais (acontecimentos do dia a dia) inclui um conjunto de

detalhes que podem (e devem) ser descartados. O problema deverá ser identificado
e tratado de uma forma abstracta.
A abstracção permite encontrar soluções comuns para os diferentes problemas que
vão surgindo.

Exemplo elucidativo: pretende-se fazer a gestão das bolas existentes num

complexo desportivo. Existem bolas de futebol (em couro, com determinado peso e
diâmetro, etc.), bolas de basquetebol (de borracha, com outro peso), bolas de ténis,
e muitas outras. Se o pretendido é gerir o número e estado das bolas, não é
necessário considerar as características associadas a cada tipo específico de bola.
Basta criar um objecto que contenha informação acerca do tipo de bola, número de
bolas utilizáveis e número de bolas danificadas.

Surge aqui a necessidade de definir o conceito de objecto.

Um objecto corresponde à representação abstracta de uma entidade autónoma sob
a forma de:
 Uma identidade única;
 Um conjunto de atributos (elementos ou dados) privados que o caracterizam
(o estado interno do objecto);
 Um conjunto de operações que podem aceder ao estado interno do objecto;

Um objecto pode ser visto como uma “caixa-negra”, a qual pode ser acedida por
operações, as quais devolvem um resultado. 67
 ALGORITMIA

Criar uma instância do objecto significa atribuir valores aos seus atributos. Um
desses atributos terá que constituir a identidade única. Podem ser criadas várias
instâncias de um mesmo objecto.

Exemplo:
Considere-se o objecto Bola.
Este objecto possui os atributos (elementos ou dados):
 Tipo de bola (identidade única);
 Número de bolas utilizáveis;
 Número de bolas danificadas.

Operações que podem ser realizadas sobre este objecto:

 Identificar tipo de bola;
 Saber número de bolas utilizáveis;
 Saber número de bolas danificadas.

A abstracção focaliza-se naquilo que o objecto é e faz, considerando aspectos

essenciais e ignorando propriedades desnecessárias à resolução do problema.
Exemplo:

Objecto Bola {
Tipo_bola
N_bolas_utilizaveis
N_bolas_danificadas
}

68
funcao Bolas_Danificadas(Bola bolas)
 ALGORITMIA

{
...
retorna booleano;
}

Esta função devolve verdadeiro caso existam bolas danificadas e falso caso não
existam.
Criação de objectos do tipo Bola:
Bola futebol = new Bola(Futebol, 3, 0);
Criou-se um objecto do tipo bola, com o nome Futebol, e com a informação de que
existem três bolas utilizáveis e zero bolas danificadas;
Bola Tenis = new Bola(Ténis,4,1);
Criação do objecto tipo bola, com o nome Tenis, , e com a informação de que
existem quatro bolas utilizáveis e uma bola danificada;

O conceito de abstracção apresenta como principais vantagens:

 Melhor compreensão dos algoritmos;

 Maior facilidade de programação.

E como consequência, apresenta como principais desvantagens:

 Aumento da complexidade dos programas;

 Modelação prévia dos dados do projecto.

Note-se que as vantagens compensam largamente a existência de desvantagens.

69
 ALGORITMIA

Posteriormente, esta metodologia foi também incorporada nas próprias linguagens

de programação, pelo que actualmente existem as linguagens de programação
orientadas a objectos (OOP - Object Oriented Programming).

Utilização de abstracção

Como já foi visto, a descrição de problemas reais inclui um conjunto de detalhes que
podem ser descartados. A melhor abordagem é então a de identificar o problema
de uma forma abstracta.

A abstracção permite soluções comuns para os problemas que se apresentam com

características diferentes, mas que podem ser tratados como semelhantes.

Como também já foi referido, a especificação dos algoritmos e estruturas de dados,

nomeadamente em pseudo código, poder ser posteriormente implementada em
qualquer linguagem. Codificar, ou programar, é implementar as estruturas de dados
abstractos e os algoritmos, numa linguagem.

Cuidado para evitar ambiguidades.

Assim, utilizamos abstracção sempre que utilizamos estruturas de dados de uma

forma abstracta.

Conceito e uso de objectos em programação

Tal como já visto, as linguagens mais actuais são orientadas a objectos (C++, Java,
C#). Um objecto representa uma entidade, física ou não. Trata-se de uma
abstracção, conceito já abordado neste manual. Um objecto encontra-se bem
definido e possui um significado válido na aplicação.

Exemplo de um objecto: 70
 ALGORITMIA

Objecto Pessoa

nome;

idade;

morada;

O objecto possui a estrutura definida, os dados enumerados na sua estrutura.

Podem ser criados vários objectos do mesmo tipo:

Exemplo:

Pessoa Maria;

Pessoa João;

Tanto Maria como João têm um nome, uma idade e uma morada, diferentes entre
si.

A vantagem do uso de objectos na programação é que estes permitem utilizar

funções e atributos conhecidos sem necessidade de conhecimento sobre sua
estrutura interna.

Exemplo: É possível conhecer o nome de um objecto sem conhecer a sua idade, ou

vice-versa.

71
 ALGORITMIA

Programação por objectivos

Quando se pretende desenvolver uma aplicação, devemos começar por definir os

objectivos que pretendemos alcançar. Definir o que se pretende que o programa
execute, de que forma, que informação necessita para o fazer e que informação irá
fornecer no fim da execução.
Este raciocínio parece fácil quando se trata de pequenos problemas. No entanto,
para grandes aplicações, há que valorizar esta questão.
Analisemos, como exemplo, uma aplicação para gestão de uma escola.
O que é pretendido da aplicação:
 Criar horários para os professores;

 Criar horários para as turmas;

 Colocar alunos nas turmas;

 Atribuir salas a cada turma;

 Verificar faltas de professores;

 Verificar faltas de alunos;

 Coordenar visitas de estudo;

 Calcular nota final de cada aluno;

 …

Tentar desenvolver um algoritmo para resolver todos estes aspectos de uma só vez,
é garantia de insucesso.

Então, definir e programar por objectivos.

Começar por desenvolver o algoritmo, em pseudo código (ou outro), para criar os
horários para os professores. Implementar. Se não funcionar, corrigir. Se funcionar,
passar ao objectivo seguinte.
72
 ALGORITMIA

Ter sempre em atenção que, por vezes, acrescentar algo novo interfere com o que
já se encontra implementado. Efectuar sempre um plano de testes o mais completo
possível.

73