PRINCÍPIOS DE

ALGORITMIA

Formadora: Gisela Firmino

Índice
Conceitos sobre linguagens de programação ............................................................................................................................... 1

Programa .................................................................................................................................................................................. 1

Linguagens de programação ..................................................................................................................................................... 1

Tipos de Linguagens.................................................................................................................................................................. 1

Linguagem de Alto-nível ....................................................................................................................................................... 1

Linguagem de Baixo-nível ..................................................................................................................................................... 2

Linguagem máquina ............................................................................................................................................................. 2

Tipos de Linguagens de programação de Alto-nível............................................................................................................. 2

Fases da Programação .......................................................................................................................................................... 3

Algoritmia e Algoritmos Fundamentais .................................................................................................................................... 3

Algoritmos ............................................................................................................................................................................ 4

Propriedades dos Algoritmos ........................................................................................................................................... 4

Tipos de Dados ..................................................................................................................................................................... 4

Dados simples ou primitivos ............................................................................................................................................ 4

Caracteres .................................................................................................................................................................... 4

Dados numéricos ......................................................................................................................................................... 5

Inteiros......................................................................................................................................................................... 5

Reais ............................................................................................................................................................................ 5

Decimais .................................................................................................................................................................. 5

Vírgula flutuante ..................................................................................................................................................... 5

Dados lógicos ou booleanos ........................................................................................................................................ 5

Dados estruturados.......................................................................................................................................................... 5

Arrays e Matrizes ......................................................................................................................................................... 6

Registos ....................................................................................................................................................................... 6

Constantes e Variáveis .............................................................................................................................................................. 6

Constantes ............................................................................................................................................................................ 7

Variáveis ............................................................................................................................................................................... 7

Regras para nomes de identificadores (Variáveis) ........................................................................................................... 7

Atribuição de valores a variáveis ..................................................................................................................................... 8

 Expressões ............................................................................................................................................................................ 8

Operadores Existentes ......................................................................................................................................................... 8

Prioridades de Operadores .................................................................................................................................................. 8

Funções ................................................................................................................................................................................ 9

Linguagem Algorítmica ........................................................................................................................................................... 10

Entrada e Saída de Dados ................................................................................................................................................... 10

Entrada de Dados ........................................................................................................................................................... 10

Saída de Dados ............................................................................................................................................................... 11

Operadores Relacionais e Operadores Lógicos .................................................................................................................. 11

Operadores Relacionais ou de comparação .................................................................................................................. 11

Operadores lógicos ........................................................................................................................................................ 12

Tabelas de Verdade dos operadores lógicos ............................................................................................................. 12

Negação ..................................................................................................................................................................... 12

Conjunção .................................................................................................................................................................. 12

Disjunção ................................................................................................................................................................... 13

Ordem de prioridades de todos os operadores ........................................................................................................ 13

Elaboração de Algoritmos ........................................................................................................................................................... 14

Abordagem Top-Down ........................................................................................................................................................... 14

Passos para a elaboração de um algoritmo ............................................................................................................................ 14

Método geral para a elaboração do Algoritmo ...................................................................................................................... 17

Estruturas de Controlo............................................................................................................................................................ 17

Estruturas de Decisão ......................................................................................................................................................... 17

Estruturas de decisão com base numa condição ........................................................................................................... 18

SE ENTAO ................................................................................................................................................................... 18

SE ENTAO SENAO ....................................................................................................................................................... 18

SE ENTAO SENAO para várias condições ................................................................................................................... 19

Estruturas de seleção ou escolha múltipla .................................................................................................................... 19

SELECIONAR… CASO... FIM_SELECIONAR .................................................................................................................. 19

Comparação entre estruturas de decisão e de seleção múltipla ................................................................................... 21

Estruturas de Repetição ............................................................................................................................................ 21

 Iteração, Contador, Acumulador ........................................................................................................................... 22

Iteração ............................................................................................................................................................. 22

Contador ........................................................................................................................................................... 22

Acumulador....................................................................................................................................................... 22

Analisando a necessidade de um ciclo .................................................................................................................. 23

Estruturas de repetição com contador automático .................................................................................................. 23

PARA variável de valor_inicial ATE valor_final FAZER ........................................................................................... 23

Desmistificando iteração, contador e acumulador .......................................................................................... 25

Estruturas de Repetição controladas por uma condição........................................................................................... 25

Estruturas de decisão controlados no final do Ciclo ............................................................................................. 25

REPETIR… ATE …................................................................................................................................................ 25

Condição de controlo no início do ciclo ................................................................................................................ 27

ENQUANTO… FAZER… FIM_ENQUANTO .......................................................................................................... 27

Conceitos sobre linguagens de programação

Programa

O que é um programa?

Um programa é um conjunto de instruções (sequência) executado pelo microprocessador e que transmitem ao

