Estruturas de repetição (1)

       Olá! Boa noite! Hoje darei início aos posts abordando também as estruturas de repetição. Elas podem ser o For(para), While (Enquanto) e Do-While(Faça-Enquanto). Basicamente a diferença entre o For e as estruturas While, é que o primeiro é geralmente usado para problemas em que se sabe quantas iterações (repetições) serão realizadas, e que a realização dessas não depende de outra condição inicial. Já as estruturas While são usadas para quando se quer uma contagem indefinida, por exemplo procurar uma solução de equação ou problema de Programação Linear*. Ou seja, quando uma solução é encontrada o While pára automaticamente.

       As estruturas tem as seguintes "caras":

              
              For(Inicialização;Limite;Incremento){Comandos;}
          
              While(Condição){Comandos;}

              Do{Comandos;}While(Condiçao);

       Há ainda a diferença entre While e Do-While que é o seguinte: o While só executa se a condição for atendida. O Do-While executa pelo menos uma vez, ainda que sua condição não esteja satisfeita, e então, se for este o caso, pára. Ou seja:

Programa 2: While e Do-While em C

1.               #include<stdio.h>
2.               
3.               int main(){
4. 
   
5.                                int i=6;
6. 
   
7.                                while(i==2){
8.                                                    i=i*3;
9.                                                    printf("\n\n%d\n\n",i);
10.                                                   }//Este loop nunca irá rodar
11. 
    
12.                                do{
13.                                       i=i*5;
14.                                       printf("\n\n%d\n\n",i);
15.                                      }while(i==2); // Este loop será executado e trará resposta 30 na tela.
16.                                
17.                                system("pause");
18.                                return 0;
19.                               
20.                               }

      Entretanto, pensei esse post para falar mais do For, na sequência lançar outros sobre While/Do-While e mais tarde mais aplicações dos três...

    O For, como já foi dito, tem a seguinte "cara": For(Inicialização;Limite;Incremento){Comandos;}. A inicialização, é de onde partirá a "contagem", o limite é até onde ela vai, e o incremento de qual valore ela vai ser acrescida ou decrescida a cada repetição. Imagine o seguinte, um algoritmo que diga para subir uma escada de 30 degraus, um a um. Logo, você parte do primeiro degrau ( 0 ), chega ao último degrau (29) e sobe de um em um (i++). Seria algo mais ou menos assim:

Programa 3: For básico em C

