4. Problem mit Fibonacci

Problem mit Fibonacci

  • T

    Hi hab vor kurzem angefangen mit C zu programmieren.
    Habe zum üben dieses Programm geschrieben.
    Es soll mir eine Anzahl von Fibonacci Zahlen berechnen und ausgeben.

    Nun zu meinem Problem:

    1. Am ende der Ausgabe kommt es zu einer Fehlermeldung.
    Exception der Klasse EAccessViolation .....Zugriffsverletzung bei .....Schreiben von......

    2. Die Fibonaccizahlen werden mir bis 1836311903 richtig angezeigt.
    Danach geht der komischerweise in den negativen Bereich.

    Müsste es mir nicht alle Werte bis 2^32 (4294967296)anzeigen?
    Es hört bei 1836311903 auf, müsste doch eigentlich bei 2971215073 aufhören.
    Stimmt das so?

    #include <stdio.h>
#include <stdlib.h>

int main(int argc, char* argv[])
{
        int erste,zweite,grenze,i,*dynarray;

                printf("Geben sie die erste Zahl ein: ");
                scanf("%d",&erste);
                printf("Geben sie die zweite Zahl ein: ");
                scanf("%d",&zweite);
                printf("Wieviele zahlen sollen ausgegeben werden: ");
                scanf("%d",&grenze);
                dynarray = (int *) malloc(grenze * sizeof(int));

                dynarray[0]=erste;
                dynarray[1]=zweite;

                for (i=0;i<grenze;i++)
                {
                 dynarray[i+2]=dynarray[i]+dynarray[i+1];

                 printf("%d\n",dynarray[i]);
                 }
                 getchar();
                 fflush(stdin);
                 free(dynarray);
        return 0;
}
    0
  • W

    du gehst in der schleife bis grenze, schreibst also in speicher, der dir nicht gehört. du musst also 2 ints mehr alloziieren oder in der schleife 2 schritte weniger machen.

    0
  • T

    danke!

    so geht es
    for (i=0;i<grenze-2;i++)

    wie mache ich es wenn ich 2 ints mehr allozieren will??
    etwa so?
    dynarray = (int 😉 malloc(grenze+2 * sizeof(int));

    Warum ist denn die grösste Zahl die ausgegeben werden kann 1836311903
    (mit folgenden werten erste=0 zweite=1)
    Es können doch alle Zahlen bis 2^32 sein oder irre ich mich da?

    1836311903 <-wird angezeigt
    2971215073 <- wird nicht angezeigt! sondern folgendes = -1323752223
    4807526976 geht nicht weil > 2^32

    0
  • K

    Also,

    1. int geht blos bis -2 147 483 648 bis + 2 147 483 648 ( es sei denn du machst unsigned int)
    2. kannst du den Zahlenbereich auf double umstellen und dann einfach die Kommstellen nicht ausgeben. Dann kommst du bis 1.1 * 10^4932. Und das sollte reichen.
    3. Wenn du Interesse hast kann ich dir die rekursive Methode (uneffizient) oder die iterative (wie deine) posten.

    0
  • T

    stimmt 🙂
    hab gar nicht dran gedacht.

    komisch,...hab das ganze mal mit unsigned int ausprobiert.
    wird compiliert wunderbar aber der kann immer noch nicht weiter rechnen...

    ist da vielleicht was im code falsch? glaub ich zwar nicht aber man weiss ja nie......

    @Krugman wäre nett wenn du es posten würdest.

    0
  • W

    ThaMubber schrieb:

    wie mache ich es wenn ich 2 ints mehr allozieren will??
    etwa so?
    dynarray = (int 😉 malloc(grenze+2 * sizeof(int));

    Nein, das ist wie in der Schule: "Punkt vor Strichrechnung".
    Folgendes wäre also richtig: (grenze + 2) * sizeof(int)

    0
  • ?

    Krugman schrieb:

    1. int geht blos bis -2 147 483 648 bis + 2 147 483 648 ( es sei denn du machst unsigned int)

    Ohne kleinlich sein zu wollen, aber ein 32 Bit int geht bis maximal + 2 147 483 647.

    0
  • K

    das is ohne felder, aber man kann es auch mit feldern machen.

    #include <stdio.h>
#include <stdlib.h>

int main(void)
{
	long int zaehl,n;
	long double Fibo,vor,nach;

	printf("Iterative Fibonacciberechnung\n");
	printf("Geben Sie einen beliebigen POSITIVEN Wert ein: "); scanf("%d",&n);

	if(n==0 || n<0)
	{
		printf("F(n)= 0\n");
		exit(1);
	}
	else if(n==1)
	{
			printf("F(n)= 1\n");
			exit(1);
	}
	vor=0;      // vorgänger (Fibo=0,1,1,2,3,5,...)
	nach=1;     // nachfolger

	for(zaehl=0;n>1;n--,zaehl++)
	{

		Fibo=vor+nach;
		vor=nach;
		nach=Fibo;
	}

	printf("\nF(n)= %.0lf\n",Fibo);				// Ausgabe
	printf("\nFunktionsaufrufe: %d\n",zaehl);	// Ausgabe des Zählers/Funktionsaufrufe

}
    0
  • ?

    Hier ist noch eine Rekursive Variante, die bietet sich aber nur für kleine Werte an, da sonst die ganzen Rekursionen den Speicher sprengen würden 🙄

    int refib(int a)
{
if (a == 0)
	return(0);
if (a == 1)
	return(1);
return(refib(a - 1) + refib(a - 2));
}
    0
Anmelden zum Antworten