computador o que ele tem que fazer.

Linguagens de programação

O que é uma linguagem de programação?

Uma linguagem de programação é uma linguagem com uma sintaxe própria, com a qual se podem escrever
programas de software. Existem várias linguagens de programação, cada qual com o seu conjunto de estruturas,
sentenças e regras específicas.

Tipos de Linguagens

Linguagem de Alto-nível
São assim chamadas por estarem muito acima da linguagem máquina ou do hardware e se aproxima da linguagem
humana (inglês). A maior parte das aplicações desenvolvidas por programadores é feita utilizando linguagens de
alto-nível. Exemplos de linguagem de alto nível:

• C
• Pascal
• Visual Basic
• Delphi, etc.

[1]
Linguagem de Baixo-nível
Pelo contrário, a programação em linguagens de baixo nível implica que o programador tenha um profundo
conhecimento da arquitectura interna do computador e do seu conjunto de instruções máquina, pelo que esta
linguagem não é normalmente utilizada para o desenvolvimento de aplicações. Cada família de processadores criou
a sua própria linguagem Assembly.

Uma linguagem Assembly consiste num conjunto de palavras que codificam as instruções de máquina (zeros e uns)
com que cada determinado processador funciona.

Estas linguagens são muito complexas e difíceis de utilizar pois, para cada instrução-máquina tem de se escrever
uma instrução em Assembly, o que torna os programas muito extensos e sujeitos a erros difíceis de detectar. Por
essa razão apareceram as linguagens de alto-nível.

Linguagem máquina
É a codificação das instruções com que os computadores funcionam e a única que o seu hardware reconhece e
decifra. Essas instruções são dadas em agrupamentos de bits ou bytes, utilizando a linguagem binária, devidamente
codificados em sinais eléctricos.

Cada arquitectura de processador ou CPU determina uma linguagem – máquina própria que consiste no conjunto
de instruções codificadas em zeros e uns que o processador reconhece e sabe decifrar.

Estas linguagens são muito difíceis de utilizar (eram utilizadas no início) e obrigava os programadores a terem de
conhecer em grande pormenor a estrutura e a forma de funcionamento de cada modelo de computador com eu
trabalhasse. Por isso era uma tarefa reservada a uma minoria de especialistas.

Tipos de Linguagens de programação de Alto-nível

As linguagens de programação de alto nível, podem subdividir-se em 2 grupos: as chamadas tradicionais e as
linguagens orientadas a objectos.

Diferenças

A principal diferença prende-se com o facto de, nas linguagens tradicionais o programador é obrigado a escrever o
código para o interface e só depois de executar o código é que pode ver o resultado do código desenvolvido.
Exemplos: Pascal, C, Cobol, etc.

[2]
Com o aparecimento de novos utilizadores de computadores surgiu a necessidade de encarar a programação como
uma simulação do mundo real, surgiram então linguagens de programação como o Visual C, CBuilder, Visual Basic,
Delphi, etc.

Com estas linguagens de programação, o desenho do interface pode ser feito sem recurso directo à programação.
O ambiente de desenvolvimento proporciona as funcionalidades necessárias para que o programador possa
manipular os vários objectos do interface obtendo de imediato uma visualização prévia da aplicação que se está a
desenvolver.

Fases da Programação
1. Análise do problema;
2. Desenvolvimento da solução;
3. Construção da solução sob a forma de programa;
4. Testagem/ Traçagem;
5. Preparação da documentação.

Algoritmia e Algoritmos Fundamentais

Os computadores executam apenas o que lhe mandam fazer e não necessariamente o que queremos que o
computador faça.

Não deve existir ambiguidade nas instruções fornecidas nos programas, nem a possibilidade de interpretações
alternativas.

A programação em computadores é uma actividade complexa e que utiliza muita actividade mental. O seu trabalho
pode ser facilitado quando se utiliza a aproximação “dividir para conquistar”.

Para que a programação seja concisa e bem feita, é necessário separar a fase de resolução da fase de
implementação com é ilustrado na figura seguinte:

Fase de resolução de problemas

Problema Solução em
forma de
Algoritmo

Passo difícil

Figura 1 - Fases do algoritmo

Fase de implementação

Programa de
Computador
[3]
Algoritmos
O que é um Algoritmo?

Um Algoritmo pode ser definido como uma sequência de passos sem ambiguidades e que levam à resolução de um
dado problema.

Propriedades dos Algoritmos

• Os passos de um algoritmo devem ser simples, sem ambiguidades e com uma sequência lógica.
• Devem ter um número finito de passos.

Tipos de Dados
Existem 2 tipos de dados: Dados simples ou primitivos e dados estruturados.

Dados simples ou primitivos

A grande maioria das operações básicas é efetuada sobre dados, desta forma leva-nos a ter de saber que tipos de
dados com que pretendemos ou podemos trabalhar.