1.               #include<stdio.h>
2.               
3.               int main(){
4. 
   
5.                                int i=0;
6. 
   
7.                                for(i=0;i<30;i++){//(Inicialização;Limite;Incremento)
8.                                                              printf("\n\n%d\n\n",i);
9.                                                             }//Este loop executa 30 passos, do 0 ao 29.
10. 
    
11.                                
12.                                system("pause");
13.                                return 0;
14.                               
15.                               }

    Note que o a variável de repetição, i, na linguagem C tem que ser declarada antes da estrutura For. Também é bom notar que o limite imposto NUNCA é atingido. Por exemplo, se o limite é 30, os loops vão até i = 29! Parece óbvio, pois olhando o sinal, o limite é menor que 30. Entretanto essa é uma característica do For que pode trazer resultados errados ao seu programa, se você se esquecer dela. 

      Há também o For usado com decremento, ou seja diminuindo. Imagine agora, que você quer descer a mesma escada que acabou de subir, o programa fica quase igual, exceto pela linha 7:

      7.                                for(i=30;i>0;i--){//(Inicialização;Limite;Incremento)

    Nesse For, o i começa de fato em 30, decresce um a um, chega em 1 e pára. É o chamado For Backward (de trás pra frente). O anterior é o For Foward.

      Na maior parte das vezes, usa-se o for para contagens, para adicionar dados a algum problema, para realizar testes nos programas, etc... A seguir um exemplo simples:

Programa 4: Fatorial com For em C

1.               #include<stdio.h>
2.               
3.               int main(){
4. 
   
5.                                int i=0,s=1;
6. 
   
7.                                for(i=1;i<11;i++){//(Inicialização;Limite;Incremento)
8.                                                            s*=i; // A cada repetição, s é multiplicada por i.
9.                                                             }//Este loop executa 10 passos, do 1 ao 10.
10. 
    
11.                                printf("\n\n%d\n\n",i);//Saída 3628800
12. 
    
13.                                
14.                                system("pause");
15.                                return 0;
16.                               
17.                               }

Observações:

    Programação Linear é uma área da otimização, que utiliza uma função objetivo, e restrições lineares. Ou seja, problemas do tipo maximizar lucro de uma fábrica que possui "x" funcionários e precisa produzir "y".
    

    Os sinais "++","--" são alternativos para "i=i+1" e "i=i-1". Já " s*=i " é o mesmo que " s=s*i ". Isso funciona da mesma forma para " s+=i ", " s-=i "...

    A seguir alguns bons livros sobre C/C++:

      Introdução à programação. 500 Algoritmos resolvidos. Por Anita Lopes e Guto Garcia.
      Guia C++ para Iniciantes por Herbet Schildt.

      C Completo e Total por Herbert Schildt.

Proposta: Tente, usando o For, resolver o seguinte problema de Programação Linear.

    A Capitão Caverna S.A., localizada em Pedra Lascada, aluga 3 tipos de barcos para passeios marítimos: jangadas, super-canoas e arcas com cabine. A companhia fornece juntamente com o barco um capitão para navegá-lo e uma tripulação que varia de acordo com a embarcação: uma para jangadas, duas para super-canoas e três para arcas. 

    A companhia tem 4 jangadas, 8 super-canoas e 3 arcas; e em seu corpo de funcionários: 10 capitães e 18 tripulantes.

    O aluguel é por diárias e a Capitão Caverna lucra $50 por jangada, $70 por super-canoa e $100 por arca.

    Objetivo: Maximizar o lucro obedecendo as restrições impostas.

(Resposta 4 jangadas, 4 super-canoas, 2 arcas, lucro $ 680)
Solução: Programa 5 - Barcos Otimização

Bom fim de semana à todos!

Um pouco sobre C/C++, Linhas Condicionais.

       Bom dia! Me chamo Rodrigo. Atualmente sou estudante de Engenharia Elétrica da UFJF, tendo começado o curso de    engenharia no IFET-Sudeste.. De agora em diante serei colaborador do blog e vou postar alguns tópicos de estudo sobre C, C++, posteriormente aplicações nas áreas de modelagem computacional (basicamente a implementação de problemas reais), curiosidades, desafios... Enfim, será uma série para estudos das linguagens C, C++ e sobre aplicações práticas da programação.

       Pra quem precise aprender para a faculdade é uma boa, pra quem gosta ou tem bolsa de pesquisa mais ainda. É uma área muito visada no meio da engenharia, pois muito da pesquisa que se faz em universidades se passa pela simulação computacional...
       Não farei aqui algum tipo de apostila ( pois na internet já existem várias), o que farei são postagens com programas já feitos e algumas discussões sobre seu funcionamento. Para iniciar (seguir) seus estudos, já foi recomendado aqui, o material do Prof. Jabour disponível em Apostila, na aba Ensino, é uma boa pedida pra quem nunca viu C... Também há vários bons livros sobre C e C++, que no próximo post irei recomendar aqui. Podem fazer perguntas e sugestões à vontade nos comentários!

Programa 1: Soma e Subtração básica em C

1. #include <stdio.h>// biblioteca padrão em C
2. 
   
3. int main ( ) {
4.                   int a, b, soma, final; // Declaração das variáveis
5. 
   
6.                   printf("\n Digite um valor:\n"); // Comando de impressão na tela
7. 
   
8.                   scanf ("%d",&a); // Lê o que o usuário digitou no teclado
9. 
   
10.                   printf("\n Digite um segundo valor:\n");
11. 
    
12.                   scanf ("%d",&b);
13. 
    
14.                   soma = a+b; // Soma os valores a e b e atribui o resultado à variável soma.
15. 
    
16.                   if (soma>20) {
17.                                          final = soma+8; } // Comando condicional
18.     
19.                   else {
20.                            final = soma-5; } // Complemento do comando condicional
21.                   
22.                   printf ("\n O resultado e: %d", final);
23. 
    
24.          
25.                   system("pause") // Linha de comando para que se possa visualizar o resultado na tela
26.                   return 0; } // Retorno da função main( )

       Bem, esse é um programa bem simples de ser entendido, mesmo por quem ainda está começando. São 26 linhas de código, o que é bem pouco. Na linha 1 temos a inclusão da biblioteca stdio.h, que faz parte da biblioteca padrão de C. Biblioteca é, basicamente, um conjunto de funções. Na linha 3 temos a declaração da função main ( ), que deve estar em qualquer programa em C. Por ela se dá a execução do código. Em seguida dois pares printf/scanf que servem para pedir que o usuário digite um valor e em seguida armazenam esse valor em variáveis int. Na linha 14 faz-se a soma dos valores que o usuário digitou. Logo vem o mais interessante desse programa, as linhas condicionais. Na linha 16 temos : Se a soma for maior que 20 faça isto ( soma + 8). Na sequência, na linha 19 temos o complemento: Senão faça isto (soma - 5). Ou seja, se a soma de 'a' e 'b' for menor ou igual a 20 ( note que a condição é >20) ele subtrai 5 e, somente se, for maior que 20 ele soma 8. O resultado é impresso e o código retorna 0 para main ( ).

Observações:
     
       //As linhas verdes, precedidas por // são apenas comentários! Não interferem no código e são muito úteis em qualquer programa... Lembre-se de que há programas complexos e extensos, e sem comentários é praticamente impossível entender seu funcionamento.

       Atente para a identação do código. Ou seja, os espaços antes de cada comando. O que pertence ao if, à frente do if, o que pertence ao else, à frente do else...

       A linha 25 serve somente para que a tela "congele" ao mostrar o resultado. É uma maneira de fazer isso, apesar de haver controversas, nunca tive problemas com ela. Mais adiante postarei uma alternativa.

       A linha 26 dá o retorno da função main ( ). É recomendado dar algum retorno para toda função que não seja do tipo void ( que não possui retorno ).

Proposta:

       Modifique o programa bastante. Mude as operações, faça com produtos( * ), divisões( / ), etc... Inclua printf para que mostre o resultado da operação antes de entrar nas linhas condicionais ( essa é uma ótima maneira de testar programas que dão errado, e achar o erro!), mude o else da linha 19 por outro if, e tente obter o mesmo resultado...

Boa semana à todos!

Algoritmos, "colocando no papel" parte II

Hoje vamos aprender um importante recursos para visualizar o fluxo do algoritmo e nos ajudar a entender as consequências dos condicionais e dos ciclos:  a montagem de fluxogramas, diagramas com setas e símbolos que representam os passos do algoritmo.

Mais uma vez não vamos aqui seguir a regra pura de construção de fluxogramas. Vamos ver uma versão simplificada e fácil, apenas para termos mais um recurso a mão. Quem quiser pode se aprofundar, procurando materiais didáticos sobre o assunto. Na internet temos diversos gratuitos.

Iniciadores e terminadores:

Iniciador e terminador

Aparecem no início e no final do programa e servem exatamente para isso (indicar o começo e o fim do algoritmo). Podem ser representados de diversas formas, mas aqui adotaremos a do retângulo-oval (essa salsicha ai em cima).

Processos genéricos (Passos):

Um verdadeiro processo genérico!

A maior parte das instruções, os passos do programa, os chamados "processos genéricos", são representados por esse retângulo (não, não ESSE exatamente, se o passo for x = a+1, você vai escrever isso dentro do retângulo e não "solte o barro", por favor, nada de programas diarrentos!)

Condicionais:

Um condicional

Representam os testes condicionais e comparativos, além disso, são usados para representar os ciclos também. Isso mesmo! Os ciclos aqui são representados como testes condicionais! O caso é que todos os símbolos só admitem uma única seta entrando e uma única seta saindo, menos... este, que pode ter saindo dele duas, ou mais setas de fluxo.

Setas de fluxo:

Setas de fluxo

Unem os símbolos e representam o fluxo de dados do algoritmo. Em geral, cada símbolo possui duas setas: uma entrando e outra saindo. Inicializadores tem apenas uma seta saindo, enquanto terminadores tem apenas uma seta entrando. Condicionais tem uma seta entrando e duas, ou mais, saindo. Pode acontecer também de uma seta apontar para outra seta.

Entradas e saídas:

Entrada e saída

Representam ah... hã... bem... as entradas e saídas do programa. O símbolo é o mesmo para ambos, um paralelogramo.

Um fluxo simples:

Um fluxo simples e retilíneo

Peguei um dos primeiros algoritmos da postagem anterior e passei para um fluxograma. Notem que é fácil entender onde ele começa, por onde deve seguir e onde termina. Usei o editor de imagens do google docs para desenhar isso. Qualquer um que tenha uma conta google (é grátis, se você tem uma conta blogger, gmail, conta no youtube, google+ e etc, provavelmente você tem acesso ao google docs).

Representando o SE ENTÃO:

Apesar do condicional "SE ENTÃO" ser um só, ele pode ter dois efeitos em um algoritmo, o que gera "duas representações" num fluxograma. No geral, um SE ENTÃO é representado por uma seta entrando num símbolo condicional e duas saindo dela. O problema está nessas setas.

Temos casos em que o SE ENTÃO só serve para adicionar passos em um programa, ou seja, ele não tem um "SE NÃO". O programa corre normalmente e quando chega no "SE ENTÃO", sendo o teste verdadeiro, ele inclui instruções do bloco SE e depois retorna a linha normal do programa. Se o teste for falso, ele simplesmente salta o bloco SE e continua o programa. Veja um modelo:

Um SE sem um SE NÃO

Nesse caso ele vai executar 1-2-3-{4-5}-6-7 se A for verdadeiro e 1-2-3-{}-6-7 se A for falso. A representação para casos como esse é, uma seta entrando no simbolo condicional e duas saindo, uma à direita para caso o teste for verdadeiro e uma para baixo, seguindo a seqüência do programa.

Um SE sem um SE NÃO

Temos também os SE ENTÃO que usam o "SE NÃO", ou seja, o programa vai correndo em sua linha normal, chega no "SE ENTÃO" e realiza o teste lógico, se o teste der verdadeiro executa um bloco de instruções, se der falso executa outro. Depois de realizar os blocos o programa volta para o curso normal. Veja o modelo:

Um SE com um SE NÃO

Nesse caso ele vai executar 1-2-3-{4-5}-8-9 se o teste for verdadeiros e 1-2-3-{6-7}-8-9 se for falso. A representação segue a anterior, seta para o lado para o caso verdadeiro, seta para baixo para o caso falso. A diferença é que da ultima instrução verdadeira vai seguir uma seta e esta vai apontar para a seta que sai da última instrução falsa.

Representando o ESCOLHA UM CASO:

Como vimos, temos os ESCOLHA UM CASO com "SAIR" em cada caso, os ESCOLHA UM CASO sem o "SAIR" em alguns casos e os escolha um caso e os sem o "SAIR" em todos os casos. Embora o condicional seja o mesmo a representação gráfica pode mudar.

A representação geral do escolha um caso é uma seta entrando em um símbolo condicional e uma saindo se dividindo em várias setas, uma para cada caso. Os casos que tiverem um "SAIR", ao fim das instruções deverá sair uma seta convergindo para a linha normal do programa. Os sem "SAIR", ao fim das instruções, deverão ter uma seta convergindo para o início do próximo caso. Veja os modelos:

Escolha um caso com SAIR em todos os casos

Escolha um caso com SAIR em todos os casos 

ESCOLHA UM CASO sem SAIR em alguns dos casos

ESCOLHA UM CASO sem SAIR em alguns dos casos 

ESCOLHA UM CASO sem SAIR

ESCOLHA UM CASO sem SAIR

 Obs.: Parece que eu esqueci de mudar o conteúdo dos símbolos condicionais em algumas figuras, está escrito "Motor ligado" ao invés de "Variável".

Ciclos:
Os ciclos, apesarem de terem diversas formas para serem escritas (teste de quebra no início, no meio e no fim) não tem maiores delongas quanto a sua representação gráfica: Eles são representados por uma seta saindo de um condicional e apontando para algum ponto anterior ao mesmo. As instruções entre esse ponto de retorno e o condicional são as que ficam entre o início do ciclo e o teste de sua quebra. As instruções que ficam na seta de retorno até o ponto de retorno são as que ficam entre do condicional de quebra e o final do bloco do ciclo. O importante é lembrar que, no caso dos ciclos, quando o condicional é verdadeiro a seta segue para baixo, voltando a linha normal do algoritmo. Quando é falso ele segue o caminho do loop, para a esquerda. Veja os modelos:

Ciclo com teste de quebra no final

Ciclo com teste de quebra no final

Ciclo com teste de quebra no meio

Ciclo com teste de quebra no meio

Ciclo com teste de quebra no início

Ciclo com teste de quebra no início

Exercícios:

1) Montar os fluxogramas dos algoritmos dos exercícios 1 a 7 da postagem anterior.

