transEBERiano - Somatório Série em JavaScript

Listagem

Este programa é a implementação daquele exemplo do capítulo Elementos que transforma {0; 1; 2; 3} em {10; 11; 12; 13}.

A página HTML tá fazendo o papel de programa principal.
O objeto HTML usado pra armazenar o texto de saída é <P>, nesse exemplo chamado de Paragrafo.
Ao se clicar no botão Calcular a execução é desviada pra rotina CalcularSomatorio.
Dentro da rotina CalcularSomatorio duas outra rotinas (LimparSaida e EnviarSaida) são chamadas.

LimparSaida → nada mais faz do que inicializar o parágrafo <P> com uma string em branco.

EnviarSaida → simplesmente envia pra tela uma linha de texto.

CalcularSomatorio → resolve propriamente dito o problema, transformar {0; 1; 2; 3} em {10; 11; 12; 13}.

      function LimparSaida ()

      {
        Paragrafo.innerHTML= '';
      }

      function EnviarSaida (Linha)

      {
        Paragrafo.innerHTML+= Linha + '<br>';
      }

      function CalcularSomatorio ()

      {
        var X, Y;

        LimparSaida ();

        X= 0;
        while (X <= 3) {
          Y= X + 10;
          EnviarSaida ('X: ' + X + ' -> Y: ' + Y);
          X= X + 1;
        }
      }

    </script>
  </head>
  <body>
    <p id="Paragrafo"></p>
    <input id="Botao" type="button" value="Calcular" onclick="javascript: CalcularSomatorio ();">
  </body>
</html>

Clique aqui pra abrir no navegador

Somatório

Este programa mostra uma listagem dum somatório simples.

O internauta deve notar que os nomes das rotinas permaneceram os mesmos. Apenas os códigos internos é que mudaram.
Esse tipo de prática facilita numa migração entre diversos ambientes de programação.

      function LimparSaida ()

      {
        Editor.value= '';
      }

      function EnviarSaida (Linha)

      {
        Editor.value+= Linha + String.fromCharCode (10);
      }

      function CalcularSomatorio ()

      {
        var N, X;

        LimparSaida ();

        X= 0;
        N= Entrada.value;
        while (X < N) {
          EnviarSaida ('X: ' + X);
          X= X + 1;
        }
      }

    </script>
  </head>
  <body>
    Digite um número menor que 200:
    <input id="Entrada" type="text" value="10">
    <input id="Botao" type="button" value="Calcular" onclick="javascript: CalcularSomatorio ();">
    <br /><br />
    <textarea id="Editor" rows="15"></textarea>
  </body>
</html>

Clique aqui pra abrir no navegador

Números pares e ímpares

Mostra uma listagem dos N primeiros inteiros, classificando-os em pares e ímpares.

Este código usa o operador mod (módulo). Em JavaScript é representado por %.
Este operador nada mais faz do que retornar o resto duma divisão.
Pra saber se um número é par basta verificar o resto da divisão dele por 2. Se for zero é divisível por 2, portanto par. Do contrário é ímpar.

      function LimparSaida ()

      {
        Editor.value= '';
      }

      function EnviarSaida (Linha)

      {
        Editor.value+= Linha + String.fromCharCode (10);
      }

      function SerPar (Valor)

      {
        return (Valor % 2) == 0;
      }

      function CalcularSomatorio ()

      {
        var N, X;

        LimparSaida ();

        X= 0;
        N= Entrada.value;
        while (X < N) {
          if (SerPar (X))
            EnviarSaida ('X: ' + X + ' é par');
          else
            EnviarSaida ('X: ' + X + ' é ímpar');
          X= X + 1;
        }
      }

Clique aqui pra abrir no navegador

Números primos

Este programa mostra uma listagem dos N primeiros números primos.
A rotina SqRt (Square Root) retorna a raiz quadrada dum número dado.

      function LimparSaida ()

      {
        Editor.value= '';
      }

      function EnviarSaida (Linha)

      {
        Editor.value+= Linha + String.fromCharCode (10);
      }

      function SerPrimo (Valor)

      {
        var K, M, R;

        if (Valor < 2)
          return false;
        else if (Valor == 2)
          return true;
        else {
          R= true;
          K= 2;
          M= Math.sqrt (Valor);
          while (R && (K <= M)) {
            R= (Valor % K) != 0;
            K= K + 1;
          }
          return R;
        }
      }

      function CalcularSomatorio ()

      {
        var N, X;

        LimparSaida ();

        X= 0;
        N= Entrada.value;
        while (N > 0) {
          if (SerPrimo (X)) {
            EnviarSaida ('X: ' + X);
            N= N - 1;
          }
          X= X + 1;
        }
      }

Clique aqui pra abrir no navegador

Recursão

Uma das ilustrações mais clássicas prum processo recursivo é a listagem da Série de Fibonacci.

Uma rotina recursiva é uma rotina que chama a si própria até satisfazer alguma condição de saída.
Antes de pensar na rotina em si é importante definir essa tal condição de saída. Do contrário a rotina nunca terminará (ela entrará em loop).

Essa série começa com 0 e 1. Pros números posteriores cada um deles é composto da soma dos dois antecessores.
Ou seja→ 0; 1; 1; 2; 3; 5; 8; 13; 21; 34; e aí por diante.

A condição de saída define quando a rotina vai parar de chamar a si mesma.
Pra resolver essa série com recursão não adiante lê-la ascendentemente da esquerda pra direita. Ou seja, de 0 pro infinito.
Deve-se pegar um número qualquer e ir voltando pra trás até chegar em 1.
Por exemplo, o número 5 nessa série é igual a 3+2. O número 3 é igual 2+1. O número 2 é igual 1+1. A partir daí já se está na condição de saída. Afinal 1 não é composto de nenhum outro número inteiro antecessor.

      function LimparSaida ()

      {
        Editor.value= '';
      }

      function EnviarSaida (Linha)

      {
        Editor.value+= Linha + String.fromCharCode (10);
      }

      function CalcularProximoNumeroSerieFibonacci (Nivel)

      {
        if ((Nivel == 0) || (Nivel == 1))
          return Nivel;
        else
          return CalcularProximoNumeroSerieFibonacci (Nivel-1) + CalcularProximoNumeroSerieFibonacci (Nivel-2);
      }

      function CalcularSomatorio ()

      {
        var N, X, Y;

        LimparSaida ();

        X= 0;
        N= Entrada.value;
        while (X < N) {
          Y= CalcularProximoNumeroSerieFibonacci (X);
          EnviarSaida ('Y: ' + Y);
          X= X + 1;
        }
      }

    </script>
  </head>
  <body>
    Digite um número menor que 20:
    <input id="Entrada" type="text" value="10">
    <input id="Botao" type="button" value="Calcular" onclick="javascript: CalcularSomatorio ();">
    <br /><br />
    <textarea id="Editor" rows="15"></textarea>
  </body>
</html>

Clique aqui pra abrir no navegador

Como o internauta deve notar em todos esses exemplos o X representa valores de domínio (0; 1; 2; 3; 4; ... N). Ou seja, X está fazendo papel de contador.
Os programas dos exemplos estão dizendo pegue cada um desses valores X e liquidifique ele pralgum outro qualquer.
O núcleo de todos os exemplos acima pode ser posto na forma→

X= 0;
while (X dentro de determinado intervalo) {
LiquidifiqueAlgo;
X= X + 1;
}

http://transeberiano.brinkster.net

Get 30% off webhosting