Fibo große Zahlen in c++ oder c Sprache drucken

Lesezeit: 5 Minuten

Benutzer-Avatar
masoodtav

Ich schreibe diesen Code für die Show-Fibonacci-Reihe mit Rekursion. Aber es wird nicht korrekt für n> 43 angezeigt (z. B. für n = 100 show:-980107325).

#include<stdio.h>
#include<conio.h>

void fibonacciSeries(int);

void fibonacciSeries(int n)
{
static long d = 0, e = 1;
long c;
if (n>1)
{
    c = d + e;
    d = e;
    e = c;
    printf("%d \n", c);
    fibonacciSeries(n - 1);
}
}

int main()
{
long a, n;
long long i = 0, j = 1, f;
printf("How many number you want to print in the fibonnaci series :\n");
scanf("%d", &n);

printf("\nFibonacci Series: ");
printf("%d", 0);
fibonacciSeries(n);
_getch();
return 0;
}

  • Definieren Sie, was Sie mit “nicht korrekt anzeigen” meinen.

    – Algirdas Preidžius

    18. Dezember 2015 um 10:38 Uhr

  • Mögliches Duplikat von How to printf long long

    – entzaubert

    18. Dezember 2015 um 10:40 Uhr

  • fib(100) ist 354,224,848,179,261,915,075 – Dies ist selbst für eine vorzeichenlose 64-Bit-Ganzzahl zu groß.

    – melak47

    18. Dezember 2015 um 10:41 Uhr

  • Bitte rücken Sie Ihren Code ein.

    – Jabberwocky

    18. Dezember 2015 um 10:44 Uhr

  • Warum sind Sie sich nicht sicher, ob es sich um C oder C++ handelt? FYI, es sieht für mich auf jeden Fall wie ein einfaches C aus. (Und lehre dich, davon wegzusteuern conio.h Funktionen.)

    – Jongware

    18. Dezember 2015 um 11:16 Uhr

Der Wert von fib(100) ist so groß, dass sogar eine 64-Bit-Zahl überläuft. Um mit so großen Werten zu arbeiten, müssen Sie tun Arithmetik mit beliebiger Genauigkeit. Arithmetik mit beliebiger Genauigkeit wird weder von C- noch von C++-Standardbibliotheken bereitgestellt, daher müssen Sie sie entweder selbst implementieren oder eine Bibliothek verwenden, die von jemand anderem geschrieben wurde.

Für kleinere Werte, die zu Ihrem passen long longIhr Problem ist, dass Sie das Falsche verwenden printf Formatbezeichner. Drucken a long longmüssen Sie verwenden %lld.

Benutzer-Avatar
Chux – Wiedereinsetzung von Monica

Code überschreitet den Bereich der verwendeten Ganzzahl long.
Könnte benutzen long longaber selbst das kann nicht handhaben Fib(100) was mindestens 69 Bit benötigt.

Code verwenden könnte long double Wenn 1.0/LDBL_EPSILON > 3.6e20

Es gibt verschiedene Bibliotheken, um sehr große Ganzzahlen zu verarbeiten.

Für diese Aufgabe brauchen Sie nur zwei große ganze Zahlen zu addieren. Erwägen Sie die Verwendung einer Zeichenfolge. Es folgt eine ineffiziente, aber einfache Zeichenfolgenaddition. Keine Eventualitäten für Pufferüberlauf.

#include <stdio.h>
#include <string.h>
#include <assert.h>

char *str_revese_inplace(char *s) {
  char *left = s;
  char *right = s + strlen(s);
  while (right > left) {
    right--;
    char t = *right;
    *right = *left;
    *left = t;
    left++;
  }
  return s;
}

char *str_add(char *ssum, const char *sa, const char *sb) {
  const char *pa = sa + strlen(sa);
  const char *pb = sb + strlen(sb);
  char *psum = ssum;
  int carry = 0;
  while (pa > sa || pb > sb || carry) {
    int sum = carry;
    if (pa > sa) sum += *(--pa) - '0';
    if (pb > sb) sum += *(--pb) - '0';
    *psum++ = sum % 10 + '0';
    carry = sum / 10;
  }
  *psum = '\0';
  return str_revese_inplace(ssum);
}