2) Montar primeiro o fluxograma e depois escrever os algoritmos para os seguintes programas:

a) Que receba 3 números e diga qual deles é o maior.
b) Que receba 5 números e os coloque em ordem crescente.
c) Que receba 10 temperaturas e armazene classifique elas em 4 classes: a < 50º, 50º <= b < 0º, 0º <= c < 50º, d >= 50º.
d) Receba 2 números e tire o mínimo múltiplo comum.

Pronto, eu pessoalmente já devia estar dormindo. Escrevi isso aqui 12/09 0130h, às 0800h vou dar um curso em um batalhão de infantaria. Já sei que a greve acabou e por isso a próxima postagem está prevista só para mês que vem, provavelmente 19/11. Trabalharemos com o MS Excel / BrOffice Calc para aprendermos a lidar com condicionais.

Isso é tudo.

Respostas aos exercícios de 19/09

1) Variáveis: hipotenusa "a", catetos "b" e "c". Entradas: dimensões dos catetos "b" e "c". Saídas: dimensão da hipotenusa "a".

Exercício 1

2) Variáveis: hipotenusa "a", catetos "b" e "c", ângulo "g". Entradas: hipotenusa "a", ângulo "g". Saídas: catetos "b" e "c".

Exercício 2

3) Variáveis: coeficientes "a", "b" e "c", delta "d", raízes "x1" e "x2", verificador "grau "(declarei esse errado, com o nome de "ver"). Entradas: coeficientes "a", "b" e "c". Saídas: raízes "x1", "x2" e textos "não existem raízes reais" e "equação de 1º grau". Blocos(em cores): nível 1(mais externos): vermelho, lilás e vermelho escuro. Nível 2 (ambos  internos ao bloco lilás) azul e ciano. Nível 3(ambos internos ao ciano): verde e amarelo. Condicionais: "Coeficiente "a" é igual à zero?" (a==0), "Delta é maior que zero?" (d>0), "Delta é igual a zero?" (d==0), "Comparar verificador grau com caso 1,2,restante" (ver).