Os tipos de dados simples em algoritmia e em programação podem dividir-se em 3 grupos:

• Caracteres;
• Dados numéricos;
• Lógicos ou booleanos.

Há ainda autores que defendem um quarto tipo de dados simples: Data. No entanto, há autores que defendem
que a data é um tipo de dados estruturado, composto ou complexo, uma vez que, na realidade é uma composição
de 3 elementos: dia, mês e ano que, só por si fazem sentido.

No âmbito desta UFCD iremos considerar a data como dados simples.

Caracteres
Também chamados de Alfanuméricos ou Strings, o que quer dizer que neste tipo de dados podemos utilizar letras
ou números, porém estes não são reconhecidos como números, mas como simples caracteres como os outros.
Exemplo: “Amanhã é dia 25 de Fevereiro”.

Se pretendermos “somar” os dígitos 1 +1 e estes sejam do tipo caractere, vai ocorrer uma concatenação, ou seja,
uma junção. Assim:

[4]
1+1 =2, se estivermos a falar de dados do tipo numéricos

1+1=11, se estivermos a falar de dados do tipo caractere

Dados numéricos
Outro grupo de dados é constituído pelos vários tipos de dados numéricos. A principal divisão dos tipos de dados
numéricos é a que os divide em:

• Inteiros
• Reais
• Decimais
• Vírgula Flutuante

Inteiros
Números inteiros negativos, zero e positivos. Exemplos: 2,0; 2x106; -12x108.

Nota: Todos os números inteiros têm expoentes positivos.

Reais
Muitos autores subdividem este grupo em 2 subgrupos, outros apenas falam no grupo dos reais. A subdivisão é
feita da seguinte forma:

Decimais
Números reais em que figuram partes decimais. Exemplos: 2,5; 2x10-5

Vírgula flutuante
Quando as casas decimais são superiores a 15, entramos neste subgrupo, por exemplo: 17,5x10-16.

Nota: Todos os números decimais têm expoentes negativos.

Dados lógicos ou booleanos

Este tipo de dados também é muito frequente e caracteriza-se por apenas admitir um entre dois resultados:
verdadeiro (true) ou falso (false).

Dados estruturados
A partir dos tipos de dados simples podem criar-se outros tipos de dados mais complexos: os dados estruturados.

[5]
Neste grupo podemos ter conjuntos ordenados de dados todos do mesmo tipo base chamados Arrays. Também
podemos ter estruturas com tipos de dados diferentes neste caso estamos perante um registo.

Arrays e Matrizes
Estruturas de dados todas do mesmo tipo (por exemplo inteiros), e com um nome comum em todos eles. A sua
identificação é dada por um número. Estes tipos de dados podem ser simples (ou vetores) ou bidimensionais
(matrizes) , como podes ver na figura seguinte:

Registos
São conjuntos de dados que podem ou não ser diferentes entre si. Normalmente estes dados são considerados
campos da estrutura. Podemos ainda ter arrays ou ficheiros de registos, etc, como podes ver na figura seguinte:

Constantes e Variáveis

Em algoritmos e em programas de computador, os dados podem surgir sob a forma de constantes ou de variáveis.

[6]
Constantes
Um dado que permanece inalterável do início ao fim do algoritmo. Exemplo: o valor de π (Pi).

Estas podem surgir:

De forma direta – Valores numéricos, alfanuméricos ou outros, expressos literalmente pelo que são. Exemplos:
0,75; “Janeiro”.

Sob a forma de identificadores – nomes que identificam ou representam determinados dados ou valores. Por
exemplo:

Constante taxa←0,19 - Define uma constante com o nome taxa e esta terá o valor 0,19

Constante nome← “Ana Matias” - Define uma constante chamada nome e esta associada a si a string ou conjunto
de caracteres “Ana Matias”.

Nota: Os tipos de dados alfanuméricos (strings, caracteres) são inseridos entre aspas ou apóstrofes (plicas), isto
evita que possa haver confusão entre identificadores e strings.

Variáveis
É uma entidade que possui um valor que pode sofrer alterações durante o algoritmo e é reconhecida nos programas
pelo seu nome. As variáveis são sempre designadas através de identificadores, ou seja, nomes que as identificam.

A cada variável é também associado um determinado tipo de dados e a sua declaração é sempre realizada no início
do algoritmo, por exemplo:

Variavel idade: inteiro

Esta declaração define que no decorrer de um algoritmo vai ser utilizado um valor que se pode alterar, com o nome
idade e TODOS os dados terão obrigatoriamente de ser inteiros.

Regras para nomes de identificadores (Variáveis)

• Letras do Alfabeto
• Dígitos
• Caracter _ (underscore)
• Começa sempre por uma letra

