Tutorial sobre algoritmos e lógica de programação

<<< Parte 1

Parte 3 >>>

Se esta página lhe ajudar, considere fazer uma doação

Desvio condicional

A estrutura de desvio condicional deve ser utilizada quando nos deparamos com a seguinte situação:

Queremos que uma condição seja analisada;
Caso esta condição seja verdadeira, um comando será executado;
Caso esta condição seja falsa, outro comando será executado.

Sua sintaxe é:

se CONDIÇÃO
COMANDO1;
senão
COMANDO2;
fimse;

Se CONDIÇÃO for verdadeira, COMANDO1 será executado. Se CONDIÇÃO for falsa, COMANDO2 será executado.

Tanto COMANDO1 como COMANDO2 podem constituir um bloco de instruções. Quando isso acontecer você deve delimitar o bloco com os comandos "início" e "fim".

Você pode aninhar mais de uma estrutura "se" e analisar mais de uma condição:

se CONDIÇÃO1
COMANDO1;
senão se CONDIÇÃO2
COMANDO2;
senão
COMANDO3;
fimse;

Cuidado quando usar isto para não deixar o algoritmo ruim de compreender. Às vezes, escolhendo outro tipo de estrutura conseguimos o mesmo efeito com um algoritmo mais legível.

Exemplo demonstrativo: algoritmo que recebe a idade do usuário e verifica se o mesmo tem mais de 21 anos:

início
inteiro: idade;

imprimir ("Entre com sua idade :");
ler (idade);

se (idade >=21)
imprimir ("Você é de maior !!!");
senão
imprimir ("Você é de menor !!!");
fimse;
fim

Múltipla escolha

Esta estrutura analisa o valor de uma variável e, de acordo com este valor, executa determinado comando. Sua sintaxe é:

escolha VARIÁVEL
caso VALOR1: COMANDO1;
caso VALOR2: COMANDO2;
caso VALOR3: COMANDO3;
..............................................
caso contrário: COMANDO4;
fimescolha;

Na sintaxe acima, caso o valor de VARIÁVEL seja igual a VALOR1, COMANDO1 será executado. Caso seja igual a VALOR2, COMANDO2 será executado, e assim por diante. Se VARIÁVEL não coincidir com nenhum valor, o COMANDO4 será executado.

Como na estrutura de desvio condicional, os COMANDOS podem constituir blocos com mais de um comando. Quando isso acontecer, não esqueça de delimitar o bloco.

Exemplo demonstrativo: Este algoritmo exibe um menu de formas de pagamento, analisa qual foi a forma escolhida e exibe uma mensagem relativa ao desconto.

início
inteiro: opcao;

imprimir ("Forma de pagamento");
imprimir ("-------------------------------------");
imprimir ("1. A vista em dinheiro.");
imprimir ("2. Cheque para trinta dias.");
imprimir ("3. Em duas vezes.");
imprimir ("4. Em três vezes.");
imprimir ("5. Em quatro vezes.");
imprimir ("6. A partir de cinco vezes.");
imprimir ("--------------------------------------");
imprimir ("Entre com sua opção :");
ler (opcao);