Exercício 3

4) Variáveis: nivel_da_agua (nível da água no balde). Entradas "nivel_da_agua". Blocos (em cores): Nível 1(mais externo): vermelho. Nível 2(interno ao vermelho): lilás. Condicionais: "O balde está cheio?" (nivel_da_agua == cheio). Ciclos:  tudo o que está dentro do bloco vermelho.

Exercicio 4

5) Variáveis: nivel_do_combustivel, capacidade_do_tanque (poderia ter feito igual ao do problema do balde, colocando um nível fixo, ou um não numérico, mas dessa vez eu quis aprimorar), motor_ligado. Entradas nivel_do_combustivel, capacidade_do_tanque e motor_ligado. Blocos: Nível 1(mais externos) vermelho e ciano. Nível 2 (internos ao vermelho): lilás e azul, (internos ao ciano): verde. Condicionais: "o motor está ligado?" (motor_ligado), "o tanque está cheio?" (nivel_de_combustivel == capacidade_do_tanque). Ciclos: (1) tudo o que está dentro do bloco vermelho, (2) tudo o que está dentro do bloco ciano.

Exercício 5

6) Variáveis: nivel_de_combustivel, capacidade_do_tanque, litros_pedidos, nivel_inicial_do_tanque, motor_ligado. Entradas: nivel_de_combustivel, capacidade_do_tanque, nivel_inicial_do_combustivel, litros_pedidos. Blocos: Nível 1(mais externos): vermelho, ciano, vermelho-escuro. Nível 2 (internos ao vermelho): lilás, azul, (internos ao ciano): verde e amarelo, (interno ao vermelho-escuro): roxo. Condicionais: "o motor está ligado?" (motor_ligado), "é possível colocar todo esse combustível no tanque do veículo?" (litros pedidos > capacidade_do_tanque - nivel_inicial_do_tanque), "os litros pedidos foram colocados?" (nivel_de_combustivel == nivel_inicial_do_tanque + litros_pedidos). Ciclos (1) tudo o que está dentro do bloco vermelho, (2) tudo o que está dentro do bloco ciano, (3) tudo o que está dentro do bloco vermelho escuro.