[7]
Atribuição de valores a variáveis
Chamam-se Instruções de atribuição às operações internas de um programa ou algoritmo que atribuem um valor
à variável. Esta operação de atribuição especifica que a uma variável é dado um novo valor. Esta operação utiliza o
seguinte símbolo:

Exemplos:

Nome←“Ana Matias” - Indica que a variável Nome recebe a cadeia de caracteres “Ana Matias”.

Preco←20 - Indica que a variável Preco recebe o valor de 20.

Expressões
Uma expressão é uma combinação de variáveis, constantes e operadores. O resultado da avaliação da expressão é
atribuído a uma variável.

Variável ← Expressão

Existem expressões que embora não tenham sentido na matemática têm em computação, como por exemplo:

X ← X+1

Esta expressão significa que o valor da variável x é incrementado em 1 unidade.

Operadores Existentes
1.Exponenciação ↑

2.Sinal (positivo ou negativo) -;+

3.Multiplicação ou divisão *,/, div

4.Adição, subtração +;-

Prioridades de Operadores
Em algoritmia numa expressão com vários operadores e funções temos precedências para a realização das
operações como aliás já acontece com as expressões matemáticas.

[8]
As precedências ou prioridades são as seguintes:

1. Parêntesis retos
2. Parêntesis curvos
3. Expoentes
4. Multiplicação, divisão e funções
5. Soma e subtração

Nota bem: Quando 2 operadores são iguais (soma e subtração, por exemplo), as operações fazem-se da esquerda
para a direita. Exemplo:

5+3-1=8-1=7

Exemplo da resolução de uma expressão:

2*(3+2*5) +3=2*(3+10) +3=2*(13) +3=26+3=29

O parêntesis é avaliado antes dos outros operadores. Dentro do parêntesis, são utilizadas as precedências normais.

Funções
Existem algumas fórmulas pré-programadas em algoritmia e nas diversas linguagens de programação. Isto significa
que não é necessário haver uma preocupação da nossa parte para conhecer o seu funcionamento, apenas na forma
de aplicação. De seguida, apresentam-se algumas funções utilizadas em algoritmia. Cada linguagem de
programação terá os próprios nomes para as evocar. Os nomes das funções são PALAVRAS RESERVADAS, ou seja,
não podem ser utilizadas como nomes de variáveis para não haver confusão.

Função Definição Exemplo de aplicação

ABS (X) Calcula o valor absoluto de um número ou de uma expressão. ABS (-1) ←1 | ABS (1) ←1

SQRT (X) Calcula a raiz quadrada de um número ou de uma expressão. SQRT(4) ←2

TRUNC (X) Trunca (corta) o valor de um número com casas decimais ou de TRUNC(2,6) ←2 | TRUNC(2,3) ←2
uma expressão.

ROUND (X) Arredonda o valor de um número com casas decimais ou de uma ROUND(2,6) ←3 | ROUND(2,3) ←2
expressão.

LOG (X) Calcula o logaritmo de um número ou de uma expressão. LOG(9) ← 2,19722458

[9]
 Função Definição Exemplo de aplicação

LOG10 (X) Calcula o logaritmo de base 10 de um número ou de uma LOG10(9) ← 0,9542425

expressão.

SIN (X) Calcula o seno de um número ou de uma expressão. SIN(9) ← 0,156434465

COS (X) Calcula o cosseno de um número ou de uma expressão. COS(9) ← 0,987688341

TAN (X) Calcula a tangente de um número ou de uma expressão. TAN(9) ← 0,158384440

X MOD Y Calcula o resto da divisão inteira entre dois números ou 4 MOD 2 ← 0

expressões

Linguagem Algorítmica

Como é que apareceu?

Extraindo as melhores características das duas últimas aproximações e combinando-as numa linguagem especial.

Como é que se pode definir?

É um conjunto de instruções para a resolução dos problemas computacionais, escrito em PSEUDO-CÓDIGO.

Entrada e Saída de Dados

Entrada de Dados
Um programa de computador ou um algoritmo têm de ter em conta a interação com o exterior ou as pessoas que
podem fornecer os dados com que se vão efetuar as operações. Uma entrada de dados é feita normalmente
através do armazenamento de valores em variáveis. Para introduzir ou obter dados num algoritmo é feito através
das instruções:

LER (variável) ou,

OBTER (variável)

[10]
Saída de Dados
A saída dos dados num algoritmo pode ser feita através de vários dispositivos, por exemplo: monitor, impressora,
um disco, etc.. Esta saída é representada pelas seguintes palavras reservadas:

IMPRIMIR (lista de variáveis) – exclusivo para enviar dados para a impressora

ESCREVER (lista de variáveis)

APRESENTAR (lista de variáveis)

Nota: Também poderemos apresentar texto e variáveis na mesma instrução. Exemplo:

ESCREVER (“A soma dos números é:”, soma)

