Seguidores

sábado, 16 de março de 2013

TOMADA DE DECISÃO #2 - Função CASE

Fala jovens garotos.., e garotas é claro. ‘:) Vamos dar continuidade a postagem que comecei a duas postagens atrás que foi sobre tomada de decisão. Bom, não será bem uma continuação, pois na oportunidade falamos sobre a função IF, agora, falaremos de uma função que tem a mesma semelhança de tomada de decisão. Imagine uma função que por meio da entrada de numero inteiro o programa ira fazer um comando e tomar um rumo. A função CASE funciona exatamente assim. Ai você vai pensar: “Brother.., a função IF não faz a mesma coisa” e eu lhe respondo jovens.. “Não.., não faz.”

Em termos a função IF toma uma decisão e escolhe o seu rumo conforme a sua resposta, o programa continua de duas formas, ou segue o caminho de forma verdadeira ou segue de forma falsa.  Claro que existem formas de encadear uma função IF com a outra. Fazendo assim um numero de funções if’s para chegar a um determinado ponto do programa, no qual, o seu resultado é obtido.

A função case não funciona exatamente assim. Ela nos traz a facilidade de montar e até mesmo organizar a sua linguagem de programação. (Claro jovem, tudo isto dependendo da ocasião). A função CASE não realiza nenhum teste lógico por parâmetros igual IF e sim realiza testes por comandos. Si ela achar uma entrada de um comando igual ao que esta declarado dentro da função ela vai fazer com que apenas essa parte do programa seja executada, logo em seguida vai continuar com a o programa que esta fora da função CASE. O legal é que com ela podemos fazer o programa tomar um rumo simples ou mesmo um rumo mais complexo,isso irá depender da sua necessidade e de como vai usá-la. Dizem que uma imagem vale mais do que mil palavras..


Esse é um exemplo de fluxograma para a função CASE. Existem outros exemplos de fluxo, mas como nosso foco aqui é mão na massa na programação, vamos explicar melhor abaixo como a função funciona na sintaxe. Tentarei ser o mais breve possível, porém ela precisa de mais atenção que a função IF, então acomodasse na sua poltrona com o notebook, na sua cadeira com em frente ao seu pc ou no travesseiro que você jogou no chão gelado porque sua mãe ta lavando o tapete da sala para ler no seu tablet e venha programar. (y)’
Analisem a situação:

  • Vamos montar um programinha que faça diversos cálculos a partir de dois números que você entrar. Digamos que é algo como uma calculadora. Você terá que apresentar um cardápio contendo operações de soma, subtração, multiplicação e divisão.
Com a função IF que é a que conhecemos até agora, ele ficaria assim:

