ALG Sebenta

Instituto Superior de Engenharia
Departamento de Engenharia Informática (DEI)

Instituto
Politécnico do Porto
Introdução à Informática
e Algoritmia
Isabel Sampaio e Alberto Sampaio
Texto de Apoio para disciplinas de Algoritmia e Programação
1995-2006
ÍNDICE
I INTRODUÇÃO À INFORMÁTICA ............................................................................................................................. 1
1. CONCEITOS GERAIS.............................................................................................................................................. 1
2. EVOLUÇÃO HISTÓRICA DOS COMPUTADORES........................................................................................... 2
3. REPRESENTAÇÃO DA INFORMAÇÃO .............................................................................................................. 2
4. EXERCÍCIOS............................................................................................................................................................. 4
II INTRODUÇÃO À PROGRAMAÇÃO ......................................................................................................................... 5
5. RESOLUÇÃO DE PROBLEMAS EM INFORMÁTICA ...................................................................................... 5
6. ALGORITMOS .......................................................................................................................................................... 7
7. TIPOS DE DADOS, VARIÁVEIS, OPERAÇÕES ELEMENTARES E EXPRESSÕES.................................... 8
8. ESTRUTURAS DE CONTROLO DE FLUXO ..................................................................................................... 11

8.1 SEQUÊNCIA ............................................................................................................................................................ 11
8.2 DECISÕES .............................................................................................................................................................. 12
8.3 REPETIÇÕES ........................................................................................................................................................... 16
9. TRAÇAGEM ............................................................................................................................................................ 20
10. MANIPULAÇÃO DE NÚMEROS INTEIROS ..................................................................................................... 21
11. EXERCÍCIOS........................................................................................................................................................... 21
III SUBROTINAS ............................................................................................................................................................ 23
12. INTRODUÇÃO ........................................................................................................................................................ 23
13. FUNÇÕES................................................................................................................................................................. 23
14. PROCEDIMENTOS ................................................................................................................................................ 24

14.1 FLUXOGRAMA ............................................................................................................................................. 25
14.2 VARIÁVEIS LOCAIS E VARIÁVEIS GLOBAIS.......................................................................................... 25
14.3 EXERCÍCIOS ...................................................................................................................................................... 25
IV VECTORES ................................................................................................................................................................ 27
15. INTRODUÇÃO ........................................................................................................................................................ 27

15.1 DEFINIÇÃO .................................................................................................................................................... 28
I
15.2 PESQUISA .......................................................................................................................................................... 30
15.3 ELIMINAÇÃO ................................................................................................................................................ 30
15.4 EXERCÍCIOS ...................................................................................................................................................... 31
16. ORDENAÇÃO E PESQUISA ................................................................................................................................. 31
16.1 ORDENAÇÃO POR TROCA DIRECTA ................................................................................................................... 31
16.2 ORDENAÇÃO POR SELECÇÃO ............................................................................................................................ 31
16.3 ORDENAÇÃO POR INSERÇÃO ............................................................................................................................. 32
16.4 PESQUISA SEQUENCIAL ..................................................................................................................................... 32
17. EXERCÍCIOS........................................................................................................................................................... 33
V PROGRAMAÇÃO ORIENTADA POR OBJECTOS .............................................................................................. 34
18. OBJECTOS E EVENTOS ....................................................................................................................................... 34
APÊNDICE A. EXEMPLOS DO PNEU FURADO E DA LÂMPADA FUNDIDA .................................................... 37
II
I INTRODUÇÃO À INFORMÁTICA
1. CONCEITOS GERAIS
• Dados: Informação automatizável. Diz-se automatizável, se pode ser sujeita a um conjunto de
operações repetitivas.
A informação ou é útil ou não interessa: Para a informação ser útil, é essencial que os
dados recolhidos nos conduzam a resultados utilizáveis.
OPERAÇÕES
DADOS SOBRE RESULTADOS
DADOS
• Definição de Informática: A informática (Informação Automática) é a ciência do tratamento
racional, nomeadamente por processos automáticos, da informação, considerada como suporte
do conhecimento humano e da comunicação nos diferentes domínios da actividade humana.
• Ciclo de informação
Recolha Classif. Saída Utilização
Processa-
de e de de
mento
Dados Entrada resultados Resultados
Pré Processamento Pós

processamento processamento
• O que caracteriza os dados?
• conteúdo
• estrutura
• tipo
Erro! Estilo não definido.. Erro! Estilo não definido.
Quanto à estrutura e tipo, é necessário proceder a um estudo da sua composição e

interligações.
2. EVOLUÇÃO HISTÓRICA DOS COMPUTADORES

1ª Geração
• válvulas
• programação em linguagem máquina
• velocidade tratamento - 10-3 s (ms)
• grande aquecimento
• fraca fiabilidade
Exemplo: ENIAC - primeiro computador
2ª Geração
• Transístores e circuitos impressos
• Programação linguagem simbólica
• Velocidade - 10-6 s (µs)
• Memória por anéis de ferrite
• Aumento da fiabilidade
Exemplo: IBM 1401
3ª Geração
• Circuitos integrados
• Velocidade - 10-9 s (ns)
• Aumento da potência e fiabilidade
• Tratamento de dados à distância (telemática)
• generalização das linguagens evoluídas
Exemplo: IBM 360
4ª Geração
• Memória electrónica
• Velocidade - 10-12 s (pico segundo)
• Miniaturização (LSI e VLSI)
• Microprocessadores
• Queda de preços
Exemplo: Microcomputadores (PC)
5ª Geração
• Desencadeada por um programa japonês
• Massificação de sistemas e inteligência artificial
• Velocidade tratamento muito elevada
• Arquitecturas paralelas e distribuídas
3. REPRESENTAÇÃO DA INFORMAÇÃO
A representação da informação no computador está de acordo com o modo de funcionamento dos
computadores. Um programa é executado a partir da memória pricipal do computador. Sendo esta
um dispositivo digital de dois estados, ligado e desligado, então o sistema de numeração que
2
naturalmente se adequa para a representação da informação é o binário (ou base 2) em virtude de

ser constituído por apenas dois dígitos, o 0 e o 1, a que chamamos bits.
Antes de prosseguirmos, e para aqueles que estão mais “presos” ao sistema de numeração
decimal, base 10 (0 a 9), informamos que a única diferença entre estes dois sistemas é o conjunto
de dígitos de base.
Vejamos a numeração nos dois sistemas:
Decimal Em qualquer sistema esgotado o conjunto de base Binário
0 disponível constituem-se agrupamentos, como 0

1 forma de representar valores ainda maiores 1
2 Notar o agrupamento 10
3 11
4 Agora com três 100
5 101
6 110
7 111
8 Agora com quatro 1000
9 1001
10 Notar o agrupamento 1010
... ...
Também é possível realizar a conversão de valores de um sistema para o outro. Comecemos por
ver um exemplo.
Número a converter: 8910 (sistema de numeração decimal).
89 2
1 44 2
0 22 2
0 11 2
1 5 2
1 2 2
0 1 2
1 0
O número binário contrói-se com os restos obtidos, do último para o primeiro. Assim o
correspondente de 8910 em binário é 10110012.
A conversão de binário para decimal do valor obtido deve resultar em 89.
1 0 1 1 0 0 1
+ + + + + + 1*20 = 1
0*21 = 0
0*22 = 0
1*23 = 8
1*24 = 16
0*25 = 0
1*26 = 64
89
3
A conversão para o sistema de numeração decimal a partir de outros, e vice-versa, obedece

exactamente às mesmas regras, substituindo-se o valor 2 pelo do novo sistema.
Conversão de um número composto por m digítos numa qualquer base b (nm n3 n2 n1)b, para base
10:
N10, = nm * bm-1 + n3 *b3 + n2 b2 + n1 * b0
Em conclusão, a conversão entre dois sistemas de numeração quaisquer faz-se em dois passos;
primeiro conversão para decimal e só depois de decimal para o sistema pretendido.
4. EXERCÍCIOS
Exercício 1: Realize as seguintes conversões entre sistemas de numeração.

♦ Do número 1010100111112 para o sistema Hexadecimal(16).
♦ Do número 9AF16 para o sistema binário(2).
♦ Do número 1010100111112 para o sistema Octal(8).
4
II INTRODUÇÃO À
PROGRAMAÇÃO
5. RESOLUÇÃO DE PROBLEMAS EM INFORMÁTICA1

Uma afirmação como “calcule a nota mais elevada da turma na disciplina de Introdução à
Computação”, especifica o que pretendemos, mas é demasiado ambígua para poder ser resolvida
por um computador pois faltam detalhes tais como: que notas, onde estão, devem ou não ser
incluídos alunos ausentes, etc.
Deste modo a programação de computadores pode tornar-se difícil. No entanto, podemos torná-la
mais fácil. Tal pode ser feito se subdividirmos um problema sistematicamente em partes mais
pequenas e menos complexas chegando a um ponto em que compreendemos claramente cada uma
das partes. Essa é a fase de análise do problema. A partir daqui podemos, mais facilmente, indicar
sem ambiguidade os passos (algoritmo) para a solução do problema. Trata-se da fase de resolução
do problema. O algoritmo é portanto a solução do problema.
Os passos da nossa abordagem estruturada de desenvolvimento de aplicações são os seguintes:
1. Analisar o problema
a) Conhecer o problema: ouvir o problema, entendê-lo, perceber qual o objectivo.
b) Descrever o problema: subdividir o problema (esquematizar), detalhar.
c) Especificar os dados do problema.
2. Resolver o problema: escrever passo a passo o raciocínio da solução do problema;

verificar se não existe ambiguidade. O resultado deste passo é apresentado sob a forma
de estruturas de dados e do algoritmo.
3. Implementar: esta fase acontece apenas após o problema estar resolvido e consiste em
implementar o algoritmo numa linguagem de programação.
1 Para um estudo mais detalhado ver: “Ciência dos Computadores” de Tremblay e Bunt, McGraw-Hill.
O processo é descrito na figura seguinte. Aí pretende-se mostrar a dificuldade de caminhar

