P. 1
Apostila_Algoritmos II

Apostila_Algoritmos II

|Views: 2.326|Likes:
Publicado porMichel Ramos

More info:

Published by: Michel Ramos on Oct 23, 2010
Direitos Autorais:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as DOC, PDF, TXT or read online from Scribd
See more
See less

07/17/2013

pdf

text

original

Sections

  • PLANO DE CURSO
  • Objetivo
  • Ementa
  • Metodologia
  • Avaliação
  • Referências
  • Recursos/Material de Apoio
  • INTRODUÇÃO
  • Conceitos
  • Métodos de Desenvolvimento de Algoritmos
  • Fluxogramas
  • Pseudocódigos Portugol
  • COMPILADOR DE ALGORITMOS VISUALG
  • Exercícios
  • Linearização de Expressões
  • Operadores Aritméticos
  • Operadores Aritméticos não convencionais
  • Operadores Relacionais
  • Operadores Lógicos
  • Tabela Verdade
  • Prioridade dos operadores
  • Modularização de Expressões
  • Expressões Lógicas
  • Primeiros Elementos da Linguagem
  • Identificadores
  • Regras para a nomeação de identificadores
  • Variáveis
  • Declaração de Variáveis
  • Tipos Primitivos de Dados
  • Sinal de Atribuição
  • Comandos de E/S (Entrada/Saída)
  • Linhas de Comentário
  • Estruturas Seqüenciais - Construindo os Primeiros Algoritmos
  • Estrutura Condicional
  • Tipos de comandos condicionais
  • Testando o Algoritmo
  • Regras Práticas para Construir Algoritmos Legíveis
  • Exercício resolvido
  • Estrutura de Repetição
  • Repita..Até
  • Enquanto..Faca
  • Para..Faca
  • Exercícios de Algoritmos com Repetição
  • Variáveis Compostas Homogêneas
  • Variáveis Indexadas Unidimensionais (Vetores)
  • Declaração de Vetores
  • Atribuindo Valores a Elementos do Vetor
  • Exercícios sobre Vetores
  • Ordenação de Vetores
  • Variáveis Indexadas Multidimensionais (Matrizes)
  • Atribuindo Valores a Elementos da Matriz bidimensional
  • Anexo I – Lista de exercícios resolvidos
  • Seção 3.8
  • Exercício 6
  • Exercício 8
  • Exercício 15
  • Seção 3.10
  • Exercício 5
  • Exercício 11
  • Seção 3.11.1.2

FACULDADE DA REGIÃO SERRANA

SISTEMAS DE INFORMAÇÃO
ALGORITMOS II
Prof.: EMERSON PEDREIRA MATOS
Versão: JUL/2010
ÍNDICE
PLANO DE CURSO.........................................................................1
Objetivo.......................................................................................1
Ementa........................................................................................1
Metodologia ................................................................................1
Avaliação ....................................................................................1
Referências..................................................................................1
Recursos/Material de Apoio...........................................................1
INTRODUÇÃO................................................................................2
Conceitos.....................................................................................2
Métodos de Desenvolvimento de Algoritmos..................................3
Fluxogramas................................................................................3
Pseudocódigos Portugol...............................................................4
COMPILADOR DE ALGORITMOS VISUALG........................................5
Exercícios....................................................................................6
Linearização de Expressões...........................................................7
Operadores Aritméticos ...............................................................7
Operadores Aritméticos não convencionais....................................7
Operadores Relacionais ...............................................................7
Operadores Lógicos .....................................................................8
Tabela Verdade............................................................................8
Prioridade dos operadores............................................................8
Modularização de Expressões .......................................................8
Expressões Lógicas ......................................................................8
Exercícios....................................................................................9
Primeiros Elementos da Linguagem ............................................10
Identificadores ..........................................................................11
Regras para a nomeação de identificadores.................................11
Variáveis ...................................................................................11
Declaração de Variáveis .............................................................12
Tipos Primitivos de Dados ..........................................................13
Sinal de Atribuição ....................................................................13
Comandos de E/S (Entrada/Saída) ...............................................13
Linhas de Comentário ................................................................14
Estruturas Seqüenciais - Construindo os Primeiros Algoritmos......15
Exercícios ..................................................................................17
Estrutura Condicional.................................................................19
Tipos de comandos condicionais..................................................21
Testando o Algoritmo..................................................................23
Regras Práticas para Construir Algoritmos Legíveis......................24
Exercício resolvido......................................................................24
Exercícios – Resolver os algoritmos de números pares na forma de
pseudocódigo e os ímpares na forma de fluxogramas...................27
Estrutura de Repetição...............................................................29
Repita..Até ................................................................................29
Enquanto..Faca ..........................................................................30
Para..Faca .................................................................................31
Exercícios de Algoritmos com Repetição......................................33
Variáveis Compostas Homogêneas...............................................36
Variáveis Indexadas Unidimensionais (Vetores) ...........................37
Declaração de Vetores ...............................................................37
Atribuindo Valores a Elementos do Vetor............................................37
Exercícios sobre Vetores.............................................................38
Ordenação de Vetores.................................................................39
Variáveis Indexadas Multidimensionais (Matrizes) .......................39
Atribuindo Valores a Elementos da Matriz bidimensional..............40
Exercícios...................................................................................41
Anexo I – Lista de exercícios resolvidos........................................42
Seção 3.8...................................................................................42
Exercício 6......................................................................................................................42
Exercício 8......................................................................................................................42
Exercício 15....................................................................................................................43
Seção 3.10.................................................................................45
Exercício 5......................................................................................................................45
Exercício 8......................................................................................................................46
Exercício 11....................................................................................................................46
Exercício 15....................................................................................................................47
Seção 3.11.1.2............................................................................48
Exercício 6......................................................................................................................48
1
PLANO DE CURSO
Nome da disciplina: Prática Pedagógica VI - Informática na Educação II
Carga Horária Total: 80 horas/aulas
Objetivo
Esta disciplina tem por objetivo fornecer subsídios técnicos e práticos na
construção de algoritmos e desenvolvimento de programas, utilizando uma
ferramenta de compilação de algoritmos (Visualg 2.0), e uma linguagem de
programação científica, nos moldes das necessidades dos cursos de
Matemática (MATLAB 7.0).
Ementa
 Os conceitos de Lógica de Programação;
 Ferramentas de desenvolvimento:
 Pseudocódigo – PORTUGOL;
 Fluxogramas;
 Compilador de Algoritmos: Visualg 2.0
 Tipos básicos de variáveis;
 Declaração de variáveis;
 Comandos de atribuição;
 Operadores Aritméticos, Lógicos e Relacionais;
 Comandos de E/S;
 Comandos Alternativos;
 Estruturas de repetição;
 Vetor;
 Matriz;
Metodologia
Aulas expositivas, aulas práticas em laboratório, dinâmica de grupo, seminários, estudos de caso;
Avaliação
Testes diagnósticos;
Provas formativas;
Trabalhos em grupo (teóricos);
Trabalhos em grupo (práticos em laboratório);
Referências
1 – Guimarães/Lages – Algoritmos e Estruturas de Dados - Livros Técnicos e Científicos Editora
S.A.
2 - Pinto, Wilson Silva - Algoritmos e Estruturas de Dados - Ed. Erika.
3 - Villar, André/Eberspcaher, Henri F. – Lógica de Programação. Ed. Makron Books.
4 - Farrer/Becker/Faria/Matos/Maia – Algoritmos Estruturados - Ed. Guanabara.
Recursos/Material de Apoio
2
Quadro e pincel. Retroprojetor e transparências. Fontes bibliográficas e
Apostilas. Laboratório contendo softwares necessários (Visualg 2.0 e Matlab
7.0)
INTRODUÇÃO
O COMPUTADOR é uma máquina capaz de fornecer a solução de um problema executando um
roteiro com grande velocidade. Esse roteiro deve ser o mais detalhado possível, cercando todas as
condições possíveis de acontecer, pois o computador não tem a capacidade de decidir por si só. Esse
roteiro deve ser escrito em uma linguagem aceita pela maquina e que em sua fase final é chamado
de PROGRAMA. A fase inicial, de definição dos passos a serem seguidos e dos desvios a serem
considerados na solução de um problema, independe da linguagem de programação que será
utilizada. Nesta fase o roteiro é chamado de ALGORITMO, e muitos métodos podem ser utilizados
para defini-los.
Então a utilização de um computador para resolver um problema exige, antes de mais nada, que se
desenvolva um algoritmo, isto é, que se faça descrição de um conjunto de comandos que,
obedecidos, provocarão uma sucessão finita de ações que resultarão na resolução do problema
proposto. Este algoritmo deve ser transmitido ao computador e armazenado em sua memória, para
em seguida, ser posto em execução e conduzir o computador para a solução desejada.
A tarefa de programação envolve basicamente um processo de abstração de fatos e informações do
mundo real. As informações devem ser modeladas em estruturas de dados enquanto as ações são
transformadas em algoritmos. Deste modo devemos ter em mente que:
PROGRAMA = ALGORITMO + ESTRUTURA DE DADOS
Conceitos
O processamento de dados é baseado num número finito de operações com os dados, organizados
em certas seqüências lógicas, para obtenção dos resultados desejáveis.
Segundo o Aurélio, Algoritmo é “um processo de cálculo, ou de resolução de um grupo de
problemas semelhantes, em que se estipulam, com generalidade e sem restrições, as regras formais
para a obtenção do resultado ou da solução do problema”.
Um algoritmo é uma norma executável para estabelecer um efeito desejável.
Na nossa vida quotidiana encontramos constantemente algoritmos, por exemplo: instruções de uso,
receitas de cozinha, indicações de montagens, partituras musicais etc., que em sua grande maioria,
apresentam o mesmo padrão de comportamento.
Num algoritmo (e um programa) devemos distinguir claramente dois aspectos: um estático e um
dinâmico.
A formulação de um algoritmo geralmente consiste em um texto contendo comandos (instruções)
que devem ser executadas numa ordem prescrita. Esse texto é uma representação concreta do
algoritmo e tem um caráter evidentemente estático e atemporal.
Por outro lado esse texto não nos interessa em si, mas pelos efeitos que pode evocar sua execução
no tempo, dado um conjunto de valores iniciais.
3
A grande dificuldade na concepção e no entendimento de algoritmos e o problema do
relacionamento desses dois aspectos, ou seja, como entender as estruturas dinâmicas das possíveis
execuções do algoritmo a partir da estrutura estática do texto do algoritmo.
Um algoritmo deve nos permitir que dado um estado inicial, sua execução nos leve sempre a um
mesmo resultado final, através dos mesmos caminhos.
Métodos de Desenvolvimento de Algoritmos
O uso desses métodos surgiu com a necessidade de se obter algoritmos de uma forma estruturada,
concisa e padronizada, para que possa ser de fácil entendimento por outras pessoas sem gerar
ambigüidades.
Esses métodos devem possuir certa estruturação para que o trabalho de transformação de algoritmos
para programas seja fácil e eficiente.
Dentre os vários existentes podemos citar: FLUXOGRAMAS, DIAGRAMAS NASSI-
SCHNEIDERMAN, TABELAS DE DECISÃO, PSEUDOCÓDIGO, ETC...
Fluxogramas
Início/Fim
Entrada de Dados (Cartão)
Atribuição, Operação, Processamento

Decisão

Imprimir
Direção do Fluxo

← Atribuição
Repetição (modelo 1)
Repetição (modelo 2)
4
Pseudocódigos Portugol
Escreve a lógica da solução de forma narrativa, de acordo com certas regras.
Pode ser modificado facilmente e facilmente traduzido em linguagem humana ou em instruções
formais para computadores. Dentre os existentes podemos citar o Portugol, que é uma simbiose do
português, Algol e Pascal. É uma pseudo-linguagem cujo objetivo principal é fazer com que o
projetista passe a pensar no problema e não na máquina, porém não se afastando dela.
5
COMPILADOR DE ALGORITMOS VISUALG
O objetivo principal do sistema VisuAlg (a versão na época da confecção da apostila é a 2.0) é
fornecer uma ferramenta de apoio programação baseado no Português Estruturado, sem reduzir o
estudo teórico. Com estas ferramentas pretende-se proporcionar uma forma de estimular os alunos a
praticar e exercitar o desenvolvimento de algoritmos em uma pseudo-linguagem conhecida como
Portugol ou Português Estruturado.
Portugol é derivado da aglutinação de Português + Algol + Pascal. Algol é o nome de uma
linguagem de programação estruturada usada no final da década de 50.
Embora o português estruturado seja uma linguagem bastante simplificada, possui todos os
elementos básicos e uma estrutura semelhante à de uma linguagem típica para programação de
computadores. Além disso, resolver problemas com português estruturado, pode ser uma tarefa tão
complexa quanto escrever um programa em uma linguagem de programação qualquer. Portanto,
neste manual, estaremos na verdade procurando desenvolver as habilidades básicas que serão
necessárias para adquirir-se competência na programação de computadores.
Exemplo de um Algoritmo não Computacional
Abaixo é apresentado um algoritmo não computacional cujo objetivo é usar um telefone público.
Algoritmo1: Trocar uma lâmpada
• Pegar uma escada
• Posicionar a escada embaixo da lâmpada
• Buscar uma lâmpada nova
• Subir na escada
• Retirar a lâmpada velha
• Colocar a lâmpada nova
Determinar uma seqüência é importante para reger o fluxo de execução do algoritmo. Ao
analisar novamente o algoritmo anterior, perceber-se que tem um objetivo definido de trocar a
lâmpada. Porém, e se a lâmpada não estiver queimada? Pode-se efetuar um teste para verificar essa
possibilidade. Uma nova solução seria:
6
Algoritmo2: Trocar uma lâmpada verificando se a mesma está queimada
• Acionar o interruptor
• Se a lâmpada não acender, então
• Pegar uma escada
• Posicionar a escada embaixo da lâmpada
• Buscar uma lâmpada nova
• Subir na escada
• Retirar a lâmpada velha
• Colocar a lâmpada nova
Percebe-se que sempre é possível melhorar um algoritmo prevendo situações que são pertinentes ao
problema. Muitas outras instruções poderão ser acrescentadas a esse algoritmo.
Todo mundo que tem contato com computadores sabe que eles precisam ser programados para
executar tarefas. Um programa é um conjunto de milhares de instruções que indicam ao
computador, passo a passo, o que ele tem que fazer. Estes programas são construídos com
ferramentas chamadas "linguagens de programação". Estas linguagens contêm os comandos que
fazem o computador escreverem algo na tela realizar cálculos aritméticos, receber uma entrada de
dados via teclado, e milhares de outras coisas, mas estes comandos precisam estar em uma ordem
lógica e contribuir, cada um, para a tarefa em questão.
Exercícios
Escreva um algoritmo para resolver os seguintes problemas:
A - Descrever como você faz para trocar o pneu de um carro.
B - Três homens desejam atravessar um rio. O barco que possuem tem a capacidade máxima de 150
quilos. Eles pesam 50, 75 e 120 quilos. Como podem atravessar sem afundar o barco?
C - Um homem precisa atravessar um rio com um barco que possui capacidade para carregar apenas
ele mesma, e mais uma de suas três cargas, que são: um lobo, um bode e um fardo de alfafa, mais o
lobo não pode ficar sozinho com o bode e o bode com a alfafa.
D – Três homens participam de uma brincadeira, em que dois deles enxergam normalmente, e um
terceiro é cego. Existem 5 chapéus, sendo 3 vermelhos e 2 brancos. São colocados ao acaso um
desses chapéus na cabeça de cada um deles. A idéia é a seguinte: O primeiro consegue enxergar o
chapéu do segundo e do terceiro (cego), mas não consegue enxergar o próprio chapéu. O segundo
consegue enxergar o chapéu do primeiro e do terceiro (cego), mas não consegue enxergar o seu
próprio. E o terceiro, obviamente, não enxerga. Foi perguntado ao primeiro homem, se ele, ao ver o
chapéu do segundo e do terceiro, sabe com certeza a cor do próprio chapéu. Ele responde que não.
O segundo ouve a resposta do primeiro, e também responde que também não sabe a cor do próprio
chapéu. O cego, por sua vez, ouve a resposta do primeiro e do segundo, e responde que sabe com
certeza qual a cor do próprio chapéu. A questão é: Qual a cor do chapéu do cego? Porque ele afirma
com certeza que sabe a resposta certa?
Desafio - Dois monges estão perdidos numa mata e estão passando fome. Só existe uma planta que
podem comer, mas para comê-la deverá esquentá-la 30 segundos exatos, senão os matará. Para
marcar o tempo, eles só têm 2 ampulhetas: uma que marca 22 segundos e outra que marca 14
segundos. Como eles devem fazer para conseguir marcar o tempo de 30 segundos?
7
Linearização de Expressões
Para a construção de algoritmos, todas as expressões aritméticas devem ser linearizadas, ou seja,
colocadas em linhas. É importante também ressaltar o uso dos operadores correspondentes da
aritmética tradicional para a computacional.
Exemplo:
( ) 1 3 5
3
2
+
]
]
]

− +
(2/3+(5-3))+1
Tradicional Computacional
Operadores Aritméticos
Operador Sintaxe Visualg
Adição +
Subtração -
Multiplicação *
Divisão /
Divisão Inteira \
Potenciação ^ ou exp(base,expoente)
Módulo (resto da divisão) %
Raiz quadrada Raizq(expressão)
Quadrado Quad(expressão)
Operadores Aritméticos não convencionais
7 % 3: obtém o resto da divisão de 7 por 3. Normalmente utilizado para agrupar conjunto de
valores. Nesse exemplo, o resultado é 1.
Ex.: Par, Impar, Bissexto, etc.
18 \ 7: obtém o quociente da divisão de 18 por 5. Nesse exemplo, o resultado é 2.
Operadores Relacionais
Operadores relacionais atuam sobre operandos numéricos e resultam em valores lógicos
(operadores de comparação entre dois operandos).
Operador VisuAlg
Maior >
Menor <
Maior ou igual >=
Menor ou igual <=
Igual =
Diferente <>
8
Operadores Lógicos
Atuam sobre expressões retornando sempre os valores lógicos: VERDADEIRO ou FALSO.
VisuAlgFunção
E Retorna verdadeiras se ambas as partes forem verdadeiras.
OU Basta que uma das partes seja verdadeira para retornar verdadeiro.
NAO
Nega uma afirmação, invertendo o seu valor lógico. Se for verdadeiro vira falso, se
for falso vira verdadeiro.
XOU
Operador que resulta em VERDADEIRO se os operandos forem diferentes, e em
FALSO se forem iguais.

Tabela Verdade
A B A E B A OU B NÃO (A) NÃO (B) A XOU B
V V V V F F F
V F F V F V V
F V F V V F V
F F F F V V F
Prioridade dos operadores
Assim como nas operações aritméticas, também existe uma relação de prioridade entre os
operadores. A lista abaixo mostra as prioridades, da maior prioridade para a menor.
Parênteses e Funções
Operadores Aritméticos na seguinte ordem:
Potenciação: ^;
Multiplicação e Divisão: *, /;
Soma e Subtração: +, -;
Operadores Relacionais: = ,<> ,> ,< ,>= ,<=;
Operadores Lógicos na seguinte ordem: NAO, E, OU.
Modularização de Expressões
Modularização é a divisão da expressão em partes, proporcionando maior compreensão e definindo
prioridades para a resolução da mesma.
((2 + 2)*4 +8)/ 2 = 12 é diferente de 2 + 2*4 +8/ 2 = 14
Como pôde ser observado no exemplo anterior, é importante definir a prioridade das operações
através dos parênteses, pois na informática podemos ter parênteses dentro de parênteses, como
seriam os colchetes e as chaves na matemática. Além disso, em expressões computacionais
utilizamos somente parênteses para modularização.
Expressões Lógicas
São as expressões compostas de relações que sempre retornam um valor lógico.
Exemplos:
2+5>4 ? Verdadeiro 3<>3 ? Falso
9
De acordo com a necessidade, as expressões podem ser unidas pelos operadores lógicos.
Exercícios
1 - Escreva as expressões na forma de computacional
a) · +
2
) 3 (
c
b
ae
x

b) ·
+
+

+
2
) 1 ( 2
1
2
) 3 ( 2
x
x x x
x

c) ·

,
`

.
|
− − −
k
h h
x
h
22
) 3 ( 4
3
45
2
d) ·

+ −

a
f a b
2 3
2 4 2
3 2

e)
·
+ −
9
3
1
3
) 2 ( 6 y
x
10
f)
·
+
+
bc a
u x
3
2
2
2 - Escreva as expressões da forma tradicional
a+b+(34+exp(e,9))/u-89^(1/2)=
23+5/((7*a)/47)^(2/x)=
((a+x)^(2+w)-quad(5b))/2=
(12*x)/(36-9^x)^2=
3 - Resolva as expressões lógicas
a) não (2^3 < raizq(16) ou 15\2 < 10
b) (6<8) ou (3>7) =
c) Não (2<3) =
d) (5>=6) ou (6<7) ou não (a+5-6=8) {sabendo-se que A=5}
e) (34>9 e 5+u = 34) ou (5=15/3 e 8>12) {sabendo-se que u=29}
f) 10%4 < 16%3
g) 2+8%7 >= 6-raizq(8^(2/3))
h) 15\7 >= 27 % 5
i) 2 < 5 ou 15/3=5 < 4 e 17%5 = 2
Primeiros Elementos da Linguagem
No curso de algoritmos vamos escrever soluções para problemas utilizando o português estruturado.
Nessa seção vamos conhecer os primeiros elementos que compõem a linguagem e escrever alguns
algoritmos.
Estrutura Geral
Algoritmo "NomedoAlgoritmo"
< declaração de variáveis>
Inicio
< lista de Comandos>
Fimalgoritmo
Os algoritmos que vamos escrever têm a seguinte forma geral:
A palavra “Algoritmo” e a expressão “Fimalgoritmo” fazem parte da sintaxe da linguagem e sempre
delimitam o início e fim de um algoritmo.
Em < declaração de Variáveis> descrevemos os tipos de dados que serão usados na lista de
comandos. Por exemplo, poderíamos definir que fruta é um tipo de dado que pode assumir apenas
os valores maça, pêra, banana, abacaxi e outras frutas, sobre os quais podemos efetuar as operações
de comparar, comprar, comer e servir.
“Inicio” indica o fim das declarações e o início dos comandos.
< listas-de-comando> é apenas uma indicação de que entre a palavra “Inicio” e a expressão
“Fimalgoritmo” podemos escrever uma lista com uma ou mais instruções ou comandos.
É importante salientar que, quando um algoritmo é “executado” as instruções ou comandos de um
algoritmo são sempre executados na ordem em que aparecem no mesmo.
As palavras que fazem parte da sintaxe da linguagem são palavras reservadas, ou seja, não podem
ser usadas para outro propósito em um algoritmo que não seja aquele previsto nas regras de sintaxe.
11
A palavra “Algoritmo”, por exemplo, é uma palavra reservada. As palavras reservadas sempre
aparecerão em negrito e itálico, neste manual.
Identificadores
Tudo que usamos tem um nome. Este nome ou rótulo é utilizado para que possamos reconhecer
uma determinada variável ou constante. O objetivo desse rótulo ou nome é estabelecer a
necessidade de identificarmos o espaço que iremos armazenar determinado conteúdo. Esta
identificação deve ser clara, precisa e deve identificar o conteúdo guardado para o usuário.
Regras para a nomeação de identificadores
Não podem ter nomes de palavras reservadas;
Devem possuir como primeiro caractere uma letra ou sublinhado '_’;
Outros caracteres podem ser letras, números e sublinhado;
Ter no máximo 127 caracteres;
Não possuir espaços em branco;
O VisuAlg não difere letras maiúsculas de minúsculas (NOME é o mesmo que noMe).
Identificadores válidos: NOME, TELEFONE, IDADE_FILHO, NOTA1, Est_Civil
Identificadores inválidos: 3Endereco, Estado Civil, PARA, fim, numero/complemento
Variáveis
O computador possui uma área de armazenamento conhecida como memória. Todas as informações
existentes no computador estão ou na memória primária (memória RAM), ou na memória
secundária (discos, fitas, CD-ROM, etc.). Nós iremos trabalhar, neste curso, somente com a
memória primária, especificamente com as informações armazenadas na RAM (memória de acesso
aleatório).
A memória do computador pode ser entendida como uma seqüência finita de caixas, que, num dado
momento, guarda algum tipo de informação, como número, uma letra, uma palavra, uma frase, etc,
não importa, basta saber que lá sempre existe alguma informação.
O computador, para poder trabalhar como alguma destas informações precisa saber onde, na
memória, o dado está localizado. Fisicamente, cada caixa, ou cada posição de memória, possui um
endereço, ou seja, um número que indica onde cada informação está localizada. Este número é
representado através da notação hexadecimal, tendo o tamanho de quatro, ou mais bytes. Abaixo
segue alguns exemplos:
Endereço Físico Informação
3000: B712 é o endereço físico de "João"
2000: 12EC é o endereço físico de 12345
3000: 0004 é o endereço físico de "H"
Como pode ser observado, o endereçamento das posições de memória através de números
hexadecimais é perfeitamente compreendido pela máquina, mas para nós humanos torna-se uma
tarefa complicada. Pensando nisto, as linguagens de computador facilitaram o manuseio, por parte
dos usuários, das posições de memória da máquina, permitindo que, ao invés de trabalhar
diretamente com o número hexadecimal, fosse possível dar nomes diferentes a cada posição da
memória. Tais nomes seriam de livre escolha do usuário. Com este recurso, os usuários ficaram
livres dos endereços físicos (números hexadecimais) e passaram a trabalhar com endereços lógicos
12
(nomes dados pelos próprios usuários). Desta forma, o exemplo acima poderia ser alterado para ter
o seguinte aspecto:
Endereço Físico Informação
Nome : "João"
número : 12345
letra : "H"
Como tínhamos falado, os endereços lógicos são como caixas, que num dado instante guardam
algum tipo de informação. Mas é importante saber que o conteúdo desta caixa não é algo fixo,
permanente, na verdade, uma caixa pode conter diversas informações, ou seja, como no Exemplo
acima, a caixa (Endereço Lógico) rotulada de "Nome" num dado momento contém a informação
"João", mas em um outro momento, poderá conter uma outra informação, por Exemplo, "Pedro".
Com isto queremos dizer que o conteúdo de uma destas caixas (endereço lógico) pode variar, isto é,
podem sofrer alterações em seu conteúdo. Tendo este conceito em mente, a partir de agora iremos
chamar de forma genérica, as caixas ou endereços lógicos, de variáveis.
Desta forma podemos dizer que uma variável é uma posição de memória, representada por um
nome simbólico (atribuído pelo usuário), a qual contém, num dado instante, uma informação,
conforme pode ser observado na figura abaixo:
Uma variável pode ser vista como uma caixa identificada por um nome colocado na tampa desta e
por um valor de uma constante que poderá estar colocado no interior desta caixa. Enquanto o nome
sempre permanece o mesmo, o conteúdo da caixa, isto é, a constante nela armazenada pode ser
alterada a qualquer momento.
Declaração de Variáveis
Variáveis são palavras que tem um significado bem específico em um algoritmo. Para que o
computador possa executar comandos que envolvem variáveis da maneira correta, ele deve
conhecer os detalhes das variáveis que pretendemos usar. Esses detalhes são: o identificador desta
variável e o tipo de valores que essa variável irá conter. Precisamos assim, de uma maneira de
especificar esses detalhes e comunicá-los ao computador. Para isso utilizamos o comando de
declaração de variáveis que faz parte da nossa linguagem que tem a seguinte forma:
<identificador> [, <lista_identificadores>] : <tipo_das_variáveis>
onde:
<identificador> - é uma lista de palavras que pretendemos empregar como variáveis em nosso
algoritmo;
<tipo_das_variáveis> - determina que tipo de valor as variáveis poderão receber.
13
Todas as Variáveis devem assumir um determinado tipo de informação
O tipo de dado pode ser:
Primitivo: Pré-definido pela linguagem;
Estáticos: É uma parte de um tipo já existente (vetores, como será visto adiante);
Dinâmicos - Definidos pelo programador(alocação dinâmica).
Tipos Primitivos de Dados
Esses tipos de dados são os mais freqüentes nas linguagens de programação, pois oferecem alguns
tipos básicos pré-definidos, para criação de outros tipos. Cada um desses tipos primitivos tem um
conjunto de valores restrito, veja abaixo:
Descrição
Inteiro Representa valores inteiros. Exemplo: 10, 33, -56
Real
Representa valores inteiros ou reais (com ponto separador da parte
decimal). Exemplos: 10, 15.5
Caracter
Um número, uma letra, qualquer símbolo especial ou seqüência de
caracteres entre aspas duplas.
Exemplos: “a”, “=”, “#$%@”,”999”, ”678.90”
Logico Só podem assumir dois valores: verdadeiro ou falso.
Sinal de Atribuição
Quando declaramos uma variável, criamos uma área de armazenamento para os dados, mas ela
ainda está sem valor. Para que a variável seja útil, deve ter valores colocados por nós. Isso se chama
"atribuir valores". A atribuição de valores é feita pelo operador de atribuição "<-" (uma seta
apontando para a esquerda).
Por exemplo:
Peso <- 78 Este comando atribui à variável Peso o valor 78.
Nome <- "João da Silva" Este comando atribui à variável Nome o valor "João da
Silva".
É importante lembrar que só se pode atribuir às variáveis valores do mesmo tipo da variável. Nos
exemplos acima, o variável Salário é do tipo real. Então, o seguinte comando seria inválido:
Salário <- "Insuficiente"
Uma variável, como o próprio nome está dizendo, pode ter seu conteúdo (seu valor) mudado
quantas vezes forem necessárias durante um programa.
Comandos de E/S (Entrada/Saída)
Um programa que faça o seu processamento e não tenha como mostrar seus resultados é
praticamente inútil. Portanto, em algum ponto deve haver a exibição de valores, e todas as
linguagens de programação têm comandos para este fim. Nos algoritmos usamos o comando
Escreva para isto.
14
Escreva – Comando de saída que exibe uma informação no monitor.
Escreval – Comando de saída que exibe uma informação no monitor, mas executa o comando
seguinte na linha seguinte.
Sintaxe:
Escreva (<expressão | variável>[,<lista_de_variáveis>])
Exemplo: Escreva ("Este é o valor de X:", X, "e este de Y:", Y)
Nem todos os dados que um programa manipula são gerados por ele. Um programa de caixa
automático, por exemplo, têm que obter do usuário o número da conta, a senha, a opção de serviço
desejada, etc. Assim, deve haver um meio para que sejam digitados (ou fornecidos de outra
maneira) dados para uso do programa. Mais uma vez, todas as linguagens de programação
permitem isto, e nos algoritmos usamos o comando Leia. A sintaxe deste comando é:
Leia – Comando de entrada que permite a leitura de variáveis de entrada utilizando o teclado.
Sintaxe:
Leia (<variavel>[,<lista_de_variáveis>])
Assim, temos:
Comando de Saída Comando de Entrada
Escreva (variável) ou Escreval(variável) Leia (variável)
Linhas de Comentário
Os comentários são declarações não compiladas que podem conter qualquer informação textual que
você queira adicionar ao código-fonte para referência e documentação de seu programa.
Uma Linha
São representados por duas barras normais ( // ). Todo o texto que você digitar após as duas barras
será comentário.
Exemplo:
// Este método calcula o fatorial de n.
.
.
x <- y // Inicializa a variável x com o valor de y.
Múltiplas Linhas
Para tal, basta colocar o comentário entre chaves { }
Exemplo:
ALGORITMO “Exemplo”
{algoritmo que pega o nome do aluno, seu código e as suas notas, e verifica se ele passou de ano }
codigo, i, j, nota1, nota2, nota3: inteiro { declaração das variáveis do tipo
inteiro}
nome: caracter // declaração das variáveis de cadeia de caracteres
FIMALGORITMO
Uma Linha Múltiplas Linhas
15
// TEXTO {TEXTO}
Estruturas Seqüenciais - Construindo os Primeiros Algoritmos
Basicamente a construção de um algoritmo se resume às seguintes etapas:
Entendimento do problema;
Definição dos dados que serão necessários para resolvê-lo (as entradas); aí já deveremos ter idéia
dos tipos de dados que usaremos;
Obtenção destes dados; alguns vêm do "exterior" do programa, e outros são calculados no próprio
programa;
Processamento em si;
Exibição dos resultados.
A primeira fase é a mais difícil de se "pegar", pois depende um pouco da experiência do
programador. Entretanto, mesmo nesta fase há técnicas que podem ser aprendidas, e modelos que
podem ser aplicados. Programação é arte, ciência e técnica, tudo ao mesmo tempo...
Problema 1 - Cálculo de Média Aritmética
Enunciado:
Faça um programa que leia dois valores inteiros, e calcule e exiba a sua média aritmética.
Etapa 1
Simples, hein? Dos tempos de escola lembramos que a média aritmética de dois valores é calculada
como (a+b)/2, e sendo assim a primeira etapa já está pronta.
Etapa 2
Os dados necessários serão os dois valores, que colocaremos em duas variáveis A e B, do tipo real,
e uma terceira variável, que chamaremos Media, que armazenará a média aritmética calculada.
Etapa 3
A obtenção dos dados neste programa é simples e direta. Basta pedir ao usuário que digite os
valores.
Etapa 4
O processamento aqui é o cálculo da média, usando o método citado acima, na etapa 1. O resultado
do cálculo será armazenado na variável Media.
Etapa 5
Basta exibir o conteúdo da variável Media.
Solução:
Algoritmo “CalculaMedia”
A,B: Inteiro
Media : Real
Inicio
Escreval(“Programa que calcula a média aritmética de dois
valores.")
Escreval("Digite um valor : ")
Leia(A)
Escreva("Digite outro valor : ")
16
Leia(B)
Media <- (A+B)/2
Escreva("A média dos dois valores é : ", Media)
FimAlgoritmo
Comentários
Você deve ter notado que colocamos na tela instruções para o usuário usando o comando
Escreva. Esta é uma boa técnica de programação, mesmo hoje em dia, com o ambiente gráfico do
Windows. Da mesma forma, ao imprimir o resultado, não mostramos simplesmente a média, mas
explicamos ao usuário o que aquele valor significa.
Como pode ser analisado no tópico anterior todo programa possui uma estrutura seqüencial
determinada por um Inicio e Fim. Em um algoritmo, estes limites são definidos com as palavras.
Algoritmo “teste”
var
prod: caracter
valor_prod, qtd, tot: real
Inicio
escreva("digite o nome do produto:")
leia(prod)
escreva("digite o valor unitário do produto:")
leia(valor_prod)
escreva("digite a quantidade:")
leia(qtd)
tot <- valor_prod*qtd
escreva("total:",qtd, " unidades de ",prod," = ", tot)
fimalgoritmo
Lembrete:
Os comandos devem ser inseridos linha por linha.
Não são diferenciadas as letras maiúsculas de minúsculas.
As palavras não devem ser acentuadas.
E não deve ser utilizada a letra 'ç'.
Se executássemos esse algoritmo, teríamos o seguinte resultado:
1º Passo: "Digite o produto:" Uma janela irá aparecer, pedindo para inserir o dado desejado. Vamos
supor que você digite Abacaxi
2º Passo: "Digite o valor unitário do produto:" Você digita 5.50
3º Passo: "Digite a quantidade:" Você digita o valor 10
4º Passo: O computador irá executar a operação da antepenúltima linha do algoritmo: atribuir o
resultado da multiplicação entre valor_prod e qtd à variável tot.
5º Passo: Total: 10 unidades de Abacaxi = 55.0
17
Exercícios
A. Classifique os conteúdos das variáveis abaixo de acordo com seu tipo, assinalando com I os
dados Inteiros, com R os dados Reais, com L os lógicos, e com C os caracteres.
( )0.1 ( ) "abc" ( )"João"
( )5.7 ( ) 1012 ( )"F"
( )-49 ( ) +342 ( )569
( )"Lucas" ( ) "V" ( )0.00001
( )falso ( ) -545 ( )"444"
B. Assinale com um X os nomes de variáveis válidos.
( ) abc ( ) 3abc ( ) a
( ) 123a ( ) –a ( ) acd1
( ) -_ad ( ) A&a ( ) 1
( ) A123 ( ) Aa ( ) guarda-chuva
( ) AB CDE ( ) etc... ( ) b316

C. Para as variáveis declaradas a seguir são dados os valores informados. Determine o resultado da
avaliação das expressões abaixo. X, Y e Z são variáveis do tipo inteiro, sendo que: X = 2, Y = 3 e Z
= 5.
a) X * Y – Z e) (X + Y) * Z
b) X * (Y – Z) f) exp(X, Y) – 1
c) X + Y * Z g) (X ^ Y) – 1
d) X + (Y * Z) h) X ^ (Y – 1)
D. Assinalar os comandos de atribuição considerados inválidos.
Nome, cor, Teste, Dia: Caracter
Soma, Num: Real
X: Logico
a) ( ) NOME <- 5
b) ( ) SOMA <- NUM + 2 * X
c) ( ) TESTE <- SOMA
d) ( ) NUM <- SOMA
e) ( ) COR <- "PRETO"
f) ( ) X <- X + 1
g) ( ) NUM <- "*ABC*"
h) ( ) DIA <- "SEGUNDA"
i) ( ) SOMA + 2 <- X
j) ( ) X <- (NOME = COR)
E. Quais os valores armazenados em SOMA, NOME e TUDO, supondo-se que NUM, X, COR,
DIA, TESTE e COD valem, respectivamente, 5; 2; "AZUL"; "TERÇA"; Falso e Verdadeiro?
18
a) NOME <- DIA
b) SOMA <- (NUM^2/X) + (X + 1)
c) TUDO <- NÃO ((TESTE OU COD) E (SOMA < X))
F. Observar o seguinte algoritmo e descreva o que ele faz.
Algoritmo “CalculaMedia”
var
nota1, nota2, nota3, nota4, media: real
nome: caracter
inicio
leia(nome)
leia(nota1, nota2, nota3, nota4)
media <- (nota1 + nota2 + nota3 + nota4)/4
escreva (nome, media)
FimAlgoritmo
G. Resolva os exercícios na forma de pseudocódigos Portugol
1) Faça um programa que leia três valores inteiros, e calcule e exiba a sua média ponderada. A
primeira nota tem peso 2, a segunda tem peso 3 e a terceira tem peso 5.
2) Realizarei uma viagem de vários dias em meu automóvel, e gostaria de saber a
quilometragem média por litro de gasolina. Para isto, anotarei a quilometragem no velocímetro
ao sair de viagem, e depois ao chegar. Também vou somar toda a gasolina que comprar para o
carro. Você poderia fazer um programa que me desse, com estes dados, quantos km fiz, em
média, por litro de gasolina?
3) Faça um programa que leia o nome de um piloto, uma distância percorrida em km e o tempo
que o piloto levou para percorrê-la (em horas). O programa deve calcular a velocidade média
em km/h, e exibir a seguinte frase: A velocidade média de XX foi YY km/h, onde XX é o nome
do piloto, e YY é a velocidade média.
4) Em uma pizzaria, cada tulipa de chope custa R$1,80 e uma pizza mista grande custa R$25,00
mais R$ 3,50 por tipo de cobertura pedida (queijo, presunto, banana, etc.). Uma turma vai à
pizzaria e pede uma determinada quantidade de "chopes" e uma pizza grande com uma
determinada quantidade de coberturas. Faca um programa que calcula a conta e, sabendo que a
será informada a quantidade de pessoas, quanto que cada um deve pagar. Lembre-se dos 10%
do garçom.
5) A conversão de graus Fahrenheit para Celsius é obtida pela fórmula abaixo. Faça um
algoritmo que leia um valor em graus Centígrados e imprima seu correspondente em graus
Fahrenheit.
) 32 (
9
5
− ∗ · F C
19
6) Fazer um programa que leia um número inteiro e mostre o seu triplo, sua metade, a sua raiz
cúbica, e por fim, o número elevado a potência fracionária 2/3.
7) Construa um algoritmo que, tendo como dados de entrada dois pontos quaisquer no plano,
P(x1,y1) e P(x2,y2), escreva a distância entre eles. A fórmula que efetua tal cálculo é:
(Exercício resolvido no Anexo I)
8) Um sistema de equações lineares do tipo:
ax + by = c
dx + ey = f
pode ser resolvido segundo mostrado abaixo. Escreva um algoritmo que lê os coeficientes a,b,c,d,e,f
e calcula e mostra os valores de x e y.

9) Determine o que será impresso após a execução do algoritmo abaixo.
Algoritmo "misterio"
var
num, a, b, c, d : inteiro
inicio
escreva("Informe um número inteiro de 4 dígitos diferentes:")
leia(num)
d <- num\1000
a <- (num\100)%10
b <- (num%100)\10
c <- (num%10)%10
escreva("Resultado:",d,a,b,c)
Fimalgoritmo
Estrutura Condicional
Na vida real tomamos decisões a todo o momento baseado em uma situação existente. Em
programação chamamos esta situação de condição, e as alternativas possíveis de ações.
Por exemplo: "Se tiver R$ 10,00 sobrando, irei ao cinema hoje à noite, mas se não tiver ficarei
vendo TV em casa".

Qual é a condição nesta frase? Fácil, "tiver R$ 10,00 sobrando". Ela é uma expressão lógica, pois a
pergunta "Tenho R$ 10,00 sobrando?" pode (tem que) ser respondida com "Sim" ou "Não".
Lembre-se, então: em um algoritmo, toda condição tem que ser uma expressão lógica. Quais são as
ações possíveis? Fácil, mais uma vez; "irei ao cinema" e "ficarei vendo TV em casa". A primeira só
será realizada se a resposta à pergunta "Tenho dinheiro suficiente?" for "Sim", enquanto que a
segunda será realizada caso a resposta seja "Não".
Então, em um algoritmo, as ações são um ou mais comandos que serão realizados, em alguns casos
a avaliação da condição resulte em Verdadeiro, outros caso ela resulta em Falso.
( )
2 2
1 2 ) 1 2 ( y y x x d − + − ·
bd ae
cd af
y
bd ae
bf ce
x


·


·
20
Vamos colocar agora a frase do parágrafo anterior em outra forma, mais parecida com o que é um
programa de computador:
Se "tiver R$ 10,00 sobrando" então
"Irei ao cinema"
Senão
"ficarei vendo TV em casa".
Veja que grifamos três palavras: Se, então, senão. Elas são muito importantes na estrutura dos
comandos de decisão. Como próximo passo, vamos generalizar a estrutura que criamos acima:

Se <condição> então
<ações (uma ou mais) a serem realizadas se a condição for verdadeira>
senão
<ações (uma ou mais) a serem realizadas se a condição for falsa>
Para terminar a nossa comparação, devemos lembrar que os comandos do algoritmo são sempre
imperativos, e que o computador só lida com quantidades definidas (ou seja, ele não sabe o que é
"ter R$ 10,00 sobrando"). Para aproximar mais nossa frase de um algoritmo, poderemos ter a
seguinte forma:

Se Dinheiro >= 10 então
Ir ao Cinema
senão
Ver TV em Casa
Entendeu a transformação? "Dinheiro" faz o papel de uma variável que contém o que eu tenho
sobrando no momento, e se valor é maior ou igual a 10, então "tenho R$ 10,00 sobrando". Por falar
nisso, fique sabendo que a técnica (ou arte) de se transformar perguntas do dia-a-dia em quantidades
definidas que possam ser colocadas em um programa é a chave de se fazer algoritmos. Não se
preocupe, no entanto: é algo fácil e que pode ser aprendido e desenvolvido. Bom, agora já podemos
fazer um programa que ajude nosso amigo...
O que faço esta noite?
Faça um programa que peça ao usuário a quantia em dinheiro que tem sobrando e sugira, caso ele
tenha 10 ou mais reais, que vá ao cinema, e se não tiver, fique em casa vendo TV.
Algoritmo "Tem dinheiro sobrando?"
Var
Dinheiro: Real
Inicio
Escreval("Serviço Informatizado de Sugestões")
Escreva("Quanto dinheiro você tem sobrando?")
Leia (Dinheiro)
Se Dinheiro >= 10 entao
Escreva("Vá ao cinema hoje à noite.")
senao
Escreva("Fique em casa vendo TV.")
Fimse
Escreval("Obrigado e volte sempre.")
21
Em relação ao que vimos até agora, apenas uma novidade: a expressão fimse ao final do comando
de decisão. Ela delimita o comando, isto é, mostra onde as ações da parte senão do comando
terminam. O algoritmo abaixo está incorreto:
Se Dinheiro >= 10 entao
Escreva ("Vá ao cinema hoje à noite.")
Senao
Escreva ("Fique em casa vendo TV.")
Escreva (“Obrigado e volte sempre.”).
Neste caso, o computador não saberia se o comando Escreva "Obrigado e volte sempre." faria ou
não parte do comando de decisão (a endentação, ou seja, o fato de algumas linhas estarem mais
distantes da margem esquerda que as outras não quer dizer nada para o computador. Fazemos isto
apenas - e esta é uma dica importante para você - para que o algoritmo fique mais fácil de ler).
Assim o fimse é fundamental, e todas as linguagens de programação têm algo que cumpra esta
função.
A estrutura condicional permite a mudança de caminho em um determinado fluxo devido à
veracidade de um determinado teste feito no decorrer do desenvolvimento do algoritmo.
A estrutura "Se" deve ser aplicada nos momentos em que, de acordo com uma determinada
condição, um processamento deva ser feito.
Os comandos internos a essa estrutura só serão executados após o teste da condição ter sido feito e
seu resultado for verdadeiro. Após serem executados os comandos internos a essa estrutura, o
primeiro comando após o “fimse" será executado e o algoritmo seguirá a seqüência lógica
normalmente.
Tipos de comandos condicionais
- Seleção Simples: testa uma condição, se esta for verdadeira executa uma ação ou um conjunto
de ações.
Sintaxe Exemplo
Algoritmo “Verifica condicional”
var
//Declaração de
variáveis
Inicio
//Comandos
Se <condição> entao
C1
...
Cn
Fimse
FimAlgoritmo
Algoritmo “Teste”
Var
A,B: inteiro
Inicio
A <- 1
B <- 1
Se A = B entao
A <- A+1
Fimse
FimAlgoritmo
{Se a condição testada for
verdadeira, os comandos
C1 a Cn serão
executados.}
22
- Seleção Composta: testa uma condição, se esta for verdadeira executa uma ação ou um
conjunto de ações. Caso contrário executa outro conjunto de ações
Sintaxe Exemplo
Algoritmo “Verifica condicional”
var
//Declaração de variáveis
Inicio
//Comandos
Se <condição> entao
C1
...
Cn
senao
D1
...
Dn
Fimse
FimAlgoritmo
Algoritmo “Teste”
Var
A,B: inteiro
Inicio
A <- 1
B <- 2
Se A > B entao
A <- 5
senao
A <- B+2
Fimse
FimAlgoritmo
- Seleção Encadeada: agrupa várias alternativas a fim de inspecionar mais de duas condições.
Sintaxe Exemplo
Algoritmo “Verifica condicional”
var
//Declaração de variáveis
Inicio
//Comandos
Se <condição1> entao
C1
...
Cn
Senao
Se <condição2> entao
D1
...
Dn
Senao
Se <condição3> entao
X1
...
Xn
Fimse
Fimse
Fimse
FimAlgoritmo
Algoritmo “Teste”
Var
A,B: inteiro
Inicio
A <- 1
B <- 3
Se A > B então
A <- A+1
B <- B*2
Senao
Se B % 2 = 0 entao
A <- 0
B <- B+2
Senao
Se B % 3 = 0 entao
A <- A*2
B <- 5
Fimse
Fimse
Fimse
FimAlgoritmo
- Seleção de Múltipla Escolha: usada quando um conjunto de valores precisa ser testado e ações
diferentes são associadas a esses valores.
{Se a condição testada for
verdadeira, os comandos
C1 a Cn serão
executados.}
{Os comandos D1 a Dn só
serão executados se a
condição for falsa.}
23
Sintaxe Exemplo
Algoritmo “Verifica Escolha”
var
//Declaração de variáveis
Inicio
//Comandos
escolha<expressão-de-seleção >
caso <exp1>,<exp2>,...,<expn>
<lista-de-comandos-1>
caso <exp1>,<exp2>,...,<expn>
<lista-de-comandos-2>
outrocaso
<lista-de-comandos-3>
fimescolha
Fimalgoritmo
Algoritmo "Verifica trimestre"
var
mes: inteiro
inicio
escreva("Informe o número do mês:
(1 a 12): ")
leia(mes)
escolha mes
caso 1,2,3
escreva("Primeiro trimestre")
caso 4,5,6
escreva("Segundo trimestre")
caso 7,8,9
escreva("Terceiro trimestre")
caso 10,11,12
escreva("Quarto trimestre")
outrocaso
escreva("Mes informado errado")
fimescolha
Fimalgoritmo
Testando o Algoritmo
Um algoritmo depois de ser elaborado pode e deve ser testado. Utilizamos um método conhecido
como teste de mesa. O teste de mesa é como uma simulação de todos os passos, ou seja, entradas,
comandos e instruções do algoritmo, a fim de saber se ele chega ao resultado a que se propõe e se a
lógica está correta. Preenchendo uma tabela com valores para as variáveis e seguindo-se o fluxo de
execução do algoritmo. A cada comando o valor das variáveis deve ser atualizado, concluído o teste
de mesa podemos analisar os resultados, obtivemos a resposta correta? Se não, onde estão os erros?
Sempre que é realizado um teste de mesa, utiliza-se de tabelas para armazenar os valores e
estados das variáveis do algoritmo. Monitorando as variáveis é fácil determinar a eficiência do
algoritmo. Uma vez entendido o funcionamento de um teste de mesa, e sabendo aplicá-lo nos
algoritmos elaborados o aprendizado da lógica computacional se torna muito mais fácil, visto que o
teste de mesa faz uma simulação do raciocínio estruturado, utilizando a entrada de variáveis e
seguindo passo a passo a lógica. Caso em algum ponto a lógica esteja falha, o erro é facilmente
encontrado e facilmente resolvido.
Exemplo:
Para cada variável você deve fazer uma coluna e uma coluna para saída de dados.
Algoritmo Teste de Mesa
Algoritmo “Teste”
var
a, b, c: Real A B C Saída
Inicio
? ? ?
a <- 5 5 ? ?
b <- 15 5 15 ?
c <- a+b 5 15 20
24
Escreva (c) 5 15 20 20
a <- 10 10 15 20
b <- 25 10 25 20
c <- a+b 10 25 35
Escreva ( c ) 10 25 35 35
a <- a-b -15 25 35
Escreva (a)
-15 25 35 -15
a <- 0 0 25 35
b <- 0
0 0 35
c <- 0
0 0 0
FimAlgoritmo


Quando estamos escrevendo um algoritmo devemos ter em mente que eles devem ser facilmente
entendidos, testados e modificados por outras pessoas (e por nos mesmos após algum tempo).
Regras Práticas para Construir Algoritmos Legíveis
1. Use nomes significativos para suas variáveis;
2. Use endentação, isto é, os comandos devem ser alinhados de acordo com o nível a que pertença;
3. Use parênteses para aumentar a legibilidade e prevenir-se contra erros
4. Use apenas um comando por linha
5. Utilize espaços e linhas em branco para melhorar a legibilidade
6. Comentários:
. Use comentários para descrever o significado de algumas variáveis;
. Coloque-os no momento em que estiver escrevendo o algoritmo;
. Coloque comentários no inicio do algoritmo para explicar o que faz, como utilizá-lo, autor, etc...
. Coloque comentários nos principais comandos (os mais importantes), para explicar o objetivo
dos mesmos;
. Altere os comentários quando alterar o algoritmo;
Exercício resolvido
Em uma escola, o aluno faz duas provas por período, com as notas variando de 0 a 10. Caso a média
aritmética das duas notas seja 7 ou mais, ele passa de ano; senão, ele é reprovado. Faça um
programa que receba as duas notas de um aluno e escreva se ele passou ou não de ano.
Visualg 2.0 Fluxograma
25
Algoritmo "calcula média"
var
nota1, nota2, media: real
inicio
escreva("Informe as duas notas
do aluno:")
leia(nota1, nota2)
media <- (nota1+nota2)/2
se media >= 7 entao
escreva("Aluno aprovado")
senao
escreva("Aluno reprovado")
fimse
Fimalgoritmo
nota1,nota2,media: real
nota1, nota2
media <- (nota1+nota2)/2
Inicio
V
“Reprovado”
F
Fim
Media>=7
>= 7
“Informe duas notas
do aluno”
“Aprovado”
26
Dizer os valores a serem impressos após a execução dos algoritmos abaixo:
algoritmo "exerc 1"
var
A,B:inteiro
inicio
A <- 10
B <- 15
se A<= B entao
A <- B - 1
senao
B <- B +1;
A <- A -1;
fimse
A <- A + 2
escreva(A,B)
fimalgoritmo
Algoritmo "exerc 2"
var
A,B,C,D,X,Y: inteiro
inicio
A <- 62
B <- 30
C <- 44
D <- 75
X <- 4
Y <- 3
se (A> B) e (X > Y) entao
X <-Y + A
D <-9 + B*2
Y <- QUAD(Y)
senao
B <- A + D
fimse
A <- A+B
escreva (A, B, C)
escreva (D, X, Y)
fimalgoritmo
Dizer os valores a serem impressos após a execução dos algoritmos abaixo, e convertê-los para
fluxogramas.
Algoritmo "Exerc 3"
var
X,Y,Z: Inteiro
W: Real
Inicio
X <- 5
Y <- 12
Z <- 4
W <- 0
Se X > Z entao
Se Z > Y entao
Escreva(Y)
W <- (X + Y + Z)/3
Senao
escreva(Z)
W <- Z + 12
fimse
senao
escreva(X)
fimse
escreva(W)
fimalgoritmo
Algoritmo "Exerc 4"
var
N1,N2: inteiro
SOMA: real
inicio
N1 <- 8
N2 <- 11
SOMA <- 4
Se N1 > 0 entao
SOMA <-SOMA + (N2 - N1)
Se N1 % 2 = 0 entao
escreval(N1)
escreval(soma)
fimse
escreva(N2)
Senao
SOMA <- SOMA + N1 + N2
escreva(SOMA)
fimse
fimalgoritmo
27
Exercícios – Resolver os algoritmos de números pares na forma de pseudocódigo e os ímpares
na forma de fluxogramas
1. Faça um programa que receba o valor do salário de uma pessoa e o valor de um
financiamento pretendido. Caso o financiamento seja menor ou igual a 5 vezes o salário da
pessoa, o programa deverá escrever "Financiamento Concedido"; senão, escreverá
"Financiamento Negado". Independente de conceder ou não o financiamento, o programa
escreverá depois a frase "Obrigado por nos consultar."
2. Dois carros percorreram diferentes distâncias em diferentes tempos. Sabendo que a
velocidade média é a razão entre a distância percorrida e o tempo levado para percorrê-la, faça
um programa para ler as distâncias que cada carro percorreu e o tempo que cada um levou, e
indique o carro que teve maior velocidade média.
3. Faça um programa que leia o nome e idade de duas pessoas e imprima o nome da pessoa
mais nova, e seu ano de nascimento (o programa deve funcionar corretamente para qualquer que
seja o ano atual).
4. Leia três números e imprima o maior deles. Não é necessário verificar se os números são
iguais.
5. Leia um nome e duas notas dadas a um aluno e imprima: nome, média e “aprovado”,
“reprovado” ou “recuperação”, de acordo com as regras abaixo:
Reprovado, se média maior igual a zero e menor que 5;
Recuperação, se média maior igual a 5 e menor que 7;
Aprovado, se média maior igual a 7 e menor igual a 10.
6. Leia uma média e um número de faltas dadas a um aluno e imprima aprovado, reprovado
por média e por falta, reprovado por média ou reprovado por falta. Sendo média maior igual a 7
indica aprovado, e faltas maior igual a 32 indica reprovado.(Exercício resolvido no Anexo I)
7. Leia três valores que representam os lados de um triângulo, e verificar se compõe um
triângulo equilátero (três lados iguais), isósceles (dois lados iguais) ou escaleno (três lados
diferentes).
(Dica: Verificar primeiro se os três lados formam um triângulo: cada lado é menor do que a soma
dos outros dois).
8. Construa um algoritmo para calcular as raízes de uma equação do 2
o
. grau, sendo que os
valores de A , B e C são fornecidos pelo usuário. Não esquecer de verificar se o valor de Delta é
maior ou igual a zero, ou seja, se existem raízes reais. (Exercício resolvido no Anexo I)
9. Tendo como dados de entrada a altura e o sexo de uma pessoa, construa um algoritmo que
calcule seu peso ideal, utilizando as seguintes formulas:
Para homens: (72.7 * Altura) - 58
Para mulheres: (62.1 * Altura) - 44.7
10. Leia um salário bruto e imprima o salário bruto, o desconto e salário líquido, após os
descontos do imposto de renda, que será calculado da seguinte maneira:
28
Salário Imposto Dedução
Até 1.372,81 I S E N T O
Acima de 1.372,81até 2.743,25 15% 205,92
Acima de 2.743,25 27.5% 548,82
11. Leia um mês e ano e imprima a quantidade de dias que este mês possui. Lembre-se dos anos
bissextos.
12. Leia sexo e idade de uma pessoa e imprima maior idade ou menor idade, considerando que
sexo masculino e maior idade se maior igual a 21 anos e sexo feminino e maior idade se maior
igual a 18 anos.
13. A loja Constrói em Partes produz dois tipos de hastes: cobre e alumínio. Cada haste de cobre
é vendida por R$ 2,00, e cada haste de alumínio é vendida por R$ 4,00. O desconto dado
dependerá da quantidade de hastes compradas, conforme tabela abaixo. Fazer um algoritmo para
ler a quantidade comprada de cada tipo de haste e imprima o total pago.
Quantidade comprada (duas hastes juntas) Percentual de Desconto
Abaixo de 5 0
Entre 5 e 15 10
Entre 16 e 20 15
Acima de 20 20
14. Uma empresa de energia elétrica trabalha com 3 tipos de consumidores: I – Industrial; C –
Comercial; R – Residencial. Fazer um algoritmo para ler o tipo de consumidor (‘I’, ‘C’ ou ‘R’),
a quantidade de energia consumida, e calcular e imprimir qual será o valor pago. Para calcular o
valor pago, verificar a tabela abaixo.
Tipo de Consumidor Cálculo
Industrial 0.68 ∗ Consumo + 34
Comercial 0.37 ∗ Consumo + 45
Residencial 0.77 ∗ Consumo – 22
15. Escrever um algoritmo para ler a hora de início e hora de término de um jogo, ambas
expressas em horas e minutos. Calcular e escrever a duração do jogo, também em horas e
minutos, considerando que o tempo máximo de duração de um jogo é de 24 horas e que o jogo
pode iniciar em um dia e terminar no dia seguinte. Se o usuário informar horas maiores que 24
ou minutos maiores que 59, informar mensagem de erro: “Entrada de dados não é válida”.
Exemplo: Hora inicial do jogo: 23 Minuto inicial do jogo: 50
Hora final do jogo: 01 Minuto final do jogo: 45
Duração do jogo: 1 hora e 55 minutos
(Exercício resolvido no Anexo I)
16. Escreva um algoritmo que leia um número inteiro de três dígitos e calcule a soma dos seus
dígitos. Verificar se o novo número formado é divisor de 16 e múltiplo de 4 ao mesmo tempo.
Exemplo: Número informado: 125
29
Soma dos dígitos do número 125 é igual a 8
O número informado é divisor de 16 e múltiplo de 4 ao mesmo tempo.
17. Fazer um algoritmo para ler os valores de z e w, e calcular e imprimir:
y = (7x
2
- 3x - 8t) / 5(x + 1)
sabendo-se que os valores de x são assim definidos:
se w > 0 ou z < 7
x = (5w + 1) / 3;
t = (5z + 2);
caso contrário
x = (5z + 2);
t = (5w + 1) / 3;
Estrutura de Repetição
Nos exemplos e exercícios que vimos até agora sempre foi possível resolver os problemas com uma
seqüência de instruções onde todas eram necessariamente executadas uma única vez. Os algoritmos
que escrevemos eram, portanto, apenas uma seqüência linear de operações. Nesta seção veremos
um conjunto de estruturas sintáticas que nos dão mais flexibilidade para determinar a seqüência de
execução dos comandos da linguagem.
Quando queremos que um trecho de um algoritmo seja repetido num determinado número de vezes,
utilizamos os comandos de repetição. A nossa linguagem possui três estruturas de repetição:
Repita..Até, Para..Faça e Enquanto..Faça.
Repita..Até
Nessa estrutura todos os comandos da lista são executados e a expressão é avaliada. Isto se repete
até que a avaliação da condição resulte em verdadeiro, quanto então o próximo comando a ser
executado é o comando imediatamente após o até. Cada repetição da lista de comandos também é
chamada de iteração. Essa estrutura também é chamada de laço de repetição. Eis a sua forma geral:
Repita
<lista de comandos>
até <expressão lógica ou relacional>
ex.: escrever os números de 1 a 10.
algoritmo “repetição”
var
i:inteiro
inicio
i <- 1
repita
escreva (i)
i <- i + 1
ate i > 10
fimalgoritmo
30
Obs.: A variável "i" controla o número de repetições do laço. Normalmente a variável de controle
do laço recebe um valor inicial, é incrementada de um valor constante no laço e tem seu valor
testado em algum ponto do laço. Ao chegar a um determinado valor o laço é interrompido. A
inicialização da variável contadora deve acontecer fora do laço, antes do seu início.
Existem diversas maneiras de implementar o mesmo laço, mas todo laço com variável de controle
deve conter:
a) inicialização
b) incremento(i=i+1) ou decremento(i=i-1)
c) teste de valor final
Veja um outro exemplo: Escreva os números de 10 a 1.
algoritmo “repetição”
var
i:inteiro
inicio
i <- 10
repita
escreva (i)
i <- i - 1
ate i = 0
fimalgoritmo
Enquanto..Faca
Na estrutura Enquanto..faca, a expressão lógica é avaliada e, se ela for verdadeira, a lista de
comandos é executada. Isso se repete até que a condição seja falsa. Veja a sua forma geral:
Enquanto <expressão lógica ou relacional> Faca
<lista de comandos>
Fim Enquanto
A estrutura enquanto...faca também é uma estrutura de repetição, semelhante a repita. A diferença
básica entre as duas estruturas é a posição onde é testada a expressão. No repita, a condição é
avaliada após a execução dos comandos, o que garante que os comandos serão executados pelo
menos uma vez. No enquanto, a expressão é avaliada no início e se o resultado for falso no primeiro
teste a lista de comandos não é executada nenhuma vez. Essa diferença faz com que em
determinadas situações o uso de uma estrutura seja mais vantajoso que o uso da outra. O exemplo a
seguir, onde são mostradas soluções para um problema, utilizando as duas estruturas, ilustram essa
diferença:
31
Problema: Faça um algoritmo que leia diversos números positivos e escreva, para cada um, o
número recebido. Terminar o algoritmo quando for informado um número negativo.
algoritmo "teste 1"
var
i:inteiro
inicio
escreva("Informe um número inteiro e positivo:")
leia(i)
enquanto i >=0 faca
escreval(i)
escreva("Informe um número inteiro e positivo.
Para sair informe -1:")
leia(i)
fimenquanto
fimalgoritmo
algoritmo "teste 2"
var
i:inteiro
inicio
repita
escreva("Informe um número inteiro e positivo:")
leia(i)
se i>=0 entao
escreval(i)
fimse
ate i < 0
fimalgoritmo
Neste algoritmo, se o primeiro valor for negativo, o algoritmo não deve escrever nada. Para que isso
ocorra um teste do valor deve ser feito antes da escrita. Como no Repita o teste é feito ao final,
outro teste deve ser colocado no início do laço, o que faz com que, a cada iteração, dois testes sejam
feitos. Isto não ocorre no Enquanto, onde o teste é feito no início, não sendo, portanto, necessário
um teste adicional.
Para..Faca
Forma geral:
Para <variável de controle> De <valor inicial> Ate<valor final> [Passo<incremento>] Faca
<lista de comandos>
FimPara
Na estrutura Para, a variável de controle é inicializada com <valor inicial> e no início de cada
iteração o valor da variável de controle é comparado com <valor final>. Se o valor da variável for
menor ou igual a <valor final>, a lista de comandos é executada e após ser executado o último
comando da lista, a variável de controle é incrementada. Isto repete-se até que o valor da variável de
controle seja maior que <valor final>, quando então é executado o comando imediatamente após a
32
palavra Fim. A condição Passo não é obrigatória, mas se precisar incrementar a variável de controle
você deve utilizar, por exemplo, você quer que a variável de controle pule em Dois em Dois a
sintaxe ficaria assim:
para i de 1 ate 1000 passo 2 faca
<lista de comandos>
fimpara
A estrutura Para é uma estrutura de repetição mais completa que as anteriores, pois ela incorpora a
inicialização, incremento e teste de valor final da variável de controle. É preferencialmente utilizada
em situações em que sabe-se previamente o número de repetições a serem feitas. Este número de
repetições pode ser uma constante ou estar em uma variável.
A seguir serão apresentados alguns problemas utilizando estruturas de repetição e desenvolvidas
algumas soluções para os mesmos.
Problema 1:
Faça um algoritmo que leia 5 números e escreva somente os que forem positivos.
Solução:
Neste problema, a mesma ação é repetida 5 vezes. Em cada uma delas um número é lido e, se for
positivo, é escrito. Como o número de repetições é definido (5), pode-se utilizar a estrutura para.
Uma possível solução para o algoritmo é a seguinte:
algoritmo "teste 3"
var
numero :real
i: inteiro
inicio
para i de 1 ate 5 passo 1 faca
escreva("Informe um
número:")
leia (numero)
se numero>0 entao
escreval (numero)
fimse
fimpara
fimalgoritmo
Neste algoritmo são utilizadas duas variáveis, cada uma com uma função bem definida. A variável i
é usada para controlar o número de repetições e a variável número é utilizada para armazenar cada
um dos valores lidos. Ao escrever um algoritmo é importante ter bem clara a função de cada
variável. Como serão lidos 5 números diferentes, a leitura do número deve ser feita dentro do laço.
Problema 2:
Faça um algoritmo que leia um número N e escreva todos os números de 1 a N.
Solução:
Neste problema, é lido um número N, e são escritos todos os números de 1 a N. Para isso deve ser
utilizado uma estrutura de repetição. Como o número de repetições é conhecido (está na variável N)
33
pode-se utilizar a estrutura Para. Uma possível solução para o problema é a seguinte:
algoritmo "teste 4"
var
i,numero :inteiro
inicio
escreva("Informe um número:")
leia (numero)
para i de 1 ate numero faca
escreval(i)
fimpara
fimalgoritmo
Vale observar que, como nesse algoritmo é lido apenas um número, a leitura do mesmo deve ser
feita fora da estrutura de repetição.

Exercícios de Algoritmos com Repetição
1) A conversão de graus Fahrenheit para centígrados é obtida pela fórmula C = 5/9 (F-32). Escreva
um algoritmo que calcule e escreva uma tabela de graus centígrados em função de graus
Fahrenheit que variem de 32 a 212 de 1 em 1. A tabela deverá ser semelhante à mostrada
abaixo:
Graus Fahrenheit Graus Celsius
32 0
33 0.6
34 1.1
... ...
212 100
2) Implementar um algoritmo capaz de encontrar o maior e o menor dentre 20 números inteiros
quaisquer. Desconsiderar números iguais. (Exercício resolvido no Anexo I)
3) Escrever um algoritmo que calcule a média obtida por uma turma de "n" alunos na primeira
prova do semestre, onde o valor de n será informado pelo usuário.
4) Escrever um algoritmo que, dada uma seqüência de valores inteiros e positivos, determine qual
é o menor valor desta seqüência e a média aritmética dos valores pares. O valor 0 (zero) indica o
término dos dados de entrada, ou seja, o programa termina quando for informado o valor
0(zero).
5) Em uma cidade do interior, sabe-se que, de janeiro a abril de 1976(121 dias), não ocorreu
temperatura inferior a 15ºC nem superior a 40ºC. As temperaturas verificadas em cada dia serão
lidas e armazenadas em um vetor. Fazer um algoritmo leia a temperatura ocorrida dia-a-dia,
calcular e imprimir:
a) A menor temperatura ocorrida;
b) A maior temperatura ocorrida;
c) A temperatura média; (Exercício resolvido no Anexo I)
34
6) Num frigorífico existem 90 bois. Cada boi traz preso no seu pescoço um cartão contendo um
número de identificação e seu peso. Implementar um algoritmo que escreva o número e o peso
do boi mais gordo e do boi mais magro (não é necessário armazenar os dados de todos os bois).
7) Escrever um algoritmo que leia o nome, sexo, altura e idade de um grupo de 50 pessoas e
informe:
- Média das alturas dos homens; - Média de idades das mulheres;
- Nome do homem mais alto; - Nome da mulher mais nova;
8) Escrever um algoritmo que lê vários valores reais, um de cada vez, e calcular o percentual de
números negativos em relação ao total de números informados. Imprimir o resultado final. Sair
do algoritmo quando for informado o valor 0(zero) no valor lido. O percentual de números
negativos é calculado dividindo-se a quantidade de números negativos informados pela
quantidade total de números. (Exercício resolvido no Anexo I)
A série de Fibonacci tem como valores iniciais os dois primeiros termos da série que são
respectivamente 0 e 1. A partir deles os demais termos são construídos pela regra abaixo. Escrever
um algoritmo que gera os 15 primeiros termos da série de Fibonacci e calcula e escreve a soma
destes termos.
9) Escrever um algoritmo que lê um valor n e outro valor m, e calcula a tabuada de n de 1 até m.
Exemplo: Supor que o usuário informe os seguintes valores: n=8 e m=12. Então tem-se:
1 x 8 = 8
2 x 8 = 16
. . .
. . .
12 x 8 = 96
10) Um prédio comercial tem três elevadores, denominados A, B e C. Para otimizar o sistema de
controle dos elevadores, foi realizado um levantamento estatístico com 1000 usuários, onde
cada usuário respondia:
• O elevador que utilizava com maior freqüencia;
• O andar ao qual se dirigia;
• O período que utilizava o elevador, entre M = matutino, V = vespertino e N = noturno;
Construa um algoritmo que calcule e imprima:
• Quantos usuários que utilizaram o elevador A foram para o décimo andar;
• Qual é o elevador mais freqüentado e em que horário se encontra seu maior fluxo;
• Qual o horário mais usado de todos e a que elevador pertence;
• Qual a diferença percentual entre o horário mais usado e o menos usado;
• Quantos usuários utilizam os elevadores que estão do primeiro ao quinto andar.
11)Fazer um algoritmo para calcular a soma de todos os múltiplos de 7 entre 100 e 500. (Exercício
resolvido no Anexo I)
12) Faça um algoritmo que imprima os números inteiros decrescentes compreendidos entre 100 e
10.
13) Faça um algoritmo que imprima a tabuada do número 5 da seguinte maneira:
35
5x0=0
5x1=5
5x2=10
...
5x10=50
14) Faça um algoritmo que imprima a soma dos números ímpares compreendidos entre 10 e 100.
15)Faça um algoritmo que imprima o valor de S da seguinte série: (Exercício resolvido no Anexo I)
16) Faça um algoritmo que imprima o valor de H da seguinte série:
17) Faça um algoritmo que leia um número inteiro e positivo N e imprima o valor de S da seguinte
série:
S = 1 + 1/2 + 1/3 + ... + 1/N
18)Faça um algoritmo que imprima a soma dos 20 primeiros termos da serie abaixo, onde o
denominador representa o fatorial do número.
19)Um Jequitibá tem 1.50 e cresce 1 centímetro por ano. Uma jaqueira tem 1.10 e cresce 2
centímetros por ano. Uma Jabuticabeira tem 1.98 e não cresce mais. Construa um programa em
C/C++ que calcule e imprima: a) qual árvore terá a maior altura após 32 anos e, b) Após quantos
anos a jaqueira será a maior das três árvores.
20) Faça um algoritmo que leia um conjunto de valores que representam a idade de pessoas e
imprima a maior e a menor idade. O último valor informado não é válido e será o finalizador do
programa.
21) Faça um algoritmo que leia a altura de moças inscritas em um concurso de beleza. Para finalizar
será digitado zero na altura. Imprima as duas maiores alturas.
22) Faça um algoritmo que leia a altura de 1000 pessoas e imprima a maior, a menor, a média destas
alturas. Imprima também quantas alturas maiores que 1.60 e quantas menores que 1.30.
23)Faça um algoritmo que leia os dados de cada empregado: nome, salário por dia e número de dias
trabalhados de uma firma de 200 empregados. Imprima o salário a ser pago a cada empregado, o
salário total a ser pago aos empregados e a média dos salários.
24) Faça um algoritmo que leia a altura e o sexo de 100 pessoas e imprima:
50
99
4
7
3
5
2
3
1
1
H + + + + + · 
2
30
54
4
56
3
58
2
60
1
S − + − + − · 
 + + + +
! 3
97
! 2
98
! 1
99
! 0
100

36
- Quantos homens e mulheres foram medidas;
- Quantos homens acima de 1,70;
- Percentual entre as mulheres que possuem altura entre 1.50 e 1.90.
- A média das alturas das mulheres.
25) Deseja-se fazer uma pesquisa a respeito do consumo mensal de energia elétrica em uma
determinada cidade. Para isso, são fornecidos os seguintes dados: Preço do KWH consumido,
Número do consumidor, Quantidade de KWH consumidos durante o mês e o Código do tipo de
consumidor ( R para residencial , C para Comercial e I para industrial). O Número do consumidor
igual a zero deve ser usado para término do algoritmo. Ler os dados acima e imprimir:
- Para cada consumidor, o seu número e o total a pagar;
- Maior e o menor consumo verificado;
- Total do consumo para cada um dos três tipos de consumidores;
- A média de consumo.
26) Fazer um algoritmo para ler 20 números reais e calcular e imprimir o desvio-padrão e a
variância, utilizando a seguinte fórmula:
( )

− ·
N
i
x x
N
1
2 1
σ
Seguir os seguintes passos:
1. Calcular o valor médio .
2. Para cada valor x
i
, calcula-se a diferença entre x
i
e o valor médio .
3. Calcula-se o quadrado dessa diferença.
4. Encontra-se a soma das diferenças dos quadrados.
5. Divide-se este resultado pelo número de valores (N). Esta quantidade é a variância.
6. Tome a raiz quadrada deste resultado. Este novo valor é o desvio-padrão.
Variáveis Compostas Homogêneas
Vimos, no início deste curso, ser possível dar um Nome para uma posição de memória, sendo que a
esta memória será associada a um valor qualquer. Pois bem, acontece que, muitas vezes, esta forma
de definição, ou, melhor dizendo, de alocação de memória, não é suficiente para resolver certos
problemas computacionais. Imagine por Exemplo, como faríamos para construir um algoritmo, para
ler 1000 números e que imprimisse um relatório destes mesmos números, mas ordenados
alfabeticamente? Não seria uma tarefa simples, como é mostrado abaixo:
algoritmo "loucura"
var
num1, num2, num3, num4, num5, num6, num7, num8,... num1000:inteiro
inicio
leia(num1,num2,num3,num4,..,num1000)
:
:
fimalgoritmo
Considere o tamanho do algoritmo, e o trabalho braçal necessário para construí-lo. Isto só com
1.000 Números, imagine agora 1.000.000 de números. A construção deste algoritmo começaria a
ficar inviável na prática. Para resolver problemas como este, e outros, foi criado um novo conceito
37
para alocação de memória sendo, desta forma, também criado uma nova maneira de definirem
variáveis, a qual foi denominada de variável indexada.
Uma variável indexada corresponde a uma seqüência de posições de memória, a qual será dada um
único nome, sendo que cada uma destas pode ser acessada através do que conhecemos por índice. O
índice corresponde a um valor inteiro, ou a um valor caractere (exceto CADEIA). Cada uma das
posições de memória de uma variável indexada pode receber valores no decorrer do algoritmo como
se fosse uma variável comum, a única diferença reside na Sintaxe de utilização desta variável.
Variáveis Indexadas Unidimensionais (Vetores)
Também conhecida por "Vetor". Uma variável unidimensional, como o próprio nome já indica,
possui apenas uma dimensão, sendo possível definir variáveis com quaisquer tipos de dados.
Declaração de Vetores
Sintaxe:
<identificador>: VETOR [<tamanho>] <tipo (numerico, logico, caracter ou cadeia)>
Ex.: idades: vetor [5] de inteiro
Atribuindo Valores a Elementos do Vetor
Para se atribuir um valor a um elemento do vetor devemos utilizar o seguinte padrão:
Sintaxe:
< identificador>[<posição>] <- <valor>

Exemplo :
idades[3] <- x
idades[1] <- 2
idades[i] <- i^2
Problema 1 - Escrever um algoritmo que lê um vetor V de 6 posições e o escreve. Conte, a seguir,
quantos valores de V são negativos e escreva esta informação.
Solução:
Neste problema, a mesma ação é repetida 6 vezes e mostra os valores lidos, logo a seguir pede para
dizer quantos desses números são negativos. Para isso deve ser utilizada uma estrutura de repetição
para receber os valores lidos e uma condição para contar quantos números são negativos. Uma
possível solução para o algoritmo é a seguinte:
38
Algoritmo conta_vetor
vet: vetor[6] de inteiro
i,conta_neg: inteiro
Inicio
conta_neg <- 0
Para i de 1 ate 6 faca
leia(vet[i])
se vet[i]<0 entao
conta_neg <- conta_neg + 1
fimse
fimpara
para i de 1 ate 6 faca
escreval(vet[i])
fimpara
escreva("total de números negativos: ", conta_neg)
Fimalgoritmo
Exercícios sobre Vetores
1) Qual será a configuração do vetor depois de executado os comandos abaixo?
Para I de 2 ate 4 faca
aux <- C[I]
C[I] <- C[8-I+1]
C[8-I+1] <- aux
fimpara
aux <- C[1]
C[1] <- C[8]
C[8] <- aux
2) Declarar um vetor de 100 posições e preenchê-lo com 0 nas posições pares e 1 nas posições
ímpares.
3) Dados 2 vetores V1 de 5 elementos e V2 de 10 elementos. Ler os dois vetores e gerar um
terceiro vetor V3 de 15 elementos, cujas 5 primeiras posições devem ser preenchidas com os
elementos de V1 e as outras 10 devem ser preenchidas com os elementos de V2.
4) Implementar um algoritmo que leia 50 notas de provas e as respectivas matrículas dos
indivíduos, e calcule e imprima:
a) A média das notas;
b) Quantas notas estão acima e abaixo da média calculada no item a (não considerar notas iguais à
média);
c) Quantas pessoas possuem a maior e a menor das notas, e quais são elas (isto é, suas matrículas).
5) Existem 20 candidatos a prefeitura com códigos que variam de 1 a 20. O código 21 é definido
para voto em branco e o 22 é para voto nulo. Qual é o numero de votos de cada candidato, o número
de votos em branco, o numero de votos nulos e o total de votantes. Para o processamento quando
for lido -1 no código.
U O T R E C A
1 2 3 4 5 6 7 8
!
39
6) Fazer um algoritmo para ler 80 valores inteiros entre 0 e 10, e responder qual é a freqüência
absoluta e a freqüência relativa. Freqüência absoluta é a quantidade de cada valor. Freqüência
relativa é a quantidade de cada valor dividido pela quantidade total de valores. (Exercício resolvido
no Anexo I)
7) Vetor suavizado é uma técnica utilizada para cálculos de configuração de cores, para 50
elementos reais, conforme regra abaixo. Ler os valores do vetor V e calcular e imprimir o vetor
suavizado S.
S[I]=(V[I-1]+V[I]+V[I+1])/3, se I <> 1 e I <> 50;
S[I]=(V[I]+V[I+1])/2, se I = 1;
S[I]=(V[I-1]+V[I])/2, se I = 50;
8) Dada uma seqüência numérica de 50 elementos armazenados num vetor, determinar o maior
elemento do conjunto e o seu índice (posição). Suponha que não existam elementos repetidos no
vetor.
Ordenação de Vetores
Ordenar um vetor é colocar seus componentes sob algum critério de ordenação (ascendente ou
descendente). Existem vários algoritmos de ordenação. Um método simples de ordenação é
comparar cada elemento com todos os outros elementos a partir dele. Por exemplo, para a
ordenação de um vetor de N elementos:
Para I de 1 ate (N-1) faca
Para J de (I+1) ate N faca
Se V[J] > V[I] entao
AUX <- V[I]
V[I] <- V[J]
V[J] <- AUX
Fimse
Fimpara
Fimpara
Existem vários algoritmos de ordenação, cada um apresentando maior ou menor eficiência, por
exemplo Bubble Sort, Quick Sort, HeapSort, Shell Sort etc...
Exercício:
1. Faça um algoritmo que leia 20 números inteiros e apresente-os em ordem crescente.
Variáveis Indexadas Multidimensionais (Matrizes)
Também conhecida por "Matriz". Uma variável Multidimensional, como o próprio nome já indica,
possui duas ou mais dimensões, sendo ser possível definir variáveis com quaisquer tipo de dados
válidos.

40
Atribuindo Valores a Elementos da Matriz bidimensional
Problema 1 - Escreva um algoritmo que lê uma matriz M(3,3) e calcula as somas:
a) da linha 3 de M.
b) da coluna 2 de M.
c) da diagonal principal.
d) da diagonal secundária.
e) de todos os elementos da matriz.
Solução:
Neste problema, temos uma matriz quadrada de ordem três por três, sendo 3x3 = 9 ações que são
repetidas, logo a seguir o problema solicita a soma da linha três da matriz M[3,quantidade de
colunas], soma da coluna dois M[quantidade de linhas,2], diagonal principal onde os índices da
coluna e linha sempre são iguais, soma da diagonal secundária onde o índice da coluna vai ser a
ordem da matriz quadrada mais um e menos o índice da linha e a soma de todos os elementos da
matriz. Para isso deve ser utilizada uma estrutura de repetição para receber os valores lidos e
algumas condições para verificar as questões pedidas. Uma possível solução para o algoritmo é a
seguinte:
ALGORITMO "Matrizes"
var
mat: VETOR[1..3,1..3] de Inteiro
i,j,somaLinha3,somaColuna2: Inteiro somaDiagPrinc,somaDiagSecu,somaTudo:
Inteiro
Inicio
somaLinha3 <- 0
somaColuna2 <- 0
somaDiagPrinc <- 0
somaDiagSecu <- 0
somaTudo <- 0
para i de 1 ate 3 faca
para j de 1 ate 3 faca
leia(mat[i,j])
somatudo <- mat[i,j] + somaTudo
se i=3 entao
somalinha3 <- mat[i,j]+ somaLinha3
fimse
se j=2 entao
somaColuna2 <- mat[i,j]+ somaColuna2
fimse
se i=j entao
somaDiagPrinc <- mat[i,j]+ somaDiagPrinc
fimse
se j=4-i entao
somaDiagsecu <- mat[i,j]+ somaDiagsecu
fimse
fimpara
fimpara
para i de 1 ate 3 faca
para j de 1 ate 3 faca
escreva (mat[i,j])
fimpara
fimpara
escreval("soma de todos os elementos é ", somatudo)
41
escreval("soma dos elementos da linha 3 é ", somalinha3)
escreval("soma dos elementos da coluna 2 é ", somacoluna2)
escreval("soma dos elementos da diagonal principal é ", somadiagprinc)
escreval("soma dos elementos da diagonal secundária é ", somadiagsecu)
fimalgoritmo
Exercícios
1) Implementar um algoritmo para multiplicar duas matrizes de números inteiros. A multiplicação
só é possível se o número de colunas da matriz A for igual ao número de linhas da matriz B. Supor
a Matriz A sendo 3x4 e a matriz B é 4x3. Sugestão: Procurar livro Algoritmo Estruturado – Ferrer.
2) Faça um algoritmo que leia uma matriz 3 X 4 por linha e imprima a soma de todos os elementos
da matriz superior.
3) Faça um algoritmo que leia uma matriz 7 X 7 por linha e imprima somente a matriz triangular
inferior.
4) Faça um algoritmo que leia 5 notas dadas a cada aluno durante o período letivo em uma turma de
30 alunos. Calcule a média de cada aluno, a média geral da turma, e imprima de acordo com o
seguinte layout:
Núm. Aluno Notas Média Aluno
1 9.9 9.9 9.9 9.9 9.9 9.9 9.9
.... ... ... ... ... ... ... ...
.... ... ... ... ... ... ... ...
.... ... ... ... ... ... ... ...
Média Geral da Turma: 9.9
5) Na Teoria de Sistemas define-se como elemento minimax de uma matriz o menor elemento da
linha em que se encontra o maior elemento da matriz. Escreva um programa que preencha uma
matriz M(15,15) por leitura e determine o seu elemento minimax.
42
Anexo I – Lista de exercícios resolvidos
Seção 3.8
Exercício 6
Leia uma média e um número de faltas dadas a um aluno e imprima aprovado, reprovado por média
e por falta, reprovado por média ou reprovado por falta. Sendo média maior igual a 7 indica
aprovado, e faltas maior igual a 32 indica reprovado.
algoritmo "Verifica aprovação do aluno"
// Função : Ler média e um número de faltas dadas a um aluno e verifica
aprovação ou reprovação
// Autor : Edilson Luiz do Nascimento
// Data : 16/2/2008
var
media,nota1,nota2:real
faltas:inteiro
inicio
escreva("Informe as duas notas do aluno:")
leia(nota1,nota2)
escreva("Informe o número de faltas:")
leia(faltas)
media<-(nota1+nota2)/2
Escreva("A média do aluno foi ",media:6:1," e ",faltas," faltas,")
se (media >= 7) e (faltas < 32) entao
Escreva(" e o aluno foi APROVADO.")
senao
se (media < 7) e (faltas < 32) entao
Escreva(" e o aluno foi Reprovado por Nota.")
senao
se (media >= 7) e (faltas > 32) entao
Escreva(" e o aluno foi Reprovado por Nota.")
senao
se (media < 7) e (faltas > 32) entao
Escreva(" e o aluno foi Reprovado por Nota e Faltas.")
fimse
fimse
fimse
fimse
fimalgoritmo
Exercício 8
Construa um algoritmo para calcular as raízes de uma equação do 2o. grau, sendo que os valores de
A , B e C são fornecidos pelo usuário. Não se esqueça de verificar se o valor de Delta é maior ou
igual a zero, ou seja, se existem raízes reais.
algoritmo "Calcula raizes"
// Função : Calcular as raízes de uma equação de 2o. grau, sendo os
coeficientes
// da equação Ax2 + Bx + C = 0 fornecidos pelo usuário
// Autor : Edilson Luiz do Nascimento
// Data : 16/2/2008
// Seção de Declarações
43
// A, B, C - Coeficientes da equaão de primeiro grau, fornecidos pelo
usuário
// Delta - Calcula o valor de Delta
// X1, X2 - Raízes da equação
var
A,B,C,Delta,X1,X2:Real //Declaração das variáveis
inicio
Escreva("Informe os valores dos coeficientes da equação:")
Leia(A,B,C) //Entrada de dados
Delta <- Quad(B) - 4*A*C //Cálculo do valor de delta
Se Delta > 0 entao //Serão duas raízes reais
X1<- (-B + Raizq(Delta))/(2*A)
X2<- (-B - Raizq(Delta))/(2*A)
Escreva("As raizes serão:", X1:6:1, X2:6:1)
senao
Se Delta = 0 entao //Uma única raiz real
X1<- (-B + Raizq(Delta))/(2*A)
Escreva("A raiz será:", X1:6:1)
senao
Escreva("Não há raizes reais")
fimse
fimse
fimalgoritmo
Exercício 15
Escrever um algoritmo para ler a hora de início e hora de término de um jogo, ambas expressas em
horas e minutos. Calcular e escrever a duração do jogo, também em horas e minutos, considerando
que o tempo máximo de duração de um jogo é de 24 horas e que o jogo pode iniciar em um dia e
terminar no dia seguinte. Se o usuário informar horas maiores que 24 ou minutos maiores que 59,
informar mensagem de erro: “Entrada de dados não é válida”.
Exemplo: Hora inicial do jogo: 23 Minuto inicial do jogo: 50
Hora final do jogo: 01 Minuto final do jogo: 45
Duração do jogo: 1 hora e 55 minutos
Observação: Neste problema temos que analisar vários casos:
1 - Hora início do jogo menor que Hora Fim do jogo
1.1 - Minuto Início do jogo maior que minuto fim do jogo
Exemplo 1: 8:40H até 10:30H
Nesse caso teremos que subtrair os minutos, mas "pegando emprestado" uma hora para que a
subtração fique correta, ou seja, acrescentamos 60 aos minutos finais e subtraimos em um da hora
final;
1.2 - Minuto Início do jogo menor que minuto fim do jogo;
Exemplo 2: 8:40H até 10:50H
Nesse caso fazemos a subtração dos minutos e das horas normalmente.
2 - Hora início do jogo maior que Hora Fim do jogo
2.1 - Minuto Início do jogo menor que minuto fim do jogo
Exemplo 3:22:30 até 1:40
44
Neste caso o jogo passou para o dia seguinte. No caso dos minutos, a subtração ocorre normalmente
e somamos 24 a hora final para podermos fazer a subtração correta.
2.2 - Minuto Início do jogo maior que minuto fim do jogo
Exemplo 4 - 22:50 até 1:40
Neste caso o jogo passou para o dia seguinte, e, além disso, os minutos do fim de jogo são menores
que os minutos de início. Nesse caso teremos que subtrair os minutos, mas "pegando emprestado"
uma hora para que a subtração fique correta, ou seja, acrescentamos 60 aos minutos finais e
subtraimos em um da hora final. Além disso, Assim, somamos 24 na hora final para podermos fazer
a subtração correta.
algoritmo "Calcula duração do jogo"
// Função : Lê hora início e término do jogo, e calcula a sua duração
// Autor : Edilson Luiz do Nascimento
// Data : 16/2/2008
//HoraIni - Hora de início do jogo
//HoraIni - Hora de fim do jogo
//MinIni - Minuto de início do jogo
//MinIni - Minuto de fim do jogo
//DurHoras – Duração do jogo em Horas
//DurMin – Duração do jogo em Minutos
var
HoraIni,HoraFim, MinIni, MinFim,DurHoras,DurMin:Inteiro
inicio
Escreva("Escreva o horário do início do jogo, em horas e minutos:")
Leia(HoraIni,MinIni)
Escreva("Escreva o horário de Fim do jogo, em horas e minutos:")
Leia(HoraFim,MinFim)
//Item 1 - Hora início do jogo menor que hora fim
Se HoraIni < HoraFim então
//Item 1.1 - Minuto início do menor maior que minuto fim
Se MinIni > MinFim entao
DurMin <- MinFim - MinIni + 60 // "pega emprestado" uma hora
//Subtraindo de um, pois os minutos "pegaram emprestado" uma hora
DurHoras <- HoraFim - HoraIni - 1
Senão
//Item 1.2 - Minuto início menor ou igual ao minuto fim do jogo
Se MinIni <= MinFim entao
DurMin <- MinFim – MinIni // Calcula normalmente os minutos
DurHoras <- HoraFim - HoraIni //Calcula normalmente as horas
fimse
fimse
senao
//Item 2 - Hora início do jogo maior ou igual à hora fim
Se HoraIni >= HoraFim entao
//Item 2.1 - Minuto início do menor maior que minuto fim
Se MinIni > MinFim entao
DurMin <- MinFim - MinIni + 60 //"pega emprestado" uma hora
//subtrai de um, pois os minutos "pegaram emprestado" uma hora, além
do //jogo ter terminado no dia seguinte
DurHoras <- HoraFim - HoraIni - 1 + 24
Senao
//Item 2.2 - Minuto início do menor maior que minuto fim
Se MinIni <= MinFim então
DurMin <- MinFim - MinIni // Calcula normalmente os minutos
DurHoras <- HoraFim - HoraIni + 24
45
fimse
fimse
fimse
fimse
escreval //Deixar uma linha em branco
//Impressão da duração do jogo
escreval("A duração do jogo foi de ",DurHoras," Horas e ",DurMin,"
minutos.")
fimalgoritmo
Seção 3.10
Exercício 5
Em uma cidade do interior, sabe-se que, de janeiro a abril de 1976(121 dias), não ocorreu
temperatura inferior a 15ºC nem superior a 40ºC. As temperaturas verificadas em cada dia serão
lidas e armazenadas em um vetor. Fazer um algoritmo que calcule e imprima:
d) A menor temperatura ocorrida;
e) A maior temperatura ocorrida;
f) A temperatura média;
Algoritmo "Temperaturas"
//Função: Ler 121 temperaturas, e calcular a maior, menor e temperatura
média
//Autor: Edilson Luiz do Nascimento
//Data: 16/02/2008
//Temp - Temperatura a ser lida
//Maior - Armazena a maior temperatura
//Menor - Armazena a maior temperatura
//Soma - Acumula a leitura das temperaturas, para posterior cálculo da
Temperatura média
//TempMedia - Temperatura média do período
//primeiro - Auxilia na inicialização da maior e menor temperatura com a
primeira temperatura lida
//I - índice da variável de controle da repetição
var
primeiro:logico
I,Tam:inteiro
Temp,Maior, Menor, Soma, TempMedia:Real
Inicio
Soma <- 0
TempMedia <- 0
Tam <-3
primeiro <- verdadeiro
Para I de 1 ate Tam faca
Escreva("Informe a ",I,"ª temperatura:")
Leia(Temp)
Enquanto (Temp < 15) ou (Temp > 40) faca
Escreval("Erro. Não ocorreu temperaturas menores que 15ºC nem
maiores que 40ºC")
Escreva("Informe a ",I,"ª temperatura correta: ")
Leia(Temp)
Fimenquanto
//Acumula as temperaturas de todos os dias para o cálculo da média
Soma <- Soma + Temp
Se primeiro entao
{Inicialização das variáveis Maior e Menor}
46
Maior <- Temp
Menor <- Temp
primeiro <- falso
fimse
Se Temp > Maior entao {Verificação da Maior temperatura do período}
Maior <- Temp
Fimse
Se Temp < Menor entao {Verificação da Menor temperatura do período}
Menor <- Temp
Fimse
Fimpara
TempMedia <- Soma/Tam
Escreval("A menor temperatura no período foi:", Menor:6:2)
Escreval("A maior temperatura no período foi:", Maior:6:2)
Escreva("A temperatura média do período foi de:",TempMedia:6:2)
Fimalgoritmo
Exercício 8
algoritmo "Calcula percentual de negativos"
// Função : Ler diversos números reais e imprimir o percentual de
// números negativos em relação ao total de números lidos. Sair quando
// for informado o valor zero.
// Autor : Edilson Luiz do Nascimento
// Data : 18/2/2008
// Seção de Declarações
var
num,perc_neg:real
cont_neg, cont_num: inteiro
inicio
//Inicialização das variáveis com zero
cont_num<-0
cont_neg<-0
Escreva("Informe um número real. Para sair informe 0(zero):")
leia(num)
enquanto num <> 0 faca // repetição até encontrar valor informado zero
cont_num <- cont_num+1 //Conta a quantidade de números lidos
se num<0 entao //Verifica se o número lido é igual a zero, contando-o
cont_neg <- cont_neg +1
fimse
Escreva("Informe um número real. Para sair informe 0(zero):") //Lê
novo número
leia(num)
fimenquanto
perc_neg <- (cont_neg/cont_num)*100 //Calcula o percentual de números
negativos
escreva("Existem ",perc_neg:4:1,"% de números negativos.") //Mostra
// resultados finais, alinhando 4 posições e 1 casa após a vírgula
fimalgoritmo
Exercício 11
algoritmo "Calcula Soma"
// Função : Calcula e imprime a soma dos múltiplos de 7 entre 100 e 500
// Autor : Edilson Luiz do Nascimento
// Data : 18/2/2008
// Seção de Declarações
47
//I - Variável de controle da repetição
//Soma - Acumula a soma dos múltiplos de 7 no intervalo especificado
var
I,Soma:Inteiro
inicio
Soma<-0
Para I de 100 ate 500 faca
Se I%7=0 entao //Captura os múltiplos de 7
Soma<-Soma+I //Acumula os múltiplos de 7
fimse
Fimpara
Escreva("A soma de todos os múltiplos de 7 entre 100 e 500 é ",Soma)
fimalgoritmo
// Outra solução
inicio
Soma<-0
//Inicia com o primeiro múltiplo de 7 após o valor 100, e conta de 7 em 7
Para I de 105 ate 500 passo 7 faca
Soma<-Soma+I
Fimpara
Escreva("A soma de todos os múltiplos de 7 entre 100 e 500 é ",Soma)
fimalgoritmo
Exercício 15
algoritmo "Calcula termos da série”
// Função : Calcular a soma da série 1/60 – 2/58 + 3/56...-30/2
// Autor :
// Data : 18/2/2008
// Seção de Declarações
var
//I - Variável de controle da repetição
//Num - Variável que assume os valores do Numerador
//Den - Variável que assume os valores do Denominador
//Soma - Acumula os valores das frações geradas
I,Num,Den, TAM:Inteiro
Soma:Real
inicio
//Inicialização das variáveis
Num<-1
Den<-60
Soma<-1/60
TAM<- 30
Para I de 2 ate TAM faca
Se I%2=0 entao
Soma<-Soma - (Num/Den) //Parcelas negativas das frações
senao
Soma<-Soma + (Num/Den) //Parcelas positivas das frações
Fimse
Num<-Num+1 //Avança o numerador
Den<-Den-2 //Avança o denominador
Fimpara
Escreva("A soma da Série é ",Soma:4:2)
Fimalgoritmo
48
Seção 3.11.1.2
Exercício 6
Fazer um algoritmo para ler 80 valores inteiros entre 0 e 10, e responder qual é a freqüência
absoluta e a freqüência relativa. Freqüência absoluta é a quantidade de cada valor. Freqüência
relativa é a quantidade de cada valor dividido pela quantidade total de valores.
Algoritmo "Frequências"
//Função: Ler 80 valores inteiros e calcular a freqüência absoluta e
relativa.
//Autor: Edilson Luiz do Nascimento
//Data: 18/02/2008
var
//Declaração do vetor de Notas
Nota: Vetor[1..10] de Inteiro
//Declaração do vetor de Frequência absoluta
F: Vetor[0..10] de Inteiro
I, TAM : Inteiro
inicio
TAM<-10
Escreva("Informe as Notas:") {Leitura das notas}
Para I de 1 ate TAM faca
Leia(Nota[I])
Fimpara
Para I de 0 ate TAM faca {Inicialização da variável que vai
acumular a frequência absoluta}
F[I] <- 0
Fimpara
{Cálculo da Freqüência Absoluta das notas - Observar que o conteúdo do
vetor nota é o índice do vetor de freqüência absoluta}
Para I de 1 ate TAM faca
F[Nota[I]] <- F[Nota[I]] + 1
Fimpara
{Impressão da freqüência absoluta e freqüência relativa}
Para I de 0 ate 10 faca
Se F[I]<>0 entao //Imprime apenas as freqüências diferentes de zero
Escreval("A freqüência absoluta da nota:", I, " é ", F[I])
Escreval("A freqüência relativa da nota:", I, " é ",
(F[I]/TAM*100):0:1," %")
Escreval
fimse
Fimpara
Fimalgoritmo

ÍNDICE PLANO DE CURSO.........................................................................1 Objetivo.......................................................................................1 Ementa........................................................................................1 Metodologia ................................................................................1 Avaliação ....................................................................................1 Referências..................................................................................1 Recursos/Material de Apoio...........................................................1 INTRODUÇÃO................................................................................2 Conceitos.....................................................................................2 Métodos de Desenvolvimento de Algoritmos..................................3 Fluxogramas................................................................................3 Pseudocódigos Portugol...............................................................4 COMPILADOR DE ALGORITMOS VISUALG........................................5 Exercícios....................................................................................6 Linearização de Expressões...........................................................7 Operadores Aritméticos ...............................................................7 Operadores Aritméticos não convencionais....................................7 Operadores Relacionais ...............................................................7 Operadores Lógicos .....................................................................8 Tabela Verdade............................................................................8 Prioridade dos operadores............................................................8 Modularização de Expressões .......................................................8 Expressões Lógicas ......................................................................8 Exercícios....................................................................................9 Primeiros Elementos da Linguagem ............................................10 Identificadores ..........................................................................11 Regras para a nomeação de identificadores.................................11 Variáveis ...................................................................................11 Declaração de Variáveis .............................................................12 Tipos Primitivos de Dados ..........................................................13 Sinal de Atribuição ....................................................................13 Comandos de E/S (Entrada/Saída) ...............................................13

Linhas de Comentário ................................................................14 Estruturas Seqüenciais - Construindo os Primeiros Algoritmos......15 Exercícios ..................................................................................17 Estrutura Condicional.................................................................19 Tipos de comandos condicionais..................................................21 Testando o Algoritmo..................................................................23 Regras Práticas para Construir Algoritmos Legíveis......................24 Exercício resolvido......................................................................24 Exercícios – Resolver os algoritmos de números pares na forma de pseudocódigo e os ímpares na forma de fluxogramas...................27 Estrutura de Repetição...............................................................29 Repita..Até ................................................................................29 Enquanto..Faca ..........................................................................30 Para..Faca .................................................................................31 Exercícios de Algoritmos com Repetição......................................33 Variáveis Compostas Homogêneas...............................................36 Variáveis Indexadas Unidimensionais (Vetores) ...........................37 Declaração de Vetores ...............................................................37
Atribuindo Valores a Elementos do Vetor............................................37

Exercícios sobre Vetores.............................................................38 Ordenação de Vetores.................................................................39 Variáveis Indexadas Multidimensionais (Matrizes) .......................39 Atribuindo Valores a Elementos da Matriz bidimensional..............40 Exercícios...................................................................................41 Anexo I – Lista de exercícios resolvidos........................................42 Seção 3.8...................................................................................42
Exercício 6......................................................................................................................42 Exercício 8......................................................................................................................42 Exercício 15....................................................................................................................43

Seção 3.10.................................................................................45
Exercício Exercício Exercício Exercício 5......................................................................................................................45 8......................................................................................................................46 11....................................................................................................................46 15....................................................................................................................47

Seção 3.11.1.2............................................................................48
Exercício 6......................................................................................................................48

1

PLANO DE CURSO Nome da disciplina: Prática Pedagógica VI - Informática na Educação II Carga Horária Total: 80 horas/aulas Objetivo Esta disciplina tem por objetivo fornecer subsídios técnicos e práticos na construção de algoritmos e desenvolvimento de programas, utilizando uma ferramenta de compilação de algoritmos (Visualg 2.0), e uma linguagem de programação científica, nos moldes das necessidades dos cursos de Matemática (MATLAB 7.0). Ementa               Os conceitos de Lógica de Programação; Ferramentas de desenvolvimento: Pseudocódigo – PORTUGOL; Fluxogramas; Compilador de Algoritmos: Visualg 2.0 Tipos básicos de variáveis; Declaração de variáveis; Comandos de atribuição; Operadores Aritméticos, Lógicos e Relacionais; Comandos de E/S; Comandos Alternativos; Estruturas de repetição; Vetor; Matriz;

Metodologia Aulas expositivas, aulas práticas em laboratório, dinâmica de grupo, seminários, estudos de caso; Avaliação Testes diagnósticos; Provas formativas; Trabalhos em grupo (teóricos); Trabalhos em grupo (práticos em laboratório); Referências 1 – Guimarães/Lages – Algoritmos e Estruturas de Dados - Livros Técnicos e Científicos Editora S.A. 2 - Pinto, Wilson Silva - Algoritmos e Estruturas de Dados - Ed. Erika. 3 - Villar, André/Eberspcaher, Henri F. – Lógica de Programação. Ed. Makron Books. 4 - Farrer/Becker/Faria/Matos/Maia – Algoritmos Estruturados - Ed. Guanabara. Recursos/Material de Apoio

2

Quadro e pincel. Retroprojetor e transparências. Fontes bibliográficas e Apostilas. Laboratório contendo softwares necessários (Visualg 2.0 e Matlab 7.0) INTRODUÇÃO O COMPUTADOR é uma máquina capaz de fornecer a solução de um problema executando um roteiro com grande velocidade. Esse roteiro deve ser o mais detalhado possível, cercando todas as condições possíveis de acontecer, pois o computador não tem a capacidade de decidir por si só. Esse roteiro deve ser escrito em uma linguagem aceita pela maquina e que em sua fase final é chamado de PROGRAMA. A fase inicial, de definição dos passos a serem seguidos e dos desvios a serem considerados na solução de um problema, independe da linguagem de programação que será utilizada. Nesta fase o roteiro é chamado de ALGORITMO, e muitos métodos podem ser utilizados para defini-los. Então a utilização de um computador para resolver um problema exige, antes de mais nada, que se desenvolva um algoritmo, isto é, que se faça descrição de um conjunto de comandos que, obedecidos, provocarão uma sucessão finita de ações que resultarão na resolução do problema proposto. Este algoritmo deve ser transmitido ao computador e armazenado em sua memória, para em seguida, ser posto em execução e conduzir o computador para a solução desejada. A tarefa de programação envolve basicamente um processo de abstração de fatos e informações do mundo real. As informações devem ser modeladas em estruturas de dados enquanto as ações são transformadas em algoritmos. Deste modo devemos ter em mente que: PROGRAMA = ALGORITMO + ESTRUTURA DE DADOS Conceitos O processamento de dados é baseado num número finito de operações com os dados, organizados em certas seqüências lógicas, para obtenção dos resultados desejáveis. Segundo o Aurélio, Algoritmo é “um processo de cálculo, ou de resolução de um grupo de problemas semelhantes, em que se estipulam, com generalidade e sem restrições, as regras formais para a obtenção do resultado ou da solução do problema”. Um algoritmo é uma norma executável para estabelecer um efeito desejável. Na nossa vida quotidiana encontramos constantemente algoritmos, por exemplo: instruções de uso, receitas de cozinha, indicações de montagens, partituras musicais etc., que em sua grande maioria, apresentam o mesmo padrão de comportamento. Num algoritmo (e um programa) devemos distinguir claramente dois aspectos: um estático e um dinâmico. A formulação de um algoritmo geralmente consiste em um texto contendo comandos (instruções) que devem ser executadas numa ordem prescrita. Esse texto é uma representação concreta do algoritmo e tem um caráter evidentemente estático e atemporal. Por outro lado esse texto não nos interessa em si, mas pelos efeitos que pode evocar sua execução no tempo, dado um conjunto de valores iniciais.

Um algoritmo deve nos permitir que dado um estado inicial.3 A grande dificuldade na concepção e no entendimento de algoritmos e o problema do relacionamento desses dois aspectos. Fluxogramas Início/Fim Entrada de Dados (Cartão) Atribuição... Dentre os vários existentes podemos citar: FLUXOGRAMAS. ETC. sua execução nos leve sempre a um mesmo resultado final. Esses métodos devem possuir certa estruturação para que o trabalho de transformação de algoritmos para programas seja fácil e eficiente. Processamento Decisão Imprimir Direção do Fluxo ← Atribuição Repetição (modelo 1) Repetição (modelo 2) . ou seja. para que possa ser de fácil entendimento por outras pessoas sem gerar ambigüidades. Operação. TABELAS DE DECISÃO. como entender as estruturas dinâmicas das possíveis execuções do algoritmo a partir da estrutura estática do texto do algoritmo. DIAGRAMAS NASSISCHNEIDERMAN. Métodos de Desenvolvimento de Algoritmos O uso desses métodos surgiu com a necessidade de se obter algoritmos de uma forma estruturada. através dos mesmos caminhos. concisa e padronizada. PSEUDOCÓDIGO.

Algol e Pascal. É uma pseudo-linguagem cujo objetivo principal é fazer com que o projetista passe a pensar no problema e não na máquina.4 Pseudocódigos Portugol Escreve a lógica da solução de forma narrativa. Dentre os existentes podemos citar o Portugol. de acordo com certas regras. porém não se afastando dela. que é uma simbiose do português. Pode ser modificado facilmente e facilmente traduzido em linguagem humana ou em instruções formais para computadores. .

neste manual. Portanto. Além disso.0) é fornecer uma ferramenta de apoio programação baseado no Português Estruturado. e se a lâmpada não estiver queimada? Pode-se efetuar um teste para verificar essa possibilidade. Algol é o nome de uma linguagem de programação estruturada usada no final da década de 50. Algoritmo1: Trocar uma lâmpada • Pegar uma escada • Posicionar a escada embaixo da lâmpada • Buscar uma lâmpada nova • Subir na escada • Retirar a lâmpada velha • Colocar a lâmpada nova Determinar uma seqüência é importante para reger o fluxo de execução do algoritmo. Uma nova solução seria: . possui todos os elementos básicos e uma estrutura semelhante à de uma linguagem típica para programação de computadores. sem reduzir o estudo teórico. Portugol é derivado da aglutinação de Português + Algol + Pascal. Porém. perceber-se que tem um objetivo definido de trocar a lâmpada. Exemplo de um Algoritmo não Computacional Abaixo é apresentado um algoritmo não computacional cujo objetivo é usar um telefone público. Com estas ferramentas pretende-se proporcionar uma forma de estimular os alunos a praticar e exercitar o desenvolvimento de algoritmos em uma pseudo-linguagem conhecida como Portugol ou Português Estruturado. pode ser uma tarefa tão complexa quanto escrever um programa em uma linguagem de programação qualquer. resolver problemas com português estruturado.5 COMPILADOR DE ALGORITMOS VISUALG O objetivo principal do sistema VisuAlg (a versão na época da confecção da apostila é a 2. Ao analisar novamente o algoritmo anterior. estaremos na verdade procurando desenvolver as habilidades básicas que serão necessárias para adquirir-se competência na programação de computadores. Embora o português estruturado seja uma linguagem bastante simplificada.

mas não consegue enxergar o seu próprio. sabe com certeza a cor do próprio chapéu. Todo mundo que tem contato com computadores sabe que eles precisam ser programados para executar tarefas. O cego. Eles pesam 50. ouve a resposta do primeiro e do segundo. que são: um lobo.6 Algoritmo2: Trocar uma lâmpada verificando se a mesma está queimada • Acionar o interruptor • Se a lâmpada não acender. Para marcar o tempo. Só existe uma planta que podem comer.Três homens desejam atravessar um rio. Exercícios Escreva um algoritmo para resolver os seguintes problemas: A .Um homem precisa atravessar um rio com um barco que possui capacidade para carregar apenas ele mesma. B . Existem 5 chapéus. D – Três homens participam de uma brincadeira. eles só têm 2 ampulhetas: uma que marca 22 segundos e outra que marca 14 segundos. um bode e um fardo de alfafa. então • Pegar uma escada • Posicionar a escada embaixo da lâmpada • Buscar uma lâmpada nova • Subir na escada • Retirar a lâmpada velha • Colocar a lâmpada nova Percebe-se que sempre é possível melhorar um algoritmo prevendo situações que são pertinentes ao problema. O segundo ouve a resposta do primeiro. mais o lobo não pode ficar sozinho com o bode e o bode com a alfafa. Ele responde que não. O segundo consegue enxergar o chapéu do primeiro e do terceiro (cego). A idéia é a seguinte: O primeiro consegue enxergar o chapéu do segundo e do terceiro (cego). e milhares de outras coisas. sendo 3 vermelhos e 2 brancos. passo a passo. ao ver o chapéu do segundo e do terceiro. senão os matará. Foi perguntado ao primeiro homem.Descrever como você faz para trocar o pneu de um carro. Estas linguagens contêm os comandos que fazem o computador escreverem algo na tela realizar cálculos aritméticos. receber uma entrada de dados via teclado. Muitas outras instruções poderão ser acrescentadas a esse algoritmo. o que ele tem que fazer. E o terceiro. se ele. A questão é: Qual a cor do chapéu do cego? Porque ele afirma com certeza que sabe a resposta certa? Desafio . mas para comê-la deverá esquentá-la 30 segundos exatos. por sua vez. obviamente. e responde que sabe com certeza qual a cor do próprio chapéu. em que dois deles enxergam normalmente. Como eles devem fazer para conseguir marcar o tempo de 30 segundos? . Estes programas são construídos com ferramentas chamadas "linguagens de programação". Como podem atravessar sem afundar o barco? C . e um terceiro é cego. não enxerga. O barco que possuem tem a capacidade máxima de 150 quilos. Um programa é um conjunto de milhares de instruções que indicam ao computador. e mais uma de suas três cargas.Dois monges estão perdidos numa mata e estão passando fome. mas estes comandos precisam estar em uma ordem lógica e contribuir. cada um. e também responde que também não sabe a cor do próprio chapéu. mas não consegue enxergar o próprio chapéu. 75 e 120 quilos. São colocados ao acaso um desses chapéus na cabeça de cada um deles. para a tarefa em questão.

o resultado é 1. Impar. Operadores Relacionais Operadores relacionais atuam sobre operandos numéricos e resultam em valores lógicos (operadores de comparação entre dois operandos). etc. Exemplo: 2   3 + ( 5 − 3)  +1   (2/3+(5-3))+1 Computacional Tradicional Operadores Aritméticos Operador Adição Subtração Multiplicação Divisão Divisão Inteira Potenciação Módulo (resto da divisão) Raiz quadrada Quadrado Sintaxe Visualg + * / \ ^ ou exp(base. o resultado é 2. Bissexto.expoente) % Raizq(expressão) Quad(expressão) Operadores Aritméticos não convencionais 7 % 3: obtém o resto da divisão de 7 por 3. Nesse exemplo. Operador Maior Menor Maior ou igual Menor ou igual Igual Diferente VisuAlg > < >= <= = <> . É importante também ressaltar o uso dos operadores correspondentes da aritmética tradicional para a computacional. Normalmente utilizado para agrupar conjunto de valores. ou seja. Ex. 18 \ 7: obtém o quociente da divisão de 18 por 5. todas as expressões aritméticas devem ser linearizadas.: Par. Nesse exemplo.7 Linearização de Expressões Para a construção de algoritmos. colocadas em linhas.

<=. -. Exemplos: 2+5>4 ? Verdadeiro 3<>3 ? Falso . se NAO for falso vira verdadeiro. /. OU Basta que uma das partes seja verdadeira para retornar verdadeiro.<> . Expressões Lógicas São as expressões compostas de relações que sempre retornam um valor lógico. Parênteses e Funções Operadores Aritméticos na seguinte ordem: Potenciação: ^. A lista abaixo mostra as prioridades. Modularização de Expressões Modularização é a divisão da expressão em partes. Se for verdadeiro vira falso. como seriam os colchetes e as chaves na matemática. Além disso. Operadores Lógicos na seguinte ordem: NAO. é importante definir a prioridade das operações através dos parênteses.8 Operadores Lógicos Atuam sobre expressões retornando sempre os valores lógicos: VERDADEIRO ou FALSO. da maior prioridade para a menor. Operadores Relacionais: = . pois na informática podemos ter parênteses dentro de parênteses.> . E. Soma e Subtração: +.< . proporcionando maior compreensão e definindo prioridades para a resolução da mesma. Operador que resulta em VERDADEIRO se os operandos forem diferentes. em expressões computacionais utilizamos somente parênteses para modularização. também existe uma relação de prioridade entre os operadores. e em XOU FALSO se forem iguais. invertendo o seu valor lógico. Multiplicação e Divisão: *. Nega uma afirmação. Tabela Verdade A V V F F B V F V F AEB V F F F A OU B V V V F NÃO (A) F F V V NÃO (B) F V F V A XOU B F V V F Prioridade dos operadores Assim como nas operações aritméticas. OU.>= . ((2 + 2)*4 +8)/ 2 = 12 é diferente de 2 + 2*4 +8/ 2 = 14 Como pôde ser observado no exemplo anterior. VisuAlg Função E Retorna verdadeiras se ambas as partes forem verdadeiras.

as expressões podem ser unidas pelos operadores lógicos.9 De acordo com a necessidade.Escreva as expressões na forma de computacional a) ae + b) b (3 x ) = c2 x +1 = x2 22 k 2 x 2 − (3 x) ( x+1) + 2  c) 2h −  45  − 4h(3 − h)  3x   −3 = d) 2b − 4a 2 + 2 f 3 − 2a = e) − 6 + (2 y ) = 39 x 1 3 . Exercícios 1 .

Escreva as expressões da forma tradicional a+b+(34+exp(e. < listas-de-comando> é apenas uma indicação de que entre a palavra “Inicio” e a expressão “Fimalgoritmo” podemos escrever uma lista com uma ou mais instruções ou comandos. quando um algoritmo é “executado” as instruções ou comandos de um algoritmo são sempre executados na ordem em que aparecem no mesmo. abacaxi e outras frutas. comprar.9))/u-89^(1/2)= 23+5/((7*a)/47)^(2/x)= ((a+x)^(2+w)-quad(5b))/2= (12*x)/(36-9^x)^2= 3 . ou seja.10 f) 2x + u = a + bc 2 3 2 . “Inicio” indica o fim das declarações e o início dos comandos.Resolva as expressões lógicas a) não (2^3 < raizq(16) ou 15\2 < 10 b) (6<8) ou (3>7) = c) Não (2<3) = d) (5>=6) ou (6<7) ou não (a+5-6=8) e) (34>9 e 5+u = 34) ou (5=15/3 e 8>12) f) 10%4 < 16%3 g) 2+8%7 >= 6-raizq(8^(2/3)) h) 15\7 >= 27 % 5 i) 2 < 5 ou 15/3=5 < 4 e 17%5 = 2 Primeiros Elementos da Linguagem No curso de algoritmos vamos escrever soluções para problemas utilizando o português estruturado. Em < declaração de Variáveis> descrevemos os tipos de dados que serão usados na lista de comandos. Estrutura Geral Algoritmo "NomedoAlgoritmo" < declaração de variáveis> Inicio < lista de Comandos> Fimalgoritmo Os algoritmos que vamos escrever têm a seguinte forma geral: A palavra “Algoritmo” e a expressão “Fimalgoritmo” fazem parte da sintaxe da linguagem e sempre delimitam o início e fim de um algoritmo. pêra. {sabendo-se que A=5} {sabendo-se que u=29} . É importante salientar que. não podem ser usadas para outro propósito em um algoritmo que não seja aquele previsto nas regras de sintaxe. poderíamos definir que fruta é um tipo de dado que pode assumir apenas os valores maça. banana. comer e servir. sobre os quais podemos efetuar as operações de comparar. As palavras que fazem parte da sintaxe da linguagem são palavras reservadas. Por exemplo. Nessa seção vamos conhecer os primeiros elementos que compõem a linguagem e escrever alguns algoritmos.

neste curso. A memória do computador pode ser entendida como uma seqüência finita de caixas. das posições de memória da máquina. numero/complemento Variáveis O computador possui uma área de armazenamento conhecida como memória. Esta identificação deve ser clara. somente com a memória primária. Fisicamente. fim. TELEFONE. para poder trabalhar como alguma destas informações precisa saber onde. permitindo que. etc. CD-ROM. NOTA1. um número que indica onde cada informação está localizada. Outros caracteres podem ser letras. num dado momento. o endereçamento das posições de memória através de números hexadecimais é perfeitamente compreendido pela máquina. números e sublinhado. precisa e deve identificar o conteúdo guardado para o usuário. por parte dos usuários. Identificadores Tudo que usamos tem um nome. Estado Civil. as linguagens de computador facilitaram o manuseio. por exemplo. Regras para a nomeação de identificadores Não podem ter nomes de palavras reservadas. ou seja. neste manual. Nós iremos trabalhar. os usuários ficaram livres dos endereços físicos (números hexadecimais) e passaram a trabalhar com endereços lógicos . possui um endereço. cada caixa. Não possuir espaços em branco. O computador.11 A palavra “Algoritmo”. que. na memória. tendo o tamanho de quatro. Abaixo segue alguns exemplos: Endereço Físico Informação 3000: B712 é o endereço físico de "João" 2000: 12EC é o endereço físico de 12345 3000: 0004 é o endereço físico de "H" Como pode ser observado. como número. o dado está localizado. uma palavra. uma letra. Est_Civil Identificadores inválidos: 3Endereco. especificamente com as informações armazenadas na RAM (memória de acesso aleatório). uma frase. Ter no máximo 127 caracteres. basta saber que lá sempre existe alguma informação. Com este recurso. Este nome ou rótulo é utilizado para que possamos reconhecer uma determinada variável ou constante. ao invés de trabalhar diretamente com o número hexadecimal. mas para nós humanos torna-se uma tarefa complicada. etc. Este número é representado através da notação hexadecimal. não importa. ou cada posição de memória. Pensando nisto. guarda algum tipo de informação. fitas. Todas as informações existentes no computador estão ou na memória primária (memória RAM). As palavras reservadas sempre aparecerão em negrito e itálico. Identificadores válidos: NOME. ou mais bytes. fosse possível dar nomes diferentes a cada posição da memória. Devem possuir como primeiro caractere uma letra ou sublinhado '_’. O objetivo desse rótulo ou nome é estabelecer a necessidade de identificarmos o espaço que iremos armazenar determinado conteúdo. é uma palavra reservada.). O VisuAlg não difere letras maiúsculas de minúsculas (NOME é o mesmo que noMe). PARA. IDADE_FILHO. Tais nomes seriam de livre escolha do usuário. ou na memória secundária (discos.

as caixas ou endereços lógicos. a qual contém. de uma maneira de especificar esses detalhes e comunicá-los ao computador. permanente. isto é. <lista_identificadores>] : <tipo_das_variáveis> onde: <identificador> .é uma lista de palavras que pretendemos empregar como variáveis em nosso algoritmo. Precisamos assim. por Exemplo. Com isto queremos dizer que o conteúdo de uma destas caixas (endereço lógico) pode variar. conforme pode ser observado na figura abaixo: Uma variável pode ser vista como uma caixa identificada por um nome colocado na tampa desta e por um valor de uma constante que poderá estar colocado no interior desta caixa. mas em um outro momento. a partir de agora iremos chamar de forma genérica. como no Exemplo acima. de variáveis.determina que tipo de valor as variáveis poderão receber. Esses detalhes são: o identificador desta variável e o tipo de valores que essa variável irá conter. ele deve conhecer os detalhes das variáveis que pretendemos usar. <tipo_das_variáveis> . poderá conter uma outra informação. Desta forma. uma informação. ou seja. a constante nela armazenada pode ser alterada a qualquer momento. "Pedro". Declaração de Variáveis Variáveis são palavras que tem um significado bem específico em um algoritmo. na verdade. representada por um nome simbólico (atribuído pelo usuário). uma caixa pode conter diversas informações. . o conteúdo da caixa. Desta forma podemos dizer que uma variável é uma posição de memória. Para isso utilizamos o comando de declaração de variáveis que faz parte da nossa linguagem que tem a seguinte forma: <identificador> [. Mas é importante saber que o conteúdo desta caixa não é algo fixo. os endereços lógicos são como caixas. que num dado instante guardam algum tipo de informação. isto é. num dado instante.12 (nomes dados pelos próprios usuários). Tendo este conceito em mente. Para que o computador possa executar comandos que envolvem variáveis da maneira correta. podem sofrer alterações em seu conteúdo. a caixa (Endereço Lógico) rotulada de "Nome" num dado momento contém a informação "João". o exemplo acima poderia ser alterado para ter o seguinte aspecto: Endereço Físico Informação Nome : "João" número : 12345 letra : "H" Como tínhamos falado. Enquanto o nome sempre permanece o mesmo.

veja abaixo: Descrição Inteiro Representa valores inteiros.78 Nome <. Exemplos: “a”. Este comando atribui à variável Nome o valor "João da É importante lembrar que só se pode atribuir às variáveis valores do mesmo tipo da variável. Tipos Primitivos de Dados Esses tipos de dados são os mais freqüentes nas linguagens de programação. em algum ponto deve haver a exibição de valores. Por exemplo: Peso <. e todas as linguagens de programação têm comandos para este fim. Isso se chama "atribuir valores". Para que a variável seja útil. . Este comando atribui à variável Peso o valor 78. qualquer símbolo especial ou seqüência de Caracter caracteres entre aspas duplas. Nos algoritmos usamos o comando Escreva para isto. Então. “#$%@”. “=”.”999”. como o próprio nome está dizendo."João da Silva" Silva". deve ter valores colocados por nós. A atribuição de valores é feita pelo operador de atribuição "<-" (uma seta apontando para a esquerda). Comandos de E/S (Entrada/Saída) Um programa que faça o seu processamento e não tenha como mostrar seus resultados é praticamente inútil. Portanto. ”678.Definidos pelo programador(alocação dinâmica). para criação de outros tipos. uma letra. Cada um desses tipos primitivos tem um conjunto de valores restrito. como será visto adiante).5 Um número. Nos exemplos acima. o variável Salário é do tipo real.13 Todas as Variáveis devem assumir um determinado tipo de informação O tipo de dado pode ser: Primitivo: Pré-definido pela linguagem. pode ter seu conteúdo (seu valor) mudado quantas vezes forem necessárias durante um programa. Sinal de Atribuição Quando declaramos uma variável. Dinâmicos . Exemplo: 10.90” Logico Só podem assumir dois valores: verdadeiro ou falso. 33."Insuficiente" Uma variável. -56 Representa valores inteiros ou reais (com ponto separador da parte Real decimal). mas ela ainda está sem valor. o seguinte comando seria inválido: Salário <. 15. Estáticos: É uma parte de um tipo já existente (vetores. pois oferecem alguns tipos básicos pré-definidos. criamos uma área de armazenamento para os dados. Exemplos: 10.

y // Inicializa a variável x com o valor de y. X. etc. x <. seu código e as suas notas. nota1. todas as linguagens de programação permitem isto. nota2. i. Assim. . A sintaxe deste comando é: Leia – Comando de entrada que permite a leitura de variáveis de entrada utilizando o teclado. Sintaxe: Escreva (<expressão | variável>[. Exemplo: // Este método calcula o fatorial de n. Y) Nem todos os dados que um programa manipula são gerados por ele. Mais uma vez. nota3: inteiro { declaração das variáveis do tipo inteiro} nome: caracter // declaração das variáveis de cadeia de caracteres FIMALGORITMO Uma Linha Múltiplas Linhas Comando de Entrada Leia (variável) . Uma Linha São representados por duas barras normais ( // ).<lista_de_variáveis>]) Assim. por exemplo. e verifica se ele passou de ano } codigo. Escreval – Comando de saída que exibe uma informação no monitor. j. "e este de Y:". Sintaxe: Leia (<variavel>[. a senha. Todo o texto que você digitar após as duas barras será comentário.14 Escreva – Comando de saída que exibe uma informação no monitor. a opção de serviço desejada. . Um programa de caixa automático. temos: Comando de Saída Escreva (variável) ou Escreval(variável) Linhas de Comentário Os comentários são declarações não compiladas que podem conter qualquer informação textual que você queira adicionar ao código-fonte para referência e documentação de seu programa.<lista_de_variáveis>]) Exemplo: Escreva ("Este é o valor de X:". deve haver um meio para que sejam digitados (ou fornecidos de outra maneira) dados para uso do programa. basta colocar o comentário entre chaves { } Exemplo: ALGORITMO “Exemplo” {algoritmo que pega o nome do aluno. Múltiplas Linhas Para tal. têm que obter do usuário o número da conta. mas executa o comando seguinte na linha seguinte. e nos algoritmos usamos o comando Leia.

Cálculo de Média Aritmética Enunciado: Faça um programa que leia dois valores inteiros.") Escreval("Digite um valor : ") Leia(A) Escreva("Digite outro valor : ") . Programação é arte. Etapa 1 Simples. e calcule e exiba a sua média aritmética. pois depende um pouco da experiência do programador. O resultado do cálculo será armazenado na variável Media. hein? Dos tempos de escola lembramos que a média aritmética de dois valores é calculada como (a+b)/2. alguns vêm do "exterior" do programa. Etapa 4 O processamento aqui é o cálculo da média. que colocaremos em duas variáveis A e B.. Obtenção destes dados. Entretanto. e sendo assim a primeira etapa já está pronta. na etapa 1. ciência e técnica. aí já deveremos ter idéia dos tipos de dados que usaremos.B: Inteiro Media : Real Inicio Escreval(“Programa que calcula a média aritmética de dois valores. e modelos que podem ser aplicados. que armazenará a média aritmética calculada.15 // TEXTO {TEXTO} Estruturas Seqüenciais . A primeira fase é a mais difícil de se "pegar". e uma terceira variável. Exibição dos resultados. Etapa 3 A obtenção dos dados neste programa é simples e direta. e outros são calculados no próprio programa.. tudo ao mesmo tempo. usando o método citado acima. Solução: Algoritmo “CalculaMedia” A. Definição dos dados que serão necessários para resolvê-lo (as entradas).Construindo os Primeiros Algoritmos Basicamente a construção de um algoritmo se resume às seguintes etapas: Entendimento do problema. Etapa 2 Os dados necessários serão os dois valores. mesmo nesta fase há técnicas que podem ser aprendidas. do tipo real. Processamento em si. Problema 1 . Etapa 5 Basta exibir o conteúdo da variável Media. Basta pedir ao usuário que digite os valores. que chamaremos Media.

5º Passo: Total: 10 unidades de Abacaxi = 55.16 Leia(B) Media <.50 3º Passo: "Digite a quantidade:" Você digita o valor 10 4º Passo: O computador irá executar a operação da antepenúltima linha do algoritmo: atribuir o resultado da multiplicação entre valor_prod e qtd à variável tot. com o ambiente gráfico do Windows. " unidades de ". Se executássemos esse algoritmo. Vamos supor que você digite Abacaxi 2º Passo: "Digite o valor unitário do produto:" Você digita 5. As palavras não devem ser acentuadas." = ". Media) FimAlgoritmo Comentários Você deve ter notado que colocamos na tela instruções para o usuário usando o comando Escreva. ao imprimir o resultado. mesmo hoje em dia. Algoritmo “teste” var prod: caracter valor_prod. Em um algoritmo. Como pode ser analisado no tópico anterior todo programa possui uma estrutura seqüencial determinada por um Inicio e Fim.prod. não mostramos simplesmente a média. tot: real Inicio escreva("digite o nome do produto:") leia(prod) escreva("digite o valor unitário do produto:") leia(valor_prod) escreva("digite a quantidade:") leia(qtd) tot <. E não deve ser utilizada a letra 'ç'. Não são diferenciadas as letras maiúsculas de minúsculas.qtd. Esta é uma boa técnica de programação.(A+B)/2 Escreva("A média dos dois valores é : ". mas explicamos ao usuário o que aquele valor significa. teríamos o seguinte resultado: 1º Passo: "Digite o produto:" Uma janela irá aparecer. Da mesma forma. estes limites são definidos com as palavras. qtd. tot) fimalgoritmo Lembrete: Os comandos devem ser inseridos linha por linha. pedindo para inserir o dado desejado.0 .valor_prod*qtd escreva("total:".

TESTE e COD valem. supondo-se que NUM. Assinalar os comandos de atribuição considerados inválidos. assinalando com I os dados Inteiros.X j) ( ) X <. ( ( ( ( ( )0. "AZUL". X. Nome. e com C os caracteres. Falso e Verdadeiro? .5 b) ( ) SOMA <."*ABC*" h) ( ) DIA <. 5. Y = 3 e Z = 5. "TERÇA".(NOME = COR) E. Teste. Quais os valores armazenados em SOMA. a) X * Y – Z b) X * (Y – Z) c) X + Y * Z d) X + (Y * Z) e) (X + Y) * Z f) exp(X. Determine o resultado da avaliação das expressões abaixo. Y) – 1 g) (X ^ Y) – 1 h) X ^ (Y – 1) D. cor. sendo que: X = 2.. com L os lógicos.00001 )"444" B. COR. NOME e TUDO.SOMA d) ( ) NUM <. ()a ( ) acd1 ()1 ( ) guarda-chuva ( ) b316 C. Dia: Caracter Soma. 2. DIA.1 )5. ( ) abc ( ) 123a ( ) -_ad ( ) A123 ( ) AB CDE ( ) 3abc ( ) –a ( ) A&a ( ) Aa ( ) etc.SOMA e) ( ) COR <.7 )-49 )"Lucas" )falso ( ( ( ( ( ) "abc" ) 1012 ) +342 ) "V" ) -545 ( ( ( ( ( )"João" )"F" )569 )0.X + 1 g) ( ) NUM <. Y e Z são variáveis do tipo inteiro."SEGUNDA" i) ( ) SOMA + 2 <. Para as variáveis declaradas a seguir são dados os valores informados. Assinale com um X os nomes de variáveis válidos. respectivamente. Classifique os conteúdos das variáveis abaixo de acordo com seu tipo..17 Exercícios A. X.NUM + 2 * X c) ( ) TESTE <."PRETO" f) ( ) X <. com R os dados Reais. Num: Real X: Logico a) ( ) NOME <.

Observar o seguinte algoritmo e descreva o que ele faz. com estes dados. A primeira nota tem peso 2. Você poderia fazer um programa que me desse. media) FimAlgoritmo G. e YY é a velocidade média. nota4. quantos km fiz. quanto que cada um deve pagar. Faca um programa que calcula a conta e.(nota1 + nota2 + nota3 + nota4)/4 escreva (nome. Uma turma vai à pizzaria e pede uma determinada quantidade de "chopes" e uma pizza grande com uma determinada quantidade de coberturas. media: real nome: caracter inicio leia(nome) leia(nota1. nota4) media <. e depois ao chegar. sabendo que a será informada a quantidade de pessoas. 5 C = ∗ F −2 ) ( 3 9 . banana. e calcule e exiba a sua média ponderada. a segunda tem peso 3 e a terceira tem peso 5. O programa deve calcular a velocidade média em km/h. onde XX é o nome do piloto. 4) Em uma pizzaria. 2) Realizarei uma viagem de vários dias em meu automóvel.(NUM^2/X) + (X + 1) c) TUDO <. etc.80 e uma pizza mista grande custa R$25. em média.18 a) NOME <. por litro de gasolina? 3) Faça um programa que leia o nome de um piloto. presunto. 5) A conversão de graus Fahrenheit para Celsius é obtida pela fórmula abaixo. nota3. uma distância percorrida em km e o tempo que o piloto levou para percorrê-la (em horas). Faça um algoritmo que leia um valor em graus Centígrados e imprima seu correspondente em graus Fahrenheit. e exibir a seguinte frase: A velocidade média de XX foi YY km/h. e gostaria de saber a quilometragem média por litro de gasolina. Para isto. anotarei a quilometragem no velocímetro ao sair de viagem.NÃO ((TESTE OU COD) E (SOMA < X)) F. nota2. Lembre-se dos 10% do garçom. Algoritmo “CalculaMedia” var nota1.). Também vou somar toda a gasolina que comprar para o carro.50 por tipo de cobertura pedida (queijo. Resolva os exercícios na forma de pseudocódigos Portugol 1) Faça um programa que leia três valores inteiros. nota3. nota2. cada tulipa de chope custa R$1.DIA b) SOMA <.00 mais R$ 3.

Algoritmo "misterio" var num. tendo como dados de entrada dois pontos quaisquer no plano.num\1000 a <.(num\100)%10 b <.e. pois a pergunta "Tenho R$ 10. "tiver R$ 10. irei ao cinema hoje à noite. Escreva um algoritmo que lê os coeficientes a. toda condição tem que ser uma expressão lógica. Ela é uma expressão lógica. sua metade. x= ce − bf ae − bd y= af − cd ae − bd 9) Determine o que será impresso após a execução do algoritmo abaixo.d.00 sobrando". Então.(num%10)%10 escreva("Resultado:". em alguns casos a avaliação da condição resulte em Verdadeiro. a sua raiz cúbica. "irei ao cinema" e "ficarei vendo TV em casa". b. P(x1.b.c. Lembre-se.a. c.00 sobrando?" pode (tem que) ser respondida com "Sim" ou "Não". e as alternativas possíveis de ações. a. enquanto que a segunda será realizada caso a resposta seja "Não". A primeira só será realizada se a resposta à pergunta "Tenho dinheiro suficiente?" for "Sim". escreva a distância entre eles. Em programação chamamos esta situação de condição. então: em um algoritmo. Qual é a condição nesta frase? Fácil. e por fim. d : inteiro inicio escreva("Informe um número inteiro de 4 dígitos diferentes:") leia(num) d <. 7) Construa um algoritmo que. as ações são um ou mais comandos que serão realizados.y2). em um algoritmo.f e calcula e mostra os valores de x e y. mais uma vez. A fórmula que efetua tal cálculo é: (Exercício resolvido no Anexo I) d = ( x 2 − x1) 2 + ( y 2 − y1) 2 8) Um sistema de equações lineares do tipo: ax + by = c dx + ey = f pode ser resolvido segundo mostrado abaixo.00 sobrando. Quais são as ações possíveis? Fácil. .b.d.c) Fimalgoritmo Estrutura Condicional Na vida real tomamos decisões a todo o momento baseado em uma situação existente. Por exemplo: "Se tiver R$ 10.(num%100)\10 c <.y1) e P(x2. mas se não tiver ficarei vendo TV em casa".19 6) Fazer um programa que leia um número inteiro e mostre o seu triplo. o número elevado a potência fracionária 2/3. outros caso ela resulta em Falso.

. agora já podemos fazer um programa que ajude nosso amigo. mais parecida com o que é um programa de computador: Se "tiver R$ 10. fique em casa vendo TV. e que o computador só lida com quantidades definidas (ou seja.") Fimse Escreval("Obrigado e volte sempre. Não se preocupe. caso ele tenha 10 ou mais reais. no entanto: é algo fácil e que pode ser aprendido e desenvolvido.. fique sabendo que a técnica (ou arte) de se transformar perguntas do dia-a-dia em quantidades definidas que possam ser colocadas em um programa é a chave de se fazer algoritmos. Bom. O que faço esta noite? Faça um programa que peça ao usuário a quantia em dinheiro que tem sobrando e sugira. então. Algoritmo "Tem dinheiro sobrando?" Var Dinheiro: Real Inicio Escreval("Serviço Informatizado de Sugestões") Escreva("Quanto dinheiro você tem sobrando?") Leia (Dinheiro) Se Dinheiro >= 10 entao Escreva("Vá ao cinema hoje à noite. vamos generalizar a estrutura que criamos acima: Se <condição> então <ações (uma ou mais) a serem realizadas se a condição for verdadeira> senão <ações (uma ou mais) a serem realizadas se a condição for falsa> Para terminar a nossa comparação. que vá ao cinema.") .") senao Escreva("Fique em casa vendo TV. então "tenho R$ 10. Como próximo passo. Por falar nisso. devemos lembrar que os comandos do algoritmo são sempre imperativos. Veja que grifamos três palavras: Se. poderemos ter a seguinte forma: Se Dinheiro >= 10 então Ir ao Cinema senão Ver TV em Casa Entendeu a transformação? "Dinheiro" faz o papel de uma variável que contém o que eu tenho sobrando no momento. Para aproximar mais nossa frase de um algoritmo.20 Vamos colocar agora a frase do parágrafo anterior em outra forma. e se valor é maior ou igual a 10. e se não tiver.00 sobrando".00 sobrando").00 sobrando" então "Irei ao cinema" Senão "ficarei vendo TV em casa". Elas são muito importantes na estrutura dos comandos de decisão. senão. ele não sabe o que é "ter R$ 10.

.1 Se A = B entao A <. o fato de algumas linhas estarem mais distantes da margem esquerda que as outras não quer dizer nada para o computador. ou seja. um processamento deva ser feito. Tipos de comandos condicionais - Seleção Simples: testa uma condição. e todas as linguagens de programação têm algo que cumpra esta função. apenas uma novidade: a expressão fimse ao final do comando de decisão.") Escreva (“Obrigado e volte sempre. A estrutura "Se" deve ser aplicada nos momentos em que.A+1 Fimse FimAlgoritmo Algoritmo “Verifica condicional” var //Declaração de {Se a condição testada for verdadeira. de acordo com uma determinada condição.e esta é uma dica importante para você .1 B <. o computador não saberia se o comando Escreva "Obrigado e volte sempre. O algoritmo abaixo está incorreto: Se Dinheiro >= 10 entao Escreva ("Vá ao cinema hoje à noite. o primeiro comando após o “fimse" será executado e o algoritmo seguirá a seqüência lógica normalmente. Os comandos internos a essa estrutura só serão executados após o teste da condição ter sido feito e seu resultado for verdadeiro. mostra onde as ações da parte senão do comando terminam. Fazemos isto apenas . se esta for verdadeira executa uma ação ou um conjunto de ações. Após serem executados os comandos internos a essa estrutura. A estrutura condicional permite a mudança de caminho em um determinado fluxo devido à veracidade de um determinado teste feito no decorrer do desenvolvimento do algoritmo. isto é.") Senao Escreva ("Fique em casa vendo TV.} Se <condição> entao C1 . Neste caso. Ela delimita o comando. Sintaxe Exemplo Algoritmo “Teste” Var A.21 Em relação ao que vimos até agora.para que o algoritmo fique mais fácil de ler). Assim o fimse é fundamental. os comandos variáveis Inicio C1 a Cn serão //Comandos executados. Cn Fimse FimAlgoritmo .”)." faria ou não parte do comando de decisão (a endentação..B: inteiro Inicio A <.

.. ..B: inteiro Inicio A <.2 Se A > B entao A <. Cn executados.. Xn Fimse Fimse Fimse FimAlgoritmo Exemplo Algoritmo “Teste” Var A. condição for falsa.B+2 Senao Se B % 3 = 0 entao A <. Dn Senao Se <condição3> entao X1 ..1 B <..B: inteiro Inicio A <.} Dn Fimse FimAlgoritmo .B*2 Senao Se B % 2 = 0 entao A <. Caso contrário executa outro conjunto de ações Sintaxe Exemplo Algoritmo “Teste” Var A.} senao {Os comandos D1 a Dn só D1 serão executados se a .5 Fimse Fimse Fimse FimAlgoritmo - Seleção de Múltipla Escolha: usada quando um conjunto de valores precisa ser testado e ações diferentes são associadas a esses valores. Sintaxe Algoritmo “Verifica condicional” var //Declaração de variáveis Inicio //Comandos Se <condição1> entao C1 .. os comandos C1 C1 a Cn serão .0 B <..B+2 Fimse FimAlgoritmo Algoritmo “Verifica condicional” var //Declaração de variáveis Inicio //Comandos {Se a condição testada for Se <condição> entao verdadeira. se esta for verdadeira executa uma ação ou um conjunto de ações.22 - Seleção Composta: testa uma condição.3 Se A > B então A <.A+1 B <. Cn Senao Se <condição2> entao D1 .A*2 B <.1 B <.Seleção Encadeada: agrupa várias alternativas a fim de inspecionar mais de duas condições...5 senao A <.

15 c <.5. concluído o teste de mesa podemos analisar os resultados. c: Real Inicio a <.5 b <.2.<exp2>.. e sabendo aplicá-lo nos algoritmos elaborados o aprendizado da lógica computacional se torna muito mais fácil. obtivemos a resposta correta? Se não.12 escreva("Quarto trimestre") outrocaso escreva("Mes informado errado") fimescolha Fimalgoritmo Testando o Algoritmo Um algoritmo depois de ser elaborado pode e deve ser testado.23 Sintaxe Algoritmo “Verifica Escolha” var //Declaração de variáveis Inicio //Comandos escolha<expressão-de-seleção > caso <exp1>. utiliza-se de tabelas para armazenar os valores e estados das variáveis do algoritmo... Exemplo: Para cada variável você deve fazer uma coluna e uma coluna para saída de dados.8.3 escreva("Primeiro trimestre") caso 4.6 escreva("Segundo trimestre") caso 7..9 escreva("Terceiro trimestre") caso 10. Caso em algum ponto a lógica esteja falha.<exp2>. onde estão os erros? Sempre que é realizado um teste de mesa. Algoritmo Algoritmo “Teste” var a. ou seja.<expn> <lista-de-comandos-1> caso <exp1>.. Utilizamos um método conhecido como teste de mesa... comandos e instruções do algoritmo. entradas. o erro é facilmente encontrado e facilmente resolvido. Monitorando as variáveis é fácil determinar a eficiência do algoritmo. O teste de mesa é como uma simulação de todos os passos. Preenchendo uma tabela com valores para as variáveis e seguindo-se o fluxo de execução do algoritmo..11.a+b Teste de Mesa A ? 5 5 5 B ? ? 15 15 C ? ? ? 20 Saída . b.<expn> <lista-de-comandos-2> outrocaso <lista-de-comandos-3> fimescolha Fimalgoritmo Exemplo Algoritmo "Verifica trimestre" var mes: inteiro inicio escreva("Informe o número do mês: (1 a 12): ") leia(mes) escolha mes caso 1. Uma vez entendido o funcionamento de um teste de mesa. A cada comando o valor das variáveis deve ser atualizado. visto que o teste de mesa faz uma simulação do raciocínio estruturado. utilizando a entrada de variáveis e seguindo passo a passo a lógica. a fim de saber se ele chega ao resultado a que se propõe e se a lógica está correta.

como utilizá-lo. 3. com as notas variando de 0 a 10.0 c <.10 b <. . os comandos devem ser alinhados de acordo com o nível a que pertença. Altere os comentários quando alterar o algoritmo. Use comentários para descrever o significado de algumas variáveis. Caso a média aritmética das duas notas seja 7 ou mais.25 c <. . Coloque comentários nos principais comandos (os mais importantes). . testados e modificados por outras pessoas (e por nos mesmos após algum tempo). Coloque-os no momento em que estiver escrevendo o algoritmo. Utilize espaços e linhas em branco para melhorar a legibilidade 6. 2. Use apenas um comando por linha 5. Exercício resolvido Em uma escola. Use parênteses para aumentar a legibilidade e prevenir-se contra erros 4.. senão. para explicar o objetivo dos mesmos.a+b Escreva ( c ) a <.0 Fluxograma .0 FimAlgoritmo 5 10 10 10 10 -15 -15 0 0 0 15 15 25 25 25 25 25 25 0 0 20 20 20 35 35 35 35 35 35 0 20 35 -15 Quando estamos escrevendo um algoritmo devemos ter em mente que eles devem ser facilmente entendidos. Regras Práticas para Construir Algoritmos Legíveis 1. . Use endentação. ele é reprovado. o aluno faz duas provas por período. autor. Coloque comentários no inicio do algoritmo para explicar o que faz.0 b <. etc. Use nomes significativos para suas variáveis.. Faça um programa que receba as duas notas de um aluno e escreva se ele passou ou não de ano. Comentários: .24 Escreva (c) a <. ele passa de ano. isto é.a-b Escreva (a) a <. Visualg 2.

media: real inicio escreva("Informe as duas notas do aluno:") leia(nota1.nota2.25 Algoritmo "calcula média" var nota1. nota2. nota2) media <.(nota1+nota2)/2 se media >= 7 entao escreva("Aluno aprovado") senao escreva("Aluno reprovado") fimse Fimalgoritmo Inicio nota1. nota2 media <.media: real “Informe duas notas do aluno” nota1.(nota1+nota2)/2 V Media>=7 >= 7 F “Reprovado” “Aprovado” Fim .

A+B escreva (A.C. B.B .Z: Inteiro W: Real Inicio X <.A -1. Algoritmo "Exerc 3" var X. C) escreva (D.15 se A<= B entao A <. X.B +1.N2: inteiro SOMA: real inicio N1 <.75 X <.N1) Se N1 % 2 = 0 entao escreval(N1) escreval(soma) fimse escreva(N2) Senao SOMA <. Y) fimalgoritmo Dizer os valores a serem impressos após a execução dos algoritmos abaixo.A + D fimse A <.B) fimalgoritmo Algoritmo "exerc 2" var A.Z + 12 fimse senao escreva(X) fimse escreva(W) fimalgoritmo Algoritmo "Exerc 4" var N1. A <.D.B:inteiro inicio A <.SOMA + N1 + N2 escreva(SOMA) fimse fimalgoritmo .QUAD(Y) senao B <.62 B <.26 Dizer os valores a serem impressos após a execução dos algoritmos abaixo: algoritmo "exerc 1" var A.12 Z <.1 senao B <. fimse A <.30 C <.44 D <.11 SOMA <. e convertê-los para fluxogramas.10 B <.(X + Y + Z)/3 Senao escreva(Z) W <.5 Y <.Y: inteiro inicio A <.Y.4 W <.0 Se X > Z entao Se Z > Y entao Escreva(Y) W <.X.4 Se N1 > 0 entao SOMA <-SOMA + (N2 .3 se (A> B) e (X > Y) entao X <-Y + A D <-9 + B*2 Y <.8 N2 <.B.A + 2 escreva(A.4 Y <.

44. senão. reprovado por média e por falta. Caso o financiamento seja menor ou igual a 5 vezes o salário da pessoa. Reprovado. Tendo como dados de entrada a altura e o sexo de uma pessoa. Aprovado. e faltas maior igual a 32 indica reprovado. e seu ano de nascimento (o programa deve funcionar corretamente para qualquer que seja o ano atual). isósceles (dois lados iguais) ou escaleno (três lados diferentes). e indique o carro que teve maior velocidade média. o desconto e salário líquido. se existem raízes reais. faça um programa para ler as distâncias que cada carro percorreu e o tempo que cada um levou. se média maior igual a 5 e menor que 7. utilizando as seguintes formulas: Para homens: (72. após os descontos do imposto de renda." 1.27 Exercícios – Resolver os algoritmos de números pares na forma de pseudocódigo e os ímpares na forma de fluxogramas Faça um programa que receba o valor do salário de uma pessoa e o valor de um financiamento pretendido. Não esquecer de verificar se o valor de Delta é maior ou igual a zero. 2.58 Para mulheres: (62. Leia três valores que representam os lados de um triângulo.(Exercício resolvido no Anexo I) 7. (Exercício resolvido no Anexo I) 8. e verificar se compõe um triângulo equilátero (três lados iguais). 3. 9. B e C são fornecidos pelo usuário. Leia três números e imprima o maior deles. média e “aprovado”. (Dica: Verificar primeiro se os três lados formam um triângulo: cada lado é menor do que a soma dos outros dois). Leia uma média e um número de faltas dadas a um aluno e imprima aprovado. Leia um salário bruto e imprima o salário bruto. 6. Dois carros percorreram diferentes distâncias em diferentes tempos. 4. se média maior igual a zero e menor que 5. Leia um nome e duas notas dadas a um aluno e imprima: nome.7 10. escreverá "Financiamento Negado". o programa deverá escrever "Financiamento Concedido".1 * Altura) . Sabendo que a velocidade média é a razão entre a distância percorrida e o tempo levado para percorrê-la. construa um algoritmo que calcule seu peso ideal.7 * Altura) . de acordo com as regras abaixo: 5. reprovado por média ou reprovado por falta. se média maior igual a 7 e menor igual a 10. Faça um programa que leia o nome e idade de duas pessoas e imprima o nome da pessoa mais nova. Construa um algoritmo para calcular as raízes de uma equação do 2o. Não é necessário verificar se os números são iguais. o programa escreverá depois a frase "Obrigado por nos consultar. que será calculado da seguinte maneira: . Independente de conceder ou não o financiamento. ou seja. sendo que os valores de A . grau. “reprovado” ou “recuperação”. Recuperação. Sendo média maior igual a 7 indica aprovado.

00. conforme tabela abaixo. Exemplo: Hora inicial do jogo: 23 Minuto inicial do jogo: 50 Hora final do jogo: 01 Minuto final do jogo: 45 Duração do jogo: 1 hora e 55 minutos (Exercício resolvido no Anexo I) 16. Calcular e escrever a duração do jogo. informar mensagem de erro: “Entrada de dados não é válida”. considerando que o tempo máximo de duração de um jogo é de 24 horas e que o jogo pode iniciar em um dia e terminar no dia seguinte.743. Escreva um algoritmo que leia um número inteiro de três dígitos e calcule a soma dos seus dígitos. 12.25 Acima de 2.81até 2. Uma empresa de energia elétrica trabalha com 3 tipos de consumidores: I – Industrial. Se o usuário informar horas maiores que 24 ou minutos maiores que 59. Fazer um algoritmo para ler o tipo de consumidor (‘I’. a quantidade de energia consumida. Leia sexo e idade de uma pessoa e imprima maior idade ou menor idade. verificar a tabela abaixo.372. ‘C’ ou ‘R’). Tipo de Consumidor Industrial Comercial Residencial Cálculo 0.77 ∗ Consumo – 22 15. Escrever um algoritmo para ler a hora de início e hora de término de um jogo. considerando que sexo masculino e maior idade se maior igual a 21 anos e sexo feminino e maior idade se maior igual a 18 anos. também em horas e minutos.82 11. Fazer um algoritmo para ler a quantidade comprada de cada tipo de haste e imprima o total pago.81 Acima de 1. Leia um mês e ano e imprima a quantidade de dias que este mês possui.372.28 Salário Até 1.743. ambas expressas em horas e minutos.68 ∗ Consumo + 34 0. Cada haste de cobre é vendida por R$ 2. Lembre-se dos anos bissextos. e cada haste de alumínio é vendida por R$ 4. Exemplo: Número informado: 125 . Para calcular o valor pago. C – Comercial.00. Quantidade comprada (duas hastes juntas) Abaixo de 5 Entre 5 e 15 Entre 16 e 20 Acima de 20 Percentual de Desconto 0 10 15 20 14. Verificar se o novo número formado é divisor de 16 e múltiplo de 4 ao mesmo tempo. O desconto dado dependerá da quantidade de hastes compradas. e calcular e imprimir qual será o valor pago.37 ∗ Consumo + 45 0. A loja Constrói em Partes produz dois tipos de hastes: cobre e alumínio.92 548.5% Dedução 205. R – Residencial. 13.25 Imposto ISENTO 15% 27.

8t) / 5(x + 1) sabendo-se que os valores de x são assim definidos: se w > 0 ou z < 7 x = (5w + 1) / 3. Quando queremos que um trecho de um algoritmo seja repetido num determinado número de vezes..Faça. algoritmo “repetição” var i:inteiro inicio i <. t = (5z + 2).. caso contrário x = (5z + 2). Estrutura de Repetição Nos exemplos e exercícios que vimos até agora sempre foi possível resolver os problemas com uma seqüência de instruções onde todas eram necessariamente executadas uma única vez..Até Nessa estrutura todos os comandos da lista são executados e a expressão é avaliada. Isto se repete até que a avaliação da condição resulte em verdadeiro.1 repita escreva (i) i <. Eis a sua forma geral: Repita <lista de comandos> até <expressão lógica ou relacional> ex. Fazer um algoritmo para ler os valores de z e w. Para. apenas uma seqüência linear de operações. Os algoritmos que escrevemos eram. Nesta seção veremos um conjunto de estruturas sintáticas que nos dão mais flexibilidade para determinar a seqüência de execução dos comandos da linguagem.. e calcular e imprimir: y = (7x2 . utilizamos os comandos de repetição.i + 1 ate i > 10 fimalgoritmo . A nossa linguagem possui três estruturas de repetição: Repita.Até. portanto. Essa estrutura também é chamada de laço de repetição. t = (5w + 1) / 3.29 Soma dos dígitos do número 125 é igual a 8 O número informado é divisor de 16 e múltiplo de 4 ao mesmo tempo.3x .Faça e Enquanto. 17. Cada repetição da lista de comandos também é chamada de iteração. quanto então o próximo comando a ser executado é o comando imediatamente após o até. Repita.: escrever os números de 1 a 10.

é incrementada de um valor constante no laço e tem seu valor testado em algum ponto do laço. algoritmo “repetição” var i:inteiro inicio i <... utilizando as duas estruturas. Essa diferença faz com que em determinadas situações o uso de uma estrutura seja mais vantajoso que o uso da outra. a expressão é avaliada no início e se o resultado for falso no primeiro teste a lista de comandos não é executada nenhuma vez. No enquanto. Veja a sua forma geral: Enquanto <expressão lógica ou relacional> Faca <lista de comandos> Fim Enquanto A estrutura enquanto.i .. a lista de comandos é executada. a condição é avaliada após a execução dos comandos. o que garante que os comandos serão executados pelo menos uma vez.10 repita escreva (i) i <.faca. onde são mostradas soluções para um problema.faca também é uma estrutura de repetição. O exemplo a seguir. Existem diversas maneiras de implementar o mesmo laço. mas todo laço com variável de controle deve conter: a) inicialização b) incremento(i=i+1) ou decremento(i=i-1) c) teste de valor final Veja um outro exemplo: Escreva os números de 10 a 1.: A variável "i" controla o número de repetições do laço. A diferença básica entre as duas estruturas é a posição onde é testada a expressão. ilustram essa diferença: .1 ate i = 0 fimalgoritmo Enquanto. semelhante a repita.. a expressão lógica é avaliada e. No repita. A inicialização da variável contadora deve acontecer fora do laço. se ela for verdadeira.Faca Na estrutura Enquanto. Ao chegar a um determinado valor o laço é interrompido. Isso se repete até que a condição seja falsa.30 Obs. antes do seu início. Normalmente a variável de controle do laço recebe um valor inicial.

a cada iteração. Isto não ocorre no Enquanto. algoritmo "teste 1" var i:inteiro inicio escreva("Informe um número inteiro e positivo:") leia(i) enquanto i >=0 faca escreval(i) escreva("Informe um número inteiro e positivo. a variável de controle é incrementada. Terminar o algoritmo quando for informado um número negativo. Para que isso ocorra um teste do valor deve ser feito antes da escrita.. quando então é executado o comando imediatamente após a . o número recebido. Se o valor da variável for menor ou igual a <valor final>. Como no Repita o teste é feito ao final. se o primeiro valor for negativo.31 Problema: Faça um algoritmo que leia diversos números positivos e escreva. dois testes sejam feitos. a lista de comandos é executada e após ser executado o último comando da lista. para cada um. portanto. Para. Isto repete-se até que o valor da variável de controle seja maior que <valor final>. não sendo. a variável de controle é inicializada com <valor inicial> e no início de cada iteração o valor da variável de controle é comparado com <valor final>. necessário um teste adicional.Faca Forma geral: Para <variável de controle> De <valor inicial> Ate<valor final> [Passo<incremento>] Faca <lista de comandos> FimPara Na estrutura Para. Para sair informe -1:") leia(i) fimenquanto fimalgoritmo algoritmo "teste 2" var i:inteiro inicio repita escreva("Informe um número inteiro e positivo:") leia(i) se i>=0 entao escreval(i) fimse ate i < 0 fimalgoritmo Neste algoritmo. outro teste deve ser colocado no início do laço. o que faz com que. onde o teste é feito no início. o algoritmo não deve escrever nada.

é lido um número N. você quer que a variável de controle pule em Dois em Dois a sintaxe ficaria assim: para i de 1 ate 1000 passo 2 faca <lista de comandos> fimpara A estrutura Para é uma estrutura de repetição mais completa que as anteriores. a mesma ação é repetida 5 vezes. Para isso deve ser utilizado uma estrutura de repetição. É preferencialmente utilizada em situações em que sabe-se previamente o número de repetições a serem feitas. Solução: Neste problema. mas se precisar incrementar a variável de controle você deve utilizar. Ao escrever um algoritmo é importante ter bem clara a função de cada variável. Este número de repetições pode ser uma constante ou estar em uma variável. A condição Passo não é obrigatória. Como o número de repetições é definido (5). Como o número de repetições é conhecido (está na variável N) . Em cada uma delas um número é lido e. Problema 2: Faça um algoritmo que leia um número N e escreva todos os números de 1 a N. Solução: Neste problema. Problema 1: Faça um algoritmo que leia 5 números e escreva somente os que forem positivos. A variável i é usada para controlar o número de repetições e a variável número é utilizada para armazenar cada um dos valores lidos. pode-se utilizar a estrutura para. a leitura do número deve ser feita dentro do laço. A seguir serão apresentados alguns problemas utilizando estruturas de repetição e desenvolvidas algumas soluções para os mesmos. por exemplo. e são escritos todos os números de 1 a N. Uma possível solução para o algoritmo é a seguinte: algoritmo "teste 3" var numero :real i: inteiro inicio para i de 1 ate 5 passo 1 faca escreva("Informe um número:") leia (numero) se numero>0 entao escreval (numero) fimse fimpara fimalgoritmo Neste algoritmo são utilizadas duas variáveis. Como serão lidos 5 números diferentes. é escrito.32 palavra Fim. pois ela incorpora a inicialização. cada uma com uma função bem definida. se for positivo. incremento e teste de valor final da variável de controle.

4) Escrever um algoritmo que.. Desconsiderar números iguais. não ocorreu temperatura inferior a 15ºC nem superior a 40ºC. calcular e imprimir: a) A menor temperatura ocorrida. Fazer um algoritmo leia a temperatura ocorrida dia-a-dia. As temperaturas verificadas em cada dia serão lidas e armazenadas em um vetor. a leitura do mesmo deve ser feita fora da estrutura de repetição. c) A temperatura média. b) A maior temperatura ocorrida. como nesse algoritmo é lido apenas um número. (Exercício resolvido no Anexo I) 3) Escrever um algoritmo que calcule a média obtida por uma turma de "n" alunos na primeira prova do semestre.33 pode-se utilizar a estrutura Para. (Exercício resolvido no Anexo I) . onde o valor de n será informado pelo usuário. Uma possível solução para o problema é a seguinte: algoritmo "teste 4" var i. determine qual é o menor valor desta seqüência e a média aritmética dos valores pares. sabe-se que.6 1. O valor 0 (zero) indica o término dos dados de entrada. 5) Em uma cidade do interior.. 100 2) Implementar um algoritmo capaz de encontrar o maior e o menor dentre 20 números inteiros quaisquer.. de janeiro a abril de 1976(121 dias). Exercícios de Algoritmos com Repetição 1) A conversão de graus Fahrenheit para centígrados é obtida pela fórmula C = 5/9 (F-32). A tabela deverá ser semelhante à mostrada abaixo: Graus Fahrenheit 32 33 34 . o programa termina quando for informado o valor 0(zero). 212 Graus Celsius 0 0.numero :inteiro inicio escreva("Informe um número:") leia (numero) para i de 1 ate numero faca escreval(i) fimpara fimalgoritmo Vale observar que. dada uma seqüência de valores inteiros e positivos.. ou seja. Escreva um algoritmo que calcule e escreva uma tabela de graus centígrados em função de graus Fahrenheit que variem de 32 a 212 de 1 em 1.1 .

Sair do algoritmo quando for informado o valor 0(zero) no valor lido. sexo. Para otimizar o sistema de controle dos elevadores. Imprimir o resultado final. 8) Escrever um algoritmo que lê vários valores reais. . denominados A.. (Exercício resolvido no Anexo I) 12) Faça um algoritmo que imprima os números inteiros decrescentes compreendidos entre 100 e 10. onde cada usuário respondia: • O elevador que utilizava com maior freqüencia. 9) Escrever um algoritmo que lê um valor n e outro valor m. • Qual é o elevador mais freqüentado e em que horário se encontra seu maior fluxo.Nome do homem mais alto.Média das alturas dos homens. . Então tem-se: 1x8=8 2 x 8 = 16 .. Exemplo: Supor que o usuário informe os seguintes valores: n=8 e m=12. . B e C. O percentual de números negativos é calculado dividindo-se a quantidade de números negativos informados pela quantidade total de números. e calcular o percentual de números negativos em relação ao total de números informados. Construa um algoritmo que calcule e imprima: • Quantos usuários que utilizaram o elevador A foram para o décimo andar. Cada boi traz preso no seu pescoço um cartão contendo um número de identificação e seu peso. • O andar ao qual se dirigia. A partir deles os demais termos são construídos pela regra abaixo. um de cada vez. altura e idade de um grupo de 50 pessoas e informe: . V = vespertino e N = noturno. • O período que utilizava o elevador. • Quantos usuários utilizam os elevadores que estão do primeiro ao quinto andar. 11) Fazer um algoritmo para calcular a soma de todos os múltiplos de 7 entre 100 e 500. .. (Exercício resolvido no Anexo I) A série de Fibonacci tem como valores iniciais os dois primeiros termos da série que são respectivamente 0 e 1. 7) Escrever um algoritmo que leia o nome. • Qual o horário mais usado de todos e a que elevador pertence. Escrever um algoritmo que gera os 15 primeiros termos da série de Fibonacci e calcula e escreve a soma destes termos. foi realizado um levantamento estatístico com 1000 usuários.Média de idades das mulheres.Nome da mulher mais nova. Implementar um algoritmo que escreva o número e o peso do boi mais gordo e do boi mais magro (não é necessário armazenar os dados de todos os bois).34 6) Num frigorífico existem 90 bois. e calcula a tabuada de n de 1 até m. entre M = matutino. 12 x 8 = 96 10) Um prédio comercial tem três elevadores. • Qual a diferença percentual entre o horário mais usado e o menos usado. 13) Faça um algoritmo que imprima a tabuada do número 5 da seguinte maneira: ..

50 e cresce 1 centímetro por ano. + 1/N 18) Faça um algoritmo que imprima a soma dos 20 primeiros termos da serie abaixo. a média destas alturas. salário por dia e número de dias trabalhados de uma firma de 200 empregados. 15) Faça um algoritmo que imprima o valor de S da seguinte série: (Exercício resolvido no Anexo I) S= 1 2 3 4 30 − + − + − 60 58 56 54 2 16) Faça um algoritmo que imprima o valor de H da seguinte série: H= 1 3 5 7 99 + + + + + 1 2 3 4 50 17) Faça um algoritmo que leia um número inteiro e positivo N e imprima o valor de S da seguinte série: S = 1 + 1/2 + 1/3 + .98 e não cresce mais. 20) Faça um algoritmo que leia um conjunto de valores que representam a idade de pessoas e imprima a maior e a menor idade. Uma Jabuticabeira tem 1. 100 99 98 97 + + + + 0! 1! 2! 3! 19) Um Jequitibá tem 1. 24) Faça um algoritmo que leia a altura e o sexo de 100 pessoas e imprima: . onde o denominador representa o fatorial do número. b) Após quantos anos a jaqueira será a maior das três árvores. Para finalizar será digitado zero na altura.. Construa um programa em C/C++ que calcule e imprima: a) qual árvore terá a maior altura após 32 anos e. o salário total a ser pago aos empregados e a média dos salários. 23) Faça um algoritmo que leia os dados de cada empregado: nome. 5x10=50 14) Faça um algoritmo que imprima a soma dos números ímpares compreendidos entre 10 e 100. Imprima o salário a ser pago a cada empregado. Uma jaqueira tem 1.. Imprima também quantas alturas maiores que 1.35 5x0=0 5x1=5 5x2=10 ..10 e cresce 2 centímetros por ano.30. a menor..60 e quantas menores que 1. O último valor informado não é válido e será o finalizador do programa. 22) Faça um algoritmo que leia a altura de 1000 pessoas e imprima a maior. 21) Faça um algoritmo que leia a altura de moças inscritas em um concurso de beleza. Imprima as duas maiores alturas.

000 de números. num4. não é suficiente para resolver certos problemas computacionais. de alocação de memória. .A média de consumo.50 e 1.. 5.num2. 6. como é mostrado abaixo: algoritmo "loucura" var num1. 3. melhor dizendo. para ler 1000 números e que imprimisse um relatório destes mesmos números. . 2. num7.. calcula-se a diferença entre xi e o valor médio .num3. num1000:inteiro inicio leia(num1.000 Números. Pois bem.36 . . 25) Deseja-se fazer uma pesquisa a respeito do consumo mensal de energia elétrica em uma determinada cidade. A construção deste algoritmo começaria a ficar inviável na prática.Quantos homens acima de 1. Encontra-se a soma das diferenças dos quadrados. Imagine por Exemplo.. Este novo valor é o desvio-padrão.. ser possível dar um Nome para uma posição de memória. Divide-se este resultado pelo número de valores (N). no início deste curso.Percentual entre as mulheres que possuem altura entre 1. são fornecidos os seguintes dados: Preço do KWH consumido. e outros.. num6. Calcula-se o quadrado dessa diferença. Quantidade de KWH consumidos durante o mês e o Código do tipo de consumidor ( R para residencial . num8.70. Para cada valor xi .num1000) : : fimalgoritmo Considere o tamanho do algoritmo.90. o seu número e o total a pagar..Maior e o menor consumo verificado. Para isso. Variáveis Compostas Homogêneas Vimos. ou. 4. como faríamos para construir um algoritmo.000. Esta quantidade é a variância.Quantos homens e mulheres foram medidas. Número do consumidor. acontece que. utilizando a seguinte fórmula: 1 N ∑ xi − x N 1 Seguir os seguintes passos: σ= ( ) 2 1. 26) Fazer um algoritmo para ler 20 números reais e calcular e imprimir o desvio-padrão e a variância. imagine agora 1. . num2. mas ordenados alfabeticamente? Não seria uma tarefa simples. muitas vezes.Para cada consumidor. foi criado um novo conceito . Isto só com 1. Ler os dados acima e imprimir: . sendo que a esta memória será associada a um valor qualquer. num5.A média das alturas das mulheres. O Número do consumidor igual a zero deve ser usado para término do algoritmo.num4. Para resolver problemas como este. C para Comercial e I para industrial). Tome a raiz quadrada deste resultado. num3. e o trabalho braçal necessário para construí-lo.Total do consumo para cada um dos três tipos de consumidores. Calcular o valor médio . . esta forma de definição. .

Variáveis Indexadas Unidimensionais (Vetores) Também conhecida por "Vetor". logo a seguir pede para dizer quantos desses números são negativos. O índice corresponde a um valor inteiro. Uma variável unidimensional. Declaração de Vetores Sintaxe: <identificador>: VETOR [<tamanho>] <tipo (numerico. caracter ou cadeia)> Ex. possui apenas uma dimensão. ou a um valor caractere (exceto CADEIA). como o próprio nome já indica. Uma variável indexada corresponde a uma seqüência de posições de memória. sendo possível definir variáveis com quaisquer tipos de dados. Para isso deve ser utilizada uma estrutura de repetição para receber os valores lidos e uma condição para contar quantos números são negativos. a qual será dada um único nome. sendo que cada uma destas pode ser acessada através do que conhecemos por índice.Escrever um algoritmo que lê um vetor V de 6 posições e o escreve.i^2 Problema 1 . a mesma ação é repetida 6 vezes e mostra os valores lidos. Uma possível solução para o algoritmo é a seguinte: .x idades[1] <. a seguir.: idades: vetor [5] de inteiro Atribuindo Valores a Elementos do Vetor Para se atribuir um valor a um elemento do vetor devemos utilizar o seguinte padrão: Sintaxe: < identificador>[<posição>] <. logico. Conte. a única diferença reside na Sintaxe de utilização desta variável. Cada uma das posições de memória de uma variável indexada pode receber valores no decorrer do algoritmo como se fosse uma variável comum. desta forma.2 idades[i] <. a qual foi denominada de variável indexada. quantos valores de V são negativos e escreva esta informação.37 para alocação de memória sendo. também criado uma nova maneira de definirem variáveis.<valor> Exemplo : idades[3] <. Solução: Neste problema.

aux fimpara aux <.0 Para i de 1 ate 6 faca leia(vet[i]) se vet[i]<0 entao conta_neg <. cujas 5 primeiras posições devem ser preenchidas com os elementos de V1 e as outras 10 devem ser preenchidas com os elementos de V2.conta_neg: inteiro Inicio conta_neg <. c) Quantas pessoas possuem a maior e a menor das notas. o número de votos em branco. Ler os dois vetores e gerar um terceiro vetor V3 de 15 elementos. suas matrículas).C[8-I+1] C[8-I+1] <. 5) .conta_neg + 1 fimse fimpara para i de 1 ate 6 faca escreval(vet[i]) fimpara escreva("total de números negativos: ". Para o processamento quando for lido -1 no código. e calcule e imprima: a) A média das notas. 4) Implementar um algoritmo que leia 50 notas de provas e as respectivas matrículas dos indivíduos.38 Algoritmo conta_vetor vet: vetor[6] de inteiro i. o numero de votos nulos e o total de votantes. e quais são elas (isto é. conta_neg) Fimalgoritmo Exercícios sobre Vetores 1) Qual será a configuração do vetor depois de executado os comandos abaixo? ! 1 U 2 O 3 T 4 R 5 E 6 C 7 A 8 Para I de 2 ate 4 faca aux <. 3) Dados 2 vetores V1 de 5 elementos e V2 de 10 elementos. Qual é o numero de votos de cada candidato. Existem 20 candidatos a prefeitura com códigos que variam de 1 a 20.C[I] C[I] <. O código 21 é definido para voto em branco e o 22 é para voto nulo.C[8] C[8] <. b) Quantas notas estão acima e abaixo da média calculada no item a (não considerar notas iguais à média).C[1] C[1] <.aux 2) Declarar um vetor de 100 posições e preenchê-lo com 0 nas posições pares e 1 nas posições ímpares.

Faça um algoritmo que leia 20 números inteiros e apresente-os em ordem crescente. determinar o maior elemento do conjunto e o seu índice (posição). Uma variável Multidimensional. se I <> 1 e I <> 50. Por exemplo. Um método simples de ordenação é comparar cada elemento com todos os outros elementos a partir dele. 8) Ordenação de Vetores Ordenar um vetor é colocar seus componentes sob algum critério de ordenação (ascendente ou descendente). Dada uma seqüência numérica de 50 elementos armazenados num vetor. sendo ser possível definir variáveis com quaisquer tipo de dados válidos. Freqüência absoluta é a quantidade de cada valor. como o próprio nome já indica. Quick Sort. para a ordenação de um vetor de N elementos: Para I de 1 ate (N-1) faca Para J de (I+1) ate N faca Se V[J] > V[I] entao AUX <. para 50 elementos reais.. Shell Sort etc. . S[I]=(V[I]+V[I+1])/2. 7) S[I]=(V[I-1]+V[I]+V[I+1])/3. Suponha que não existam elementos repetidos no vetor.V[J] V[J] <. cada um apresentando maior ou menor eficiência. possui duas ou mais dimensões. Exercício: 1. (Exercício resolvido no Anexo I) 6) Vetor suavizado é uma técnica utilizada para cálculos de configuração de cores. se I = 50.. HeapSort. e responder qual é a freqüência absoluta e a freqüência relativa. S[I]=(V[I-1]+V[I])/2. Variáveis Indexadas Multidimensionais (Matrizes) Também conhecida por "Matriz". Ler os valores do vetor V e calcular e imprimir o vetor suavizado S.39 Fazer um algoritmo para ler 80 valores inteiros entre 0 e 10. conforme regra abaixo. se I = 1.AUX Fimse Fimpara Fimpara Existem vários algoritmos de ordenação.V[I] V[I] <. por exemplo Bubble Sort. Existem vários algoritmos de ordenação. Freqüência relativa é a quantidade de cada valor dividido pela quantidade total de valores.

40 Atribuindo Valores a Elementos da Matriz bidimensional Problema 1 . Para isso deve ser utilizada uma estrutura de repetição para receber os valores lidos e algumas condições para verificar as questões pedidas. logo a seguir o problema solicita a soma da linha três da matriz M[3. sendo 3x3 = 9 ações que são repetidas. d) da diagonal secundária.mat[i.quantidade de colunas].j] + somaTudo se i=3 entao somalinha3 <.Escreva um algoritmo que lê uma matriz M(3.j.1.mat[i.0 somaColuna2 <.3) e calcula as somas: a) da linha 3 de M.mat[i.somaLinha3.j]+ somaDiagsecu fimse fimpara fimpara para i de 1 ate 3 faca para j de 1 ate 3 faca escreva (mat[i.0 somaDiagPrinc <.. somatudo) .somaTudo: Inteiro Inicio somaLinha3 <.somaColuna2: Inteiro somaDiagPrinc.j]) somatudo <.j]+ somaLinha3 fimse se j=2 entao somaColuna2 <.j]+ somaDiagPrinc fimse se j=4-i entao somaDiagsecu <.0 somaTudo <. Solução: Neste problema.j]+ somaColuna2 fimse se i=j entao somaDiagPrinc <.0 somaDiagSecu <.3] de Inteiro i. soma da diagonal secundária onde o índice da coluna vai ser a ordem da matriz quadrada mais um e menos o índice da linha e a soma de todos os elementos da matriz. Uma possível solução para o algoritmo é a seguinte: ALGORITMO "Matrizes" var mat: VETOR[1.j]) fimpara fimpara escreval("soma de todos os elementos é ". c) da diagonal principal.mat[i.3.mat[i. temos uma matriz quadrada de ordem três por três.2].0 para i de 1 ate 3 faca para j de 1 ate 3 faca leia(mat[i. b) da coluna 2 de M. diagonal principal onde os índices da coluna e linha sempre são iguais. e) de todos os elementos da matriz.somaDiagSecu.. soma da coluna dois M[quantidade de linhas.

.. ..... somadiagprinc) diagonal secundária é ". somalinha3) coluna 2 é ". .. 4) Faça um algoritmo que leia 5 notas dadas a cada aluno durante o período letivo em uma turma de 30 alunos...9 ....9 ...9 .. ..9 . 3) Faça um algoritmo que leia uma matriz 7 X 7 por linha e imprima somente a matriz triangular inferior. ... a média geral da turma.9 .. . . . . Calcule a média de cada aluno. somacoluna2) diagonal principal é ". 2) Faça um algoritmo que leia uma matriz 3 X 4 por linha e imprima a soma de todos os elementos da matriz superior.9 5) Na Teoria de Sistemas define-se como elemento minimax de uma matriz o menor elemento da linha em que se encontra o maior elemento da matriz.. ... Notas 9... Média Geral da Turma: 9. 9.9 .......... . .. ... . e imprima de acordo com o seguinte layout: Núm... Sugestão: Procurar livro Algoritmo Estruturado – Ferrer.9 ..... . . . 9.....15) por leitura e determine o seu elemento minimax. Escreva um programa que preencha uma matriz M(15. somadiagsecu) Exercícios 1) Implementar um algoritmo para multiplicar duas matrizes de números inteiros. 9.. Média Aluno 9. .. Aluno 1 9..41 escreval("soma escreval("soma escreval("soma escreval("soma fimalgoritmo dos dos dos dos elementos elementos elementos elementos da da da da linha 3 é ".. Supor a Matriz A sendo 3x4 e a matriz B é 4x3. A multiplicação só é possível se o número de colunas da matriz A for igual ao número de linhas da matriz B.. . 9.

sendo os coeficientes // da equação Ax2 + Bx + C = 0 fornecidos pelo usuário // Autor : Edilson Luiz do Nascimento // Data : 16/2/2008 // Seção de Declarações .media:6:1.faltas. grau.42 Anexo I – Lista de exercícios resolvidos Seção 3.nota2:real faltas:inteiro inicio escreva("Informe as duas notas do aluno:") leia(nota1. Não se esqueça de verificar se o valor de Delta é maior ou igual a zero.8 Exercício 6 Leia uma média e um número de faltas dadas a um aluno e imprima aprovado.") se (media >= 7) e (faltas < 32) entao Escreva(" e o aluno foi APROVADO. B e C são fornecidos pelo usuário. algoritmo "Verifica aprovação do aluno" // Função : Ler média e um número de faltas dadas a um aluno e verifica aprovação ou reprovação // Autor : Edilson Luiz do Nascimento // Data : 16/2/2008 var media. e faltas maior igual a 32 indica reprovado." faltas.") senao se (media < 7) e (faltas < 32) entao Escreva(" e o aluno foi Reprovado por Nota. sendo que os valores de A .nota2) escreva("Informe o número de faltas:") leia(faltas) media<-(nota1+nota2)/2 Escreva("A média do aluno foi ". reprovado por média ou reprovado por falta.") fimse fimse fimse fimse fimalgoritmo Exercício 8 Construa um algoritmo para calcular as raízes de uma equação do 2o. grau. ou seja. se existem raízes reais. reprovado por média e por falta.") senao se (media < 7) e (faltas > 32) entao Escreva(" e o aluno foi Reprovado por Nota e Faltas. Sendo média maior igual a 7 indica aprovado." e ".") senao se (media >= 7) e (faltas > 32) entao Escreva(" e o aluno foi Reprovado por Nota. algoritmo "Calcula raizes" // Função : Calcular as raízes de uma equação de 2o.nota1.

Minuto Início do jogo menor que minuto fim do jogo.43 // A.Raizq(Delta))/(2*A) Escreva("As raizes serão:".X2:Real //Declaração das variáveis inicio Escreva("Informe os valores dos coeficientes da equação:") Leia(A.(-B .Coeficientes da equaão de primeiro grau.2 . Exemplo 2: 8:40H até 10:50H Nesse caso fazemos a subtração dos minutos e das horas normalmente.(-B + Raizq(Delta))/(2*A) Escreva("A raiz será:". X1:6:1) senao Escreva("Não há raizes reais") fimse fimse fimalgoritmo Exercício 15 Escrever um algoritmo para ler a hora de início e hora de término de um jogo. 1. 2 .X1. considerando que o tempo máximo de duração de um jogo é de 24 horas e que o jogo pode iniciar em um dia e terminar no dia seguinte. acrescentamos 60 aos minutos finais e subtraimos em um da hora final.Hora início do jogo maior que Hora Fim do jogo 2.Calcula o valor de Delta // X1. mas "pegando emprestado" uma hora para que a subtração fique correta.B. X2:6:1) senao Se Delta = 0 entao //Uma única raiz real X1<. ambas expressas em horas e minutos. ou seja. Exemplo: Hora inicial do jogo: 23 Minuto inicial do jogo: 50 Hora final do jogo: 01 Minuto final do jogo: 45 Duração do jogo: 1 hora e 55 minutos Observação: Neste problema temos que analisar vários casos: 1 .1 . informar mensagem de erro: “Entrada de dados não é válida”.1 .Hora início do jogo menor que Hora Fim do jogo 1. C .(-B + Raizq(Delta))/(2*A) X2<. fornecidos pelo usuário // Delta .Minuto Início do jogo menor que minuto fim do jogo Exemplo 3:22:30 até 1:40 . também em horas e minutos.C) //Entrada de dados Delta <.4*A*C //Cálculo do valor de delta Se Delta > 0 entao //Serão duas raízes reais X1<. Calcular e escrever a duração do jogo. X2 . B.Minuto Início do jogo maior que minuto fim do jogo Exemplo 1: 8:40H até 10:30H Nesse caso teremos que subtrair os minutos.Quad(B) .Raízes da equação var A.B.C.Delta. X1:6:1. Se o usuário informar horas maiores que 24 ou minutos maiores que 59.

HoraFim .HoraIni .Minuto início do menor maior que minuto fim Se MinIni > MinFim entao DurMin <.HoraFim . Além disso.MinFim – MinIni // Calcula normalmente os minutos DurHoras <.MinFim .DurMin:Inteiro inicio Escreva("Escreva o horário do início do jogo.Minuto de início do jogo //MinIni . acrescentamos 60 aos minutos finais e subtraimos em um da hora final. ou seja.MinIni + 60 // "pega emprestado" uma hora //Subtraindo de um. Nesse caso teremos que subtrair os minutos.Hora de início do jogo //HoraIni . a subtração ocorre normalmente e somamos 24 a hora final para podermos fazer a subtração correta.Hora de fim do jogo //MinIni .MinFim . pois os minutos "pegaram emprestado" uma hora. os minutos do fim de jogo são menores que os minutos de início.MinFim .Minuto início menor ou igual ao minuto fim do jogo Se MinIni <= MinFim entao DurMin <.1 .Minuto início do menor maior que minuto fim Se MinIni <= MinFim então DurMin <. em horas e minutos:") Leia(HoraIni.HoraIni //Calcula normalmente as horas fimse fimse senao //Item 2 .44 Neste caso o jogo passou para o dia seguinte.HoraFim .MinIni) Escreva("Escreva o horário de Fim do jogo.2 .1 Senão //Item 1. além do //jogo ter terminado no dia seguinte DurHoras <. e calcula a sua duração // Autor : Edilson Luiz do Nascimento // Data : 16/2/2008 //HoraIni .Minuto início do menor maior que minuto fim Se MinIni > MinFim entao DurMin <.22:50 até 1:40 Neste caso o jogo passou para o dia seguinte.2 .MinIni // Calcula normalmente os minutos DurHoras <. em horas e minutos:") Leia(HoraFim.MinIni + 60 //"pega emprestado" uma hora //subtrai de um. 2.HoraIni + 24 .DurHoras.1 . MinFim.MinFim) //Item 1 . somamos 24 na hora final para podermos fazer a subtração correta.HoraFim.HoraFim . No caso dos minutos.Minuto Início do jogo maior que minuto fim do jogo Exemplo 4 . pois os minutos "pegaram emprestado" uma hora DurHoras <. MinIni.HoraIni .2 . além disso.Hora início do jogo maior ou igual à hora fim Se HoraIni >= HoraFim entao //Item 2. algoritmo "Calcula duração do jogo" // Função : Lê hora início e término do jogo. mas "pegando emprestado" uma hora para que a subtração fique correta. Assim.1 + 24 Senao //Item 2.Minuto de fim do jogo //DurHoras – Duração do jogo em Horas //DurMin – Duração do jogo em Minutos var HoraIni. e.Hora início do jogo menor que hora fim Se HoraIni < HoraFim então //Item 1.

" Horas e ".verdadeiro Para I de 1 ate Tam faca Escreva("Informe a "."ª temperatura:") Leia(Temp) Enquanto (Temp < 15) ou (Temp > 40) faca Escreval("Erro. Não ocorreu temperaturas menores que 15ºC nem maiores que 40ºC") Escreva("Informe a ".Acumula a leitura das temperaturas. Algoritmo "Temperaturas" //Função: Ler 121 temperaturas.45 fimse fimse fimse fimse escreval //Deixar uma linha em branco //Impressão da duração do jogo escreval("A duração do jogo foi de ". para posterior cálculo da Temperatura média //TempMedia .Soma + Temp Se primeiro entao {Inicialização das variáveis Maior e Menor} .10 Exercício 5 Em uma cidade do interior.índice da variável de controle da repetição var primeiro:logico I. Fazer um algoritmo que calcule e imprima: d) A menor temperatura ocorrida. e) A maior temperatura ocorrida.0 Tam <-3 primeiro <.Armazena a maior temperatura //Soma . TempMedia:Real Inicio Soma <.Temperatura média do período //primeiro .Tam:inteiro Temp. As temperaturas verificadas em cada dia serão lidas e armazenadas em um vetor. Menor. não ocorreu temperatura inferior a 15ºC nem superior a 40ºC.I.Auxilia na inicialização da maior e menor temperatura com a primeira temperatura lida //I .I.DurHoras. de janeiro a abril de 1976(121 dias). f) A temperatura média.DurMin.0 TempMedia <." minutos."ª temperatura correta: ") Leia(Temp) Fimenquanto //Acumula as temperaturas de todos os dias para o cálculo da média Soma <.Maior. sabe-se que. menor e temperatura média //Autor: Edilson Luiz do Nascimento //Data: 16/02/2008 //Temp .") fimalgoritmo Seção 3.Armazena a maior temperatura //Menor . Soma. e calcular a maior.Temperatura a ser lida //Maior .

Maior:6:2) Escreva("A temperatura média do período foi de:". Para sair informe 0(zero):") leia(num) enquanto num <> 0 faca // repetição até encontrar valor informado zero cont_num <.Temp Fimse Fimpara TempMedia <.cont_neg +1 fimse Escreva("Informe um número real.Temp Fimse Se Temp < Menor entao {Verificação da Menor temperatura do período} Menor <."% de números negativos.Temp Menor <.46 Maior <.falso fimse Se Temp > Maior entao {Verificação da Maior temperatura do período} Maior <.(cont_neg/cont_num)*100 //Calcula o percentual de números negativos escreva("Existem ". alinhando 4 posições e 1 casa após a vírgula fimalgoritmo Exercício 11 algoritmo "Calcula Soma" // Função : Calcula e imprime a soma dos múltiplos de 7 entre 100 e 500 // Autor : Edilson Luiz do Nascimento // Data : 18/2/2008 // Seção de Declarações .Temp primeiro <.Soma/Tam Escreval("A menor temperatura no período foi:".perc_neg:real cont_neg. Sair quando // for informado o valor zero. Menor:6:2) Escreval("A maior temperatura no período foi:".perc_neg:4:1.") //Mostra // resultados finais. cont_num: inteiro inicio //Inicialização das variáveis com zero cont_num<-0 cont_neg<-0 Escreva("Informe um número real.TempMedia:6:2) Fimalgoritmo Exercício 8 algoritmo "Calcula percentual de negativos" // Função : Ler diversos números reais e imprimir o percentual de // números negativos em relação ao total de números lidos. Para sair informe 0(zero):") //Lê novo número leia(num) fimenquanto perc_neg <. // Autor : Edilson Luiz do Nascimento // Data : 18/2/2008 // Seção de Declarações var num. contando-o cont_neg <.cont_num+1 //Conta a quantidade de números lidos se num<0 entao //Verifica se o número lido é igual a zero.

Num.Variável de controle da repetição //Soma .Variável que assume os valores do Numerador //Den .-30/2 // Autor : // Data : 18/2/2008 // Seção de Declarações var //I .(Num/Den) //Parcelas negativas das frações senao Soma<-Soma + (Num/Den) //Parcelas positivas das frações Fimse Num<-Num+1 //Avança o numerador Den<-Den-2 //Avança o denominador Fimpara Escreva("A soma da Série é ". e conta de 7 em 7 Para I de 105 ate 500 passo 7 faca Soma<-Soma+I Fimpara Escreva("A soma de todos os múltiplos de 7 entre 100 e 500 é ".Acumula os valores das frações geradas I.Variável que assume os valores do Denominador //Soma .Den.Soma) fimalgoritmo Exercício 15 algoritmo "Calcula termos da série” // Função : Calcular a soma da série 1/60 – 2/58 + 3/56.Acumula a soma dos múltiplos de 7 no intervalo especificado var I.Soma) fimalgoritmo // Outra solução inicio Soma<-0 //Inicia com o primeiro múltiplo de 7 após o valor 100.Soma:4:2) Fimalgoritmo .Variável de controle da repetição //Num .Soma:Inteiro inicio Soma<-0 Para I de 100 ate 500 faca Se I%7=0 entao //Captura os múltiplos de 7 Soma<-Soma+I //Acumula os múltiplos de 7 fimse Fimpara Escreva("A soma de todos os múltiplos de 7 entre 100 e 500 é "..47 //I . TAM:Inteiro Soma:Real inicio //Inicialização das variáveis Num<-1 Den<-60 Soma<-1/60 TAM<.30 Para I de 2 ate TAM faca Se I%2=0 entao Soma<-Soma ..

0 Fimpara {Cálculo da Freqüência Absoluta das notas . //Autor: Edilson Luiz do Nascimento //Data: 18/02/2008 var //Declaração do vetor de Notas Nota: Vetor[1. " é ". I.2 Exercício 6 Fazer um algoritmo para ler 80 valores inteiros entre 0 e 10..F[Nota[I]] + 1 Fimpara {Impressão da freqüência absoluta e freqüência relativa} Para I de 0 ate 10 faca Se F[I]<>0 entao //Imprime apenas as freqüências diferentes de zero Escreval("A freqüência absoluta da nota:".11. TAM : Inteiro inicio TAM<-10 Escreva("Informe as Notas:") {Leitura das notas} Para I de 1 ate TAM faca Leia(Nota[I]) Fimpara Para I de 0 ate TAM faca {Inicialização da variável que vai acumular a frequência absoluta} F[I] <.Observar que o conteúdo do vetor nota é o índice do vetor de freqüência absoluta} Para I de 1 ate TAM faca F[Nota[I]] <.10] de Inteiro I. I. Freqüência relativa é a quantidade de cada valor dividido pela quantidade total de valores. e responder qual é a freqüência absoluta e a freqüência relativa." %") Escreval fimse Fimpara Fimalgoritmo . (F[I]/TAM*100):0:1.10] de Inteiro //Declaração do vetor de Frequência absoluta F: Vetor[0.1. Algoritmo "Frequências" //Função: Ler 80 valores inteiros e calcular a freqüência absoluta e relativa. Freqüência absoluta é a quantidade de cada valor.48 Seção 3. F[I]) Escreval("A freqüência relativa da nota:". " é "..

You're Reading a Free Preview

Descarregar
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->