Program calculadora ;
var
 a,b,res:real; // declaração da variável dos dois números
 op:integer; // declaração da variável da operação
 Begin // inicio do programa
   writeln ('Digite o primeiro numero');
   readln(a);
   writeln('Digite o segundo numero');
   readln(b);
   clrscr; //comando para apagar as informações acima
   writeln('Digite o numero correspondente a operações abaixo. O que você quer fazer?');
   writeln(' ');
   writeln('1-Você quer somar'); // aqui esta o cardápio
   writeln('2-Você quer subtrair');
   writeln('3-Você quer multiplicar');
   writeln('4-Você quer dividir'); // terminando aqui o cardápio
   readln(op); // entrada da variável da operação
   res:=0; //resultado entra como valor zerado antes do processamento
  
   {Daqui para baixo começa o processamento para a operação para que o usuário escolher.
   É justamente ai jovem que começa toda a MER@#$#! na maioria das vezes. Olha a confusão a seguir}

    if (op=1) then // decisão para operação de soma
     begin // inicio da decisão de soma
      res:=a+b;
     end //fim da decisão de soma
    else // se não for soma
     begin //inicio da decisão se não for soma
       if (op=2) then // inicio da decisão de subtração
        begin //inicio da decisão de subtração
         res:=a-b;
        end //fim da decisão de subtração
       else // se não for subtração
        begin //inicio da decisão se não for subtração
         if (op=3) then // inicio da decisão de multiplicação
          begin //inicio da decisão de multiplicação
           res:=a*b;
          end //fim da decisão de multiplicação
         else //se não for multiplicação pela logica de if só pode ser divisão então ...
          begin //inicio da decisão de divisão
           res:=a/b;
          end; //fim da decisão de divisão
                   
        end; // fim da decisão de subtração
        
     end; // fim da decisão de soma
    
  {Fim do processamento da operação escolhida}
 
  writeln('O resultado da operação é ',res:5:2);  // mostrando o resultado final.
 End.

Olha só jovem.. Que.. Quee... trampoo de fazer tudo isso. O programa funciona perfeitamente claro.. Mas olha o quanto confuso ele fica. É begin .. depois end; ai vem else .. depois outro begin já abrindo outro IF dentro depois abrindo Begin de novo.. e assim vai indo.. conforme o código acima.

Percebe.. Por mais bom que você seja e por mais que isso funcione , uma hora você vai acabar se enrolado.. fechando um end antes da hora, enfim.

Olha só como que fica mais simples se usarmos a função CASE:


Program calculadora ;
var
 a,b,res:real;// declaração da variável dos dois números
 op:integer;// declaração da variável da operação
 Begin
   writeln ('Digite o primeiro numero');
   readln(a);
   writeln('Digite o segundo numero');
   readln(b);
   clrscr; //comando para apagar as informações acima
   writeln('Digite o numero correspondente a operações abaixo. O que voc quer fazer?');
   writeln(' ');
   writeln('1-VocÊ quer somar');
   writeln('2-Você quer subtrair');
   writeln('3-VocÊ quer multiplicar');
   writeln('4-Você quer dividir');
   readln(op);// entrada da variável da operação
res:=0; //resultado entra como valor zerado antes do processamento

 {Notem a facilidade abaixo jovem}
  
 Case op of // CASO op (operação) for // INICIO do CASE
  
   1:begin {inicio caso o usuário digitar 1}
      res:=a+b;
     end;  {fim caso o usuário digitar 1}
    
   2:begin {inicio caso o usuário digitar 2}
      res:=a-b;
     end;  {fim caso o usuário digitar 2}
    
   3:begin {inicio caso o usuário digitar 3}
      res:=a*b;
                end;  {fim caso o usuário digitar 3}
               
   4:begin {inicio caso o usuário digitar 4}
      res:=a/b;
                end;  {fim caso o usuário digitar 4}

 end; // FIM do CASE {é extremamente importante de fechar o CASE nesse caso não precisamos colocar begin}

   writeln('O resultado da operação escolhida é ',res:5:2); // mostrar o resultado
End.

Putz.. Sensacional hein. Funciona da mesma forma que o IF, mas notem como fica mais simples montar o programa.., entender a lógica..
Não existe um limite para o numero de coisas que deseja fazer com a função.. nesse meu exemplo usei apenas 4, mas poderia ser usada 5, 10, 20 .. depende da sua necessidade... e da sua paciência é claro. Kkkk
É importante ressaltar que a função só funciona com a entrada de um numero inteiro para a condição. Pois só assim o programa vai identificar a qual rumo ele deve tomar. Caso nenhuma das operações for escolhida o programa não ira executar nenhum dos cases e vai continuar com o programa normalmente. Nesse exemplo de Case que coloquei se colocar um numero diferente de 1, 2, 3 e 4 o programa irá mostrar um resultado zerado no final.. pois, declarei que res (resultado) recebe zero antes de processar o programa. Agora se no na função IF voc fizer isso nesse exemplo que coloquei advinha o que ele irá fazer..
Siiiiiiim jovem. Ele vai dividir. Justamente por conta dessa simples parte:
      

         if (op=3) then // inicio da decisão de multiplicação
          begin //inicio da decisão de multiplicação
           res:=a*b;
          end //fim da decisão de multiplicação
         else //se não for multiplicação pela lógica de if só pode ser divisão então ...
          begin //inicio da decisão de divisão
           res:=a/b;
          end; //fim da decisão de divisão

Entendeu a sacada. Se qualquer outro numero diferente de 1, 2 ou 3 entrar nesse exemplo de IF ele irá fazer a operação de divisão. Claro q da para corrigir isso. Com laços de repetição que fazem o programa voltar caso o usuário não digite nenhuma das opções desejadas, mas isso é assunto para outra postagem mais breve ;) .
Bom galera, espero que tenham gostado da leitura. Tentei explicar ao máximo como que funciona a função CASE é quais as suas diferenças entre IF. Gostou seja um de nossos membros e curtam a nossa fanpage do Facebook. Lá você pode ver quando postamos algo de novo aqui no blog e temos alguns desafios legais para resolver. Tudo isso jovem ajuda na divulgação e na valorização do nosso trabalho. Certo.. Da uma brincada com os programas acima, façam o download do CASE e o download  de IF. Ok, Valew, até mais!
Continue Lendo...

