sequencia de fibonacci

[Emerson111]

Olá, estou fazendo um código em C que mostre na tela os 100 primeiros números da sequencia de fibonacci. O código que fiz até mostra uma sequencia, porém, a partir do 45º os números ficam negativos e a sequencia fica incorreta. Como posso corrigir isso.
 

#include #include int main(){int num1, num2, proximo, cont;num1 = 0;num2 = 1;for(cont=1; cont<101; cont++){proximo = num1 + num2;num1 = num2;num2 = proximo;printf("\n\n%d\t = %d\t", cont, proximo); } return 0;}

[Pedro Math.pi]

Olá!

 

Devido a limitação do tipo int, o valor máximo que pode ser mostrado é:

 

 int = 4 bytes - 32 bits = -2147483648 a + 2147483647 - números inteiros 

 

 

valores maiores que isso apresentarão resultados inesperados.

 

http://answers.yahoo.com/question/index?qid=20120419184400AAYjiN4

 

http://www.guj.com.br/java/216494-tamanho-maximo-int-e-outros

 

http://msdn.microsoft.com/pt-br/library/7fh3a000.aspx

[LNW]

@

 

O amigo @Math.Pi tem razão quando ele mostra o limite máximo suportado pelo tipo inteiro. Tem que partir para outra alternativa.

 

 

Sam, você não explicitou se isso é um exercício de escola/faculdade ou não. Se não for nada acadêmico, você poderia usar uma biblioteca qualquer para cálculo de precisão arbitrária já pronta, ou implementar a sua própria rotina para cálculo de soma, para o caso de ser um execício. Creio que essa deva ser a "pegadinha" nesse tipo de exercício (se for um). O cálculo Fibonacci de certa forma já é bem batido..

 

E na verdade não é difícil implementar uma rotina para soma. Basta preencher dois arrays de char com os números e depois percorrer ambos para ir somando cada dígito de ambos. Claro que você vai precisar levar em conta o "vai 1" do cálculo nesse momento. Basicamente, laços de repetição e testes condicionais.

 

Dica: para obter o dígito, por exemplo, faça:

d1 = arr1[i] - '0';d2 = arr2[j] - '0';

Sendo d1 e d2 inteiras.

 

 

Acabei de implementar uma rotina dessas nas coxas:

 

 

(89872349827498237498237493287423984732946328746328746238746283723+

1111111111111111112222873921374872638746287648273648262873872)

 

 

Isso lhe permitiria calcular valores Fibonacci bastante elevados.

 

 

 

 

NW

[Nayuugga]

Uma resolução fácil e você trocar o int por long int ou apenas long.

 

Pois:

    long int = 8bytes = 64 bits = (-(2⁶⁴)  a 2⁶⁴ - 1) de range.

 

O código final ficaria assim:

#include #include int main(){long num1, num2, proximo, cont;num1 = 0;num2 = 1;for(cont=1; cont<101; cont++){proximo = num1 + num2;num1 = num2;num2 = proximo;printf("\n\n%ld\t = %ld\t", cont, proximo); } return 0;}

[LNW]

Uma resolução fácil e você trocar o int por long int ou apenas long.

 

Pois:

    long int = 8bytes = 64 bits = (-(2⁶⁴)  a 2⁶⁴ - 1) de range.

 

 

Não seria suficiente.

 

O centésimo número da sequência Fibonacci é 354224848179261915075.

 

Para um inteiro sinalizado de 8 bytes (64 bits), você tem a faixa: -(2⁶³) até 2⁶³ - 1 = -9223372036854775808 até 9223372036854775807

 

Logo, não comporta.

 

Ainda que usássemos unsigned, teríamos:

 

2⁶⁴ - 1: 0 até 18446744073709551615

 

 

Ainda insuficiente.

 

 

 

 

NW

[Emerson111]

Realmente não basta mudar o tipo de váriavel. Testei com int, long, double (com e sem os modificadores: signed, unsigned, long e short), ou apresenta o mesmo resultado ou aparece resultado zero.

 

LNV é um exercíco de escola sim, de um curso a distancia que estou fazendo. Até já o enviei para correção do jeito que estava mesmo. Mas como independente de ter entregado o exercicio, gostaria de saber como resolvê-lo. Você citou sobre fazer rotina para a soma, mas o professor não explicou nada sobre isso.

[Nayuugga]

Realmente é insuficiente. Erro meu não ter testado antes de postar.

Minha segunda opção seria o unsigned mas como o LNW já postou, seria insuficiente tambem.

 

A ultima opcao que vejo em mente mencionada pelo LNW é você criar um 1bit FullAdder, que é a função mais básica de

um processador, ou seja você criará um processador virtual que realize as somas. Assim você poderia somar quantos bytes quisesse

não se limitando a um número definido de bytes como int e long.

 

Um exemplo de 1bit-FullAdder seria:

typedef unsigned char UINT8;UINT8 cout;//Vai um de saída.UINT8 cin;//Vai um de entrada.UINT8 x;//Número a ser somado.UINT8 y;//Segundo número a ser somado.UINT8 s;//Resultado da soma.//Os valores x, y e cin devem ser implementados antes de fazer as operações abaixo.//Estes valores devem ser implementados usando apenas 0x01 e 0x00 representando o 1 binário e o 0 binário.s = x ^ y ^ cin;//operador XOR(^) operador de soma, realiza a soma.cout = (x & y) | ((x ^ y) & cin);//calcula o carry out. 

Seria meio difícil explicar todo o código a ser feito, mas está aí um bom começo.