Se pretendermos escrever texto e valores das variáveis temos de colocar o texto pretendido entre aspas e separar
os elementos por vírgulas. Outro Exemplo:

ESCREVER (“A soma e a média são, respetivamente:”, soma, média)

Todos os elementos estão escritos separados por vírgulas. O que a linha anterior faz é escrever na mesma linha
todos os elementos.

Operadores Relacionais e Operadores Lógicos

As expressões podem ser de dois tipos: numéricas ou booleanas.

As expressões numéricas são aquelas que utilizam apenas operadores aritméticos. As expressões booleanas são
expressões que utilizam operadores de comparação e/ou lógicos e se espera obter um resultado lógico, ou seja:
verdadeiro ou falso.

Operadores Relacionais ou de comparação

Operador Significado

= Igualdade

< Menor do que

> Maior do que

[11]
 Operador Significado

<= Menor ou igual a

>= Maior ou igual a

<> Diferente de

|N Incluído em

Operadores lógicos
Operador Significado

NOT - NEGAR Negação

AND - E Conjunção

OR - OU Disjunção

Tabelas de Verdade dos operadores lógicos

Negação
A NEGAR(A)

V F

F V

Conjunção
A B (A) E (B)

V V V

[12]
A B (A) E (B)

V F F

F V F

F F F

Disjunção
A B (A)OU (B)

V V V

V F V

F V V

F F F

Ordem de prioridades de todos os operadores

1. Parêntesis retos
2. Parêntesis curvos
3. Sinais (positivo e negativo)
4. Expoente
5. Operadores Multiplicativos (multiplicação, divisão)
6. Operadores Aditivos (soma, subtração)
7. Operadores Relacionais (igualdade, menor do que, etc.)
8. Operador lógico NEGAR
9. Operador lógico E
10. Operador lógico OU

[13]
Elaboração de Algoritmos

Abordagem Top-Down

É um método de abordagem de problemas em que se procura identificar os pontos essenciais da questão e se parte
dos pontos gerais para os particulares, em níveis mais concretos. É o método mais utilizado para expressar
algoritmos em linguagem comum. Exemplo:

Imagine que pretendemos calcular a soma de 2 números introduzidos pelo utilizador. Poderíamos subdividir o
problema nos seguintes pontos:

1. Pedir os números ao utilizador;

2. Calcular a sua soma;
3. Apresentar o resultado.

Outro Exemplo: Calcular a hipotenusa de um triângulo

1. 1.LER valores dos dados

2. CALCULAR a hipotenusa
3. 3.IMPRIMIR os resultados

Passos para a elaboração de um algoritmo

A elaboração de um algoritmo divide-se em 3 partes:

1. Descrição das variáveis e constantes - É a primeira parte do algoritmo. Aqui serão discriminadas todas
as constantes e variáveis (identificadores e tipos) a ser utilizadas na elaboração do algoritmo.
2. Resolução do problema pedido - Expressões e raciocínio lógico necessários para e resolução do
problema.
3. Apresentação dos resultados - Apresentação dos resultados ao utilizador.

Exemplo:

Para demonstrar como se elabora um algoritmo vamos pegar no exemplo da soma de 2 números.

Passo 1: Declaração das variáveis.

[14]
Que variáveis vamos precisar e de que tipo? Esta é a primeira parte e das mais importantes do algoritmo. Devemos
ter cuidado ao escolher o tipo de dados para evitarmos possíveis erros no programa. Neste exemplo que variáveis
vamos utilizar?

Bem, se a soma é de 2 números, precisaremos obrigatoriamente de 2 variáveis para armazenar os números. E a

soma, também irá ser guardada numa variável? No nosso caso sim, então já são três variáveis.

E o tipo? Serão inteiras ou reais? Estes dados são dados no enunciado do problema, como aqui não temos nada
que nos dê indicações do tipo de dados poderemos escolher. Vou escolher inteiro.

Como respondemos às questões necessárias podemos começar por resolver o algoritmo.

{Declaração das variáveis}

Variaveis num1, num2, soma: inteiras;

Passo 2: Resolução do problema pedido

O que nos é pedido é que o utilizador introduza 2 números e seja calculada a sua soma.

{Pedir ao utilizador que introduza o 1º número}

ESCREVER (“Introduza o 1º número”)

{Ler o valor introduzido pelo utilizador, através do teclado}

LER (num1)

{Pedir ao utilizador que introduza o 2º número}

ESCREVER (“Introduza o 2º número”)

{Ler o valor introduzido pelo utilizador, através do teclado}

LER (num2)

{Calcular a soma dos 2 números e guardar o valor na variável respetiva}

soma←num1+num2

Passo 3: Apresentar os resultados

[15]
Para apresentar os resultados no ecrã poderemos utilizar a palavra reservada que se adaptar ao enunciado do
problema. Neste caso vamos escrevê-lo no monitor visto que também não nos é dito nada sobre a forma de
apresentar os resultados.