escolha opcao:
    caso 1: imprimir ("Desconto de 20%.");
    caso 2: imprimir ("Preço de a vista.");
    caso 3: imprimir ("Preço de a vista.");
    caso 4: imprimir ("Preço de a vista.");
    caso 5: imprimir ("Juros de 5%.");
    caso 6:
      início
        imprimir ("Juros de 3% ao mês");
        imprimir ("Sujeito a mudança de acordo a financeira.";
      fim;
   caso contrário: imprimir ("Opção inválida !!!");
fimescolha;
fim

Repetição com teste inicial

Esta estrutura permite repetir um trecho de algoritmo diversas vezes. O fluxo de execução é controlado por um teste feito antes da execução:

enquanto CONDIÇÃO faça
   COMANDO1;
   COMANDO2;
   ...........................
   ...........................
   ...........................
   COMANDOn;
fimenquanto;

Quando CONDIÇÃO for falso os COMANDOS serão abandonados e o algoritmo passará para o próximo comando após o "fimenquanto". Se já da primeira vez o resultado é falso, os COMANDOS não são executados nenhuma vez, o que representa a característica principal desse modelo de repetição.

Exemplo demonstrativo: algoritmo que calcula a média aritmética de uma quantidade indeterminada de números.

início
inteiro: contador; /*contará quantos números são passados para o programa*/
real: acumulador; /*acumulará a soma dos números passados*/
real: media; /*armazenará o resultado da média aritmética*/
real: numero;/*armazenará os números e controlará o encerramento do programa*/

/*Inicialização das variáveis. É uma boa regra de estilo sempre inicializar (atribuir algum valor) as variáveis
antes de usá-las. Algumas linguagens exigem isso.*/
contador <== 1;
acumulador <== 0;
media <== 0;
numero <== 0;

enquanto (numero >= 0) faça
    imprimir ("Entre com um número (-1 para encerrar) :");
    ler (numero);
    se (numero >=0) /*só computa o número se este for maior ou igual a zero*/
      acumulador <== acumulador + numero;
      contador <== contador + 1;
    fimse;
fimenquanto;

media <== acumulador / contador;

imprimir ("A média aritmética é", media);
fim

Repetição com teste final

Esta estrutura também permite repetir um trecho de algoritmo diversas vezes, porém o fluxo é controlado por um teste feito no final da execução.

faça
   COMANDO1;
   COMANDO2;
   ...........................
   ...........................
   ...........................
   COMANDOn;
enquanto CONDIÇÃO;

Observe que os COMANDOS são executados pelo menos uma vez, independente da CONDIÇÃO. Isto acontece porque a condição é avaliada após a execução dos comandos, o que representa a característica principal desta estrutura.

Exemplo demonstrativo: algoritmo que calcula a média aritmética de uma quantidade indeterminada de números.

faça
    imprimir ("Entre com um número (-1 para encerrar) :");
    ler (numero);
    se (numero >=0) /*só computa o número se este for maior ou igual a zero*/
      acumulador <== acumulador + numero;
      contador <== contador + 1;
    fimse;
   enquanto (numero >= 0);

media <== acumulador / contador;

imprimir ("A média aritmética é", media);
fim

Repetição controlada

Esta estrutura permite repetir um trecho de algoritmo um número específico de vezes. Sua sintaxe é:

para contador de inicio até fim incremento nr faça
   COMANDO1;
   COMANDO2;
   ...........................
   ...........................
   ...........................
   COMANDOn;
fimpara;

onde:

"contador" é a variável de controle;
"inicio" é o valor inicial de "contador";
"fim" é o valor final de "contador";
"nr" é o valor segundo o qual "contador" será incrementado a cada execução.

Exemplo demonstrativo: algoritmo que imprime os números até 500

início
inteiro: contador
para contador de 1 até 500 incremento 1 faça
imprimir (contador, " - ");
fimpara;
fim

Exercícios

Construa um algoritmo que receba a idade do usuário e verifique se ele tem mais de 21 anos.
Construa um algoritmo que receba três números inteiros e verifique qual o maior.
Construa um algoritmo que calcule o peso ideal de uma pessoa. Dados de entrada: altura e sexo. Fórmulas para cálculo do peso:
peso ideal de homem = (72,7 x altura) - 58
peso ideal da mulher = (62,1 x altura) - 44,7
Construa um algoritmo que receba o código de um produto e o classifique de acordo com a tabela abaixo:
CÓDIGO  CLASSIFICAÇÃO
1            Alimento não-perecível
2 a 4      Alimento perecível
5 e 6      Vestuário
7            Higiene pessoal
8 a 15     Limpeza e utensílios domésticos
Qualquer outro código Inválido
Construa um algoritmo que leia uma quantidade indeterminada de números inteiros positivos e identifique qual foi o maior número digitado. O final da série de números digitada deve ser indicada pela entrada de -1.
Construa um algoritmo que leia três valores inteiros e os imprima em ordem cresecente.
Construa um algoritmo que receba um número inteiro e verifique se o mesmo é primo.
Dada a fórmula: H = 1 + !/2 + 1/3 + 1/4 + ..... + 1/N . Construa um algoritmo que calcule o número H, dado o número inteiro N.
Construa um algoritmo que calcule o fatorial de um número N inteiro e positivo (N!). Saiba que:
N! = 1 x 2 x 3 .... x (N -1) x N
0! = 1
A série de Fibonacci é formada pela seguinte sequência: 1,1,2,3,5,8,13,21,34,55.... Construa um algoritmo que gere a série de Fibonacci até o vigésimo termo.
Construa um algoritmo que leia cinco números inteiros e identifique o maior e o menor.
Construa um algoritmo que imprima a tabela de equivalência de graus Fahrenheit para centígrados. Os limites são de 50 a 70 graus Fahrenheit com intervalo de 1 grau.
Fórmula: C = 5/9 (F -32)
Uma rainha requisitou os serviços de um monge, o qual exigiu o pagamento em grãos de trigo da seguinte maneira: os grãos de trigo seriam dispostos em um tabuleiro de xadrez, de tal forma que a primeira casa do tabuleiro tivesse um grão, e as casas seguintes o dobro da anterior. Construa um algoritmo que calcule quantos grãos de trigo a Rainha deverá pagar ao monge.
Construa um algoritmo que apure uma eleição com três candidatos. O algoritmo deve realizar as seguintes tarefas:
- Calcular o total de votos para cada candidato;
- Calcular a quantidade de votos nulos;
- Calcular a quantidade de votos em branco;
- Calcular o percentual de votos em branco e nulos em relação ao total.
- A votação deve obedecer as seguintes convenções:
1,2,3 => votos dos candidatos
4 => votos em branco
5 => votos nulos
0 => encerramento da apuração
José tem 1,50 m e cresce 2 centímetros por ano. Pedro tem 1,10 m e cresce 3 centímetros por ano. Construa um algoritmo que calcule em quantos anos Pedro será maior que José.

Se esta página lhe ajudou, considere fazer uma doação