Exercício 6

7) Variáveis: nivel_de_combustivel, capacidade_do_tanque, litros_pedidos, nivel_inicial_do_tanque, motor_ligado, preço_pedido. Entradas: nivel_de_combustivel, capacidade_do_tanque, nivel_inicial_do_combustivel, preço_pedido. Saídas: preço_pedido .Blocos: Nível 1(mais externos): vermelho, ciano, vermelho-escuro. Nível 2 (internos ao vermelho): lilás, azul, (internos ao ciano): verde e amarelo, (interno ao vermelho-escuro): roxo. Condicionais: "o motor está ligado?" (motor_ligado), "é possível colocar todo esse combustível no tanque do veículo?" (litros pedidos > capacidade_do_tanque - nivel_inicial_do_tanque), "os litros pedidos foram colocados?" (nivel_de_combustivel == nivel_inicial_do_tanque + litros_pedidos). Ciclos (1) tudo o que está dentro do bloco vermelho, (2) tudo o que está dentro do bloco ciano, (3) tudo o que está dentro do bloco vermelho escuro.

Exercício 7

8) Resposta inclusa nos exercícios anteriores.

Algoritmos, "colocando no papel" parte I

Sei que prometi que mexeríamos no BrOffice Calc nessa aula, mas eu esqueci que algumas coisas poderiam ser ensinadas antes de iniciarmos a prática. Por isso, nessas próximas duas aulas vou ensinar a montar "algoritmos escritos" e "fluxogramas", que ajudam a planejar e analisar os algoritmos.

Os algoritmos escritos, que vamos abordar hoje, não passam de um conjunto de instruções, escritos com uma sintaxe própria mas "flexível", sem obedecer nenhuma linguagem de programação. Você não tem que se ater em importar bibliotecas ou descobrir se uma função existe ou não. Você vai simplesmente escrever as operações que pretendidas na ordem desejada e assim ter uma ideia de como o programa vai ficar.

Por exemplo, temos que fazer um programa que execute a soma de dois números e mostre o resultado. Podemos escreve-lo assim:

Receber número A;
Receber número B;
C = A+B;
Exibir número C;

Com esse "esqueleto", um programador conseguirá passar ele para a linguagem de programação de seu domínio. Como por exemplo em "C":

#include<stdio.h>

int main(){
  float a,b,c;
  scanf("%f",&a);
  scanf("%f",%b);
  c = a+b;
  printf("%f",c);
}

E poderia colocar ele em outras linguagens aqui. O caso é que o mais difícil não é passar um algoritmo para uma linguagem! O maior trabalho está em montar o algoritmo! E montar ele numa linguagem com a qual estamos mais acostumados (no nosso caso, português) é mais fácil do que tentar montar direto em uma linguagem estranha (qualquer linguagem de programação).

Regras de sintaxe:

Apesar do objetivo de um algoritmo "no papel" ser expressar a ideia do "programa" que desejamos montar, sem que precisemos nos preocupar com nomes de funções, limitações de hardware e sintaxe, ainda precisamos de algumas regras com relação à essa última, se não, em algoritmos mais complexos podemos acabar não entendendo nem o que nós mesmos escrevemos.