{Apresentação da soma no ecrã}

ESCREVER (“A soma é:”, soma)

Transcrevendo o algoritmo todo seguido temos:

{Declaração das variáveis}

Variaveis num1, num2, soma: inteiras

INICIO

{Pedir ao utilizador que introduza o 1º número}

ESCREVER (“Introduza o 1º número”)

{Ler o valor introduzido pelo utilizador, através do teclado}

LER (num1)

{Pedir ao utilizador que introduza o 2º número}

ESCREVER (“Introduza o 2º número”)

{Ler o valor introduzido pelo utilizador, através do teclado}

LER (num2)

{Calcular a soma dos 2 números e guardar o valor na variável respetiva}

soma←num1+num2

{Apresentação da soma no ecrã}

ESCREVER (“A soma é:”, soma)

FIM

[16]
Nota: Todos nos algoritmos têm um INICIO e um FIM. O INICIO é colocado logo a seguir à declaração das variáveis
e o FIM é a última instrução!

Todos os algoritmos seguem os mesmos passos muda apenas o raciocínio dependendo do enunciado do desafio.

Método geral para a elaboração do Algoritmo

1. Ter certeza que as especificações do problema foram entendidas completamente

Indicar qual o resultado esperado para diferentes entradas.

2. Elaborar de um modo geral, um algoritmo para a solução do problema

Verificar se a estratégia está correta, executando traçagens (testes) para entradas diferentes.

3. Identificar e listar as variáveis necessárias

Incluir o nome, tipo e objetivo

4. Voltar ao algoritmo, desenvolvendo os seus passos com maior detalhe

Verificar sempre se cada vez que um passo é decomposto em vários, estes executam os objetivos do passo
original.

5. Executar traçagens (testes) para novas entradas.

Estruturas de Controlo

Quando se elabora um algoritmo é frequentemente necessário jogar com determinadas condições para se decidir
se se deve executar uma ou outra ação ou ações (estruturas de decisão) ou repetir uma série de instruções um
determinado número de vezes ou enquanto se verificar uma certa condição (estruturas de repetição ou ciclos).

Estruturas de Decisão
As estruturas podem subdividir-se em 2 subgrupos: estruturas de decisão com base numa condição e estruturas
de seleção ou escolha múltipla.

[17]
Estruturas de decisão com base numa condição
Existe praticamente em todas as linguagens de programação. Esta estrutura permite, com base numa condição
colocada a seguir ao SE, decidir sobre a execução ou não de determinada ação ou optar entre 2 alternativas
colocadas a seguir a ENTAO e a SENAO, sendo esta última opcional.

SE ENTAO
SE (condição)

ENTAO alternativa verdadeira

FIM_SE

Exemplo:

SE chover

ENTAO levar chapéu-de-chuva

FIM_SE

SE ENTAO SENAO
SE (condição)

ENTAO alternativa verdadeira

SENAO alternativa falsa

FIM_SE

Exemplo:

SE a turma se comportar

ENTAO vão ao intervalo

SENAO ficam na sala de aula

FIM_SE

[18]
SE ENTAO SENAO para várias condições
SE (condição_1)

ENTAO SE (condição_2)

ENTAO alternativa_verdadeira_1

SENAO alternativa falsa_1

FIM_SE

SENAO alternativa falsa_2

FIM_SE

Exemplo:

SE chover

ENTAO SE estiver sol

ENTAO aparece o arco-íris

SENAO dia triste

FIM_SE

SENAO deixar guarda - chuva em casa

FIM_SE

Nota: Todas as instruções deverão ser escritas sem acentos e sem carateres especiais!

Estruturas de seleção ou escolha múltipla

Permite optar, mediante uma variável que desempenha a função de seletor, entre um certo número de alternativas
(casos) possíveis.

SELECIONAR… CASO... FIM_SELECIONAR

SELECIONAR variável

CASO expressão1: bloco de instruções

[19]
 CASO expressão2: bloco de instruções

CASO_CONTRARIO bloco de instruções

FIM_SELECIONAR

Exemplo:

SELECIONAR idade

CASO <=12 anos: ESCREVER (“Criança”)

CASO> 12 E <= 18: ESCREVER (“Adolescente”)

CASO_CONTRARIO ESCREVER ( “Adulto”);

FIM_SELECIONAR

Exemplo:

Para entender melhor esta estrutura vamos ver um pequeno exemplo:

Quando inserida uma nota entre 0 e 5 o algoritmo vai classificá-la como Mau, Insuficiente, Bom ou Muito Bom.

Elaboração do algoritmo

{Declaração das variáveis}

VARIAVEL nota: inteira

INICIO

{Desenvolvimento do algoritmo}

ESCREVER (“Qual a nota numérica – entre 0 e 5?”)

LER (nota)

