Considere a função \boldsymbol{\operatorname { p o t }} \boldsymbol{(} \boldsymbol{n}, \boldsymbol{k})=\boldsymbol{n}^{\boldsymbol{k}} e o seguinte cabeçalho desta função escrito na linguagem C:
int pot( int n, int k ) {
}
Escreva a função pot de forma iterativa.

Passo 1

O enunciado pede para implementar de forma iterativa a função que calcula a potência inteira
\operatorname{pot}(n,k) = n^{k}
usando o cabeçalho em C
int pot( int n, int k ) {
}
Informações relevantes que o enunciado dá:
  • n e k são parâmetros do tipo inteiro.
  • A função deve retornar um inteiro que representa n^{k}.
  • Não foi dito nada sobre k negativo; vou considerar que o enunciado está formulado corretamente para uso em prova, então assumimos que k é um inteiro não negativo ( k\ge 0). Se k for negativo, o resultado em geral não é um inteiro (seria fração), portanto essa implementação iterative básica não trata expoentes negativos.
O que se pede explicitamente: escrever a função iterativa que calcule n^{k} e retorne o resultado como um inteiro.

Passo 2

Ideia básica (explicação didática): calcular n^{k} multiplicando n por si mesmo k vezes. Para isso usamos:
  • Uma variável acumuladora chamada de resultado inicializada em 1. Isto porque 1 é o elemento neutro da multiplicação: para qualquer inteiro a vale a^{0}=1.
  • Um laço que repete exatamente k vezes: a cada iteração multiplicamos o acumulador por n.
Por exemplo, para calcular 3^{4} fazemos:
  • inicio: res = 1
  • 1ª iteração: res = res \times 3 = 3 (aqui res = 3^{1})
  • 2ª iteração: res = res \times 3 = 9 (res = 3^{2})
  • 3ª iteração: res = res \times 3 = 27 (res = 3^{3})
  • 4ª iteração: res = res \times 3 = 81 (res = 3^{4})
Ou seja, depois de t iterações teremos res = n^{t}. Assim, após k iterações res = n^{k}.

Passo 3

Detalhes importantes para implementar corretamente:
  • Inicializar o acumulador com 1: int res = 1;.
  • Fazer um laço que execute exatamente k vezes. Em C uma forma comum é for (int i = 0; i < k; ++i).
  • Em cada iteração actualizar res com res *= n;.
  • Ao final, retornar res.
Propriedade de correção (intuição rápida): invariantemente, no início de cada iteração com índice i (com 0\le i\le k) temos res == n^i. Inicialmente i=0 e res=1=n^0. A cada iteração i aumenta em 1 e multiplicamos por n, então a propriedade se mantém. Ao terminar com i=k, res = n^k.
Observações práticas:
  • Caso k=0 o laço não roda e retornamos 1, que é correto pois n^{0}=1 para qualquer inteiro n (implementação também retorna 1 para o caso ambíguo 0^{0}; muitos exercícios de programação aceitam esse comportamento).
  • Se n=0 e k>0 o algoritmo retorna 0 (correto: 0^{k}=0 para k>0).
  • Cuidado com overflow: se n^{k} exceder o intervalo de int, o resultado vai “estourar”. Em prova você cite (se pedirem) que há risco de overflow, mas a implementação padrão é essa.
  • Complexidade: tempo O(k) e espaço O(1).

Passo 4

Exemplo passo a passo numérico para fixar (usei n=2 e k=5):
  • res = 1
  • i=0: res = 1 * 2 = 2
  • i=1: res = 2 * 2 = 4
  • i=2: res = 4 * 2 = 8
  • i=3: res = 8 * 2 = 16
  • i=4: res = 16 * 2 = 32
    Fim do laço: res = 32 que é 2^{5}.
Observação sobre alternativas: existe um método mais rápido chamado “exponentiação por repetição rápida” (exponentiation by squaring) com complexidade O(\log k). Ele é útil se k é grande, mas é um pouco mais sofisticado. Como a questão pediu uma implementação iterativa simples, o método por multiplicação repetida é o esperado em provas iniciais.

Passo 5

Implementação em C (iterativa simples). Esta é a resposta pronta para colar no seu código de prova:

Resposta

int pot( int n, int k ) {
    int res = 1;
    for ( int i = 0; i < k; ++i ) {
        res *= n;
    }
    return res;
}

Exercícios relacionados