[DÚVIDA] Números gigantes em C/C++

Bom dia, estou com dificuldade em um exercicío bem simples que estou tentando fazer, segue o enunciado abaixo:

" Crie um programa que contenha um array de 20 posições cujos valores devem ser dados pela seguinte fórmula:
O primeiro elemento do vetor vai receber o valor 2 e do segundo elemento em diante, o valor deverá ser o valor do elemento anterior ao quadrado.
Exemplo:
1ª posição -> 2
2ª posição -> 2 * 2 = 4
3ª posição -> 4 * 4 = 16
4ª posição -> 16 * 16 = 256
."

O problema acontece a partir do 5º valor onde o número é grande demais para ser exibido, algúem conhece alguma maneira de exibir esse número? Não precisa ser o int por extenso pode ser qualquer tipo de representação.

Obrigado.

obs: caso queiram ver a solução que fiquei travado

#include <stdio.h>

int main () {
  int vetor [20];
  int i;

  vetor[0] = 2;

  for (i = 1; i <= 20; i++) {
    vetor[i] = vetor [i-1] * vetor[i-1];
    printf("%dº Posição valor: %d\n",i, vetor[i-1]);
  }
}
1 Curtida

Ehhhh, vc pode usar long ou unsigned int no lugar de int, mas seu PC por acaso é de 32 bits? Pq um int de 32 bits, usado em PCs de 64bits, deveria conseguir segurar até ±2^32, ou 2,1bi, a não se que seja um int de 16 bits, usado em PCs de 32 bits, que só segura até ±32K

é 64 bits… Uso fedora em uma VM para programar pode ser por isso?

(tentei rodar o mesmo código no codeblocks windows e o resultado foi um loop infinito todo bugado)

caso queira ver a saída é essa

Isso é pq deu overflow, 65.536^2 sai dos limites até de um int de 32bits, usa um long mesmo, se tu quiser ter controle mais preciso sobre o tamanho dos tipos inclui stdint.h e usar ints de tamanhos bem definidos, tipo int64_t ou int32_t, se tu usar GCC ele suporta até int128_t.

Actually, onde tu arranjou esse exercicio? Com 20 posições vc dá overflow até num long, foi uma parada muito mal pensada.

cara não consegui, eu também cheguei a essa conclusão que esse ex sempre vai dar overflow pq nem a calculadora do gnome consegue calcular algo assim o.o

achei ai na internet da vida HAHAHAHAHA

Utiliza long Double. O int/long int e as variantes unsigned utilizam n bits para armazenar o número completo, sem expoente. Isso o torna mais preciso em alguns casos, mas reduz a quantidade de números que podem ser armazenados. Já o float/doubles utilizam mantissa/expoente, que permite a armazenagem de números extremamente grandes. Ex.: O range do long Double é 3.4E-4932 até 1.1E+4932, de acordo com uma rápida pesquisa na internet.

Pode parecer mais óbvio utilizar int, já que os números serão sempre inteiros nesses cálculos, mas não será possível armazena-los dessa forma. Utilizando o Double pode fazer com que em algum cálculo o resultado seja ligeiramente errado nos últimos números da dízima, mas dado o tamanho do número será desprezível. Inclusive é assim que a grande maioria dos programas no mundo funcionam, tirando aqueles utilizados pela NASA, por exemplo, que exigem uma precisão absoluta.

Fiz alguns testes utilizando long double e chegou até o 14º valor (1.09075e+2466).
Uma ideia para tentar chegar ao 20º é usar os limites numéricos para normalizar de alguma forma o valor armazenado (Numeric limits - cppreference.com). Por exemplo, armazenar o valor 2/(10^4391) ao invés de 2 e apresentar o valor como 2*(10^4391). Ou, de forma mais simples, armazenar 0,000…02 e apresentar como 2 * 100000000… No fim o resultado é o mesmo. Porém, é preciso pensar um pouco para que isso não afete os resultados das contas, já que os valores usados não serão mais os valores “verdadeiros”.

EPAAA consegui isso aqui, MEU DEUS os números são surreais O.O

e vdd consegui até o 14… que foda

1 Curtida

Vou estudar com calma esse artigo e vou tentar… obrigado mesmo

1 Curtida

Opa! Tranquilo. Programação é divertido justamente por causa dessas coisas, ter que quebrar a cabeça e pensar “fora da caixa”. Muitas vezes a solução que parece óbvia não é a melhor ou não resolve o problema, e aí é preciso parar para pensar um pouco.
Boa sorte no trabalho!

1 Curtida