directamente do problema para a implementação.
Resolução Estr. de dados
Decomposição
do +
(Top-down) problema Algoritmo
Análise do Implementação do
problema Português Português problema
narrativo estruturado
Problema
(enunciado claro Programa
e preciso) Difícil ou
Impossível
Linguagem de
Programação
A dificuldade maior do processo de desenvolvimento encontra-se nas fases de análise e resolução

do problema, já que a implementação numa linguagem de programação é “directa” desde que
estejamos de posse da solução do problema.
O “top-down” assume frequentemente uma de duas formas: gráfica, através de caixas dispostas
hierarquicamente; ou narrativa indentada. Os algoritmos também são representados de uma de
duas formas, como se verá.
Exemplo 1.1 Elabore um algoritmo que permita a um robot efectuar a mudança do pneu furado de uma
viatura.
1ºTopDown (graficamente):
Substituição do
pneu furado
Colocar macaco
Ir buscar macaco Retirar pneu Guardar
em posição
+pneu furado e substituí- macaco+pneu
correta e elevar o
bom+chave lo furado+chave
carro
2º Resumo da Narrativa Identada: [Substituição pneu furado]

1. Buscar macaco, chave e pneu sobresselente
2. Colocar o macaco em posição correta e elevar o carro
3. Retirar o pneu furado e substituí-lo
4. Guardar o macaco, chave e o pneu furado
Para se resolver o problema seria necessário saber quais as operações elementares que o robot é
capaz de executar.
Definir as operações elementares:
dar passos
abrir ou fechar
pegar ou largar
rodar
6
deslocar no sentido ...

capacidade de decisão
Este problema e outro são apresentados em detalhe no Apêndice A. O tipo de problemas que
iremos encontrar são, no entanto, para implementação em computador. A implementação em
computador é feita usando linguagens que possuem um conjunto de operações elementares pré-
definidas, e uma sintaxe definida claramente.
Muitos dos problemas que se pretendem resolver são demasiado simples para valer a pena a sua
decomposição. No entanto, o passo 1.a) deverá ser sempre realizado. Esse passo consiste na
especificação dos dados do problema em Português antecedidos da expressão “Dados:”. Ter em
atenção que operações não são dados. Por exemplo, a soma enquanto resultado é um dado, mas a
operação soma não é. Os dados podem ter uma natureza distinta. Quanto à sua natureza vamos
considerar quatro tipos: entrada; saída; cálculo intermédio; e constantes.
Dados de entrada são dados fornecidos a partir do exterior da solução. Dados de saída são
fornecidos pela solução. Normalmente constituem o resultado da solução. Os dados intemédios
são dados que é necessário obter, para se chegar ao resultado, ou a outros dados intermédios, que
por sua vez permitirão obter o resultado. Os dados intermédios surgem frequentemente quando já
se está na resolução do problema. Constantes são valores fixos, como por exemplo pi. Os dados
de entrada sinalizam-se com uma seta virada para dentro ou com a letra E entre parêntesis. Os de
saída com uma seta virada para fora ou com a letra S entre parêntesis. As constantes com a letra C
entre parêntesis. Finalmente, os intermédios a sublinhado.
Supor o seguinte problema: Determinar a média das alturas de dois alunos da turma. Neste
problema os dados são as duas alturas e a média dessas alturas. Ou seja, existem três dados. A
especificação seria.
Dados: as duas alturas

A média das duas alturas
Poder-se-ia acrescentar a soma (resultados da soma) como quarto dado. Assim viria:
Dados: as duas alturas (E)

A média das duas alturas (S)
Soma
Em seguida passa-se à solução. Se for detectada a necessidade de mais dados então estes devem
ser incluídos na especificação, como aconteceu no exemplo da média das alturas.
Frequentemente a cada dado especificado irá corresponder uma variável no algoritmo.
6. ALGORITMOS
Os computadores apenas fazem aquilo que mandamos, pelo que não deve existir qualquer
ambiguidade nas instruções que damos ao computador. Assim, um algoritmo pode ser definido
como uma sequência ordenada, e sem ambiguidade, de passos que constituem a solução de um
dado problema. Por exemplo, as indicações dadas para se chegar a uma dada rua constituem um
algoritmo para se encontrar a rua. Então, algoritmo ´é sinónimo de solução de um problema.
7
É fundamental que os algoritmos possuam as seguintes propriedades: passos simples e sem

ambiguidade, numa ordem cuidadosamente definida; devem também ser eficazes, i.e., devem
resolver o problema num número finito de passos.
Os algoritmos também podem ser descritos de duas formas: português estruturado imbricado,
chamado pseudo-código; ou em notação gráfica, o chamado fluxograma. Estas formas de
representação dos algoritmos, que iremos utilizar ao longo do texto, são bastante rigorosas e
próximas das linguagens de programação.
No nosso pseudo código os algoritmos começam e terminam sempre pelas palavras chave INÍCIO
e FIM respectivamente. Enquanto em fluxograma se utiliza para ambas as situações um
rectângulo de cantos arredondados.
Entre as duas palavras INÍCIO e FIM colocam-se as instruções do algoritmo.
As instruções são executadas ordenadamente do INÍCIO para o FIM.
Palavras chave/símbolos Significado
Pseudo código:
INICIO representa o inicio do algoritmo
FIM representa o fim do algoritmo
LER Operação (procedimento) de leitura. Lê valores para
variáveis durante a execução do algoritmo
ESCREVER operação (procedimento) de escrita. Mostra resultados,
ou outras informações ao utilizador do algoritmo.
Fluxograma:
INÍCIO FIM o início e o fim respectivamente
Data
Document a leitura e escrita respectivamente2.
No caso dos fluxogramas, a ligação entre os símbolos faz-se através de setas, indicando qual a
ordem de execução das instruções, também chamado, o fluxo de controlo.
Em muitos dos problemas os dados possuirão uma estrutura simples, e, como tal, não haverá
necessidade de especificar as estruturas de dados.
7. TIPOS DE DADOS, VARIÁVEIS, OPERAÇÕES ELEMENTARES E

EXPRESSÕES
Os nossos programas de computador vão manipular dados. Estes podem variar de tipo. Por
exemplo, o nome de um aluno é um dado alfabético, enquanto as suas notas são do tipo numérico.
No computador tipos de dados diferentes têm representações também diferentes sendo
manipulados de forma distinta. Assim podemos considerar duas grandes classes de tipos de dados:
• A dos numéricos, que podem ser inteiros ou reais;
• As cadeias de caracteres, agrupamento contendo caracteres alfabéticos, algarismos ou
outros caracteres. As cadeias são representadas entre aspas. Também são conhecidas
por “strings”.
Variável
2 Por vezes usaremos apenas o primeiro para ambas as operações, mas com a indicação de qual a operação.
8
Geralmente é necessário guardar os dados manipulados pelo algoritmo (ou programa), durante a
sua execução. Para o efeito são utilizadas variáveis. Estas caracterizam-se por um nome, que se
inicia sempre por uma letra e deve ser o mais sugestivo possível. No computador, a cada variável
corresponde um determinado espaço da memória do computador. As variáveis devem ser
definidas antes de poderem ser utilizadas. A definição de uma variável corresponde à criação
dessa variável. Para definir, uma variável ir-se-á utilizar a palavra reservada Def, do seguinte
modo, ou, por outras palavras, a sua sintaxe é a seguinte.
Def nome {,nome...} : tipo
nome O nome da variável

tipo O tipo de dado que a variável representa (vai guardar).
Na apresentação da sintaxe, as chavetas significam que o que está no seu interior se pode ocorrer
zero ou mais vezes. No caso anterior implica que se podem definir simultaneamente várias
variáveis do mesmo tipo. Já os parêntesis rectos representam algo opcional.
Tipos fundamentais:
Inteiro
Real
Carácter
Cadeia de Caracteres (ou String)
Boleana
Atribuição
Os dados podem ser guardados nas variáveis, através da operação de atribuição (representada pelo
operador =), ou introduzidos directamente pelo utilizador (aquele que executa ou usa o algoritmo
ou programa que o programador desenvolveu) através de uma instrução de leitura (representada
pelo instrução LER). A atribuição faz-se da direita para a esquerda, isto é, o valor do lado direito
da atribuição é atribuído à variável que se encontra do lado esquerdo.
Media = 5 [coloca o valor 5 na variável media]
Num algoritmo, o texto entre parêntesis rectos é comentário, ou seja, não é executado, o que
significa que tem apenas interesse para quem escreve o algoritmo.
Na leitura, a variável indicada recebe o dado introduzido pelo utilizador; é uma forma de o
utilizador poder interagir com o programa.
Ler(idade) [guarda na variável idade o valor introduzido pelo utilizador]
Estas duas expressões são destrutivas, ou seja, o valor anterior na variável é substituído pelo
actual.
Num algoritmo não basta ler valores do mundo exterior, é também necessário fornece-los. Para tal
é utilizada a instrução ESCREVER.
Exemplo: Neste exemplo são adicionadas duas idades introduzidas pelo utilizador e visualizado o
resultado.
Escrever(“Introduza duas idades:”) [pede para o utilizador introduzir duas idades]
Ler(idade1, idade2) [assim que o utilizador introduzir as idades, estas são
guardadas em idade1 e idade2]
Soma=idade1+idade2 [adiciona as idades e atribui o resultado à variável soma]
[Comunica o resultado]
Escrever(“A soma das idades:”, idade1, “e “, idade2, “é igual a”, soma)
Supondo que as idades introduzidas eram 24 e 30 respectivamente, então o resultado da instrução

Escrever seria:
9
A soma das idades: 24 e 30 é igual a 54
A primeira vez que uma variável for utilizada deverá ser para receber um valor.
Operadores e Operações
Listam-se em seguida os vários operadores a utilizar, agrupados por tipo de operação:
Operador Descrição
Operador Atribuição
= atribui o valor à direita à variável à esquerda
Operadores Aritméticos:
+ adição
- subtracção
* multiplicação
/ divisão
% ou MOD módulo; resto da divisão de dois inteiros
Operadores Relacionais:
=, = = igualdade
<= menor que
>= maior que
<>, != desigualdade
Operadores Lógicos:
NEGAR negação
E conjunção
OU disjunção
Nas expressões aritméticas a avaliação faz-se dos operadores com maior precedência para os de
menor. A ordem de precedência dos operadores anteriores é a seguinte:
1. ^
2. * /
3. MOD
4. + -
5. = < > <= >=
6. NEGAR E OU
7. =
A utilização de parêntesis permite alterar a ordem de avaliação das expressões, dando prioridade
às que se encontram entre parêntesis.
No exemplo das idades foi utilizado o operador soma.
Soma=idade1+idade2 [adiciona as idades e atribui o resultado à variável soma]
Para além destes operadores existem também funções embutidas, isto é, que fazem parte da
linguagem, como por exemplo a função raiz quadrada, SQRT(valor).
z=SQRT(4) [calcula a raiz quadrada de 4 e atribui o resultado a z]
escrever(z) [mostra o valor em z]
10
8. ESTRUTURAS DE CONTROLO DE FLUXO

Existe um teorema em informática que diz que se pode escrever qualquer programa recorrendo a
apenas três formas de controlo do fluxo de execução de um programa; a sequência, a decisão e a
repetição. Os exemplos anteriores utilizavam a sequência e a repetição. Não vamos explicar neste
momento cada uma delas, deixando antes a sua apresentação depender da necessidade da sua
utilização para a resolução dos problemas que irão surgir.
8.1 SEQUÊNCIA
Execução sequencial significa que as instruções de um programa são executadas umas a seguir às
outras pela ordem em que se encontram no programa. A notação necessária para a elaboração de
algoritmos sequenciais é a seguinte:
Pseudo código:
A apresentada até agora.
Fluxograma:
Processamento
representa processamento
Isto quer dizer que o algoritmo para o problema da soma das idades deveria ser escrito da seguinte
maneira:
INICIO
Def idade1, idade2 : inteiro
Escrever(“Introduza duas idades:”) [pede duas idades ao utilizador]
Ler(idade1, idade2) [guarda-as em idade1 e idade2]
Soma=idade1+idade2 [adiciona-as e atribui o resultado a soma]
Escrever(“A soma das idades:”, idade1, “e “, idade2, “é igual a”, soma)
FIM
E em fluxograma:
INÌCIO
"Introduza duas
idades:"
idade1,
idade2
Soma=idade1+i
dade2
"A soma das idades:",

idade1, "e ", idade2,
"é igual a" soma
FIM
Exemplo 1.2 Um artista da nossa praça produz cubos de 2cm de aresta, que depois pinta com uma tinta
que adquire ao preço de 10€ por lata de 1,5dl. Com um dl de tinta o artista consegue pintar 5cm2 da
superfície de um cubo. Calcule quanto custa pintar um cubo inteiro (seja sistemático). Nota: área
do cubo = aresta*aresta*6
11
Resolução - Para a resolução do problema e partindo dos dados disponíveis,

aresta do cubo (2)
preço da lata (10)
tinta da lata (1,5)
capacidade de pintura por dl (5)
é necessário: determinar a área do cubo, em seguida qual a tinta necessária para pintar o cubo, o
número de latas necessárias para pintar o cubo e finalmente o custo de pintar o cubo. Viria então,
área=aresta^2*6 o que dá 24
tinta necessária=24/5 o que dá 4,8
número de latas=4,8/1,5 o que 3,2
custo= 3,2 *10€ o que resultaria num custo de 32€
Exemplo 1.3 Proceda às alterações ao algoritmo anterior, que entender necessárias para que todos os
dados possam ser indicados em cada execução do algoritmo (i.e., sem ter de refazer os cálculos).
Resolução - Consiste em substituir os valores (constantes) pelas variáveis. Assim, de cada vez que
o pintor quer calcular o custo, torna-se necessário perguntar quais os valores em causa. As
variáveis para os valores de entrada poderiam ser:
aresta - aresta do cubo
preço - preço da lata
tinta_lata - quantidade de tinta da lata
capacidade - capacidade de pintura por dl
O algoritmo resultante:
INÍCIO [Custo de pintar um cubo(dados variáveis)]
Def aresta, preco, tinta_lata, capacidade, tinta_necessaria, numero_de_latas,
custo: real
escrever(“Qual a aresta?)
ler(aresta)
escrever(“qual o preço de cada lata?”)
ler(preço)
escrever(“Qual a quantidade de tinta da lata?”)
ler(tinta_lata)
escrever(“Qual a capacidade de pintura, em cm2, por cada dl?”)
ler(capacidade)
área=aresta^2*6
tinta_necessária=área/capacidade
número_latas=tinta_necessária/tinta_lata
custo= número_latas*preço
escrever(“O custo de pintar o cubo é de: “, custo)
FIM
Relembrar que o texto entre parêntesis rectos é comentário, ou seja, não é executado, o que
significa que apenas interessa a quem escreve o algoritmo.
Exemplo 1.4 Elabore um algoritmo que leia um número inteiro representando segundos, e imprima o
seu correspondente em horas, minutos e segundos.
Exemplo: 3662s → 1h 1m 2s
8.2 DECISÕES
Por vezes e necessário tomar decisões que dependem de determinadas condições. Por exemplo,
imprimir os nomes dos clientes de um banco com um saldo superior a um certo valor. As decisões
são representadas em português estruturado e fluxograma das seguintes formas:
12
SE condição
Então
Bloco de instruções1 F Condição V
Senão
Bloco de instruções2
Fse
Bloco de Bloco de
instruções 2 instruções 1
Em que Bloco de instruções representa uma ou mais instruções.

Se a condição for verdadeira executa as instruções do Bloco de instruções1, se for falsa executa
Bloco de instruções2. Portanto executa apenas um dos blocos.
A condição condição pode ser simples ou composta (dijunções e/ou conjunções). As disjunções
representam-se por OU e as conjunções por E.
Exemplo 1.5 Considere agora, que o nosso artista também passou a produzir e pintar cilindros.
Reescreva o algoritmo desenvolvido anteriormente para permitir calcular o custo do cubo ou do
cilindro, conforme se pretender. Nota: área_da_base=(π*diâmetro^2)/4
,área_da_superfície=π*diâmetro*altura, área total=2*área_da_base+ área_da_superfície.
Resolução: Começar por determinar as estruturas de dados envolvidas (de entrada/saída) vai-nos
ajudar a resolver o problema. Para além dos dados anteriores, há a considerar o tipo de objecto,
cubo ou cilindro. A indicação do tipo de objecto é da responsabilidade do utilizador, pelo que a
resolução do problema passa por perguntar ao utilizador qual o tipo de objecto para que quer
calcular o custo de pintura. Consoante o objecto variam os dados a pedir ao utilizador e a forma
de cálculo da área. Isto é, após o utilizador introduzir o tipo de objecto é necessário optar por uma
das fórmulas de cálculo da área.
INÍCIO [Custo de pintar um cubo(dados variáveis)]
Def obj: inteiro; d, h, area_da_base, pi, preco, lata, capacidade,
tinta_necessaria, custo : real
Escrever(“Qual o objecto?”)
Escrever(“Introduza: 1 para cubo, 2 para cilindro”)
Ler(obj)
Se obj=1 [se utilizador escolheu cubo]
Então escrever(“Qual a aresta?)
ler(aresta)
área=aresta^2*6
Senão Escrever(“Diâmetro e altura?”)
Ler(d, h)
Pi=3,14
area_da_base =(pi*diâmetro^2)/4
area_da_superfície=pi*diâmetro*altura
área= area_da_base+ area_da_superfície
Fse
escrever(“qual o preço de cada lata?”)
ler(preço)
escrever(“Qual a quantidade de tinta da lata?”)
ler(tinta_lata)
escrever(“Qual a capacidade de pintura, em cm2, por cada dl?”)
ler(capacidade)
tinta_necessária=área/capacidade
número_latas=tinta_necessária/tinta_lata
custo= número_latas*preço
13
escrever(“O custo de pintar é de: “, custo)

FIM
Exercício 1.1 Este algoritmo pode ser melhorado no sentido de garantir que o custo apenas é
calculado nos casos de o utilizador introduzir o valor 1, ou o valor 2 para o tipo de objecto. Outra
melhoria poderia ser feita na mensagem com o custo, identificando o objecto para o qual se
calculou o custo. Realize as alterações necessárias ao algoritmo para introdução das melhoria
sugeridas.
Exemplo 1.6 Elabore um algoritmo (pseudo código e fluxograma) que, dados 3 números, todos
diferentes, determine e imprima o maior dos três.
Resolução: Determinar os dados envolvidos. Neste caso os 3 números e o maior dos três. Em
seguida elaborar o algoritmo.
INÍCIO
Início [Maior de 3 números]
Def A, B, C, maior : inteiro
escrever(“Introduza 3 números distintos:”)
ler(A,B,C) "Introduza três
Se A>B números:"
Então
Se A>C
Então maior=A
Senão maior=C A, B, C
Fse
Senão
Se B>C
Então maior=B
Senão maior=C
F A>B V
Fse
Fse
escrever(“O maior valor entre:”, A, “,”
, B,” e “, C, “é o “, maior) F B>C A>C V
FIM V F
maior=C maior=B maior=C maior=A
"O maior valor

entre",A,B,C, "é o", maior
FIM
Exemplo 1.7 Elabore um algoritmo (pseudo código e fluxograma) que, dados 3 números, todos
diferentes, determine e imprima o maior e o menor deles. Deve procurar determinar o menor
enquanto determina o maior.
Resolução: Determinar os dados envolvidos. Neste caso os 3 números, o maior e o menor dos três.
Em seguida elaborar o algoritmo.
Início [Maior e menor de 3 números]
escrever(“Introduza 3 números distintos:”)
ler(A,B,C)
Se A>B
14
Então
Se A>C
Então maior=A
Se B<C
Então menor=B
Senão menor=C
Fse
Senão maior=C
menor=B
Fse
Senão
Se B>C
Então maior=B
Se A<C
Então menor=A
Senão menor=C
Fse
Senão maior=C
menor=A
Fse
Fse
escrever(“O maior entre:”, A, “,”, B,” e “, C, “é o “, maior, “ O menor é o “,
menor)
FIM
Exercício 1.1 Desenvolva um algoritmo (pseudo código e fluxograma) que, dados 4 números,
calcule e imprima a diferença entre a soma dos dois maiores e a dos dois menores.
Exemplo 1.8 Elabore um algoritmo (pseudo código e fluxograma) que permita determinar se um
triângulo, dados os seus lados, é ou não rectângulo. Nota: Lembre-se do teorema de Pitágoras.
Resolução: Para um triângulo ser rectângulo é necessário que se verifique a igualdade do teorema
de Pitágoras, o que nos obriga a saber qual dos três lados é a hipotenusa e quais são os catetos.
Podemos então subdividir o problema em dois:
P1. Determinar a hipotenusa e os catetos
P2. Aplicar o teorema de Pitágoras
Como a hipotenusa será o maior dos três lados, então a resolução do primeiro subproblema passa
por determinar o maior dos 3 lados. Os catetos serão os dois lados restantes.
Os dados envolvidos são então: os 3 lados, a hipotenusa e os dois catetos.
Início [Triângulo rectângulo]
escrever(“Introduza os comprimentos dos 3 lados de 1 triângulo:”)
ler(A,B,C)
[P1. Determinar a hipotenusa(o maior) e os catetos(os restantes)]
Se A>B
Então
Se A>C
Então HIP=A
C1=B
C2=C
Senão hip=C
C1=A
C2=B
Fse
Senão
Se B>C
Então hip=B
C1=A
C2=C
Senão hip=C
C1=A
C2=B
Fse
Fse
[P2. Aplicar o teorema de Pitágoras]
15
escrever(“O triângulo de lados”, A, ”, ”, B, “ e ”, C)

Se hip^2 = c1^2 + c2^2
Então escrever(“ É Rectângulo)
Senão escrever(“ NÃO É Rectângulo)
FSe
FIM
8.3 REPETIÇÕES
Para além das decisões também é muito frequente surgir a necessidade de repetir instruções. Por
exemplo, ler as notas dos alunos da turma. As repetições podem assumir diferentes formas, aqui
consideraremos duas:
REPETIR ENQUANTO condição
Bloco de instruções
FENQ
O Bloco de instruções representa uma ou mais instruções.
A condição condição pode ser simples ou composta (dijunções e/ou conjunções). As disjunções
representam-se por OU e as conjunções por E.
A condição controla a execução do ciclo, ou seja, as instruções no interior do ciclo vão sendo
executadas repetidamente enquanto a condição for verdadeira. Quando a condição for falsa a
execução passa para a instrução imediatamente a seguir ao ciclo, isto é, após FENQ.
O controlo do número de execuções do ciclo é feito habitualmente de uma de duas formas:
- variável contadora, cujo valor vai aumentando/diminuindo até atingir um valor limite (ex: i<4).
Para isso é necessário colocar a instrução de incremento/decremento da variável como uma das
instruções do ciclo.
- bandeira, valor particular que quando ocorre torna a condição falsa (ex: a=0), aqui também é
necessário garantir que a variável poderá mudar de valor.
É necessário ter cuidado para que a condição não seja sempre verdadeira, pois tornaria o ciclo
infinito.
REPETIR PARA contador=início ATÉ fim PASSO valor
Bloco de instruções
FPARA
A segunda forma utiliza-se quando se pretende repetir uma ou mais instruções um número
determinado de vezes. Nesta construção a variável contadora, contador, é incrementada
implicitamente. O PARA é sempre convertível num ENQUANTO, o inverso nem sempre é
verdade.
A repetição representa-se em fluxograma utilizando o símbolo da decisão, como se segue.
Condição
F
V
Bloco de
instruções
Exemplo 1.9 Escreva um algoritmo (pseudo código e fluxograma) que permita calcular a média das
notas da turma na disciplina de Introdução à Computação.
16
Resolução - Decomposição do problema: saber o número de notas(alunos); somar as n notas;

calcular a média das n notas. Dados a considerar: as notas, o número de alunos, a sua soma e a
média.
Vamos considerar que o número de alunos é introduzido pelo utilizador do algoritmo que vamos
desenvolver. Para tal, necessitamos ler o número de alunos da turma.
escrever(“ Quantos alunos tem a turma?”)
ler(nalunos)
Em seguida ler as notas dos NALUNOS uma a uma e somá-la às anteriores. Para isso necessita-se
de uma variável que vá guardando as notas já somadas. Chamaremos a essa variável acumuladora
soma e ela terá que ser inicialmente colocada a zero (inicializada a zero).
soma=0
ler(nota)
Em seguida somar a nota à variável soma e atribuir o resultado a soma novamente.
soma=soma+nota [soma e depois atribui]
Como já guardamos a nota anterior, podemos utilizar a mesma variável nota para guardar a
próxima nota a ler.
ler(nota)
Em seguida somar a nota à variável soma e atribuir o resultado a soma novamente.
soma=soma+nota
E assim sucessivamente até ter lido e somado as nalunos notas.
Para saber quando é que já foram lidas todas as notas, é necessário uma variável de controlo, i.e,
uma variável que vá tomando valores desde 1 até nalunos, por exemplo chamada i. O algoritmo
seria então:
ler(nalunos)
soma=0
i=1
ler(nota)
i=i+1
ler(nota)
i=i+1
ler(nota)
......
até onde?
Não sabemos, porque o número de alunos só é conhecido no momento em que executarmos o
algoritmo. Mesmo que o soubéssemos, como se trata de repetir as mesmas duas instruções não
seria melhor que as mandássemos repetir enquanto i fosse menor ou igual a nalunos? Vejamos:
Repetir enquanto i<=nalunos
ler(nota)
i=i+1
Fenq
Desta forma, testa-se a condição (i<=nalunos) que se for verdadeira manda-se executar o bloco de
3 instruções. Executado este bloco, volta-se a testar a condição. Se ainda for verdadeira, é
novamente executado o bloco de 3 instruções. E assim sucessivamente, enquanto a condição for
verdadeira, ou seja enquanto não tiverem sido lidas todas as notas. Notar ainda a 3ª instrução do
bloco, pois sem ela o valor de i permaneceria inalterável.
O algoritmo final:
Início [Média das notas]
Def nalunos, i: inteiro; nota, soma, media: real
ler(nalunos)
soma=0
i=1
Repetir enquanto i<=nalunos
escrever(“Nota do “, i, “º aluno: “)
17
ler(nota)
i=i+1
Fenq
media=soma/nalunos
escrever(“A média das notas dos”, nalunos, “é de: “, media)
FIM
No algoritmo anterior o ciclo foi controlado através de uma variável (contadora). Se o número de
repetições não fosse conhecido, poder-se-ia controlar o ciclo através do surgimento de um valor
especial (bandeira), como se ilustra em seguida.
Exemplo 1.10 O algoritmo do exemplo anterior, sem ser conhecido o número de alunos. Neste caso
convencionou-se que o valor -1 significava o fim das notas.
Início [Média das notas]
Def nalunos, i: inteiro; nota, soma, media: real
nalunos=0
soma=0
escrever(“Nota do 1º aluno (-1 para terminar): “)
ler(nota)
Repetir enquanto nota<>-1
nalunos=nalunos+1
escrever(“Nota do “, i, “º aluno (-1 para terminar): “)
ler(nota)
Fenq
media=soma/nalunos
escrever(“A média das notas dos”, nalunos, “é de: “, media)
FIM
Exemplo 1.11 Desenvolva o algoritmo (pseudo código e fluxograma) que permita calcular a potência
inteira de um número.
Resolução: Notar que este problema, com execepção da soma e do elemento neutro,é em tudo
igual ao anterior, tratando-se agora da acumulação de produtos, o que obriga a iniciá-lo a 1
(elementro neutro da multiplicação).
Início [Potência de um número]
Def base: real; exo: inteiro
escrever(“Qual a Base e o Expoente?”)
ler(base, exp)
pot=1
i=1
Repetir enquanto i<=exp
pot=pot*base [multiplica e depois atribui]
i=i+1
Fenq
escrever(base, “^”, exp, “ = “, pot)
FIM
A versão deste algoritmo usando a construção PARA e o respectivo fluxograma, seriam:
Início [Potência de um número]

Def base: real; exo: inteiro
escrever(“Qual a Base e o Expoente?”)
ler(base, exp)
pot=1
Repetir Para i=1 Até exp Passo 1
pot=pot*base [multiplica e depois atribui]
Fpara
escrever(base, “^”, exp, “ = “, pot)
FIM
18
INÍCIO
"Qual a base e o
expoente?"
base, exp
pot=1
i=1
i<=exp
F V
pot=pot*base
i=i+1
base, "^", exp, "=", pot
FIM
Exemplo 1.12 Desenvolva o algoritmo (pseudo código e fluxograma) que permita calcular o factorial de
um dado número.
Exemplo 1.13 Elabore um algoritmo que dado número, crie um segundo que seja o primeiro invertido.
Inicio
Def n, inv, t Inteiro
Inv=0
Ler("Insira um numero: ", n)
t = n
Repetir Enquanto (t <> 0)
inv = inv*10 + t MOD10;
t = t/10;
}
escrever(inv)
Fim
Exemplo 1.14 Elabore um algoritmo (pseudo código e fluxograma) para determinar se um dado número é
ou não primo.
Resolução – Um número é primo se apenas for divisível por ele e pela unidade. Assim para se
determinar se um dado número é primo há que verificar se existe outro pelo qual ele seja divisível.
Isto implica exprimentar dividi-lo por todos os números entre 2 e o número menos 1. Na realidade
basta experimentar entre 2 e a raíz quadrada do número: [ 2 ; N ]
Início [Se número é primo]
Def num, D, Q, resto : inteiro
escrever(“Qual o número?”)
ler(num)
D=2 [divisor (1ºvalor do intervalo)]
Resto=1 [serve qualquer valor diferente de 0]
Repetir enquanto D<=SQRT(num) E resto<>0
Q=num/D
Resto=num-Q*D
D=D+1
19
Fenq
Se resto=0
Então escrever(“O número”, num, “ NÃO é Primo“)
Senão escrever(“O número”, num, “ É Primo“)
FSe
FIM
9. TRAÇAGEM
A traçagem consiste em testar um algoritmo para certos valores de entrada, observando o
comportamento interno do algoritmo para esses valores e ao longo dos vários passos que
compôem o algoritmo. Assim, a primeira etapa consiste em numerar os passos do algoritmo. Em
seguida constrói-se uma tabela colocando na primeira linha as entidades que queremos estudar ao
longo dos passos do algoritmo. Variáveis e condições, são as entidades que podem variar, e por
isso aquelas que devemos estudar. Depois é só executar os passos do algoritmo.
Exemplifiquemos para o algoritmo que permite determinar se um dado número é, ou não, primo,
começando por numerar os seus passos.
Início [Se número é primo]
Def num, D, Q, resto : inteiro
P1. escrever(“Qual o número?”)
P2. ler(num)
P3. D=2 [divisor (1ºvalor do intervalo)]
P4. Resto=1 [serve qualquer valor diferente de 0]
P5. Repetir enquanto D<=SQRT(num) E resto<>0
P6. Q=num/D
P7. Resto=num-Q*D
P8. D=D+1
Fenq
P9. Se resto=0
P10. Então escrever(“O número”, num, “ NÃO é Primo“)
P11. Senão escrever(“O número”, num, “ É Primo“)
FSe
FIM
Exemplificado para o número 5

Passos num D Resto D<=SQRT(num) Q Resto=0 Saída
E resto<>0
P1 número?
P2 5
P3 2
P4 1
P5 V
P6 2
P7 1
P8 3
P5 F
P9 F
P10 5 é Primo
FIM
20
10. MANIPULAÇÃO DE NÚMEROS INTEIROS

Por vezes é necessário aceder aos algarismos de um número, como por exemplo, na conversão de
bases. Uma forma consiste em aceder ao algarismos a partir do de menor pesso, o mais à direita.
O algarismo mais à direita pode ser obtido através do resto da divisão do número inteiro por 10.
Seguidamente, dividindo-se o número por 10 (divisão de inteiros) obtém-se um número já sem o
algarismo obtido. Depois é só repetir o processo para os restantes algarismos do número.
11. EXERCÍCIOS
Exercício 1.1 Considere a sequência de números de Fibonacci:

0, 1, 1, 2, 3, 5, 8, 13, 21, ...
Escreva um algoritmo que imprima os primeiros n números de Fibonacci.
Exercício 1.2 Desenvolva um algoritmo, para contar o número de vezes que surge o algarismo zero
num qualquer número inteiro introduzido pelo utilizador.
Exercício 1.3 Elabore um algoritmo que permita determinar, e imprima, o maior número e o menor
número de uma lista de n números introduzidos pelo utilizador.
Exercício 1.4 Desenvolva o algoritmo que permita calcular o valor do somatório com n introduzido
pelo utilizador.
Exercício 1.5 Escreva um programa que imprima o algarismo que se encontra numa dada posição de
um número inteiro. O número inteiro e a posição são introduzidos pelo utilizador.
Exercício 1.6 Em data remota, cerca de 3 séculos a.C., Euclides desenvolveu um método para ?, o
qual é utilizado no algoritmo seguinte:
INÍCIO
Def n1, n2, r : inteiro
Escrever (“Introduzir dois números: “)
Ler(n1, n2)
r = n1 % n2 [ % é o operador que permite obter o resto da divisão entre dois
inteiros]
Repetir enquanto r<>0
n1 = n2
n2 = r
r = n1 % n2
FENQ
Escrever(n2)
FIM
a) Após, escrever o respectivo fluxograma, e executar a “traçagem” utilizando os valores 25 e 15

como dados de entrada, diga qual pensa ser a finalidade do método que Euclides desenvolveu.
b) Converta o algoritmo para BASIC.
Exercício 1.7 [Frequência 17 de Fevereiro de 1997] Escreva um algoritmo que após ler um número
inteiro, troque os dígitos dos extremos do número (1º com o último).
21
Resolução:
Inicio [Troca dígitos extremos de um número inteiro]
Def N, MUL, TEMP, TROCADO Int
Ler(Enúmero?”, N)
Se N > 9 [Só troca se tiver mais de um algarismo]
Entao [Obtem o alg. da direita (o resto)]
DIGDIR = N MOD 10
TEMP = N
MUL = 1
[Reduz o numero (colocado em TEMP) a 2 algarismos]
Repetir Enquanto TEMP > 99
TEMP = TEMP \ 10
MUL = MUL * 10 '
FEnq
[Obtem o alg. da esquerda]
DIGESQ = TEMP \ 10
[Obtem o numero entre os algarismos extremos.Ex: N=2345 ->Meio=34]
MEIO = (N \ 10) MOD MUL
TROCADO = DIGDIR * MUL + MEIO
TROCADO = TROCADO * 10 + DIGESQ
Senao
TROCADO = N
FSe
Escrever("O número"; N; "trocado ="; TROCADO)
Fim
22
III SUBROTINAS
12. INTRODUÇÃO
Os algoritmos que vimos até agora eram constituídos apenas por um módulo, a que se chama
rotina principal, ou simplesmente rotina. No entanto, é possível criar rotinas que podem ser
chamadas dentro de outras rotinas. A essas rotinas que podem ser chamadas a partir de outras,
chama-se sub rotinas.
Vamos estudar dois tipos de sub rotinas, funções e procedimentos. A utilização de sub rotinas
permite modularizar os programas e encapsular processamento o que resulta em programas mais
simples de desenvolver e ler. Quanto mais independentes os módulos (sub rotinas) mais
atentamente nos podemos concentrar sobre cada uma ignorando os restantes.
Com a chamada de uma subrotina é transferido o controlo para essa sub rotina. A diferença entre
funções e procedimentos consiste no facto de as primeiras retornarem um valor, e as segundas
não.
As sub rotinas executam operações sobre dados que lhes são passados, pelo que as sub rotinas
possuem normalmente parâmetros. Por exemplo, a função embutida SQRT(valor) tem definido
um parâmetro, o do valor para o qual se pretende calcular a raiz quadrada. Quando se define na
sub rotina os dados que recebe, chama-se a esses dados parâmetros formais, ou simplesmente
parâmetros. Quando se fala desses dados na chamada (utilização) da sub rotina, chama-se
argumentos a esses dados.
As variáveis definidas nas sub rotinas são criadas no momento em que se inicia a execução da sub
rotina e destruídas no momento em que a sub rotina termina a sua execução.
13. FUNÇÕES
FUNCÃO nome_da_função ([lista_parâmetros]) : tipo
[bloco_instruções [nome = expressão]]
FIM [tb poderia ser utilizado FFUNC]
Nome_da_função O nome da funcão.
lista_parâmetros (Opcional) Uma ou mais variáveis que especificam os parâmetros a ser passados à
função quando esta é chamada. Caso não tenha parâmetros, os parêntesis surgem
vazios.
tipo O tipo de dado do valor a retor pela função.
expressão O valor a retornar pela função.
Bloco_instruções (Opcional) O conjunto das instruções contidas na sub rotina que permitem que esta
realize a operação para a qual foi concebida. Uma dessas instruções seria a atribuição à
função do valor a retornar (nome_da_função = expressão).
Quando uma função termina, “deixa ficar” no programa que a chamou o último valor atribuído ao
nome da função.
Exemplo 1.15 Desenvolva uma função que permita calcular o cubo de um número dado como argumento.
Em seguida escreva um programa que use essa função.
Resolução: O parâmetro da função será o número e a função retornará ao programa que a invoque
o cubo desse número.
FUNÇÃO cubo( num )
cubo=num*num*num
FFUNÇÃO
Agora o programa que a usa:

INÍCIO
Escrever(“Introduza um número:”)
Ler(n)
Escrever( “O cubo de “, n, “ = “, cubo(num) )
FIM
Executemos o programa por exemplo para o valor 3:

Entrada/Saída:
Introduza um número: 3
O cubo de 3 = 27
14. PROCEDIMENTOS
PROCEDIMENTO nome_do_procedimento([lista_parâmetros])
[bloco_instruções]
FIM [tb poderia ser utilizado FPROC]
nome O nome da procedimento.
lista_parâmetros (Opcional) Uma ou mais variáveis que especificam os parâmetros a ser passados ao
procedimento quando este é chamado. Caso não tenha parâmetros, os parêntesis surgem
vazios.
Bloco_instruções (Opcional) O conjunto das instruções contidas na sub rotina que permitem que esta
realize a operação para a qual foi concebida.
Exemplo 1.16 Escreva um procedimento que imprima um número inteiro pela ordem inversa.
Resolução:
24
PROCEDIMENTO impinvnum( num )

Repetir Enquanto num>0
Escrever( num MOD 10)
num=num/10 [divisão de inteiros]
FEnq
FPROC
14.1 FLUXOGRAMA
Para rotinas principais, foram vistos anteriormente quais os símbolos a utilizar. No caso de sub
rotinas, existem alguns símbolos específicos.
Símbolos Significado
INÍCIO Nome
Início. Utilizar preferencial/e o segundo
ou
FIM
Fim
Nome
Chamada da sub rotina na rotina principal
Entre o início e o fim colocam-se as instruções da sub rotina.
14.2 VARIÁVEIS LOCAIS E VARIÁVEIS GLOBAIS
Uma variável definida no interior de uma rotina diz-se local a essa rotina. Uma variável definida
fora da rotina, será global. Uma variável local apenas é reconhecida na rotina aonde foi
definida,enquanto uma variável global, é reconhecida em todas as rotinas do algoritmo.
14.3 EXERCÍCIOS
Exercício 1.1 Pretende-se calcular o mínimo múltiplo comum de dois números inteiros quaisquer.
a) Escreva uma sub rotina que determine e devolva o mínimo múltiplo comum de dois números
dados como argumentos.
b) Desenvolva um programa que, utilizando o sub algoritmo que desenvolveu na alínea anterior,
calcule o mínimo múltiplo comum de dois números inteiros introduzidos pelo utilizador.
25
IV VECTORES
15. INTRODUÇÃO
Suponha, que se pretendia desenvolver um programa que dadas as notas dos cerca de 4000 alunos
do ISEP, calculasse o desvio de cada uma relativamente à média das notas.
Para o cálculo dos desvios é necessário o cálculo prévio da média, o que implica manter as notas
após o cálculo da média, ou seja, guardar as notas em variáveis. Vamos começar por decompor o
problema, em sub problemas, como se segue:
Problema
Guardar as Calcular o desvio

Calcular a média
notas de cada nota
Uma solução para guardar cada uma das notas, seria definir 4000 variáveis, por exemplo:
nota_1, nota_2, nota_3, nota_4, nota_5, nota_6, nota_7, nota_8, nota_9, . . . , nota_4000.
Assim, as instruções para a leitura das notas seriam:
Escrever((“Introduza a média do aluno nº 1: “)
Ler(nota_1)
...
4000 vezes, o que se revela completamente impraticável. Seria preferível a possibilidade de
definir as 4000 variáveis de uma só vez, por exemplo da seguinte forma:
nota(1 até 4000)
em que nota(1) guardaria a nota do aluno 1, nota(2) a do aluno 2, e assim sucessivamente
fazendo variar o valor do índice até 4000. Mas utilizar constantes como índice continua a obrigar
a repetir as 4000 instruções. Então é necessário definir uma variável inteira para índice, por
exemplo:
num
Deste modo, para a leitura das 4000 notas, poder-se-ia utilizar um ciclo, como a seguir se ilustra:
REPETIR PARA num=1 Até 4000 Passo 1
Escrever(“Introduza a nota do aluno nº “, num)
Ler(nota(num))
FPara
15.1 DEFINIÇÃO
A solução anterior representa uma melhoria extraordinária relativamente à primeira solução. A
generalidade das linguagens de programação fornece este tipo de dados, chamado vector3.
Vector pode-se então definir como um conjunto de tamanho fixo de elementos do mesmo tipo
ocupando posições contíguas. Antes de se utilizar um vector, deve-se proceder à sua declaração,
cuja sintaxe é:
Def nome_vector( {fim | inicio ATÉ fim] )
Em que:
nome_vector é o nome do vector (escolhido pelo programador)
inicio é o valor início do índice
fim é o valor máximo do índice
Ao índice da primeira posição de um vector chama-se base do vector, que no caso de não ter sido
explicitado é zero.
O número de posições do vector é igual a fim menos início mais um, não sendo obrigatório
preencher todas as posições com valores.
O número de posições ocupadas pode ser feito de uma das seguintes formas:
− através de uma variável contendo este número,
− de uma flag (bandeira) na posição imediatamente a seguir à última ocupada, significando o
"fim" do vector.
Alguns exemplos de declaração de vectores:
Def notas(1 até 20)
Define um vector unidimensional chamado notas com 20 posições numeradas de 1 a 20.
Def notas(19)
Define um vector unidimensional chamado notas com 20 posições numeradas de 0 a 19.
Outro exemplo, mas de um vector bidimensional,
Def ecra(1 até 5, 1 até 10)
Define um vector bidimensional chamado ecra com 5 posições para primeira dimensão e 10
posições para cada uma das 5 posições da primeira dimensão. Vectores bidimensionais são usados
frequentemente para representar matrizes matemáticas. Visualizando:
1 2 3 4 5 6 7 8 9 10
1
2
3
4
5
3 Neste texto é usado o também o termo array para significar vector.
28
Um vector pode ter as dimensões que se pretenderem, fazendo-se a sua separação por vírgulas.
Exemplo 1.17 Os engenheiros químicos de um laboratório pretendem saber se existe diferença entre as
médias dos valores diurno e nocturno do PH de uma determinada solução. Para isso, durante o mês
de Janeiro, mediram, duas vezes por dia (uma medição de dia e outra à noite), o PH dessa solução.
Elabore um algoritmo que após ler os valores dos PH para dois vectores, permita responder à
dúvida dos engenheiros do laboratório.
Resolução:
Inicio
Def dia(31) Real, noite(31) Real, mdia Real, mnoite Real
Repetir Para i=0 Ate 30

Escrever(“Dia “, i+1)
Ler(“PH Diurno? “, dia(i))
Ler(“PH Nocturno? “, dia(i))
FPara
Mdia=0
Mnoite=0
Repetir Para i=0 Ate 30
mdia=mdia+dia(i)
mnoite=mnoite+noite(i)
Fpara
Escrever(”A média dos PH nocturnos é: “, mnoite/31, e a dos diurnos é: “,
mdia/31)
Fim
Exemplo 1.18 Considere que se pretende colocar uma moldura de zeros à volta dos valores de uma
matriz. Para isso elabore uma sub-rotina que copie uma dada matriz para uma segunda que deverá
incluir a moldura pretendida, como ilustrado na figura seguinte.
0 1 2 3 4 0 1 2 3 4 5 6
0 31 46 2 19 19 0 0 0 0 0 0 0 0
1 12 15 37 14 34 → 1 0 31 46 2 19 19 0
2 9 8 16 4 24 2 0 12 15 37 14 34 0
3 19 100 18 24 24 3 0 9 8 16 4 24 0
4 0 19 100 18 24 24 0
5 0 0 0 0 0 0 0
Nota: Assuma que a matriz destino possui o espaço necessário para a moldura, pelo que não deverá preocupar-se com
isso durante o desenvolvimento da sub-rotina.
Resolução: Resolução concebida a partir da saída (matriz destino), isto é o ciclo está pensado
para percorrer as posições da matriz destino aonde vai ficar a matriz origem.
Proc moldura(M1(,) Int, l Int, c Int, M2(,) Int)
Def l2 Int, c2 Int
l2=l1+2
c2=c1+2
Repetir para i=1 to l2-2 [1 á a segunda linha]
Repetir para j=1 to c2-2 [1 á a segunda coluna. Logo começa na 1,1]
M2(i,j)=M1(i-1,j-1)
Fpara
FPara
Fim Proc
29
15.2 PESQUISA
Vamos ver como pesquisar um certo valor num vector, através de um exemplo.
Exemplo 1.19 Elabore um programa que após determinar se um dado valor existe, ou não, num vector
escreva a respectiva mensagem.
Resolução: As estruturas de dados são o vector e o valor a procurar. Em primeiro lugar lêem-se
valores para o vector, em seguida faz-se a pesquisa. A pesquisa consiste em percorrer o vector até
encontrar o valor, se ele existir, ou até se chegar ao fim do vector. Como só faz sentido perguntar
se o valor foi encontrado no caso de ainda não se ter chegado ao final do vector, a ordem das
condições deverá ser trocada. A condição do ciclo que permite percorrer o vector será então:
não se chegou ao fim do vector E elemento do vector <> valor procurado
Quando uma destas condições for falsa, o ciclo terminará.
INÍCIO
Def val( 1 to 100)
Escrever(“Quantos valores?”)
Ler(n)
[Leitura de valores para o vector val]
Repetir Para i=1 até n
Escrever(“Valor?”)
Ler(val(i))
FPara
Escrever(“Qual o valor que pretende procurar?”)
Ler(procurado)
[Pesquisa de procurado]
i=1
Repetir Enquanto i<=n E val(i)<>procurado
i=i+1
FEnq
Se i<=n
Então Escrever(procurado, “ existe!”)
Senão Escrever(procurado, “ Não existe!”)
FSe
FIM
15.3 ELIMINAÇÃO
A eliminação de um elemento de um vector pode ser feita de duas formas distintas.
- Uma primeira consiste em colocar na posição do elemento a eliminar um valor impossível de
ocorrer.
- A segunda consiste em deslocar cada um dos elementos seguintes, ao que se pretende
eliminar, uma posição para baixo e actualizar o número de elementos do vector.
Exemplo 1.20 Do seguinte vector com n elementos pretende-se eliminar o elemento da posição índice 2:
31 5 46 19 47 12 ...
0 1 2 3 4 5
Após eliminação, resulta um vector de n-1 elementos:
31 5 19 47 12 ...
0 1 2 3 4
Para o primeiro método é necessário o vector, o elemento a eliminar e o número, Desenvolva o
algoritmo, em pseudo código, de uma sub rotina que dado um vector de notas de alunos, o seu
número de elementos e a posição do elemento a eliminar proceda à respectiva eliminação pelo
primeiro método.
30
15.4 EXERCÍCIOS
Exercício 1.1 Desenvolva o algoritmo, em pseudo código, de uma sub rotina que dado um vector de
notas de alunos, o seu número de elementos e a posição do elemento a eliminar proceda à
respectiva eliminação pelo segundo método.
Exercício 1.2 Elabore um algoritmo que permita eliminar o menor elemento de um vector
introduzido pelo utilizador. Pode utilizar rotinas que já tenha desenvolvido.
16. ORDENAÇÃO E PESQUISA

A ordenação de vectores e a pesquisa de um dado elemento num vector, são operações muito
comuns em programação. Por uma questão de simplificação serão utilizados vectores de números.
No entanto estes métodos poder-se-iam adaptar facilmente a vectores de outro tipo de dados.
16.1 ORDENAÇÃO POR TROCA DIRECTA

Neste tipo de ordenação comparar o primeiro elemento do vector com os restantes acima dele, e
sempre que se encontrar um menor (no caso de ordenação crescente) do que ele, procede-se à sua
troca. O processo repete-se para o segundo elemento, para o terceiro elemento, para o quarto, e
assim sucessivamente até ao penúltimo elemento do vector. No procedimento seguinte que
implementa este método vec é o vector a ordenar e num_elem o número de elementos do vector.
Este método é razoavelmente eficiente para pequenos e médios arrays.
[Passagem por referência; vector de inteiros; base do vector 0]
Proc OrdtTroca(vec(), num_elem: inteiro)
Rep Para i=0 to num_elem-2
Rep Para j=i+1 Até num_elem-1
Se vec(j)<vec(i)
Entao temp=vec(i)
vec(i)=vec(i)
vec(i)=temp
FSe
FPara
FPara
FProc
16.2 ORDENAÇÃO POR SELECÇÃO

O algoritmo do método de ordenação por selecção consiste em seleccionar repetidamente o menor
elemento dos que ainda não foram tratados, daí o nome do método. Pretendendo-se uma
ordenação por ordem crescente, primeiro selecciona-se o menor elemento do vector e faz-se a sua
troca com o elemento na primeira posição do vector, em seguida selecciona-se o segundo menor
elemento e faz-se a sua troca com o elemento na segunda posição do vector, repetindo-se o
processo até que todo o vector fique ordenado.
Como exercício elebore um procedimento que realize este tipo de ordenação.
31
16.3 ORDENAÇÃO POR INSERÇÃO

Na ordenação por inserção considera-se um novo elemento de cada vez. Este é inserido no seu
devido lugar entre os elementos já considerados, tendo-se o cuidado de os manter ordenados. Em
seguida é apresentado o seu algoritmo, no qual se considera que o vector se inicia na posição zero.
0. Considerar como parâmetros: o vector, o novo elemento e uma variável que indique
o número de elementos do vector.
1. Testar se vector existe. Isto ,é se o seu número de elementos é maior ou igual
que zero.
1.1 Testar se vector vazio.
1.1.1 Se sim então colocar o novo elemento na primeira posição.
1.1.2 Se não, puxar todos os elementos maiores que novo uma posição acima e
colocar o novo elemento na sua posição. Isto é:
1.1.2.1 Atribuir à posição índice i o elemento da posição índice i-1.
1.1.2.2 Repetir 1.1.2.1 Enquanto não percorrer todo o vector (i>0) e o novo
elemento fôr menor que o elemento na posição índice i.
1.1.2.3 Colocar o novo elemento na posição índice i.
1.2 Actualizar o número de elementos do vector.
2. Fim
16.4 PESQUISA SEQUENCIAL

Trata-se do método mais simples de pesquisa, e que consiste em pesquisar sequencial e
exaustivamente um vector na procura de um dado valor. O extracto de um algoritmo, que
executasse este método, na pesquisa num vector de números inteiros, poderia ter o seguinte
aspecto. Considera-se que vec é o vector a pesquisar, valor o valor procurado e num_elem o
número de elementos no vector que possui dim posições:
...
Def vec(dim) Int
...
i=0
Rep Enquanto i<num_elem E vec(i)<>valor
i=i+1
FEnq
Se i<num_elem
Entao Escrever(“Valor EXISTE no vector”)
Senao PRINT(“Valor NÃO existe no vector”)
FSe
...
32
17. EXERCÍCIOS
Exercício 1.3 Escreva um programa que permita determinar o maior valor (máximo) existente num
vector.
Exercício 1.4 Como sabe, podemos calcular a massa atómica (peso atómico) de um elemento, MAe,
a partir da massa atómica e abundância relativa de cada um dos seus isótopos, usando a seguinte
expressão:
∑ (MAi * Pi )
n
MAe – massa atómica do elemento e
MAi – massa atómica de cada isótopo
MA e = i =1 100
Pi – abundância relativa de cada isótopo (1-100)
Em que i varia entre 1 e o número de isótopos, n.
a) Desenvolva o algoritmo duma sub rotina que realize o somatório do numerador e devolva o
resultado. O algoritmo terá como parâmetros: dois vectores (um contendo os MAi e o outro os
Pi) e o seu número de elementos (isótopos), n.
b) Escreva um algorimto que calcule o peso atómico de um elemento, MAe. Para tal, utilize o sub
algoritmo que desenvolveu na alínea anterior.
Exercício 1.5 Numa matriz, um mínimo local é o valor que tem à sua volta apenas valores superiores
a si próprio. Elabore uma sub-rotina que dada uma matriz de números reais maiores ou iguais a
zero, determine os seus mínimos locais colocando-os num vector, e no final devolva o número de
mínimos encontrados. Tanto a matriz como o vector deverão ser parâmetros da sub-rotina a
desenvolver. Para simplificação considere que a matriz possui uma orla a zeros, que, obviamente,
não devem ser considerados como possíveis mínimos.
Exemplo: Matriz de 6 linhas por 7 colunas.
0 1 2 3 4 5 6 0 1 2
0 0 0 0 0 0 0 0 → 8 2 4
1 0 31 46 2 19 19 0
2 0 12 15 37 14 34 0
3 0 9 8 16 4 24 0
4 0 19 100 18 24 24 0
5 0 0 0 0 0 0 0
Resolução: A sub rotina deverá ser uma função porque se pretende que retorne um valor (o número de
mínimos). A função tem como parâmetros a matriz, os números de linhas e colunas da matriz e ainda o
vector que irá conter os mínimos. A solução seguinte, pode ser considerada, uma solução do tipo “força
bruta”, no entanto, é bastante clara.
Função Mininos(x(,) Real, l int, c int, Min() Real) Int
Def p Int [variável para índice do vector que guardará mínimos]
p=0
[Os dois ciclos que permitem “percorrer” a matriz, ignorando a orla]
Repetir para i=1 to l-2
Repetir para j=1 to c-2
[Procura mínimo: na 1ª linha compara posição actual com posições da linha
acima, depois compara com posições da linha abaixo, e finalmente compara
com as duas posições da sua própria linha]
if x(i,j)<x(i-1,j-1) E x(i,j)<x(i-1,j) E x(i,j)<x(i-j,j+1) E

x(i,j)<x(i+1,j-1) E x(i,j)<x(i+1,j) E x(i,j)<x(i+1,j+1) E
x(i,j)<x(i,j-1) E x(i,j)<x(i,j+1)
Então
Min(p)=x(i,j)
p=p+1
FSe
FPara
Fpara
Minimos=p
Fim função
Exercício 1.6 Suponha que as notas dos alunos de duas turmas são lidas para dois vectores, um para
cada turma. Considere que as notas foram inseridas em ambos os vectores ordenadamente, da
menor para a maior. Escreva um programa que “funda” ordenadamente os dois vectores de notas
num terceiro.
Exercício 1.7 Uma área abaixo de uma dada curva pode ser aproximada a partir de n pontos (x1,y1),
(x2,y2), ..., (x2,y2), definindo-se pequenos rectângulos e calculando-se a área destes rectângulos.
Supondo que os valores de x estão igualmente espaçados e que o número de pontos é ímpar a área
pode ser aproximada através da regra de Simpson, cuja equação é a seguinte:
Area = ( y1 + 4 y 2 +2 y3 + 4 y4 + 2 y5 + ... + yn )d / 3
em que d é a distância entre dois valores sucessivos de x. Elabore um algoritmo que calcule a
área aproximada sob a curva y = e x , para x a variar entre 0 e 1 (e = 2.718281828).
V PROGRAMAÇÃO ORIENTADA
POR OBJECTOS
18. OBJECTOS E EVENTOS

Objecto é uma entidade que possui um estado e um conjunto definido de operações que operam
nesse estado [Sommerville]. As seguintes entidades têm atributos e realizam operações que os
fazem mudar de estado. As operações são desencadeadas por outras entidades (ex: pessoas). O
estado é representado pelo conjunto de atributos do objecto.
34
Resumindo, um objecto:
• Possui propriedades e métodos.
• Para se usar um objecto, este deve ser previamente identificado.
• Existe um conjunto de eventos que o objecto reconhece.
Cada objecto é definido como um caso particular (uma instância) de uma dada classe de objectos.
Por outras palavras, um objecto é como uma variável de um dado tipo (classe). Assim, para
criarmos os nossos proprios objectos, há que definir em primeiro lugar a respective classe.
Propriedade, é um atributo do objecto (o valor das propriedades definem o estado do objecto).
Ex: altura, largura. Para alterar uma propriedade atribui-se um novo valor a essa propriedade.
Método, é uma operação que um objecto pode realizar.
Para se aceder a uma propriedade ou método:
Objecto.{propriedade | método}
Exemplo 1.21 Mudar a côr de um objecto Carro1, do tipo carro para azul. Assumir que a classe de
objectos carro possui uma propriedade cor que contéma côr do carro. Mudar a côr de um carro
chamado carro1, consistirá em atribuir o valor pretendido da côr à sua propriedade cor.
Carro1.cor= Azul
Exemplo 1.22 Sub-rotina definida pelo utilizador que move o botão command1 para a posição x,y. dada
como argumento.
Procedimento MoveBotao(x,y)
Command1.Move x, y
FProc
Pode-se obter o valor de uma propriedade. O exemplo seguinte permite visualizar o valor da
propriedade caption de um etiqueta chamada Label1.
Escrever(Label1.Caption)
Algumas propriedades não podem ser alteradas, são apenas de leitura (“read only”).
Evento (ou acontecimento), é uma acção que um objecto pode reconhecer, e que ocorre em
consequência da acção do utilizador, desencadeada pelo sistema, ou por acção do programa.. Ex:
Premir o botão do “rato” sobre um botão. Em resposta ao evento podem-se desencadear acções.
Estas acções correspondem a sub-rotinas.
Vamos convencionar o seguinte: para fazer com que um objecto reaja a um evento, escreve-se
uma sub-rotina cujo nome é formado pela associação do nome do objecto, o carácter “_” e o nome
do evento.
Exemplo: Clicar um botao chamdo botao1, existente numa janela,
Procedimento botao1_clicar()
35
FProc
O código correspondendo às acções a executar seria colocado no interior do procedimento.

Duas das características da Programação Procedimental são: o código pede entrada de dados; e o
fluxo de execução é determinístico, no sentido de determinado pelo código. Na programação
orientada por eventos: as entradas de dados invocam código; e o fluxo de execução é determinado
pelos eventos (não-determinístico).
36
APÊNDICE A. EXEMPLOS DO
PNEU FURADO E DA LÂMPADA
FUNDIDA
Exemplo 1.23 Elabore um algoritmo que permita a um robot efectuar a mudança do pneu furado de uma
viatura.
1ºTopDown (graficamente):
Substituição do
pneu furado
Colocar macaco
Ir buscar macaco Retirar pneu Guardar
em posição
+pneu furado e substituí- macaco+pneu
correta e elevar o
bom+chave lo furado+chave
carro
2º Definir as operações elementares:

dar passos
abrir ou fechar
pegar ou largar
rodar
deslocar no sentido ...
3º Narrativa Identada: [Substituição pneu furado]
1. [Buscar macaco, chave e pneu sobresselente]
1.1 Repetir até chegar ao carro
1.1.1 Dar passos
1.2 Abrir a mala
1.3 Pegar macaco, chave e pneu bom
1.4 Repetir até chegar ao pneu furado
1.4.1 Dar passos
2. [Colocar o macaco em posição correta e elevar o carro]

2.1 Largar o pneu e a chave
2.2 Encaixar macaco
2.2.1 Deslocar o macaco no sentido do carro até encaixar

2.3 Elevar o carro
2.3.1 Repetir até carro elevado
2.3.1.1 Rodar manivela no sentido horário
3.[Retirar o pneu furado e substituí-lo]
3.1 Pegar na chave
3.2 Repetir quatro vezes
3.2.1 Deslocar a chave até encaixar na porca
3.2.2 Repetir até porca cair
3.2.2.1 Rodar sentido anti-horário
3.3 Largar chave
3.4 Pegar no pneu furado
3.5 Deslocá-lo sentido contrário ao carro
3.6 Largar pneu furado
3.7 Pegar no pneu bom
3.8 Deslocar pneu no sentido do carro
3.9 Encaixar pneu
3.10 Pegar na chave
3.11 Repetir quatro vezes
3.11.1 Pegar na porca
3.11.2 Encaixar porca
3.11.3 Pegar chave
3.11.4 Repetir até ficar apertado
3.11.4.1 Rodar no sentido horário
3.12 Largar chave
4. [Guardar o macaco, chave e o pneu furado]

4.1 Baixar o carro
4.1.1 Rodar manivela no sentido contrario ao horário
4.2 Desencaixar macaco
4.3 Pegar pneu furado+macaco+chave
4.4 Repetir até à mala
4.4.1 Dar passos
4.5 Largar chave+macaco+pneu furado
4.6 Fechar mala
[FIM]
Exemplo 1.24 Elabore um algoritmo que permita a um robot efectuar a mudança de uma lâmpada
fundida.
1ºTopDown: Substituição da lâmpada fundida

1. Preparar acessos à lâmpada fundida
2. Retirar lâmpada fundida
3. Escolher lâmpada nova
4. Colocação da lâmpada nova
5. Arrumar escada
2º Definir as operações elementares:

dar passos
subir/descer degraus
pegar/largar objectos
rodar objectos sentido directo/indirecto
3º Narrativa Identada (Algoritmo):

1. [Preparar acessos à lâmpada fundida]
1.1 Repetir enquanto não chegar à escada
1.1.1 Dar passos
1.2 Pegar objecto (escada)
1.3 Repetir enquanto não chegar debaixo lâmpada fundida
1.3.1 Dar passos
2. [Retirar lâmpada fundida]
2.1 Repetir enquanto não chegar à lâmpada fundida
38
2.1.1 Subir degraus

2.2 Repetir enquanto não soltar a lâmpada fundida
2.2.1 Rodar objecto(L.F.) no sentido indirecto
2.3 Repetir enquanto não chegar ao chão
2.3.1 descer degraus
3.[Escolher lâmpada nova]
3.1 Repetir enquanto não chegar junto gaveta das lâmpadas novas
1.3.1 Dar passos
3.2 Repetir enquanto houver lâmpadas novas ou potência L.N. diferente de potência
L.F.
3.2.1 Pegar objecto (L.N.)
3.2.2 Se potência L.N. = Potência L.F.
3.2.2.1 Então largar a L.F.
3.2.2.2 Senão largar a L.N.
4. [Colocação da lâmpada nova]
4.1 Repetir enquanto não chegar à escada
4.1.1 Dar passos
4.2 Repetir enquanto não chegar ao casquilho
4.2.1 Subir degraus
4.3 Repetir enquanto não firmar a lâmpada nova
4.3.1 Rodar objecto(L.N.) no sentido directo
4.4 Repetir enquanto não chegar ao chão
4.4.1 descer degraus
5. [Arrumar escada]
5.1 Pegar objecto(escada)
5.2 Repetir enquanto não chegar ao sítio da escada
5.2.1 Dar passos
5.3 Largar objecto (escada)
6. [FIM]
39

ALG Sebenta

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

ALG Sebenta

Uploaded by

Copyright:

Available Formats

Instituto Superior de Engenharia

Departamento de Engenharia Informática (DEI)

Isabel Sampaio e Alberto Sampaio

Texto de Apoio para disciplinas de Algoritmia e Programação

I INTRODUÇÃO À INFORMÁTICA ............................................................................................................................. 1

2. EVOLUÇÃO HISTÓRICA DOS COMPUTADORES........................................................................................... 2

3. REPRESENTAÇÃO DA INFORMAÇÃO .............................................................................................................. 2

II INTRODUÇÃO À PROGRAMAÇÃO ......................................................................................................................... 5

5. RESOLUÇÃO DE PROBLEMAS EM INFORMÁTICA ...................................................................................... 5

7. TIPOS DE DADOS, VARIÁVEIS, OPERAÇÕES ELEMENTARES E EXPRESSÕES.................................... 8

8. ESTRUTURAS DE CONTROLO DE FLUXO ..................................................................................................... 11

10. MANIPULAÇÃO DE NÚMEROS INTEIROS ..................................................................................................... 21

III SUBROTINAS ............................................................................................................................................................ 23

12. INTRODUÇÃO ........................................................................................................................................................ 23

14. PROCEDIMENTOS ................................................................................................................................................ 24

15. INTRODUÇÃO ........................................................................................................................................................ 27

V PROGRAMAÇÃO ORIENTADA POR OBJECTOS .............................................................................................. 34

18. OBJECTOS E EVENTOS ....................................................................................................................................... 34

APÊNDICE A. EXEMPLOS DO PNEU FURADO E DA LÂMPADA FUNDIDA .................................................... 37

Pré Processamento Pós

Quanto à estrutura e tipo, é necessário proceder a um estudo da sua composição e

2. EVOLUÇÃO HISTÓRICA DOS COMPUTADORES

naturalmente se adequa para a representação da informação é o binário (ou base 2) em virtude de

Decimal Em qualquer sistema esgotado o conjunto de base Binário

0 disponível constituem-se agrupamentos, como 0

A conversão para o sistema de numeração decimal a partir de outros, e vice-versa, obedece

Exercício 1: Realize as seguintes conversões entre sistemas de numeração.

5. RESOLUÇÃO DE PROBLEMAS EM INFORMÁTICA1

2. Resolver o problema: escrever passo a passo o raciocínio da solução do problema;

O processo é descrito na figura seguinte. Aí pretende-se mostrar a dificuldade de caminhar

A dificuldade maior do processo de desenvolvimento encontra-se nas fases de análise e resolução

2º Resumo da Narrativa Identada: [Substituição pneu furado]

2. Colocar o macaco em posição correta e elevar o carro

3. Retirar o pneu furado e substituí-lo

4. Guardar o macaco, chave e o pneu furado

deslocar no sentido ...

Dados: as duas alturas

Dados: as duas alturas (E)

Frequentemente a cada dado especificado irá corresponder uma variável no algoritmo.

É fundamental que os algoritmos possuam as seguintes propriedades: passos simples e sem

7. TIPOS DE DADOS, VARIÁVEIS, OPERAÇÕES ELEMENTARES E

nome O nome da variável

Supondo que as idades introduzidas eram 24 e 30 respectivamente, então o resultado da instrução

A soma das idades: 24 e 30 é igual a 54

8. ESTRUTURAS DE CONTROLO DE FLUXO

"A soma das idades:",

Resolução - Para a resolução do problema e partindo dos dados disponíveis,

Em que Bloco de instruções representa uma ou mais instruções.

escrever(“O custo de pintar é de: “, custo)

maior=C maior=B maior=C maior=A

"O maior valor

escrever(“O triângulo de lados”, A, ”, ”, B, “ e ”, C)

Resolução - Decomposição do problema: saber o número de notas(alunos); somar as n notas;

A versão deste algoritmo usando a construção PARA e o respectivo fluxograma, seriam:

Início [Potência de um número]

base, "^", exp, "=", pot

Exemplificado para o número 5

10. MANIPULAÇÃO DE NÚMEROS INTEIROS

Exercício 1.1 Considere a sequência de números de Fibonacci:

a) Após, escrever o respectivo fluxograma, e executar a “traçagem” utilizando os valores 25 e 15

Agora o programa que a usa:

Executemos o programa por exemplo para o valor 3:

PROCEDIMENTO impinvnum( num )

Entre o início e o fim colocam-se as instruções da sub rotina.