SELECIONAR (nota)

CASO 0,1: ESCREVER (“Mau”)

CASO 2: ESCREVER (“Insuficiente”)

[20]
 CASO 3: ESCREVER (“Suficiente”)

CASO 4: ESCREVER (“Bom”)

CASO 5: ESCREVER (“Muito Bom”)

CASO_CONTRARIO: ESCREVER (“Nota inválida”)

FIM_SELECIONAR

FIM

Comparação entre estruturas de decisão e de seleção múltipla

Em geral, uma estrutura de selecção múltipla “Selecionar caso…” pode sempre converter-se numa série de
estruturas de decisão condicional “Se… Entao… Senao” encaixadas umas nas outras.

No entanto, o inverso não é verdade, ou seja, nem todas as estruturas “Se… Entao… Senao” podem ser convertidas
em estruturas “Selecionar … Caso”. Isto acontece quando as estrutura SE utiliza valores que não podem ser
convertidos numa lista exata.

Devemos utilizar a estrutura “Se… Entao… Senao” quando não conhecemos a lista de valores. Quando a lista desses
valores é conhecida deve ser utilizada a estrutura “Selecionar Caso” pois torna o código mais fácil de escrever sem
erros de lógica e também é mais fácil de ler e de compreender.

Estruturas de Repetição
As estruturas de repetição são estruturas que permitem a execução de uma ou mais instruções repetidamente. A
repetição é executada até que uma condição seja mantida. As estruturas de repetição são divididas em 3 tipos:

• com contador automático

• controladas no início do ciclo
• controladas no final do ciclo

Para quê utilizar ciclos?

Os ciclos, também conhecidos como loops, ou estruturas de repetição são uma ferramenta essencial na
programação de computadores. Possibilitam que os programadores executem repetidamente um bloco de código,
enquanto uma determinada condição for verdadeira. A utilização de ciclos torna o código mais eficiente,
organizado e flexível, proporcionando várias vantagens.

[21]
Uma das principais razões para usar ciclos é a redução de redundância no código. Imagine ter de executar uma
determinada tarefa repetidamente, como mostrar uma mensagem para cada item de uma lista. Sem ciclos,
teríamos de escrever o mesmo código várias vezes para cada item, o que tornaria o programa extenso e difícil de
manter. Com a utilização de ciclos, podemos realizar a mesma tarefa com um código mais curto e legível,
economizando tempo e esforço no desenvolvimento e manutenção do programa.

Além disso, os ciclos permitem que os nossos programas manipulem com uma quantidade variável de dados de
forma eficiente. Se não soubéssemos quantas vezes precisaríamos repetir uma ação, seria difícil programar
manualmente cada iteração. Com ciclos, podemos processar um conjunto de dados arbitrariamente grande,
adaptando-se dinamicamente às mudanças nos requisitos.

Outra vantagem é a capacidade de criar algoritmos poderosos. Por exemplo, ao usar ciclos para percorrer e
manipular arrays, podemos executar operações em todos os elementos de forma rápida e concisa. Isso é
especialmente útil quando trabalhamos com grande volume de dados ou realizamos cálculos complexos.

Iteração, Contador, Acumulador

No decorrer da elaboração de algoritmos vamo-nos deparar com alguns conceitos novos:

• Iteração
• Contador
• Acumulador

Iteração
Iteração significa repetição. Em algoritmia e em programação, iteração é o número de vezes que as ações de um
ciclo vão ser executadas.

Contador
Um contador é uma variável que conta o número de iterações ou repetições de um ciclo.

Exemplo:

contador←contador + 1

Acumulador
Um acumulador é uma variável que soma ou acumula o valor das parcelas introduzidas. É muitas vezes necessário
dado que precisamos de alguma forma, guardar valores para além da sua utilização temporária. Esta variável
recebe o valor que continha anteriormente mais o que é introduzido na variável parcelar.

[22]
Exemplo:

Soma ←Soma+ Numero

Analisando a necessidade de um ciclo

• O que temos que fazer?
• Temos que repetir várias vezes algum procedimento?
• Podemos simplificar o código através de um ciclo!

Estruturas de repetição com contador automático

São estruturas que têm na sua base contadores automáticos, pelo que, não temos que nos preocupar com a
necessidade de avançar o ciclo. Neste caso, temos o ciclo PARA.

PARA variável de valor_inicial ATE valor_final FAZER

PARA variável de valor_inicial ATE valor_final FAZER (passos)

Bloco de instruções

FIM_FAZER OU FIM_PARA

Exemplo 1:

PARA Y ←1 ATE 10 FAZER

ESCREVER (Y)

FIM_FAZER

Exemplo 2:

PARA Y ←1 ATE 10 FAZER Y←Y+2

ESCREVER (Y)

FIM_FAZER

Nota:

