Newsletter Desenvolvimento de Software

Receba informações de cursos gratuitos, apostilas, discussões sobre linguagens e metodologias, com esta newsletter quinzenal da Alfamídia.

e-mail

Confira as últimas mensagens da newsletter Desenvolvimento de Software

26/07/2016 - Conteúdo Gratuito de HTML 5 - Desenvolvimento de Software #2
11/07/2016 - Curso Gratuito de Python - Desenvolvimento de Software #1

segunda-feira, 13 de junho de 2016

Aprendendo a Programar: Lógica Booleana, Comando While....

Confira a primeira unidade deste curso em Lógica de Programação - Unidade 1

4. Criando um Pequeno Programa de Cálculo

Nesta unidade vamos colocar um desafio que pode ser resolvido com os conteúdos já apresentados.

4.1 Cálculo de IMC

O cálculo do IMC, ou índice de massa corpórea, é dado pela seguinte fórmula:
IMC = PESO / (ALTURA)²

No nosso desafio, o usuário entrará com as informações de peso e altura. O programa, entretanto, não retornará apenas o IMC, mas também uma avaliação com base no IMC gerado, seguindo a tabela a seguir:

ResultadoSituação
Abaixo de 17Muito abaixo do peso
Entre 17 e 18,49Abaixo do peso
Entre 18,5 e 24,99Peso normal
Entre 25 e 29,99Acima do peso
Entre 30 e 34,99Obesidade I
Entre 35 e 39,99Obesidade II (severa)
Acima de 40Obesidade III (mórbida)

Ou seja, se o usuário entrar com um peso e uma altura que gerem, no cálculo, um número de IMC maior que 25 mas menor que 30, o sistema exibirá um aviso de “Acima do peso”.

4.2 Dicas para Solução do Desafio

Se você está com dificuldades de completar o desafio, observe as seguintes dicas:

1 – Utilizando o comando ‘prompt’, você armazenará em variáveis (por exemplo, peso e altura) o peso e altura fornecidos pelo usuário.

2 – Neste momento, considere que o usuário pode entrar com números em fração, e vai utilizar o “.” como forma de entrar com os números fracionários. Mais adiante vamos ver como converter do formato brasileiro (por exemplo 5,10) para o americano (5.10). Neste momento, aceite os dados sem validar.

3 – Por enquanto, evite utilizar funções como parseInt, pois os números serão fracionários, e não inteiros. Como estamos multiplicando e dividindo, o javascript vai converter automaticamente as entradas.

4 – Utilize uma nova variável, por exemplo “imc”, para receber o resultado da operação entre “peso” e “altura”.

5 – Utilize uma sequência de ‘if” e “else” para testar cada condição do IMC.


4.3 Solução do Desafio

--------------------------------Cálculo do IMC ------------------------------
peso = prompt("entre com seu peso");
altura = prompt("entre com sua altura");
imc = peso / (altura * altura);
alert("Seu IMC ficou em: " + imc );
if (imc < 17)
  alert("muito abaixo do peso");
else {
  if (imc < 18.5)
    alert("abaixo do peso");
  else {
    if (imc < 25)
      alert("peso normal");
    else {
      if (imc < 30)
        alert("acima do peso");
      else {
if (imc < 35)
          alert("obesidade I");
else {
 if (imc < 40)
   alert("obesidade II");
 else
            alert("obesidade III");
        }
      }
    }
  }
}
----------------------------------------------------------------------------

Algumas questões são importantes de tratarmos aqui.

Primeiro, já temos um programa de alguma complexidade, então se você conseguiu criar uma solução que funcione (parecida ou não com esta), está no caminho certo.

Se você não conseguiu, é possível que algumas questões que apareceram neste exemplo tenham atrapalhado você. Vamos comentar sobre elas:

Números fracionários:

Nós não vamos entrar em detalhes de como as linguagens de programação tratam números fracionários, pelo menos neste momento. Saiba apenas que é algo que você terá que entender pelo menos em um grau superficial em algum momento.

Mas é importante dizermos aqui que, como na maioria das linguagens, o Javascript entende números fracionários na notação em que a fração é indicada por um ponto (‘.’) e não por uma vírgula (‘,’).

Nada nos impediria de alterar a string para aceitar também as vírgulas, mas envolve um tipo de recurso que não vimos ainda.

Outra questão dos números fracionários é que não podemos simplesmente utilizar “parseInt”, pois esta função retorna um inteiro, ou seja, perderíamos a parte do número depois da vírgula.

Sequências de “if” e “else”:

Para tratarmos as diferentes condições, utilizamos comandos de “if” dentro de outros comandos. No caso, utilizamos o “if” dentro do bloco executado a partir de um “else”. Poderíamos ter também um “if” dentro de outro “if”.

Este tipo de construção é muito comum, e pode ser confuso para alguém que está começando na área. Observe, por exemplo, que testamos apenas se o IMC é menor que determinado número, nunca se é maior. Isso é possível justamente pelo encadeamento de “if”. Por exemplo, no comando “if (imc < 35)” não precisamos testar se o IMC é maior ou igual a 30, já que ele só chegará no comando se for. Se for menor que 30, ele entrará em um dos “if” anteriores, e nunca entrará no else em que temos o “if (imc < 35)”.

4.4 Em Dúvida de Como Encadear “IF”s? Pratique

Você precisa saber colocar comandos dentro de um “if”, inclusive outros comandos “if”.

Talvez isso pareça mais natural a você, e você tenha conseguido criar uma solução para o problema do IMC, ou pelo menos tenha entendido claramente a solução apresentada.

Mas é também possível que, para você, isso ainda não esteja muito claro. Sem problema, só que você, neste caso, terá que praticar, até estas construções de “if” e “else” sejam mais naturais. Não quero entrar em outros comandos de fluxo antes de você ter plena naturalidade com o “if”.

Assim sendo, segue uma sugestão de prática. Faça o mesmo código anterior, porém utilizando apenas o operador “>” (ou o “>=”, que significa basicamente maior ou igual). Você terá que inverter a sequência de “if”, testando primeiro se o IMC é maior ou igual a 40, e colocando os demais testes dentro do else.

Conseguindo inverter a sequência de “if” e trocar o operador de “<” para “>=”, gerando o mesmo resultado, penso que você estará aptor a seguir para a próxima unidade.



5. Um Pouquinho de “Lógica Booleana”, mas não Vamos Chamar desse Nome Difícil

5.1 Usando “E” e  “OU”

Não existe nada, absolutamente nada, por mais simples, que um profissional de informática não consiga transformar em algo extremamente complexo e assustador.

Creio que um dos melhores exemplos é a “lógica booleana”. Com as “tabelas verdades”, e complexas operações lógicas que você nunca vai usar na prática, é possível assustar qualquer iniciante na área até o ponto dele desistir da profissão.

Vamos, então, ensinar aqui, 90% do que você vai usar daquilo que chamam de “lógica booleana”. Basicamente, vamos falar sobre situações do tipo “OU” e situações do tipo “E”.

O “e” ou “AND” em inglês, é a mais simples de entendermos, pois é exatamente igual ao que utilizamos no dia a dia. Basicamente diz que, para algo ser verdade, as duas condições apresentadas têm que ser verdade.

A única coisa complicada aqui, e é só nos acostumarmos, é que em Javascript, assim como boa parte das linguagens, o comando “AND”  ou “E” é escrito assim: “&&”.

Vejam o código abaixo, e tentem adivinhar o que vai ser mostrado:

--------------------------------Exemplo de IF com AND-----------------------------
x = 10;
y = 5;
if ( (x > 6) && (y > 6) )
alert(“x e y são maiores que 6”);
if ( (x > 3) && (y > 3) )
alert(“x e y são maiores que 3”);
------------------------------------------------------------------------------------------

Se você entendeu, mesmo antes de testar, que o código acima exibirá apenas o alerta de que “x e y são maiores que 3”, parabéns, você já entendeu 50% de tudo que precisa entender sobre lógica booleana neste momento.

Vamos agora aos outros 50% que quero que você entenda neste momento, o comando “OR” ou “OU”. Este comando só tem uma dificuldade adicional em relação ao comando “AND”. O que utilizamos na linguagem coloquial com a expressão “ou” geralmente dá a idéia de exclusividade, ou seja, a situação somente é verdadeira se um dos item for verdadeiro e o outro for falso.

Tudo que precisamos lembrar, para o comando “OR”, é que o resultado será verdadeira caso qualquer uma (OU AS DUAS) condições for verdadeira.

Por fim, importante saber que o comando OR em javascript (e muitas outras linguagens) é representado por “||”. Trata-se da tecla PIPE, que geralmente está ao lado da letra “z” no teclado, sendo necessário clicar em SHIFT, mas isso pode variar de teclado para teclado.

Vamos ver um código com OR, então:

--------------------------------Exemplo de IF com AND-----------------------------
x = 10;
y = 5;
if ( (x > 6) || (y > 6) )
alert(“x ou y, ou dos dois, são maiores que 6”);
if ( (x > 3) || (y > 3) )
alert(“x ou y, ou os dois, são maiores que 3”);
------------------------------------------------------------------------------------------

Você entendeu que ambos os alertas serão exibidos? Parabéns, você sabe o que precisa saber, por enquanto, sobre lógica booleana.

Obs: se você já teve alguma aula, ou até uma prova, de lógica booleana, talvez esteja se perguntando se estou falando sério. É isso mesmo? Lógica booleana é só isso? Em termos de 90% do que você vai precisar, sim, é só isso. E os outros 10%? Veremos mais adiante, mas, assim, lembre-se sempre que toda vez que você faz uma operação que é difícil para você entender, será difícil para outros programadores entenderem também. O segredo de um bom programador não é saber fazer códigos complexos, é saber fazer códigos simples.

5.2 Vamos Refazer Nosso Teste do IMC

Agora, com o uso de “AND”, podemos reescrever nosso código de cálculo de IMC. É questionável se o programa resultante será melhor que o apresentado originalmente, mas nosso objetivo aqui é didático.

--------------------------------Cálculo do IMC ------------------------------
peso = prompt("entre com seu peso");
altura = prompt("entre com sua altura");
imc = peso / (altura * altura);
alert("Seu IMC ficou em: " + imc );
if (imc < 17)   alert("muito abaixo do peso");
if ( (imc >= 17) && (imc < 18.5) ) alert("abaixo do peso");
if ( (imc >= 18.5) && (imc < 25) ) alert("peso normal");
if ( (imc >= 25) && (imc < 30) ) alert("acima do peso");
if ( (imc >= 30) && (imc < 35) ) alert("obesidade I");
if ( (imc >= 35) && (imc < 40) ) alert("obesidade II");
if (imc >= 40) alert("obesidade III");
----------------------------------------------------------------------------

Vale observar que o programa acima é ligeiramente menos eficiente que o anterior, porém também pesa o fato de ser também mais fácil de entender. Como não tratamos ainda de aspectos de otimização de código e eficiência, não vamos nos preocupar com isso por enquanto.


6. Controlar o Fluxo é um Desafio

6.1 Uma Soma Infinita

Nosso desafio dessa unidade é começar a controlar melhor o fluxo do programa. Para isso, iremos introduzir um novo comando de controle de fluxo, que resolve um problema que os recursos que vimos até agora não conseguem tratar.

Nosso programa é um somador infinito. Ele vai somar números sem parar, sempre mostrando o resultado e pedindo o próximo número. Quando for escrito “fim” na entrada, em vez de um número, o programa termina.

Vamos a ele:

--------------------------UM SOMADOR SIMPLÓRIO---------------------------
novaEntradaString = “0”;
resultadoSomas = 0;
while (novaEntradaString != “fim”) {
novaEntradaString = prompt(“entre com um número para somar, ou digite fim para encerrar”);
n1 = parseInt(novaEntradaString);
resultadoSomas = resultadoSomas + n1;
alert(“O resultado até o momento é: “ + resultadoSomas);
}
------------------------------------------------------------------------------------------

Como no exemplo anterior, há problemas neste código que trataremos mais adiante, a medida que vamos aprendendo mais sobre programação. O que importa é que ele gera o resultado que queremos. Digitando diversos números, eles vão sendo somados, até digitarmos “fim”.

Entretanto, este é um programa que não conseguiríamos fazer sem um novo comando que nos permita não apenas desviar o fluxo de execução, mas principalmente, voltar atrás e repetir um comando. Só que antes vamos tratar de uma outra coisa, primeiro....

6.2 Mas que Raios é Este “!=”

Vamos vê-lo muito, mais adiante. Por hora, basta saber que “!” significa “NÃO”. Assim, “!=” basicamente significa “não igual”. Algumas linguagens utilizam “<>”, que significa em essência a mesma coisa.

Se você está em dúvida, apenas observe que os dois códigos abaixo fazem a mesma coisa. Em dúvida ainda? Digite-os e pratique com eles. Este é um conceito que você não pode ter dúvidas antes de seguir adiante no curso:

--------------------------DOIS CÓDIGOS QUE FAZEM A MESMA COISA--------------------
testeNumero = prompt(“entre com um número”);
if (testeNumero == 10) alert(“o número é 10”);
else alert(“o número não é 10”);
--------------------------------------------------------------------------------------------------
testeNumero = prompt(“entre com um número”);
if (testeNumero != 10) alert(“o número não é 10”);
else alert(“o número é 10”);
--------------------------------------------------------------------------------------------------

6.3 O Comando “While”

Agora, vamos olhar nosso segundo comando de controle de fluxo de nosso curso: o “while”.
“While”, que significa “enquanto” em inglês, basicamente repete uma instrução ou um bloco de instruções (marcado entre chaves, como já vimos no “if”).

E ele repete quantas vezes? Ele vai repetir enquanto (daí seu nome) a condição entre parenteses for verdadeira.

Percebem as semelhanças e diferenças do comando “if”? Para ambos, se o que está entre parenteses é verdadeiro ou falso, eles vão direcionar o fluxo de alguma forma. A diferença é que, no caso do “while”, o que ele faz é entrar dentro do bloco repetidas vezes, até a condição entre parenteses ser falsa.

Isso significa que o código dentro das chaves pode não ser executado nenhuma vez (por exemplo se a condição já for de início falsa), até infinitas vezes.

Então, inicialmente “novaEntradaString” é igual a “0”, logo é diferente de “fim”. Ele entra no código, e ao final testa novamente, para ver se vai repetir mais uma vez ou não. Se “novaEntradaString” novamente for diferente de “fim”, ele novamente entra no bloco.

Dizemos que, quando ele está entrando neste bloco de comandos do “while”, ele está “entrando no loop”, e que quando ele finalmente sai do bloco, ele está “saindo do loop”.


6.4 O Desafio de uma Calculadora Infinita

A esta altura, você sabe como fazer uma calculadora com 4 operações. Sabe também como fazer um “loop infinito”, do qual o programa sai apenas quando o usuário digitar “fim”.

Nosso desafio, agora, é juntar as duas coisas. Tente fazer uma calculadora que vá fazendo operações uma sobre a outra, mas ao invés de termos apenas somas, como no exemplo acima, queremos as quatro operações, como vimos em unidades anteriores.

Assim, você primeiro entra com um número, depois define a operação e o segundo número. Depois uma nova operação e o próximo número, sempre aplicando sobre o resultado anterior, até receber o comando “fim”.

6.5 Algumas Dicas

Ok, você já fez a calculadora? Pode ir direto para o subitem seguinte.

Nem tentou, bom, primeiro tente, antes de continuar.

Se você já tentou, mas está empacado, bom, neste, e somente neste caso, esta unidade é para você.
Vamos tentar pensar como um programador e em como ele resolve um problema...

Primeiro, nós já temos uma parte da solução, certo? Já temos como fazer um loop infinito que apenas soma. Dê uma olha lá no início da unidade e tenha certeza que você está entendendo bem o que é feito lá.

Agora, compare com o exemplo anterior que fazia várias operações. Observe que neste novo exemplo, temos na verdade um único “prompt” e uma única variável que recebe dados. Ela recebe nosso número e acumula ainda a função de receber o comando “fim”.

No exemplo anterior, porém, tínhamos dois prompts e duas variáveis. Uma para receber a operação e uma para receber o número. É aqui que temos a chave da solução do problema.

Substitua um comando “prompt” do exemplo acima, por dois comandos, como no primeiro exemplo da calculadora. Um dos comandos define a operação, e o outro o número. Coloque, após, o mesmo código de soma, divisão, etc, com base no “if” que já vimos antes.

Ainda sem progressos. Tente realmente um pouco mais, sozinho. É importante que você tente até conseguir realizar este código, para só então seguir para o próximo passo, que é analisar a solução que apresentamos.

Lembre-se sempre, programar não é apenas conhecer os comandos e códigos, mas principalmente desenvolver a habilidade de resolver problemas. Eu realmente quero que você tenha segurança nestes exemplos antes de começarmos desafios mais complexos.

6.6 Resultado do Desafio Calculadora Infinita

Observem o código proposto a seguir. Conforme sua habilidade e naturalidade com programação, você já pode estar até desenvolvendo códigos mais elegantes. Este exemplo a seguir tem como foco ser simples e com base no que ensinamos até agora:

--------------------------UM SOMADOR SIMPLÓRIO---------------------------
operacaoMatematica = "";
entradaInicial = prompt("entre com o primeiro número");
resultado = parseInt(entradaInicial);
while (operacaoMatematica != "fim") {
operacaoMatematica = prompt("entre com uma letra para escolher a operação matemática: a(dição), (s)ubtração, (m)ultiplicação ou (d)ivisão, ou (fim) para encerrar.");
novaEntradaString = prompt("entre com o próximo número");
n1 = parseInt(novaEntradaString);
if (operacaoMatematica  == "a") resultado = resultado + n1;
if (operacaoMatematica  == "s") resultado = resultado - n1;
if (operacaoMatematica == "m") resultado = resultado * n1;
if (operacaoMatematica == "d") resultado = resultado / n1;
alert("O resultado até o momento é: " + resultado);
}
------------------------------------------------------------------------------------------

Se você não conseguiu gerar uma solução equivalente, estude-a. Execute o código e tente entender o que cada linha de código executa.

Na próxima unidade, trataremos de melhorar estes códigos desta unidade, mas nas unidades seguintes já começaremos a trabalhar com desafios mais complexos, então realmente é fundamental você se sentir seguro com os desafios até o momento.

Se não conseguiu realizar sozinho este desafio, estude-o e tente modificar o programa, alterar os nomes de variáveis, colocar outras condições, por exemplo ter um comando que define diretamente o valor de “resultado” para poder reiniciar os cálculos.

Enfim, se ainda em dúvida, pratique.

Nenhum comentário:

Postar um comentário