Vamos padronizar aqui algumas regras, entre a gente, para facilitar o entendimento dos algoritmos produzidos aqui e para já ir introduzindo um pouco da sintaxe da linguagem C.

Enumeração de ideias:

Como sabemos, um algoritmo é um conjunto de instruções claras e bem definidas em sequencia. Uma instrução é uma ação, uma operação, ou uma identificação, ela ocupará uma  linha e não dividirá essa com qualquer outra instrução. Além disso usaremos um ";" (ponto-e-vírgula) para sinalizar o fim daquela instrução. Exemplo:

Programa de comer:

Pegar comida com o talher;
Levar a comida até a boca;
Abrir a boca;
Colocar a comida na boca;
Fechar os lábios;
Retirar o talher;
Mastigar;
Engolir;

Note que a ordem é importante! Se colocássemos "Colocar a comida na boca" antes de "Abrir a boca", com certeza teríamos um triste resultado.

Condicionais, blocos e tabulação:

Vamos usar dois condicionais, o "SE ENTÃO" e o "ESCOLHA UM CASO".

O "SE ENTÃO" realiza um teste lógico, se o teste for verdadeiro ele executa um conjunto de instruções, "SE NÃO" ele executa outro conjunto.

Sua sintaxe será:

SE(teste lógico){bloco de instruções para resultado verdadeiro}
SE NÃO { bloco de instruções para resultado verdadeiro}

Veja só um exemplo:

Programa de "fazer o tipo 2"

Note que no exemplo não usamos o "SE NÃO", isso é porque não haviam instruções a serem executadas se  o teste lógico desse verdadeiro. Aqui vai um exemplo de algoritmo que usa o "SE NÃO":

Programa de ida ao banheiro

É importante assinalar que o SE NÃO depende do ultimo  teste "SE" realizado.

Vamos ver agora o "ESCOLHA UM CASO". Ele não é nada mais que um "SE ENTÃO" metido a besta. Ele é tipo aqueles atendimentos automáticos por telefone que nos infernizam quando temos que reclamar de algo. Ele basicamente lê o valor de uma variável (no caso do atendimento automático, a tecla que você pressionou) e compara com os "casos" que ele conhece, direcionando o programa para o rumo devido.

Sua sintaxe é:

ESCOLHA UM CASO

Onde a variável a ser lida é uma coisa qualquer que pode ter vários valores possíveis, como "tecla do telefone pressionada", "cor da ficha médica" e etc. A, B, C... são valores que a variável pode assumir (1,2,3, vermelho, verde e etc). RESTANTE é o caso em que a variável não assumiu nenhum dos outros caso. SAIR é o comando dado para, depois de ter executado as instruções do caso, sair do "ESCOLHA UM CASO" e continuar o programa. Se não tiver o SAIR ele vai, após executar as operações em um caso, saltar para o caso seguinte e assim por diante, até encontrar um "SAIR", ou executar as instruções do caso "RESTANTE".

Vamos a um exemplo:

Atendimento automático

Um exemplo de um atendimento automático. O programa lê o número teclado pelo usuário e envia o mesmo para o serviço requisitado. Se o usuário digitar uma tecla diferente de 1,2,3,4,ou 5 ele vai ser mandado para o atendimento geral. Depois de atendido (qualquer atendimento) o programa sai do "ESCOLHA UM CASO", passa o número do protocolo para o usuário e encerra a ligação.

Vejamos agora esse outro exemplo:

Atendimento hospitalar

É um algoritmo de atendimento médico. Conforme o sujeito chega no hospital ele é tratado de uma forma. Note que o "SAIR" foi suprimido. Qual o resultado disso? Se um sujeito chega com o estado grave, ele vai sofrer um cirurgia, realizar um tratamento com remédios, ficar de repouso, realizar uma consulta médica e receber uma conta. Ou seja, o "algoritmo" vai encaminhar o paciente para o seu "caso" e após realizar as instruções deste, ele vai realizar todas as instruções dos casos abaixo até sair do "ESCOLHA UM CASO".

Podemos colocar testes "SE ENTÃO" dentro das instruções de outro "SE ENTÃO", dentro de um "SE NÃO" dentro de um caso... podemos colocar um teste "ESCOLHA UM CASO" dentro das instruções de um "SE ENTÃO", dentro de um caso de outro "ESCOLHA UM CASO"... para fazer isso no entanto, sem gerar ambiguidade e sem nos confundimos, precisamos entender o conceito de bloco.de instruções.

Blocos de instruções são conjuntos de instruções "separadas", digamos assim, da linha do principal do algoritmo e elas só serão executadas se forem chamadas (em geral por um condicional, ou então por um loop). O bloco é iniciado e fechado por chaves "{}" e suas instruções recebem uma tabulação, ou seja, recebem um "espaço" à esquerda (apertando a tecla tab) antes de serem escritas.