terça-feira, 29 de janeiro de 2013

LAÇOS DE REPETIÇÃO


Olá mundo, agora vamos falar de um ponto muito importante, os comando de repetição, vão nos auxiliar em deixar o código menor.
Em alguns momentos precisamos repetir alguns processos no programa, ao invés de ficar escrevendo linha por linha um comando que vai ser repetido 10,15 vezes.

Utilizaremos os laços de repetição que no pascal são:

For= Para, Repeat=Repita, While=enquanto.

Laço For (para)

O laço for (para) podemos dizer que usamos na maioria das vezes, por se tratar de um que tem uma variável de controle, determinando assim o numero de vezes que será executado.

Exemplo: 

Program lacofor ;
 var
 x,numero:integer;
//esse programa tem a função de receber um numero inteiro e somar esse numero +1 cinco vezes.
 Begin
 writeln('digite um numero inteiro');
 read(numero);
       for x:=1 to 5 do
        begin
        numero:=numero+1;       
        end;
 write('o numero digitado +5 é ', numero); 
 End.

No programa acima temos a execução do laço for que para ser criado precisamos ter bem claro três coisas.
A sintaxe do laço For(para) x:=1 to(ate) 5 do(faça).
A criação da variável de controle no caso é o X.
E sempre indicar onde começa(begin) e onde termina(end;) as instruções que serão repetidas.
Quando falamos em variável de controle podemos fazer como no exemplo anterior que definimos quando estamos escrevendo o código ou colocamos na mão do usuário que vai inserir quantas vezes ele quer que o laço seja repetido.

Exemplo:

Program lacofor1 ;
 const
 y=1;//definimos o valor que vai ser somado com a variavel de controle X.
 var
 fimdolaco,soma,x:integer;
 Begin
writeln('digite o numero que o laço deve parar (exemplo:1,2,3...500)')  ;
 read(fimdolaco);
           // acima definimos onde vai ser o fim do laço.              
          For x:=comecodolaco to fimdolaco do //a variável x recebe o valor inserido como" começo do laco " e vai ate o valor definido para a variável " fim do laço "
            begin
             soma:=x+y;
            writeln(y,'+',x,'=' ,soma );
           delay(1000);   //a função de delay significa que a execução sofrera um atrasa , o delay é calculado   em milesegundo ou seja para se ter um atrasa de 1 segundo colocamos o delay de 1000 milesegundos equivalente a 1 segundo.                  
            end;                
        end;
           writeln('o valor final da soma é:',soma);
 End.

Como pudemos ver nesse programa definimos quantas vezes o laço vai ser utilizado ,inserindo o numero de vezes via teclado.

 Program lacofor2 ;
 const
 y=1;//definimos o valor que vai ser somado com a variavel de controle X.
 x=1;//valor que vai controlar o laço.
 var
 comecolaco,subtracao:integer;
 Begin
 writeln('subtração lembrando que o valor sempre será subtraído por’,y ,’digite um numero (500,600...10)')  ;
 read(comecolaco);
           // aqui definimos o inicio do laço porem com um grande diferencial o programa vai iniciar a com o contador e sempre subtraindo o valor digitado ate chegar ao valor de 'X'
          For  comecolaco:=comecolaco downto x do  //quando usamos o downto(dessa até) significa que queremos fazer o caminho inverso do to(até) como se tirássemos 1 sempre da variável de controle nesse caso o começo do laço
          begin
          subtracao:=comecolaco-y;
                        writeln(comecolaco,'-',x,'=' ,subtracao );
                        delay(1000);   //a função de delay significa que a execução sofrera um atrasa , o delay é calculado em milesegundo ou seja para se ter um atrasa de 1 segundo colocamos o delay de 1000 milesegundos equivalente a 1 segundo.