[23]
A estrutura PARA, como já foi referido, tem um contador automático, se pretendermos que o ciclo avance
sequencialmente, não precisamos realizar nenhuma operação. No entanto, caso pretendamos avançar com uma
sequencia diferente, devemos coloca essa sequência na área passos.

Exemplos:

Tipo de sequência Código complexo Código reduzido

Sequência normal (1 em 1) i←i+1 i++

De 2 em 2 i←i+2 i2+

De 3 em 3 i←i+3 i3+

Sequência inversa i←i-1 i--

Sequência de 0,5 em 0,5 crescente i←i+0,5

Sequência de 0,5 em 0,5 decrescente i←i-0,5

Exemplo:

Fazer um algoritmo que pede 10 números inteiros e apresenta a sua soma num algoritmo com o ciclo PARA.

{Declaração das variáveis}

VARIAVEL n, soma, x: inteiros

INICIO

{Desenvolvimento do algoritmo}

ESCREVER (“Este algoritmo calcula a soma de 10 números inteiros introduzidos pelo utilizador”)

soma←0

PARA x←1 ATE 10 FAZER

ESCREVER(“Introduza um número”)

[24]
 LER(n)

soma←soma+n

FIM_FAZER

ESCREVER(“A soma é:”, soma)

FIM

Desmistificando iteração, contador e acumulador

Através do exercicio anterior vamos desmistificar os conceitos de iteração, contador e acumulador.

• Iteração
o Número de vezes que o ciclo é executado
o Nesta caso: 10 iterações
• Contador
o Sequência que utilizamos para avançar o ciclo
o Nesta caso: é sequencial ( 1 em 1), assim, está oculto, mas corresponde a x←x+1 ou x++
• Acumulador
o Variável que permite acumular valores que serão necessários para a execução do algoritmo. Ao
valor inicial da variável é acrescido (de acordo com a necessidade do algoritmo) um outro valor.
Essa operação é guardada na vaiável acumuladora.
o Neste caso: soma ←soma+n

Estruturas de Repetição controladas por uma condição

Neste capítulo vamos abordar as estruturas de repetição controladas por uma condição são estruturas que
permitem a execução de uma ou mais instruções repetidamente. A repetição é executada até que uma condição
seja mantida. Estas estruturas de repetição são divididas em 2 tipos:

• controladas no início do ciclo

• controladas no final do ciclo

Estruturas de decisão controlados no final do Ciclo

REPETIR… ATE …
O que indica o início do ciclo é a palavra REPETIR, segue-se um conjunto ou bloco de instruções que deverá ser
executado até que a condição ou expressão lógica no final da estrutura assuma o valor verdadeiro.

[25]
Como a condição só é avaliada no final da estrutura, isto implica que as instruções sejam executadas pelo menos
uma vez e continuarão a ser executadas até que a condição seja verdadeira.

Estrutura:

REPETIR

Bloco de instruções

ATE (condição)

Exemplo 1:

REPETIR

X←X+1

ATE (X=10)

A estrutura repetitiva ou de repetição é constituída por 3 elementos:

• Inicialização do ciclo
• Uma condição de controlo do ciclo
• Sequência lógica de instruções
• Este ciclo é executado, pelo menos, 1 vez

Exemplo:

{Declaração das variáveis}

VARIAVEIS

contador, soma, numero: inteiros

{Início do algoritmo}

INICIO

contador←0

soma←0

[26]
 REPETIR

ESCREVER (“Introduza um número à sua escolha (utilize o -1 para sair)”);

LER (numero)

soma←soma+numero

contador←contador+1

ATE (numero = -1)

{Apresentar os resultados}

ESCREVER (“O número de parcelas introduzido foi:”, contador)

ESCREVER (“A soma dos números é:”, soma)

FIM

Notas:

1. As iterações são o nº de vezes que o utilizador introduz números diferentes de -1.

2. O contador é aqui representado pela linha: contador ← contador +1.
3. O acumulador é dado pela instrução soma←soma+ parcela.

Condição de controlo no início do ciclo

ENQUANTO… FAZER… FIM_ENQUANTO
A palavra que indica o início do ciclo é a palavra “Enquanto”. Segue-se a condição ou expressão lógica que controla
a execução das ações dentro do ciclo. Depois é que surgem as ações a executar.

Estrutura:

ENQUANTO (condição) FAZER

Bloco de instruções

FIM_ENQUANTO

Exemplo:

[27]
ENQUANTO (X <10) FAZER

X←X+2

FIM_ENQUANTO

Nota:

Se o número de vezes que o ciclo vai ser executado for desconhecido, então utilizam-se a estrutura REPETIR. Esta
pode ser controladas por:

• Condições
• Sentinelas
• Fim de ficheiro (EOF)

Se esse número for conhecido, então pode usar-se o PARA...ATE…FAZER ou ENQUANTO…FAZER

[28]
[29]