Veja a figura:

Blocos de instruções

O nosso programa segue sua linha normal até que encontra esse SE ENTÃO de teste lógico A. Se este teste der verdadeiro ele executa o bloco AZUL, ou seja, a instrução1, depois a 2 e depois o teste lógico B. Se B for verdadeiro ele vai executar o bloco vermelho, se não, vai executar o bloco verde, que tem um teste lógico C dentro, podendo executar o bloco amarelo dentro do verde.

Nesse caso, o bloco azul é o mais externo e o amarelo é o mais interno, pois está dentro do verde, que está dentro do azul. O bloco vermelho e verde estão no mesmo nível.

Notem que as instruções de mesma cor recebem o mesmo "espaço" à esquerda. As instruções em azul receberam uma tabulação (tecla tab apertada uma vez), as em vermelho e em verde receberam duas tabulações e as em amarelo receberam três tabulações. a quantidade de tabulações indicam o nível dos blocos, quanto mais tabulações, mais interno está um bloco.

Observem como o programa irá proceder de acordo com o resultado dos testes lógicos:

Tabular seu algoritmo de acordo com a estrutura dos blocos é importante, principalmente para o entendimento do programa por parte de programador-revisor. Ainda que a tabulação seja supérflua para muitas linguagens (como por exemplo o C, que se você quiser escrever tudo numa linha, colocando os "; e {}" necessários, o compilador entende e executa sem problemas) ela evita que um colga de equipe mais sensível tenha um troço ao ver o seu programa, ou que um mais estressado lhe meta um murro na cara para lhe ensinar a ser mais caprichoso com o seu trabalho;

Eis como é visto o programador que não tabula corretamente o seu algoritmo:

Esse programador, não seja esse programador.

Ciclos:

Apesar de eu ter citado que existem dois tipos de ciclos (loops) anteriormente, aqui, no algoritmo escrito, nós só vamos ter um tipo genérico. Ele vai se chamar, hum... bem... "CICLO" e sua sintaxe será "CICLO{bloco de instruções}".  As instruções no bloco do ciclo serão executadas normalmente e, quando chegarmos na última, voltaremos automaticamente para a primeira.

O programa só sairá do "CICLO" quando a instrução "QUEBRAR CICLO" for executada. É obvio que essa instrução deverá estar dentro do ciclo a ser quebrado, não menos obvio, a quebra de ciclo deverá estar dentro de um condicional, se não o ciclo não funcionará de nada.

Veja o modelo:

um "CICLO"

Percebam que, ao entrar no ciclo, o programa vai executar 1-2-3-4-testeA, se A for falso ele vai executar 1-2-3-4-testeA de novo e de novo, até A ser verdadeiro e o ciclo ser quebrado.

Se houve um "CICLO" dentro de outro "CICLO" a "QUEBRA DE CICLO" só vai agir sobre o que ela (ou o condicional dela) estiver dentro. 

Veja o exemplo:

Um "relógio"

O nosso "programa" entra no primeiro ciclo (azul) e logo entra no segundo e no terceiro. Ele vai ficar executando o terceiro (verde) até completar 60 segundos. Feito isso, ele vai zerar o contador de segundos e vai executar uma "QUEBRA DE CICLO". Ele então vai ver qual ciclo ele está executando no momento, o mais interno e nesse caso é o ciclo verde, portanto ele vai sair SOMENTE do verde. Ai então ele vai adicionar um minuto e voltar para o topo do ciclo vermelho, entrar novamente no ciclo verde, contar 60 segundos e fazer isso repetidamente até completar 60 minutos. Nessa ocasião ele já vai estar fora do ciclo verde, mas ainda dentro do azul e do vermelho. Ele vai cumprir o teste "minutos == 60", vai zerar os minutos, vai encontrar uma "QUEBRA DE CICLO", vai ver que o ciclo mais externo que ele está executando no momento é o vermelho, vai sair do ciclo vermelho, vai cair no azul e etc, etc, etc.

Variáveis, entradas, saídas e operações matemáticas: 

Variáveis, como eu já disse, é qualquer coisa que possa assumir valores diversos. Os valores não precisam ser necessariamente numéricos (1, 1,5 , -10,), podem ser lógicos (verdadeiro, falso, sim, não, ligado, desligado, levantado, abaixado...), textuais ("Frederico", "nome", "rio", " "), ou qualitativos (vermelho, verde, azul, bom, muito bom, ruim). Por enquanto não vamos nos preocupar em "declarar" as variáveis, mas já saibam em um algoritmo, antes de qualquer coisa é declarado as variáveis que vão ser usadas no mesmo, ou seja é dito os nomes das variáveis e os tipos a qual elas pertencem.

