material_intro_prog/ex2_potencia.html

  <h2>3.3 - Como computar uma potência de inteiros usando laço de repetição</h2>
  <p>
    <b>Problema 3:</b><i>Dado X real e N natural, faça um programa que calcule X<sup>N</sup></i><br />
    Novamente, se N fosse fixo, por exemplo n=3, bastaria fazer<br />
    <center>
      <table>
       <tr>
         <th> C </th>
         <th>Python</th></tr>
       <tr>
         <td>
           <pre>
  1  int x;
  2  scanf("%d", &x);
  3  printf("%d", x*x*x);
           </pre>
         </td>
         <td>
           <pre>
  1  x = input()
  2  print(x*x*x)
           </pre>
         </td>
       </tr>
      </table>
      <div>
        <img src="./imgs/potencia_x_3.png" /><br />
        <span>Código no iVProg</span>
      </div>
    </center>
  Portanto a dificuldade deste problema se encontra na repetição arbitrária: repetir a operação de multiplicação um número variável de vezes, dependente da vontade do usuário.<br />
  Novamente, vamos iniciar o processo de resolução examinando um exemplo, x=2 e n=7.<br />
  1. Multiplique X por X, guardando o resultado desta conta(4); <br />
  2. Multiplique por x o resultado guardado, guardando o novo resultado (8);<br />
  3. Repita o passo(2) outras 4 vezes (pois n=7 e x já entrou 3 vezes como fator de multiplicação) obtendo o resultado final, 128.<br />
  <h3>Quais são as variáveis necessárias?</h3>
  Claramente precisamos de variáveis para armazenar X e N. Além destas, será necessária outra variável (<b>result</b>) para armazenar o resultado das operações de potenciação de X,
  sem a qual não será possível guardar o resultado das multiplicações executadas(reflita sobre isto!).<br />
  Neste problema, notamos uma novidade em relação ao anterior, precisamos contar quantas vezes já usamos o fator X (original). assim, vamos denotar esta variável pelo sugestivo nome de
  <b>cont</b>: a cada multiplicação somaremos 1 nessa variável. Assim, deveremos declarar as seguintes variáveis:<br />
  <center>
    int x, n, result, cont;
  </center>
  <h3>Quais os comandos devem aparecer dentro do bloco de repetição?</h3>
  Podemos observar no esquema inicial, elaborado acima, que o passo (2) é a parte repetitiva do processo: multiplicar o resultado atual de <b>result</b> por X, guardando este produto
  novamente em <b>result</b>. Feito isto, devemos então somar 1 ao contador <b>cont</b>, para indicar que mais uma multiplicação foi efetuada.
  <center>
  <table>
   <tr>
     <th> C </th>
     <th>Python</th></tr>
   <tr>
     <td>
       <pre>
  while (condição){
    result = result*x;
    cont = cont+1;
  }
       </pre>
     </td>
     <td>
       <pre>
  while condição:
    result = result*x
    cont = cont+1
       </pre>
     </td>
   </tr>
  </table>
  </center>
  <h3>Qual a condição para que continue a repetição?</h3>
  Já foi observado que a variável <b>cont</b> serve para contar quantas vezes o fator X já entrou no produto, assim devemos interromper o laço quando <b>cont==n</b>, ou de outro modo,
  devemos continuar enquanto <b>cont< n</b>.
  <center>
  <table>
   <tr>
     <th> C </th>
     <th>Python</th></tr>
   <tr>
     <td>
       <pre>
  while (<b>cont < n</b>){
    result = result*x;
    cont = cont+1;
  }
       </pre>
     </td>
     <td>
       <pre>
  while <b>cont < n</b>:
    result = result*x
    cont = cont+1
       </pre>
     </td>
   </tr>
  </table>
  </center>
  <h3>O que deve vir antes da repetição?</h3>
  Em primeiro lugar, devemos ler os valores <b>x</b> e <b>n</b>. Precisamos também atribuir valores iniciais adequados às variáveis <B>cont</B> e <b>result</b>. Como <b>cont</b> totaliza
  quantos fatores <b>x</b> já entraram no produto, o valor inicial de <b>cont</b> é zero. Assim, após a primeira execução do comando <b>result = result*x</b>, gostariamos de obter o valor
  de <b>x</b> em <b>result</b> e por isto devemos impor que <b>result</b> comece com o valor 1.<br />
  Interrompido o laço, a resposta estará armazenada em <b>result</b>:
  <center>
  <table>
   <tr>
     <th> C </th>
     <th>Python</th></tr>
   <tr>
     <td>
       <pre>
  1  int x, n, result, cont;
  2  scanf("%d %d", &x, &n);
  3  cont = 0;
  4  result = 1;
  5  while (<b>cont < n</b>){
  6    result = result*x;
  7    cont = cont+1;
  8  }
  9  printf("%d", result);
       </pre>
     </td>
     <td>
       <pre>
  1  x = input()
  2  n = input()
  3  cont = 0
  4  result = 1
  5  while <b>cont < n</b>:
  6    result = result*x
  7    cont = cont+1
  8  print(result)
       </pre>
     </td>
   </tr>
  </table>
  <div>
    <img src="./imgs/potencia_x_n.png" /><br />
    <span>Código no iVProg</span>
  </div>
  </center>
  <b>Exercício 4</b> <i>Repare que o programa dá a resposta correta quando n==0, porém quando x==0 e n==0 teríamos um resultado, mesmo que na matemática 0<sup>0</sup>
    é indeterminado.</i><br />
  <b>Exercício 5</b> <i>Sugerimos como exercício a simulação deste programa, para alguns dados de entrada à escolha do leitor.</i><br />
  <b>Exercício 6</b> <i>O programa abaixo foi proposto para calcular x<sup>n</sup>. Analise o algoritmo, ele está correto? Se não estiver o que há de errado?</i>
  <center>
  <table>
   <tr>
     <th> C </th>
     <th>Python</th></tr>
   <tr>
     <td>
       <pre>
  1  int x, n, cont;
  2  scanf("%d %d", &x, &n);
  3  cont = 0;
  4  while (cont < n){
  5    x = x*x;
  6    cont = cont+1;
  7  }
  8  printf("%d", x);
       </pre>
     </td>
     <td>
       <pre>
  1  x = input()
  2  n = input()
  3  cont = 0
  4  while cont < n:
  5    x = x*x
  6    cont = cont+1
  7  print(x)
       </pre>
     </td>
   </tr>
  </table>
  <div>
    <img src="./imgs/potencia_x_n_errada.png" /><br />
    <span>Código no iVProg</span>
  </div>
  </center>
  <b>Exercício 7</b> <i>É possível alterar o programa-solução do problema 3, dispensando a variável contadora <b>cont</b>? Isto é, tente deduzir uma outra versão para o
  referido problema, utilizando apenas três variáveis <b>x</b>, <b>n</b> e <b>result</b></i>.
  </p>