int main(void) {
  char fib[3][300];
  strcpy(fib[0], "0");
  strcpy(fib[1], "1");
  int i;
  for (i = 2; i <= 1000; i++) {
    printf("Fib(%3d) %s.\n", i, str_add(fib[2], fib[1], fib[0]));
    strcpy(fib[0], fib[1]);
    strcpy(fib[1], fib[2]);
  }
  return 0;
}

Ausgabe

Fib(  2) 1.
Fib(  3) 2.
Fib(  4) 3.
Fib(  5) 5.
Fib(  6) 8.
...
Fib(100) 3542248xxxxxxxxxx5075.  // Some xx left in for a bit of mystery.

Fib(1000) --> 43466...about 200 more digits...8875

Benutzer-Avatar
Ach Bill

Nun, Sie könnten versuchen, BigInt in C++ oder C zu implementieren.

Nützliches Material:

  • Wie man big int in C++ implementiert

Benutzer-Avatar
Khaled

Try to use a different format and printfverwenden Sie unsigned, um einen größeren Bereich von Ziffern zu erhalten.

Wenn du benutzt unsigned long long Sie sollten bis bekommen 18 446 744 073 709 551 615 also bis zur 93. Zahl für die Fibonacci-Serie 12200160415121876738, aber danach erhalten Sie ein falsches Ergebnis, weil die 94. Zahl 19740274219868223167 ist zu groß für unsigned long long.

Benutzer-Avatar
marom

Denken Sie daran, dass die n-te Fibonacci-Zahl (ungefähr) ((1 + sqrt(5))/2)^n.

Dadurch erhalten Sie den Wert für n, der es ermöglicht, dass das Ergebnis in 32/64 vorzeichenlose Ganzzahlen passt. Denken Sie bei Signiert daran, dass Sie ein bisschen verlieren.

Sie können einige große Fibonacci-Zahlen nur mit drucken verkohlen, int und <stdio.h> in C.

Es gibt einige Kopfzeilen :

#include <stdio.h>
#define B_SIZE 10000 // max number of digits
typedef int positive_number;

struct buffer {
    size_t index;
    char data[B_SIZE];
};

Auch einige Funktionen :

void init_buffer(struct buffer *buffer, positive_number n) {
    for (buffer->index = B_SIZE; n; buffer->data[--buffer->index] = (char) (n % 10), n /= 10);
}

void print_buffer(const struct buffer *buffer) {
    for (size_t i = buffer->index; i < B_SIZE; ++i) putchar('0' + buffer->data[i]);
}

void fly_add_buffer(struct buffer *buffer, const struct buffer *client) {
    positive_number a = 0;
    size_t i = (B_SIZE - 1);
    for (; i >= client->index; --i) {
        buffer->data[i] = (char) (buffer->data[i] + client->data[i] + a);
        buffer->data[i] = (char) (buffer->data[i] - (a = buffer->data[i] > 9) * 10);
    }
    for (; a; buffer->data[i] = (char) (buffer->data[i] + a), a = buffer->data[i] > 9, buffer->data[i] = (char) (buffer->data[i] - a * 10), --i);
    if (++i < buffer->index) buffer->index = i;
}

Beispielverwendung:

int main() {
    struct buffer number_1, number_2, number_3;
    init_buffer(&number_1, 0);
    init_buffer(&number_2, 1);
    for (int i = 0; i < 2500; ++i) {
        number_3 = number_1;
        fly_add_buffer(&number_1, &number_2);
        number_2 = number_3;
    }
    print_buffer(&number_1);
}

// print 131709051675194962952276308712 ... 935714056959634778700594751875

Bester C-Typ ist immer noch verkohlen ? Der angegebene Code wird gedruckt f(2500)eine 523-stellige Zahl.

Die Info : f(2e5) hat 41.798 Stellen, siehe auch Factorial(10000) und Fibonacci(1000000).

1012500cookie-checkFibo große Zahlen in c++ oder c Sprache drucken

This website is using cookies to improve the user-friendliness. You agree by using the website further.

Privacy policy