Entradas são os dados recebidos de fora do programa. Quando o programa de auto-atendimento pede para o usuário apertar uma tecla e este assim o faz, este está mandando um dado para o programa, ou seja, o programa está recebendo uma entrada. Quando o médico do nosso algoritmo de atendimento olha o estado de um paciente, ele está recebendo uma "entrada", um dado externo. Vamos usar a instrução "LER variável" para obter uma entrada.

Saídas são o que o algoritmo retorna ao usuário. A imagem que você está vendo agora, não é nada mais que uma saída que o sistema operacional do seu computador está retornando para você. Vamos usar a instrução "IMPRIMA variável" ou "IMPRIMA "frase" " para expressar saídas.

As operações aritméticas simples podem ser executadas normalmente. Vale lembrar no entanto que {}, [] e () não tem mais valor matemático e não podem ser mais usados. Se tivermos uma expressão do tipo: 

E = A +{C*[D+C] - [D*(A-B) }

O melhor a fazermos é decompô-la:

G =A-B;

H=D*G;

I=D+C;

J=C*I-H;

E=A+J;

Funções matemáticas como "seno", "cosseno" e até operações como "raizquadrada", "potenciade2", serão expressadas como "FUNÇÃO(variável)", por exemplo: SENO(30), "RAIZQUADRADA(B+C)" e etc.

Exercícios: 

1) Escreva o algoritmo para que, dado os catetos b e c de um triângulo retângulo, se encontre o valor da hipotenusa.

2) Escreva o algoritmo para que, dado o valor da hipotenusa e de um ângulo não reto de um triângulo retângulo, se determine o valor dos catetos do mesmo.

3) Escreva o algoritmo para que, dado os coeficientes a, b e c de uma equação de segundo grau se determine as raízes dessa equação.

4) Escreva o algoritmo para um robô encher um balde de água.

5) Escreva o algoritmo para um frentista abastecer um carro.

6) Escreva o algoritmo para um frentista abastecer um carro de acordo com "l" litros que o cliente pedir.

7) Escreva o algoritmo para um frentista abastecer um carro de acordo com "l" litros de acordo com "r" reais que o cliente pedir em combustível, sabendo que esse combustível está a R$ 2,50 o litro.

8) Identifique as variáveis, os blocos, os condicionais, as entradas, as saídas e os ciclos dos problemas anteriores.

Bom pessoal, vamos ficando por aqui. Nossa próxima postagem está prevista para 04/10 e será sobre organogramas. Nesse dia também eu vou postar as respostas dos exercícios que eu postei hoje. Já vou avisando que se a greve tiver acabado (eu ainda não sei, estou escrevendo isso 10/09), vou parar de publicar quinzenalmente e passar a postar mensalmente. Eu não espero diminuir o ritmo da minha produção, mas eu tenho que armazenar postagens para, caso a coisa fique preta e eu fique sem tempo de escrever, vocês não fiquem sem postagens para ler.

Isso é tudo e até mais ver.

Respostas dos exercícios de 04/09

1) Se uma proposição tem "n" átomos e cada átomo só pode assumir um de dois valores (ou verdadeiro, ou falso), então existem 2n combinações possíveis de valores, ou seja, teremos 2n linhas.

2) Temos 4 átomos: (a,b,c,d), portanto teremos 24  linhas, ou seja 16 linhas. Agora, vamos às colunas: temos que ter uma coluna para cada átomo: 4, mais uma coluna para cada molécula "menor" ((a||b),(a&&b),(c||d)): 3, mais uma para cada molécula maior  ((a&&b)||(c||d)): 1 e uma para a proposição em si: 1. Com isso temos 4 + 3 + 1 +1 = 9 colunas.

3)

P

Q

R

S

T

U

V

X

Z

A

B

4)

P) Átomos:  a=ela,  b=eu. Moléculas: a^b= "ou ela, ou eu". Proposição: P = a^b. Tabela verdade:

Q) Átomos a = "aceite eu", b = "aceite o cachorro", c = "durma fora de casa". Moléculas: a&&b= "aceite eu e o cachorro", a&&b||c = "aceite eu e o cachorro ou vá dormir fora de casa". Proposição: Q = a&&b||c. Tabela verdade (Vide "T" do exercício anterior).

R) Átomos a = "dar um jeito no ninho metralhadoras", b = "dar um jeito naquele cara com lança foguetes", c= "dar a volta no morro", d = "atacar o inimigo por trás". Moléculas: a&&b = "dar um jeito no ninho de metralhadoras e no cara com lança foguetes", c&&d = "dar a volta no morro e atacar o inimigo por trás", (a&&b)||(c&&d) = "Dê a um jeito no ninho de metralhadoras e naquele cara com o lança foguetes, ou dê a volta no morro e ataque o inimigo por trás". Proposição: R =  (a&&b)||(c&&d). Tabela verdade:

S) Átomos a="bocejarás", b="arrotarás". Moléculas ~a = "não bocejarás", ~b="não arrotarás", (~a)&&(~b) = "não bocejarás e nem arrotarás". Proposição S =  (~a)&&(~b). Tabela verdade: