Algoritmos

Potenciação: dobre uma folha 10 vezes e conte 1.024 camadas

Capa do artigo Potenciação: dobre uma folha 10 vezes e conte 1.024 camadas
Leitura com foco

Entenda o contexto.
Leve para a prática.

Neste artigo
  1. Como funciona a potenciação?
  2. Como calcular uma potência com um laço de repetição?
  3. Aí você pergunta: e o expoente 0 e o expoente 1?
  4. Preciso escrever o laço toda vez?
  5. O que é crescimento exponencial?
  6. Onde o programador encontra as potências de 2?
  7. Aí você pergunta: e o caminho de volta?
  8. Quais são os erros mais comuns com potências?
  9. Agora é com você!

Potenciação é a multiplicação de fatores iguais: o mesmo número, multiplicado por ele mesmo várias vezes. O número que se repete é a base, e a quantidade de vezes em que ele aparece é o expoente.

No artigo sobre os laços de repetição, você fez o computador repetir uma soma. Hoje o laço repete uma multiplicação, e o resultado cresce de um jeito que surpreende. Se as palavras potência e exponencial lembram uma aula difícil da escola, calma! Você só precisa de uma ideia: multiplicar pelo mesmo número, de novo e de novo. O resto deste artigo sai dela, e o logaritmo, que vem em seguida, também.

Pense em uma folha de papel. Dobre ao meio: são 2 camadas. Dobre de novo: 4. Mais uma vez: 8. Repare que você não ganhou 2 camadas a cada dobra. A quantidade inteira dobrou! Cada dobra multiplica o número de camadas por 2.

História em quadrinhos em três quadros: uma pessoa dobra uma folha de papel e conta 2 camadas com uma dobra, 4 com duas e 8 com três
Três dobras: 2, 4 e 8 camadas. Cada dobra multiplica a quantidade por 2.

Como funciona a potenciação?

Depois de três dobras, a conta das camadas é 2 × 2 × 2 = 8. São três fatores iguais a 2. A potenciação é só um jeito curto de escrever essa conta:

  • Base: o número que se repete. Aqui, o 2.
  • Expoente: quantas vezes a base aparece na multiplicação. Aqui, o 3.
  • Potência: o resultado. Aqui, o 8.

Na matemática, escreve-se 23 = 8, com o expoente pequeno e no alto, e lê-se “2 elevado a 3”. Não se assuste com a notação: ela diz apenas “multiplique o 2 por ele mesmo, usando três fatores”.

ATENÇÃO: 23 não é 2 × 3. O primeiro é 2 × 2 × 2, que dá 8. O segundo dá 6. E a ordem importa: 23 é 8, mas 32 é 3 × 3, que dá 9. Sacou?

Seis pilhas de camadas de uma folha de papel dobrada de 0 a 5 vezes: 1, 2, 4, 8, 16 e 32 camadas, cada uma o dobro da anterior
De 0 a 5 dobras: a quantidade de camadas é sempre a anterior multiplicada por 2.

Como calcular uma potência com um laço de repetição?

Para o programador, a potência é um laço que multiplica. Começa-se com 1 e multiplica-se pela base uma vez a cada volta. O expoente diz quantas voltas dar. Veja em Python:

# Potência calculada com um laço que multiplica

def potencia(base, expoente):
    resultado = 1
    for volta in range(expoente):
        resultado = resultado * base   # multiplica pela base mais uma vez
    return resultado

for expoente in range(0, 11):
    print("2 elevado a", expoente, "=", potencia(2, expoente))

Em PHP:

<?php
// Potência calculada com um laço que multiplica

function potencia($base, $expoente) {
    $resultado = 1;
    for ($volta = 0; $volta < $expoente; $volta++) {
        $resultado = $resultado * $base;   // multiplica pela base mais uma vez
    }
    return $resultado;
}

for ($expoente = 0; $expoente <= 10; $expoente++) {
    echo "2 elevado a $expoente = " . potencia(2, $expoente) . "\n";
}

Em C:

// Potência calculada com um laço que multiplica
#include <stdio.h>

int potencia(int base, int expoente) {
    int resultado = 1;
    for (int volta = 0; volta < expoente; volta++) {
        resultado = resultado * base;   // multiplica pela base mais uma vez
    }
    return resultado;
}

int main(void) {
    for (int expoente = 0; expoente <= 10; expoente++) {
        printf("2 elevado a %d = %d\n", expoente, potencia(2, expoente));
    }
    return 0;
}

As três linguagens mostraram a mesma saída:

2 elevado a 0 = 1
2 elevado a 1 = 2
2 elevado a 2 = 4
2 elevado a 3 = 8
2 elevado a 4 = 16
2 elevado a 5 = 32
2 elevado a 6 = 64
2 elevado a 7 = 128
2 elevado a 8 = 256
2 elevado a 9 = 512
2 elevado a 10 = 1024

Foque no conceito, e não na linguagem! Nas três, a função tem a mesma forma: uma variável que começa em 1 e um laço que a multiplica pela base. Essa saída é a tabela das potências de 2. Guarde essa tabela: ela reaparece neste artigo e no próximo.

ExpoenteMultiplicaçãoResultado
0nenhuma1
122
22 × 24
32 × 2 × 28
42 × 2 × 2 × 216
52 × 2 × 2 × 2 × 232
10dez fatores iguais a 21.024
A tabela das potências de 2: o expoente conta os fatores.

Aí você pergunta: e o expoente 0 e o expoente 1?

Olhe as duas primeiras linhas da saída. Com expoente 1, a base aparece uma vez só, e o resultado é a própria base: 21 = 2. Com expoente 0, o laço não dá nenhuma volta, e a função devolve o valor inicial: 20 = 1.

Parece estranho, mas a tabela mostra por que a matemática fez essa escolha. Lendo de baixo para cima, cada linha é a anterior dividida por 2: 8, 4, 2… e o próximo é 1. Com o 1 na linha do expoente 0, o padrão continua valendo. É uma convenção, feita para que as regras das potências não quebrem.

Preciso escrever o laço toda vez?

No dia a dia, não. Python e PHP têm um operador de potência, o **. A linguagem C não tem operador para isso: usa-se a função pow, da biblioteca math.h, que trabalha com números reais. Em Python:

# O operador de potência e a pegadinha do ^

print("2 ** 10 =", 2 ** 10)
print("3 ** 2 =", 3 ** 2)
print("2 ** 3 =", 2 ** 3)
print("7 ** 1 =", 7 ** 1)
print("7 ** 0 =", 7 ** 0)
print("2 ^ 10 =", 2 ^ 10)   # ATENÇÃO: ^ não é potência

Em PHP:

<?php
// O operador de potência e a pegadinha do ^

echo "2 ** 10 = " . (2 ** 10) . "\n";
echo "3 ** 2 = " . (3 ** 2) . "\n";
echo "2 ** 3 = " . (2 ** 3) . "\n";
echo "7 ** 1 = " . (7 ** 1) . "\n";
echo "7 ** 0 = " . (7 ** 0) . "\n";
echo "2 ^ 10 = " . (2 ^ 10) . "\n";   // ATENÇÃO: ^ não é potência

Em C:

// A função pow e a pegadinha do ^
#include <stdio.h>
#include <math.h>

int main(void) {
    printf("pow(2, 10) = %.0f\n", pow(2, 10));
    printf("pow(3, 2) = %.0f\n", pow(3, 2));
    printf("pow(2, 3) = %.0f\n", pow(2, 3));
    printf("pow(7, 1) = %.0f\n", pow(7, 1));
    printf("pow(7, 0) = %.0f\n", pow(7, 0));
    printf("2 ^ 10 = %d\n", 2 ^ 10);   // ATENÇÃO: ^ não é potência
    return 0;
}

Saída em Python e em PHP:

2 ** 10 = 1024
3 ** 2 = 9
2 ** 3 = 8
7 ** 1 = 7
7 ** 0 = 1
2 ^ 10 = 8

Saída em C:

pow(2, 10) = 1024
pow(3, 2) = 9
pow(2, 3) = 8
pow(7, 1) = 7
pow(7, 0) = 1
2 ^ 10 = 8

ATENÇÃO: repare na última linha das saídas. Em texto digitado, é comum escrever 2^10 para “2 elevado a 10”. No código, não! Nas três linguagens, 2 ^ 10 respondeu 8. Em Python, o ^ é outro operador, o ou exclusivo, que trabalha com os bits dos números. Em C, o compilador GCC avisou do engano na hora de compilar:

alg_operador.c:11:31: warning: result of '2^10' is 8; did you mean '1 << 10' (1024)? [-Wxor-used-as-pow]

O que é crescimento exponencial?

É o crescimento do valor que é multiplicado pelo mesmo número a cada passo. Quando o valor recebe a mesma soma a cada passo, o crescimento se chama linear. A diferença entre os dois é enorme, e o programa abaixo mostra: uma variável ganha 2 a cada volta, e a outra é multiplicada por 2.

# Somar 2 a cada volta ou multiplicar por 2 a cada volta?

somando = 0
dobrando = 1
print("volta | somando 2 | multiplicando por 2")
for volta in range(1, 11):
    somando = somando + 2
    dobrando = dobrando * 2
    print(volta, "|", somando, "|", dobrando)

Saída:

volta | somando 2 | multiplicando por 2
1 | 2 | 2
2 | 4 | 4
3 | 6 | 8
4 | 8 | 16
5 | 10 | 32
6 | 12 | 64
7 | 14 | 128
8 | 16 | 256
9 | 18 | 512
10 | 20 | 1024
Gráfico de barras com dez voltas de um laço: somando 2 a cada volta o valor vai de 2 a 20, e multiplicando por 2 vai de 2 a 1.024
Dez voltas: somando 2, o valor chega a 20; multiplicando por 2, chega a 1.024.

Nas duas primeiras voltas, os dois valores são iguais. Na volta 10, um está em 20, e o outro, em 1.024. Vou repetir porque é importante: no crescimento linear, soma-se a mesma quantidade a cada passo; no exponencial, multiplica-se pelo mesmo fator a cada passo. É por isso que o exponencial começa devagar e depois dispara.

O nome vem do expoente. O número de voltas, que é o que muda, fica no expoente da potência: depois de n voltas, o valor é 2n.

Ver a animação do valor dobrando a cada volta
Animação de um laço que multiplica o valor por 2 a cada volta: os quadradinhos vão de 1 a 1.024 em dez voltas
De 1 a 1.024 em dez voltas: cada volta dobra a quantidade de quadradinhos.

Onde o programador encontra as potências de 2?

Em quase todo canto! Dois exemplos:

  • Bits. Um bit guarda 2 valores, 0 ou 1. Cada bit a mais dobra a quantidade de combinações. Por isso, com n bits é possível representar 2n valores diferentes: 8 bits, um byte, dão 256.
  • Busca binária. Cada pergunta da busca binária corta as possibilidades pela metade, que é o caminho inverso de dobrar. Como 220 passa de 1 milhão, 20 perguntas bastam para achar um valor entre 1 milhão.
# Quantos valores cabem em n bits? 2 elevado a n

for bits in [1, 2, 3, 8, 16, 32]:
    print(bits, "bits:", 2 ** bits, "valores")

print("2 elevado a 20 =", 2 ** 20)

Saída:

1 bits: 2 valores
2 bits: 4 valores
3 bits: 8 valores
8 bits: 256 valores
16 bits: 65536 valores
32 bits: 4294967296 valores
2 elevado a 20 = 1048576

Com 32 bits, já são mais de 4 bilhões de valores. E bastaram 32 multiplicações por 2 para chegar lá!

Aí você pergunta: e o caminho de volta?

Até aqui, você sabia o número de dobras e queria as camadas. A pergunta ao contrário também existe: se a folha dobrada tem 1.024 camadas, quantas dobras foram? Dá para responder com a tabela, procurando o 1.024 na coluna dos resultados: 10. E dá para responder com um laço que conta as dobras até chegar ao alvo:

# O caminho de volta: quantas dobras até chegar ao alvo?

def contar_dobras(alvo):
    camadas = 1
    dobras = 0
    while camadas < alvo:
        camadas = camadas * 2
        dobras = dobras + 1
    return dobras

print("até 8 camadas:", contar_dobras(8), "dobras")
print("até 1024 camadas:", contar_dobras(1024), "dobras")
print("até 1000000 camadas:", contar_dobras(1000000), "dobras")

Saída:

até 8 camadas: 3 dobras
até 1024 camadas: 10 dobras
até 1000000 camadas: 20 dobras

O 1 milhão não é uma potência exata de 2, e por isso a função devolveu 20: é o número de dobras necessário para chegar a 1 milhão ou passar dele.

Essa pergunta ao contrário tem nome: logaritmo. O logaritmo de 1.024 na base 2 é 10, porque 2 elevado a 10 dá 1.024. Não tem mistério: é a mesma tabela, lida da direita para a esquerda. É o assunto do próximo artigo.

Quais são os erros mais comuns com potências?

  • Confundir potência com multiplicação. 23 é 8, e não 6.
  • Trocar a base e o expoente. 23 é 8, e 32 é 9.
  • Usar o ^ no código. Em Python, PHP e C, ele não calcula potência.
  • Começar o laço com 0. Zero vezes qualquer número dá zero, e o resultado nunca sai do lugar. O valor inicial é 1.
  • Esquecer o expoente 0. A base 2 elevada a 0 dá 1, e o mesmo vale para as outras bases positivas.
  • Achar que dobrar é somar 2. Somando, o valor cresce de 2 em 2. Dobrando, ele dispara.

Agora é com você!

No papel:

  • Quanto é 26? E 27? Use a tabela e depois confira multiplicando.
  • Quanto é 34? Escreva a multiplicação antes de fazer a conta.
  • Uma folha foi dobrada e ficou com 64 camadas. Quantas dobras foram?
  • Quantos valores diferentes cabem em 10 bits?

No computador:

  • Use a função potencia para mostrar a tabela das potências de 3, do expoente 0 ao 5.
  • Mude a função para contar quantas multiplicações ela fez.
  • Escreva um programa que descobre a primeira volta em que o valor que dobra passa de 1 milhão.

Tente sozinho, sem pedir a resposta pronta para ninguém, nem para a IA!

Você viu que multiplicar sempre pelo mesmo número faz o valor disparar, e que a tabela das potências pode ser lida ao contrário. No próximo artigo, essa leitura ao contrário ganha nome e uso: o logaritmo, que explica por que a busca binária é tão rápida. Até lá!

Confiança Sempre!!!

Fontes:

Compartilhe este artigo

Sobre quem escreve

Walmir Silva

Olá! Sou Walmir, engenheiro de software com MBA em Engenharia de Software e o cérebro por trás do GrowthCode e autor do livro "Além do Código".

Se você acha que programação é apenas sobre escrever código, prepare-se para expandir seus horizontes. Aqui, nós vamos além do código e exploramos as interseções fascinantes entre tecnologia, negócios, artes e filosofia.

Você está em busca de crescimento na carreira? Quer se destacar em um mercado competitivo? Almeja uma vida mais rica em conhecimento e realização? Então você chegou ao lugar certo. No GrowthCode, oferecemos insights profundos, estratégias comprovadas e um toque de sabedoria filosófica para catalisar seu crescimento pessoal e profissional.

Ver todos os artigos →

Continue a conversa

Compartilhe sua perspectiva

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

Guardamos o IP e o navegador de quem comenta por 6 meses, para barrar spam e porque o Marco Civil da Internet pede a guarda dos registros de acesso por esse prazo. Veja como tratamos seus dados.

Encontre sua próxima resposta

O que você quer aprender?

Preferências de cookies

Os cookies opcionais começam desligados. Você pode mudar a escolha a qualquer momento por esta tela.

NecessáriosSempre ativos

Guardam a sua escolha de cookies e o código do registro dela, e mantêm o site funcionando. Não são usados para publicidade.

Contam visitas e mostram como o site é usado: Google Analytics e Microsoft Clarity, carregados pelo Google Tag Manager.

Exibem anúncios do Google AdSense sem personalização. Os cookies desta categoria limitam a repetição dos anúncios e medem o resultado deles.

Usa a sua navegação para escolher anúncios e formar públicos de anúncio: anúncios do Google escolhidos pelos seus interesses e os indicadores do Google no Analytics. Desligado, os anúncios aparecem sem personalização. Depende de Publicidade.

Também é possível bloquear cookies nas configurações do navegador. Detalhes na Política de privacidade.