end;
          writeln('');
          writeln('o valor final da subtraçao é:',subtracao);
   End.

Nesse programa pudemos ver que na execução e ele se comportou de forma diferente ,foi de forma decrescente ate o final do laço graças ao downto( dessa até).  (depois faça o seguinte teste , ao invés começar com a variavel de controle com o numero 1 coloque a variavel recebendo 0 e veja o resultado)Laço While(enquanto)Um laço que só ira executar as instruções abaixo enquanto a condição for falsa.O que significa que esse laço testa uma condição antes de executar as instruções.Exemplo:

Program lacowhile ;
 var
numero,cont:integer;
                        //esse programa tem a função de receber um numero inteiro e somar esse numero +1 enquanto o numero for diferente de vinte.
 Begin
 writeln('digite um numero inteiro');
 read(numero);
       while(numero <> 20) do
        begin
        cont:=cont+1;
               numero:=numero+1;       
        end;
 write('o laço foi utilizado ',cont,' vezes'); 
 End.

 Como pudemos ver nesse exemplo executando em pascal ele só vai repetir os comandos se a condição for verdadeira, a partir do momento que for falsa ele não executa nenhuma ação no laço e parte para instrução seguinte.

Laço repeat(repita)

Também um laço que é dependente de uma condição porém ele só testa no final a condição, ou seja, ele é executado uma vez sempre.
Exemplo:

Program Pzim ;
 var
 desligado:boolean;
 x,cont:integer;
                            //esse programa só vai parar de somar x quando uma tecla for pressionada.
 Begin
 Repeat
 cont:=cont+1;
      if(not keypressed)then
      begin
      x:=x+1;
             writeln('valor de x= ',x,' para sair pressione uma tecla');
      desligado:=false;
      end ;
      if ( keypressed) then
      begin
      desligado:=true ;
      end;
 until(desligado=true);
 writeln('contador: ',cont);
 End.

Na execução do programa acima ele vai repetir as informações até que seja pressionada alguma tecla, se não for pressionada nenhuma tecla o laço permanecera “ligado”.
A função auxiliar keypress uma função nativa do pascal, determina se uma tecla foi pressionada ou não ,ela é do tipo boolean .seguindo o mesmo padrão de “ligado” ou “desligado”
Testem a utilização desses laços exercitem bastante, pois são estruturas que ajudam muito no desenvolvimento em geral.

Continue Lendo...

segunda-feira, 21 de janeiro de 2013

OPERADORES LÓGICOS E OPERADORES RELACIONAIS

Olá programador (a), vamos preparar vossa massa cinzenta para mais uma aula, agora que sabemos utilizar os operadores aritméticos e conhecemos por cima os operadores relacionais, vamos nos aprofundar nos operadores relacionais e aprender os operadores lógicos.

Vamos tratar primeiramente dos operadores relacionais que já tivemos conhecimento na postagem de tomada de decisão.
Os Operadores Relacionais são símbolos que mostram a relação entre dois elementos. Esses operadores são:


Vamos montar um programa fácil de fazer e compreender, o programa ira pedir dois números e ele vai indicar qual o maior e qual é o menor ou se os números são iguais, para isso ser possível utilizaremos alguns operadores lógicos e tomada de decisão.
O programa fica da seguinte forma:

Program maior_menor; {nome do programa}
Var
n1,n2:integer; {as variáveis que vamos usar para receber os numeros}
Begin
{entrada do primeiro numero}
Writeln('Entre com o primeiro numero');
Readln(n1);
{entrada do segundo numero}
Writeln('Entre com o segundo numero');
Readln(n2);
{Agora usar tomada de decisão para saber qual é maior ou qual é menor}
IF n1 > n2 then  {verifica se é maior}
Begin
Writeln(n1,' é maior que ',n2);
end
                Else
                Begin
                      IF n1 < n2 then {verifica se é menor}
                      Begin
                      Writeln(n1,' é menor que ',n2);
                       End
                            Else {se nao for maior, nem menor so pode ser igual}
                                   begin
                                    writeln(n1,' é igual a ',n2);
                                    end;
                end;
end.


Os operadores relacionais podem ser usados em outros comandos que pedem funções por exemplo os laços de repetição repeat e while (serão ensinados na próxima postagem).
Agora vamos falar dos operadores lógicos.
Operadores lógicos são conectivos  usados na formação de novas preposições a partir de outra já conhecida.


Os operadores lógicos são:
Vamos montar um programa que o funcionário para ganhar um bônus precisa vender acima de 100 reais e não ter falta durante o mês. Para isso precisaremos dos operadores lógicos, relacionais e tomada de decisão.
O programa fica:


Program logico;Var
{declarado as variáveis}
venda:real;
falta:integer;
Begin

{recebe o valor da venda mensal} 
Writeln('Qual o valor da venda mensal');<>

Readln(venda);

{recebe a quantidade de faltas}                                 
Writeln('Quantidade de faltas');
Readln(falta);
                {Se venda menor que 100 ou falta diferente de zero}               
                IF (venda < 100) or (falta <> 0 )then {colocamos parênteses para separar as expressões}
                Begin                    
                {caso positivo imprime}                    
                Writeln('não ganha bônus');
                End
                               Else
                               Begin                    
                               {caso negativo imprime}                  
                               Writeln('Ganha Bonus');
                               End;
End.

Nesse programa utilizamos alem dos operadores relacionais diferente “<>” e menor “<”, utilizamos também o operador lógico “or”.
O operador lógico “or” ele vai ser verdadeiro quando uma ou outra condição for verdadeira.

Como cada um tem um jeito de pensar, esse programa pode ter o mesmo resultado com outra lógica, vamos ver como fica o programa.




Program logico;Var
{declarado as variáveis}
venda:real;
falta:integer;
Begin

{recebe o valor da venda mensal} </

Writeln('Qual o valor da venda mensal');
Readln(venda);
{recebe a quantidade de faltas}                                 
Writeln('Quantidade de faltas');
Readln(falta);
                {Se venda maior/igual que 100 e falta igual a zero}                  
                IF (venda >=100) and (falta = 0 )then {colocamos parênteses para separar as expressões}
                Begin                    
                {caso positivo imprime}                    
                Writeln('ganha bônus');
                End
                               Else
                               Begin                    
                               {caso negativo imprime}                  
                               Writeln('não ganha Bônus');
                               End;
End.

Agora utilizamos os operadores relacionais maior ou igual “>=” e igual “=” e o operador lógico “and”, mudamos os operadores mas ainda tivemos o mesmo resultado esperado.


O operador “and” será verdadeiro quando as duas condições forem verdadeiras.
Temos também um operador lógico que chamado “not”, ele expressa a negação de uma condição, porem essa condição tem que ser booleana (verdadeira ou falsa), como essa expressão é usa em partes bem especifica, não vamos montar uma programa para explicar ela, porem ao decorre das postagens esse operador poderá aparece em nossos programas.


Exemplo de uso de “not”:
Antes do comando keypressed (tecla apertada), que fica not keypressed (tecla na apertada), antes do comando true (verdade), que fica not true (não verdadeiro ou falso), antes do false (falso), que fica not false (não falso ou verdadeiro) e antes do eof ([end of file] fim do arquivo), que fica not eof (arquivo não finalizado). Podem aparecer outras expressões com not, mas essas são as mais utilizadas.
Bem pessoal por hoje ficamos por aqui, porem não se acanhem está com duvida, quer elogiar ou dar uma sugestão? Entre em contato ^^.


Ate a próxima pessoal, fiquem na paz!

Continue Lendo...