ANTES DE MAIS NADA QUERO DEIXAR BEM CLARO QUE TODOS OS TEXTOS ABAIXO FORAM EXTRAÍDOS DO SITE:
NESTE SITE ESTAVA A SEGUINTE INSCLIÇÃO DE FONTES:
Estas lições são o espelho da apostila fornecida pelo:
NAPRO :. NÚCLEO DE APOIO APRENDIZAGEM DE PROGRAMAÇÃO (UCS)
UNIVERSIDADE DE CAXIAS DO SUL e elaborado por: BRUNO TONET & CRISTIAN KOLIVER
e mais algumas outras coisas que foram acrescentadas.
--------------------------------------------------------------------------------------------------------
Aprimorem as aulas de Algoritmos através destas lições, bom estudo !!!
O SITE É DO Prof. Marcello Gennaro
*************************************************************************
Algoritmos
|
O que é Algoritmo?
Definição:
Um algoritmo é uma seqüência de instruções finita e ordenada de forma lógica para a resolução de uma determinada tarefa ou problema.
São exemplos de algoritmos instruções de montagem, receitas, manuais de uso, etc. Um algoritmo não é a solução do problema, pois, se assim fosse, cada problema teria um único algoritmo; um algoritmo é um caminho para a solução de um problema. Em geral, existem muitos (senão infinitos) caminhos que levam a uma solução satisfatória.
Características de um algoritmo:
Um algoritmo deve ter 5 características fundamentais
• Finitude: Um algoritmo deve sempre terminar após um número finito de passos.
• Definição: Cada passo de um algoritmo deve ser precisamente definido. As ações devem ser definidas rigorosamente e sem ambiguidades.
• Entradas: Um algoritmo deve ter zero ou mais entradas, isto é quantidades que lhe são fornecidas antes do algoritmo iniciar.
• Saídas: Um algoritmo deve ter uma ou mais saídas, isto é quantidades que tem uma relação específica com as entradas.
• Eficiência: Um algoritmo deve ser eficiente. Isto significa que todas as operações devem ser suficientemente básicas de modo que possam ser em princípio executadas com precisão em um tempo finito por um ser humano usando papel e lápis.
Nota: Pode haver mais do que um algoritmo para resolver um problema.
Algoritmos não computacionais
Um algoritmo não computacional é um algoritmo cuja seqüência de passos, a princípio, não pode ser executada por um computador. Abaixo é apresentado um algoritmo não computacional cujo objetivo é usar um telefone público. Provavelmente você “executou” o algoritmo deste exemplo diversas vezes. O termo algoritmo está muito ligado à Ciência da Computação, mas, na realidade, ele pode ser aplicado a qualquer problema cuja solução possa ser decomposta em um grupo de instruções.
Exemplo:
INICIO
1. Tirar o fone do gancho
2. Ouvir o sinal de linha
5. Se der o sinal de chamada
5.1 Conversar
5.2 Desligar DESVIO
5.3 Retirar o cartão
6. Senão
6.1 
FIM
Algoritmo para fritar um ovo
1. Colocar um ovo na frigideira
2. Esperar o ovo ficar frito
3. Remover o ovo da frigideira
O algoritmo acima, no entanto, poderia ser mais detalhado e completo. Uma versão mais aceitável seria:
1. Retirar um ovo da geladeira
2. Colocar a frigideira no fogo
3. Colocar óleo
4. Esperar até o óleo ficar quente
5. Quebrar o ovo separando a casca
6. Colocar o conteúdo do ovo na frigideira
7. Esperar um minuto
8. Retirar o ovo da frigideira
9. Apagar o fogo
Essa segunda versão é mais completa e detalhada que a anterior. Nela, várias ações que estavam subentendidas foram explicitadas. No entanto, para que o algoritmo possa ser útil, é necessário ainda que quem faz uso dele conheça os termos utilizados nas instruções. O algoritmo do exemplo só será útil para alguém que seja fluente na língua portuguesa e conheça o significado dos verbos Retirar, Colocar, Esperar assim como dos substantivos utilizados no contexto de uma receita culinária.
Em outras palavras, é preciso que a linguagem utilizada no algoritmo seja conhecida tanto por quem o escreveu quanto por quem vai executá-lo. Para que o algoritmo possa ser executado por uma máquina é importante que as instruções sejam corretas e sem ambigüidades. Portanto, a forma especial de linguagem que utilizaremos é bem mais restrita que o Português e com significados bem definidos para todos os termos utilizados nas instruções. Essa linguagem é conhecida comoPortuguês Estruturado (às vezes também chamada de Portugol). O português estruturado é, na verdade, uma simplificação extrema do Português, limitada a umas poucas palavras e estruturas que têm um significado muito bem definido. Ao conjunto de palavras e regras que definem o formato das sentenças válidas chamamos sintaxe da linguagem. Durante este texto, a sintaxe do Português Estruturado será apresentada progressivamente e a utilizaremos em muitos exercícios de resolução de problemas.
Aprender as palavras e regras que fazem parte dessa sintaxe é fundamental; no entanto, não é o maior objetivo deste curso. O que realmente exigirá um grande esforço por parte do estudante é aprender a resolver problemas utilizando a linguagem. Para isso, há somente um caminho: resolver muitos problemas. O processo é semelhante ao de tornar-se competente em um jogo qualquer: aprender as regras do jogo (a sintaxe) é só o primeiro passo, tornar-se um bom jogador (programador) exige tempo, muito exercício e dedicação.
Embora o Português Estruturado seja uma linguagem bastante simplificada, ela 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 a de escrever um programa em uma linguagem de programação qualquer. Portanto, neste curso, estaremos na verdade procurando desenvolver as habilidades básicas que serão necessárias para adquirir-se competência na programação de computadores.
Algoritmos Computacionais
|
O computador, a princípio, não executa nada. Para que ele faça uma determinada tarefa - calcular uma folha de pagamento, por exemplo -, é necessário que ele execute um programa. Um programa é um conjunto de milhares de instruções que indicam ao computador, passo a passo, o que ele tem que fazer. Logo, um programa nada mais é do que um algoritmo computacional descrito em uma linguagem de programação. Uma linguagem de programação contém os comandos que fazem o computador escrever 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. O termo processamento de dados é muitas vezes utilizado em conjunto com computadores, pois, em geral, é isto o que eles fazem: processar dados. Daí podem extrair os dois componentes básicos de um algoritmo computacional (de agora em diante, esta palavra sempre utilizada no contexto de algoritmos computacionais): dados e código. Dados são os valores (números, nomes, etc.) de que precisamos para resolver o problema, e código são os comandos ou instruções que usaremos para manipular e "processar" os dados.
Linearização de Expressões
|
Para a construção de algoritmos que realizam cálculo matemáticos, todas as expressões aritméticas devem ser linearizadas, ou seja, colocadas em linhas, devendo também ser feito o mapeamento dos operadores da aritmética tradicional para os do Português Estruturado.
TRADICIONAL
|
COMPUTACIONAL
|
{[2/3-(5-3)] +1}x5
|
((2/3-(5-3))+1)*5
|
As tabelas seguintes mostram os operadores aritméticos disponíveis no Português Estruturado.
OPERADORES ARITMÉTICOS
|
PORTUGUÊS ESTRUTURADO
|
Adição
|
+
|
Subtração
|
-
|
Multiplicação
|
*
|
Divisão
|
/
|
Divisão Inteira
|
\
|
Exponenciação
|
^ ou Exp (<base>,<expoente>)
|
Modulo (Resto da divisão)
|
%
|
Os operadores relacionais realizam a comparação entre dois operandos ou duas expressões e resultam em valores lógicos (VERDADEIRO ou FALSO).
OPERADORES RELACIONAIS
|
PORTUGUÊS ESTRUTURADO
|
Maior
|
>
|
Menor
|
<
|
Maior ou igual
|
>=
|
Menor ou igual
|
<=
|
Igual
|
=
|
Difrente
|
<>:
|
Os operadores lógicos atuam sobre expressões e também resultam em valores lógicos VERDADEIRO ou FALSO.
OPERADORES LÓGICOS
|
PORTUGUÊS ESTRUTURADO
|
SIGNIFICADO
|
Multiplicação
|
E
|
Resulta VERDADEIRO se ambas as partes forem verdadeiras.
|
Adição lógica
|
OU
|
Resulta VERDADEIRO se uma das partes é verdadeira.
|
Adição lógica
|
NÃO
|
Nega uma afirmação, invertendo o seu valor lógico: se for VERDADEIRO torna-se FALSO, se for FALSO torna-se VERDADEIRO.
|
A tabela abaixo – chamada tabela-verdade – mostra os resultados das aplicações dos operadores lógicos conforme os valores dos operadores envolvidos.
A
|
B
|
A E B
|
A OU B
|
NÃO A
|
NÃO B
|
Verdadeiro
|
Verdadeiro
|
Verdadeiro
|
Verdadeiro
|
Falso
|
Falso
|
Verdadeiro
|
Falso
|
Falso
|
Verdadeiro
|
Falso
|
Verdadeiro
|
Falso
|
Verdadeiro
|
Falso
|
Verdadeiro
|
Verdadeiro
|
Falso
|
Falso
|
Falso
|
Falso
|
Falso
|
Verdadeiro
|
Verdadeiro
|
Exemplo:
(2>3) ou (3<2) e (2<3) => resultado seria Falso
(2>3) e (3<2) ou (2<3) => resultado seria Verdadeiro
Lembrete:
O software VisuAlg não possui relacionamento de categorias: 2*5>3 ou 5+1<2 e 2<7-2 // resulta em erro.
(2*5>3) ou (5+1<2) e (2<7-2) // certo seria assim.
Teste seus conhecimentos adquiridos nesta lição
|
Exercício 1.
Exercício 2.
Exercício 3.
Exercício 4.
Forma Geral de um ALGORITMO
|
Nessa seção vamos conhecer os primeiros elementos que compõem o Português Estruturado e escrever alguns algoritmos.
A estrutura geral de um algoritmo é:
Algoritmo "<nome do algoritmo>"
var
< declaração de variáveis>
inicio
< lista de comandos>
Fimalgoritmo
onde as palavras algoritmo e fimalgoritmo fazem parte da sintaxe da linguagem e sempre delimitam o inicio e fim de um algoritmo; a < declaração de variáveis> é a seção ou parte do algoritmo onde 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çã, pêra, banana, abacaxi e outras frutas, sobre os quais podemos efetuar as operações comparar, comprar, comer e servir; inicio indica o fim das declarações e o início da seção de comandos;
< lista de comandos > é apenas uma indicação de que entre as palavras inicio e 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. A palavra algoritmo, por exemplo, é uma palavra reservada. Neste texto, as palavras reservadas sempre aparecerão em negrito.
Variáveis
|
Uma variável pode ser vista como uma caixa com um rótulo ou nome colado a ela, que num dado instante guarda um determinado objeto. O conteúdo desta caixa não é algo fixo, permanente. Na verdade, essa caixa pode ter seu conteúdo alterado diversas vezes.
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 devemos declarar nossas variáveis logo abaixo da expressão “VAR” que tem a seguinte forma:
VAR
<identificador 1>, <identificador 2>, ..., <identificador n>: <tipo das variáveis>
|
onde <identificador i> é o nome (identificador) de uma variável e <tipo das variáveis> determina que tipo de valor as variáveis poderão receber. Os identificadores das variáveis são usados para referenciá-las dentro do algoritmo. Tais identificadores devem ser claros e precisos, dando uma idéia do “papel” da variável no algoritmo.
A identificação ou nomeação de variáveis segue algumas regras
|
a. Nomes de variáveis não podem ser iguais a palavras reservadas;
b. Nomes de variáveis devem possuir como primeiro caractere uma letra ou sublinhado '_' (os outros caracteres podem ser letras, números e
sublinhado);
c. Nomes de variáveis devem ter no máximo 127 caracteres;
d. Nomes de variáveis não podem conter espaços em branco;
e. Na sintaxe do Português Estruturado, não há diferença entre letras maiúsculas de minúsculas (NOME é o mesmo que noMe).
Exemplo:
Identificadores válidos: NOME, TELEFONE, IDADE_FILHO, IdadeFilho, NOTA1, Est_Civil
Identificadores inválidos: 3Endereco, Estado Civil, PARA, algoritmo, numero/complemento
Você deve estar se perguntando por que a palavra “PARA e algoritmo” são identificadores inválidos. Eles são inválidos, pois são palavras reservadas da linguagem, veja outras palavras que você não deve utilizar como identificadores de variáveis.
Operador de Atribuição
|
Para “colocar” um valor em uma variável dentro de um algoritmo, utilizamos o operador de atribuição. O operador de atribuição é representado por uma seta (<-) apontando para a esquerda.
Peso <- 78.7 // Este comando atribui à variável Peso o valor 78.7.
Nome <- "João da Silva" // Este comando atribui à variável Nome o valor "João da Silva".
Achei <- FALSO // Este comando atribui à variável Achei o valor FALSO.
É importante lembrar que só se pode atribuir às variáveis valores do mesmo tipo da variável. Assim, o seguinte comando seria inválido:
VAR
salario: REAL
INICIO
salario <- "Insuficiente"
Deve estar claro, também, que sempre à esquerda do comando de atribuição deve haver um (e somente um) identificador de variável. Assim, são incorretos os seguintes
comandos:
São incorretos
2060 <- NumeroConta
NumeroAgencia+digitoControle <- 2345 + 0
NomeCliente+sobrenome <- “João” + “Silva”
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
Comandos de E/S (Entrada/Saída)
|
Em geral, um programa que faz seu processamento e não tem como mostrar seus resultados é inútil (imagine, por exemplo, uma calculadora que realiza uma infinidade de operações matemáticas, mas não tem um display para mostrar os resultados!). Portanto, em algum ponto do algoritmo geralmente deve ocorrer à exibição de valores, e todas as linguagens de programação têm comandos para este fim. Em Português Estruturado nos algoritmos usamos o comando escreva para isto. A sintaxe desse comando tem a seguinte forma:
Escreva (<expressão ou identificador ou constante>, <expressão ou identificador ou constante>, ..., <expressão ou identificador ou constante>)
|
OBS.: No Visualg existem dois comandos escreva com finalidades diferentes quando usado consecutivamente.
Escreval (<expressão ou identificador ou constante>) // Mostra o primeiro resultado na mesma linha depois em linhas diferentes.
Escreva (<expressão ou identificador ou constante>) // Mostra o resultado na mesma linha, mas em colunas diferentes.
Exemplo
X <- 3.5
Y <- 4
Escreva ("O valor de X é", X)
Escreva (" E o valor de Y é ", Y)
Escreval (" A soma de X e Y é", X+Y)
Escreval ("O valor de X é", X)
Escreval ("E o valor de Y é ", Y)
Escreval ("A soma de X e Y é", X+Y)
Faria com que aparecesse na tela:
O valor de X é 3.5 E o valor de Y é 4 A soma de X e Y é 7.5
O valor de X é 3.5
E o valor de Y é 4
A soma de X e Y é 7.5
Nem todos os dados que um algoritmo manipula são gerados por ele. Um algoritmo (programa) de caixa automático, por exemplo, tem 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 o algoritmo. Mais uma vez, todas as linguagens de programação permitem isto, e no nosso Português Estruturado usamos o comando leia.
A sintaxe deste comando é:
Leia (<identificador>)
|
Exemplo
leia (NumeroConta)
leia (NumeroAgencia)
leia (NomeCliente)
Você pode mandar uma mensagem antes para o usuário, assim ele sabe qual é o conteúdo que deve ser colocado, ou seja, digitado.
Exemplo
Escreva ("Digite seu nome: ")
Leia (nome)
Escreva ("Digite sua agencia: ")
Leia (NumeroAgencia)
Escreva ("Digite sua conta: ")
Leia (NumeroConta)
Deve estar claro que sempre à direita do comando leia haverá um identificador de variável. Assim, são incorretos os seguintes comandos:
Exemplo “São incorretos”
leia (NumeroConta+60)
leia (12345)
leia (NomeCliente+Sobrenome)
Teste seus conhecimentos adquiridos nesta lição
|
Exercício 5.
Assinalar com um X os comandos de atribuição considerados inválidos:
var
NOME, COR, TESTE, DIA: caracter
SOMA, NUM: inteiro
Salario: real
X: lógico
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 <- NUM
j. ( ) X <- (NOME = COR)
k. ( ) salário <- 5.000
l. ( ) salário <- 150
m. ( ) salário <- “insuficiente”
No seguinte algoritmo existem erros? Em caso afirmativo, onde?
algoritmo “Teste”
var
Maria: caracter
idade: numerico
_letra: literal
Maria: real
1alt: caracter
peso : tonelada
Fernando literal
inicio
leia (nome)
leia idade
escreva (idade)
dade = 678
leia "letra"
leia ABC
escreva (letra)
letra <- A
fimalgoritmo
Construindo os Primeiros Algoritmos: Estruturas seqüenciais
|
Lição 5.
O Teorema das estruturas diz que qualquer algoritmo, por mais complexo que seja pode ser resolvido com apenas três estruturas.
São elas:
Seqüência Decisão Iteração
Nesta lição veremos a estrutura seqüencial.
Fatores a serem levados em consideração na construção de um algoritmo
|
1. Complexidade
Percebeu-se, na medida em que colocávamos situações novas no problema a ser resolvido, que ia aumentando a complexidade do algoritmo. Esse certamente é o maior problema envolvido na construção de algoritmos. A complexidade pode ser vista como um sinônimo de variedade (quantidade de situações diferentes que um problema pode apresentar), as quais devem ser previstas na sua solução.
Já que conviver com a complexidade é um mal necessário, é saudável fazer o possível para diminuí-la ao máximo, a fim de controlar o problema e encontrar sua solução.
Deve-se diferenciar O que de Como. Muitos programadores aumentam a complexidade de um devido problema desnecessariamente. A forma errada de interpretação de um problema pode levar a respostas irrelevantes à solução almejada ou até mesmo a nenhuma solução, gerando algoritmos mais complexos do que o necessário.
Exemplo: digamos que se pergunte a um leigo a respeito de um relógio:
P) Como é um relógio?
= É um instrumento com três ponteiros concêntricos.
Como a descrição não é relevante, poderíamos indagar:
- Um relógio com 2 ponteiros é possível?
= É... pode ser!
Poderíamos ainda indagar:
- E um relógio com apenas 1 ponteiro não poderia ser uma possibilidade?
= Bem... Pode ser com 3, 2 ou 1 ponteiro.
- E sem ponteiro pode?
= Ah!, Sim! Pode ser digital
Já a pergunta: “O que é um relógio?”, poderia resultar na resposta:
- É um instrumento cuja finalidade é marcar o decorrer do tempo.
Ou seja, algumas variáveis podem aumentar ou diminuir a complexidade de um sistema quando forem bem ou mal utilizadas.
2. Legibilidade
Mede a capacidade de compreensão de um algoritmo por qualquer observador (que não o construiu); a clareza com que sua lógica está exposta. Quanto mais legível for um algoritmo, menor será sua complexidade.
3. Portabilidade
Devido a quantidade enorme de linguagens de programação existentes, não será adotada nenhuma linguagem específica para trabalhar os algoritmos (ex: C, pascal, Java, etc.). Isso porque a solução do problema fica ligada a características e recursos da linguagem na qual ela foi concebida.
Utilizaremos uma pseudo-linguagem (linguagem fictícia) que visa a permitir a representação dos algoritmos através da língua portuguesa (português estruturado). Esses algoritmos poderão ser convertidos facilmente para qualquer linguagem de programação usual (Basic estruturado, C, pascal, Java).
4. Técnica de resolução por método cartesiano
A famosa frase de Descartes “Dividir para conquistar” é muito importante dentro da programação. É um método que ataca um problema grande, de difícil solução, dividindo-o em problemas menores, de solução mais fácil. Se necessário, pode-se dividir novamente as partes não compreendidas. Esse método pode ser esquematizado em passos:
1. Dividir o problema em partes
2. Analisar a divisão e garantir a coerência entre as partes.
3. Reaplicar o método, se necessário
5. Planejamento reverso
Consiste em, a partir do resultado final, determinar quais são os componentes básicos. Ou seja, a partir da saída desejada, devemos poder determinar,reversamente, quais são os componentes da entrada de dados necessários.
Método para construir um algoritmo
|
Utilizando os conceitos já desenvolvidos, esquematizaremos um método para construir um algoritmo logicamente correto:
1. Ler atentamente o enunciado
Deve-se reler o enunciado de um exercício quantas vezes for necessário, até compreendê-lo completamente.
A maior parte da resolução de um exercício consiste na compreensão completa do enunciado.
2. Retirar a relação das entradas de dados do enunciado
Através do enunciado, descobrimos quais são os dados que devem ser fornecidos ao programa, via teclado, a partir dos quais são desenvolvidos os cálculos. Obs. Pode haver algum algoritmo que não necessite da entrada de dados (pouco comum).
3. Retirar do enunciado, a relação das saídas das informações
Através do enunciado podemos descobrir quais são as informações que devem ser mostradas para compor o resultado final, objetivo do algoritmo.
4. Determinar o que deve ser feito para transformar as entradas nas saídas especificadas
Nessa fase é que teremos a construção do Algoritmo propriamente dito. Devemos determinar qual sequência de passos ou ações é capaz de transformar um conjunto de dados nas informações de resultado. Para isso, utilizamos os fatores descritos anteriormente, tais como legibilidade, portabilidade, método cartesiano e planejamento reverso, e finalmente podemos construir o algoritmo.
De forma genérica, a construção de um algoritmo se resume às seguintes etapas:
a) entendimento do problema;
b) elaboração da solução algorítmica; e
c) codificação da solução no Português Estruturado;
Geralmente a etapa 2 é a mais complexa, pois depende da engenhosidade e experiência do “construtor”.
Exemplo
Enunciado: Faça um programa que leia dois valores numéricos, 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 numérico, e uma terceira variável, que chamaremos Média, 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 Média.
Etapa 5
Basta exibir o conteúdo da variável Média.
Solução:
Algoritmo "Cálculo de Média Aritmética"
VAR
A,B,Media : REAL
Inicio
Escreva ("Programa que calcula a média aritmética de dois fatores.")
Escreva ("Digite um valor : ")
Leia (A)
Escreva ("Digite outro valor : ")
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 do Windows, etc. 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 INÍCIO e FIM. Em um algoritmo, estes limites são definidos com as palavras Algoritmo e Fimalgoritmo.
Teste seus conhecimentos adquiridos nesta lição
|
Exercício 6.
Apresentador de Dimensões de Terreno em m²: Fornecendo largura e comprimento.
Exercício 7.
Calculador numero de Ferraduras sabendo o numero de cavalos.
Exercício 8.
Balanço do dia-Padaria Hotpão. Fornecendo o numero de pães e broas vendidos, informar o valor de 10 % arrecadado para guardar na poupança.
Exercício 9.
Cálculo de Dias de Vida fornecendo o numero de anos.
Exercício 10.
Calculador de Litros de Gasolina. Fornecendo o valor do litro da gasolina e o valor total pago. Calcular os litros de gasolina abastecidos no carro.
Exercício 11.
Calculador de Peso_Restaurante Bem-Bão. Sabendo que o valor do kilo é R$ 12. Calcular o valor a ser pago informando o peso do prato montado.
Exercício 12.
Média Ponderada com três notas.
Exercício 13.
Calculador de camisas. Sabendo que: Camisa pequena custa R$10, media R$12 e grand R$ 15. Calcular custo total fornecendo o numero de camisas por tamanho.
Exercício 14.
Distância entre 2 pontos das ordenadas X e Y.
Estrutura Condicional
|
Lição 6.
Estrutura Condicional (Simples, Composta e encadeada ou aninhada)
|
Simples Composta Encadeada ou aninhada
Na vida real tomamos decisões a todo o momento baseadas em uma situação existente.
Em um algoritmo, chamamos esta situação de condição. Associada a uma condição, existirá uma alternativa possível de ações.
Na condição de simples tomamos ação referente a apenas uma saída; na Composta teremos duas execuções distintas. Na encadeada teremos uma condição sendo testada por outra condição e assim sucessivamente, se for o caso.
Exemplo
"se tiver R$ 10,00 sobrando então irei ao cinema hoje à noite.”
A condição nesta frase é "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, algo que possa-se pensar como “ isto é VERDADEIRO” ou “isto éFALSO”. Se a condição for verdadeira, a ação a ser executada é "irei ao cinema", se a resposta à pergunta "Tenho dinheiro suficiente?" for "Sim". Então, em um algoritmo, as ações são um ou mais comandos que serão realizados apenas se a avaliação da condição resulta VERDADEIRO.
Vamos colocar agora a frase do exemplo anterior em outra forma, mais parecida com nosso Português Estruturado:
Exemplo
se "tiver R$ 10,00 sobrando" então
"irei ao cinema"
fimse
Veja que grifamos três palavras: se, entao e fimse. 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> entao
<ações (uma ou mais a serem realizadas se a condição for verdadeira>
fimse
Para terminar a nossa comparação, devemos lembrar que os comandos de um algoritmo são sempre indispensável, 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:
Exemplo
Se Dinheiro >= 10 entao
Ir_ao_Cinema <- VERDADEIRO
Fimse
O exemplo acima poderia ser estendido para o caso do sujeito não ter dinheiro sobrando: "se tiver R$ 10,00 sobrando irei ao cinema hoje à noite, mas se não tiver ficarei vendo TV em casa". Neste caso, uma codificação possível para esse algoritmo seria:
Exemplo
se Dinheiro >= 10 entao
Ir_ao_Cinema <- VERDADEIRO
Ver_TV <- FALSO
Fimse
se Dinheiro < 10 entao
Ir_ao_Cinema <- FALSO
Ver_TV <- VERDADEIRO
Fimse
É importante frisar que sempre à direita do comando se deverá parecer uma expressão lógica, e uma expressão cujo resultado é VERDADEIRO ou FALSO. Assim, os
seguintes comandos são incorretos:
Exemplo
se A <- B entao // É uma atribuição e não uma expressão
......
fmse
se A + B entao // É uma expressão aritmética e não uma expressão
.......
fimse
Por outro lado, estão corretos os seguintes comandos:
Exemplo
se (A > B) e (A > C) e (B <> C) entao
........
Fimse
se nao Achou entao // Correto se Achou foi declarada como logico
........
fmse
Seja o algoritmo abaixo:
Exemplo
Faça um Algoritmo para calcular a área de um circulo, fornecido o valor do raio, que deve ser positivo.
Algoritmo "Calcula Area do Circulo"
VAR
Area, Raio: Real
inicio
Escreval ("Entre com raio do círculo")
Leia (Raio)
Se Raio > 0 entao
Area <- PI*(Raio^2)
Escreva ("A área do círculo de raio ", Raio, " é ", Area)
fimse
Se Raio <= 0 entao
Escreva ("Raio não pode ser nulo ou negativo!")
fimse
fimalgoritmo
Observe que se a condição do primeiro é verdadeira, a segunda condição é falsa e vice-versa, e o conjunto de instruções a ser executado se Raio <= 0 (apenas a instrução escreva ("Raio não pode ser nulo ou negativo!")) é uma alternativa para a condição Raio > 0. Para expressar isso mais facilmente (e também por uestões de eficiência), a maioria das linguagens de programação permite associar um conjunto de instruções a ser executado se a condição do comando resultar emFALSO. Em Português Estruturado, a sintaxe para tal é a seguinte:
se <condição> entao
<ações (uma ou mais) a serem realizadas se a condição for verdadeira>
senao
<ações (uma ou mais) a serem realizadas se a condição for falsa>
fimse
Utilizando o senao, o algoritmo para calcular a área de um circulo, ficaria assim:
Exemplo
Algoritmo "Calcula Area do Circulo"
VAR
Area, Raio: Real
inicio
Escreval ("Entre com raio do círculo")
Leia (Raio)
Se Raio > 0 entao
Area <- PI*(Raio^2)
Escreva ("A área do círculo de raio ", Raio, " é ", Area)
senao
Escreva ("Raio não pode ser nulo ou negativo!")
fimse
fimalgoritmo
Teste seus conhecimentos resolvendo estes exercícios.
|
Exercício 14a.
Apresentador de Dimensões de Terreno em m²: Fornecendo largura e comprimento.
Exercício 14b.
Calculador o número de Ferraduras sabendo o numero de cavalos.
Escolha...Caso
|
Lição 7.
Em algumas situações é necessário termos várias soluções ligadas a respostas diferentes, neste caso o comando de alternativa simples ou composta não é uma solução prática, isto porque obrigará o programador a escrever muitas linhas de programa, além de ter que criar vários comandos de alternativas compostas e verificar a validade de suas condições para que o comando execute o caminho correto para uma determinada condição. Temos então o comando de alternativa de múltipla escolha.
O funcionamento deste comando obedece a seguinte regra:
escolha < expressão-de-seleção >
caso < exp 1 > , < exp 2 >, ... , < exp n >
< lista-de-comandos-1 >
caso < exp 1 > , < exp 2 >, ... , < exp n >
< lista-de-comandos-2 >
Outrocaso
< lista-de-comandos-3 >
fimescolha
|
Exemplo
Um determinado clube de futebol pretende classificar seus atletas em categorias e para isto ele contratou um programador para criar um programa que executasse esta tarefa. Para isso o clube criou uma tabela que continha a faixa etária do atleta e sua categoria. A tabela está demonstrada abaixo:
IDADE CATEGORIA
De 05 a 10 Infantil
De 11 a 15 Juvenil
De 16 a 20 Junior
De 21 a 25 Profissional
Construa um programa que solicite o nome e a idade de um atleta e imprima a sua categoria.
Algoritmo "CLASSIFICAÇÃO DE ATLETAS
var
nome, categoria : caractere
idade : inteiro
inicio
Escreva("Nome do Atleta = ")
Leia (nome)
Escreva("Idade do Atleta = ")
Leia (idade)
Escolha idade
caso 5,6,7,8,9,10
categoria <- "Infantil"
caso 11,12,13,14,15
categoria <- "Juvenil"
caso 16,17,18,19,20
categoria <- "Junior"
caso 21,22,23,24,25
categoria <- "Profissional"
outrocaso
categoria <- "INVALIDO"
Fimescolha
Escreva ("Categoria = ",categoria)
fimalgoritmo
Teste seus conhecimentos resolvendo estes exercícios.
|
Exercício 15.
Faça um algoritmo que ao perguntar qual o melhor time do mundo ele responda corretamente através do comando escolha
Exercício 16.
Construa um algoritmo de uma calculadora que execute as quatro operações básicas através do comando escolha.
Testando o Algoritmo
|
Um algoritmo, depois de ser elaborado, pode (e deve) ser testado. Para tal, 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. Para tal, preenche-se uma tabela com valores para as variáveis e segue-se o fluxo de execução do algoritmo, simulando a execução de cada instrução, ou seja, refazendo o que o computador faria ao executar cada instrução. A cada comando simulado (executado), o valor das variáveis na tabela deve ser atualizado. Se, para uma instrução executada, uma ou mais variáveis não ficaram com os valores esperados, há um erro na lógica do algoritmo.
Estrutura de Repetição
|
Lição 9.
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 seguiam, portanto, apenas uma seqüência linear de operações.
Comando repita...Ate
|
Nessa estrutura, todos os comandos da lista são executados e uma expressão lógica é avaliada. Isto se repete até que a avaliação da condição resulte em FALSO, quanto então o próximo comando a ser executado é o comando imediatamente após o ate. Cada repetição da lista de comandos também é chamada de iteração e essa estrutura também é chamada de laço de repetição. Sua forma geral é:
Repita
<lista de comandos>
ate <expressão lógica ou relacional>
|
Exemplo
Algoritmo que escreve os números de 1 a 10.
algoritmo "DemonstraRepeticao"
VAR
i: INTEIRO
inicio
i<- 1
repita
escreva (i)
i<- i + 1
ate i > 10
fimalgoritmo
No exemplo acima, 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 (ou decrementada) de um valor constante no laço e tem seu valor testado no final 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 da variável de controle;
b) incremento (aumento do valor da variável de controle) ou decremento (diminuição do valor da variável de controle) da variável de controle; e
c) teste de valor da variável de controle.
Exemplo
Algoritmo que escreve os números pares de 10 a 2.
algoritmo "DecrementoNumerosPares"
var
i: inteiro
inicio
i <- 10
Repita
escreva (i)
i <- i - 2
ate i = 0
Fimalgoritmo
Um cuidado fundamental que o construtor do algoritmo deve ter é o de certificar-se que a condição para que sejam mantidas as iterações torne-se, em algum momento, falsa, para que o algoritmo não entre em um laço infinito.
Exemplo
algoritmo “laçoInfinito”
VAR
Contador: numerico
Inicio
repita
Contador <- 1
Contador <- Contador + 1
ate Contador = 10
fimalgoritmo
No exemplo acima, a execução do algoritmo entra em um laço infinito porque a inicialização da variável Contador (instrução Contador <- 1) deveria ser feita antes do comando repita, ou seja, antes do laço. No exemplo, ela sempre voltará a ser 1 e nunca alcançará o valor 10.
algoritmo “laçoInfinito”
VAR
Soma: numerico
inicio
Soma <- 1
repita
Soma <- Soma + 2
ate Soma = 10
escreva (soma)
fimalgoritmo
No exemplo acima, a execução do algoritmo entra em um laço infinito porque a variável Soma é incrementada de 2 em 2. Como ela começa com o valor 1, ela passará do valor 9 para o 11, ou seja, nunca será igual a 10. Para corrigir o problema, bastaria alterar a condição conforme o exemplo abaixo.
algoritmo “laçoInfinito Consertado”
VAR
Soma: REAL
inicio
Soma <- 1
repita
Soma <- Soma + 2
ate Soma > 10
escreva (soma)
fimalgoritmo
Lembrete:
Quando ocorrer laço infinito no Visualg você ficará sem comunicação. Procura dar Ctrl+ALT+DEL e selecionar o programa Visualg e clicar no botão finalizar. Não se preocupe com seu algoritmo, pois quando ocorre isso o Visualg salva automaticamente.
Para recuperar seu algoritmo basta abrir Visualg novamente que mostrará uma janela como abaixo, perguntando se deseja recuperar ou não o algoritmo perdido no laço infinito.
algoritmo "Menu"
VAR
opcao: inteiro
inicio
repita
escreval ("Cadastro de clientes")
escreval ("1-Incluir")
escreval ("2-Alterar")
escreval ("3-Consultar")
escreval ("4-Excluir")
escreval ("5-Sair")
leia(opcao)
ate opcao = 5
fimalgoritmo
No exemplo acima, mostra como é feito um menu de cadastro de clientes;
Teste seus conhecimentos resolvendo estes exercícios.
|
Exercício 17.
Calcule o fatorial de um número. (Relembre em matemática o que é fatorial antes de resolver o algoritmo)
Exercício 18.
Calcule a sequencia de Fibinacci até o décimo número (Relembre o que é sequencia de Fibonacci antes de resolver o algoritmo)
Estrutura de Repetição
|
Comando para...faca
|
O comando para...faca também permite a descrição, dentro de um algoritmo, de uma estrutura de repetição. Sua forma geral é:
para <variável de controle> de <valor inicial> ate <valor final> [passo <incremento>] faca
<lista de comandos>
fimpara
|
Na estrutura para..faca, a variável de controle é inicializada com <valor inicial> e no início de cada iteração, seu valor é 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 palavra fimpara. A instrução passo é necessária se o incremento for diferente de 1.
Um algoritmo que lê escreve os números ímpares de 1 a 1000.
para i de 1 ate 1000 passo 2 faca // Incrementa i de 2 em 2
escreva i, “ é ímpar”
fimpara
A estrutura para..faca é 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.
Algoritmo que lê 5 números e escreve todos os que forem positivos.
Algoritmo "Positivos"
var
i, numero: inteiro
inicio
para i de 1 ate 5 passo 1 faca
escreval ("Digete um numero")
leia (numero)
se numero>0 entao
escreva (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ávelnumero é 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 de numero deve ser feita dentro do laço.
Algoritmo que lê um número N e escreve todos os números de 1 a N.
algoritmo "determina o tamanho do laço"
var
i, N: INTEIRO
inicio
leia (N)
para i de 1 ate N faca
escreva (i)
fimpara
fimalgoritmo
Vale observar que, como nesse algoritmo é lido apenas um número, sua leitura deve ser feita fora da estrutura de repetição. Note que não possui a sintaxe passo, pois opasso +1 é definido como padrão.
Lembrete:
O valor I e N do exemplo acima tem que ser inteiro, pois se for declarado como um valor real ou numérico o algoritmo retornara com um erro de sintaxe.
Teste seus conhecimentos resolvendo estes exercícios.
|
Repita o exercício 17 e 18 da aula anterior mudando os comandos de Repita para Para e execute no visualg ambos os casos no passo a passo.
Estrutura de Repetição
|
Comando 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>
fimenquanto
|
A estrutura enquanto...faca também é uma estrutura de repetição, semelhante à repita. A diferença básica entre as duas estruturas é a posição onde é testada a expressão. Na estrutura 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. Na estrutura 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 duas soluções para um mesmo problema, ilustra essa diferença:
Algoritmo que lê diversos números positivos e escreve, para cada um, sua raiz quadrada.
algoritmo “comEnquanto”
var
i: numerico
inicio
leia (i)
enquanto i >=0 faca
escreva (i^0.5)
leia (i)
fimenquanto
fimalgoritmo
|
algoritmo “comRepita”
var
i: numerico
inicio
repita
leia (i)
se i >=0 entao
escreva (i^0.5)
fimse
ate i<0
fimalgoritmo
|
No primeiro algoritmo, se o valor lido de i for negativo, o algoritmo não deve escrever nada. Com o uso do comando repita (segundo algoritmo), para que isso ocorra, um teste do valor deve ser feito antes da escrita.
Teste seus conhecimentos resolvendo estes exercícios.
|
Repita o exercício 17 e 18 da aula anterior mudando os comandos de Repita para Enquanto e execute no visualg ambos os casos no passo a passo.
Variáveis Compostas Homogêneas
|
Lição 12.
A declaração de variáveis, uma a uma, é suficiente para a codificação algorítmica da solução de uma ampla gama de problemas, mas é insuficiente para resolver um grande número de problemas computacionais. Imagine, por exemplo, como faríamos para construir um algoritmo, que lesse os nome de 500 pessoas e imprimisse um relatório destes mesmos nomes, mas ordenados alfabeticamente. Não seria uma tarefa simples, pois teríamos que definir 500 variáveis do tipo literal, como é mostrado abaixo:
Algoritmo "Inviável"
var
nome1, nome2, nome3, nome4, nome5,..., nome499, nome500: literal
inicio
leia (nome1,nome2,...,nome500)
...
Fimalgoritmo
Considere o tamanho do algoritmo, e o trabalho braçal necessário para construí-lo. Para resolver problemas como este, e outros, existem as variáveis indexadas. A declaração de uma variável indexada corresponde, na verdade, à declaração de várias variáveis cujo identificador difere apenas por um índice. O índice corresponde a um valor numérico começando por 1. Cada variável indexada pode receber valores no decorrer do algoritmo como se fosse uma variável comum.
Variáveis Indexadas Unidimensionais (Vetores)
|
Variáveis indexadas com uma única dimensão, também conhecidas como vetores, são referenciadas por um único índice. A sintaxe para declaração é:
<identificador> : vetor [<tamanho>] de < tipo >
Tamanho [VI..VF]
Vi = Valor inicial do índice
VF = Valor Final do índice.
|
IDADE: VETOR [1..5] DE INTEIRO
NOMES: VETOR [1..5] DE CARACTERE
A declaração acima corresponde à declaração de 10 variáveis: nomes[1], nomes[2], nomes[3], nomes[4], nomes[5], idades[1], idades[2], idades[3], idades[4] e idades[5].
Para se atribuir um valor a um elemento do vetor devemos utilizar o seguinte padrão:
< identificador>[<posição>] <- <valor>
|
nomes[1] <- “João da Silva”
idades[1] <- 35
nomes[3] <- “Maria Aparecida”
idades[3] <- idades[1]
i <- 5
idades[i] <- 45
Algoritmo que lê um vetor NUMERO de 6 posições e o escreve. A seguir, ele conta quantos valores de NUMERO são negativos e escreva esta informação.
Algoritmo "vetores"
VAR
NUMERO: VETOR [1..6] DE REAL
I, conta_neg: INTEIRO
inicio
conta_neg <- 0
para i de 1 ate 6 faca
leia (NUMERO[i])
se NUMERO[i] < 0 entao
conta_neg <- conta_neg + 1
fimse
fimpara
para i de 1 ate 6 faca
escreval (NUMERO[i])
fimpara
escreva ("Total de números negativos: ", conta_neg)
fimalgoritmo
Matriz ou vetor Nome composto de n posições UNIDIMENSIONAL:
NOME: VETOR [1..N] DE CARACTERE
Endereço da posição Conteúdo da posição de Memória
 |  | ||
1
Aldo
|
2
Bruno
|
3
Carla
|
4
Demetrio
|
5
Edir
|
6
Fabiana
|
...n
...xyz
|
Conteúdo da posição de Memória
NOME[1] => Aldo ou NOME[a] => Aldo (para a valendo 1)
Teste seus conhecimentos resolvendo estes exercícios.
|
Exercício 19.
Faça um algoritmo que calcule a média do valores de um vetor com dez posições exibindo a quantidade de alunos abaixo da média.
Exercício 20.
Construa um algoritmo que exiba a tabuada de 1 a 10 entrando com o número desejado. (Exemplo tabuada de 3)
Nenhum comentário:
Postar um comentário