Gerade Terme der Fibonacci-Folge aufsummieren

ac

Mitglied
hey,

wie in der Überschrift angegeben, wollte ich die Fibonacci-Folge (n = 4 Millionen) berechnen und von den Termen nur die geraden Terme aufsummieren.
Dazu der folgende Code :

Java:
public class Problem2 {

	static int sum = 0;
	static int cur = 0;


	//Methode zur Berechnung der Fibonacci-Folge
	public int fib(int n){
		
			if(n == 0){
				return 0 ;
			}
		
		else if(n == 1){
				return 1;
			}
		
		else{
				return fib(n-1) + fib(n-2); 
			}
		
		
	}
	
	
	//Methode, die tatsächliche Summe bildet
	//Grenze = 4 Millionen wird als Parameter übergeben
	public int berechnung(int grenze){
		
		//Schleifenkopf mit oberer Grenze und Zählvariable
		for(int i= 1; i < grenze; i++){			
			
			//für jeden Wert i wird die obige fib-Methode aufgerufender 
			//in der fib-Methode berechnete Wert wird in cur geschrieben
			cur = fib(i);
			
                       //Prüfe, ob der in cur gespeicherte Wert gerade ist
                           if(cur % 2 == 0){					
				 sum += cur;                  //Falls gerade, so speichere in sum
		
			}
		}
		
		return sum;				           //gebe am Ende das Ergebnis aus
	
	}
	
	
	
	public static void main(String[] args){
		
		Problem2 pr2 = new Problem2();
		
		System.out.println("Die Summe der geraden Terme unter 4 Mil. : "  + pr2.berechnung(4000000));
		
		
		}
		
			
		
	

}


nun, zu meinem Problem: das Programm kompiliert zwar, aber wenn ich es ausführe passiert rein gar nichts. Kann mir jmd. vtl. sagen woran das liegen kann?
Hab im Internet vorhin gelesen, dass die rekursive fib()-Methode, die die Fibonacci-Folge berechnen soll, für große n sehr ineffiezient sein soll...stimmt das? falls ja, so würde das erklären, warum das so lange dauert....falls nicht, dann muss ich irgendwo einen Fehler gemacht haben....:(
 
Zuletzt bearbeitet:

bequiet

Mitglied
Naja fang halt mal kleiner an, lass den Test mal mit 10 laufen, dann mit 100.. dann siehst du schon direkt das die Ausfühung so lange dauert.

Die Laufzeit von Fibonacci ist exponentiell.

Sofern ich mich recht erinnere, soll die Rekursive Methode gegenüber der Iterativen eine deutlich bessere Laufzeit haben, aber ist lang her.
 
Zuletzt bearbeitet:

ac

Mitglied
ok. danke für die Antwort...Habs jetzt für 10 getestet, da kam auch schon direkt ein Ergebnis raus. Für 100 dauert die berechnung schon extrem lang...jetzt wird mir klar, warum der bei 4 mille so lange gebraucht hat und trotzdem kein ergebnis ausgespuckt hat....da scheint, die fib() Methode echt ineffizient zu sein...
 

pinkysbrain

Mitglied
Du möchtest ja x Werte im Intervall von 1...x berechnen.
Zur Zeit machst du für jeden Wert die ganze Rekursion.
Allerdings lässt sich das deutlich einfacher über eine Iteration machen.

Java:
    public static long fib(int max) {
    	int n0 = 0;
    	int n1 = 1;
    	long summe = 0;
    	// Der erste Wert der hinzuaddiert wird ist fib(2) = 1
    	for (int i=0;i<max;i++) {
    	    int n2 = n0+n1;
    	    n0 = n1;
    	    n1 = n2;
    	    if (n2%2 == 0)
    	       summe+=n2;
    	}
    	return summe;
    }

Die Methode berechnet dir die Summe bis zum Maximum (bei max = 10 die summe aller Funktionswerte bis fib(9)).
Das Programm terminiert für max = 4000000 in unter 1s.
 

pinkysbrain

Mitglied
Ah ok habe den Überlauf nicht beachtet (habe vergessen abzuschätzen in welchem Bereich man sich bewegt), es ging mir auch eher um den Weg als um die korrekten Rückgabeparameter.
 

ac

Mitglied
hallo,

vielen Dank für die hilfreichen Beiträge. Die Hilfe, die man hier bekommt, ist enorm.
da ich noch nie mit BigInteger gearbeitet habe, muss ich mir ma jetzt anschauen, wie man damit umgeht.
Ansonsten ist alles ok...



gruß,
ac
 

stg

Top Contributor
Die kannst deine Summe übrigens auch explizit, also sogar in konstanter Laufzeit, berechnen. (Herleitung über die Formel von Moivre-Binet und geometrische Summen.)
 
Zuletzt bearbeitet:

ac

Mitglied
hallo,

sry, dass ich so spät antworte ;) Aber musste aus diversen Gründen diese Aufgabe beiseite legen. Nun hab ich es wieder aufgegriffen, und versucht, die obigen ratschläge in die Tat umsetzen. Bei BigInteger hatte ich probleme die vordefinierten methoden zu verstehen. Das Programm funktioniert nicht so ganz...ich vermute mal dass es an der Bedingung der for-schleife liegt, dass mit dem compareTo bereitet mir sorgen....also hier das Programm in BigInteger-Version:

Java:
import java.math.BigInteger;


public class Problem2 {

	 BigInteger sum = BigInteger.valueOf(0);
	 BigInteger cur = BigInteger.valueOf(0);
	
	


	//Methode zur Berechnung der Fibonacci-Folge
	public BigInteger fib(BigInteger n){
		
		BigInteger n0 = BigInteger.valueOf(0);
		BigInteger n1 = BigInteger.valueOf(1);
		BigInteger summe = BigInteger.valueOf(0);
		
		for(BigInteger i = BigInteger.valueOf(0); i.compareTo(n) ; i = i.add(BigInteger.ONE)){
		
			BigInteger n2 = n0.add(n1);
			n0 = n1;
			n1 = n2;
			
			if(n2.mod(2) == 0){
				summe += n2;
			}
		
		}
		
		return summe;
	}
	
	
	//Methode, die tatsächliche Summe bildet
	//Grenze = 4 Millionen wird als Parameter übergeben
	public BigInteger berechnung(BigInteger grenze){
		
		
		for(BigInteger i= BigInteger.valueOf(0); 
				i.compareTo(grenze); i = i.add(BigInteger.ONE) ){			//Schleifenkopf mit oberer Grenze und Zählvariable
			
			//für jeden Wert i wird die obige fib-Methode aufgerufender 
			//in der fib-Methode berechnete Wert wird in cur geschrieben
			cur = fib(i);
			
			if(cur.mod(2) == 0){					//Prüfe, ob der in cur gespeicherte Wert gerade ist
				sum += cur;						//Falls gerade, so speichere in sum
		
			}
		}
		
		return sum;								//gebe am Ende das Ergebnis aus
	
	}
	
	
	
	public static void main(String[] args){
		
		Problem2 pr2 = new Problem2();
		
		BigInteger max = new BigInteger("4000000");
		
		
		System.out.println("Die Summe der geraden Terme unter 4 Mil. : "  + pr2.berechnung(big));
		
		
		}
		
			
		
	

}
 
Zuletzt bearbeitet:

stg

Top Contributor
Verständnisfragen sind das eine, aber der von dir gepostete Code dürfte ja nicht einmal kompilieren, so voller Fehler ist er. Bring das doch erst mal in Ordnung, vielleicht erübrigt sich dein Problem dann ja schon von alleine?
 

ac

Mitglied
nun ich habe das Programm weiterhin ein bisschen modifiziert, nun sieht es so aus:

Java:
import java.math.BigInteger;


public class Problem2 {

	 BigInteger sum = BigInteger.valueOf(0);
	 BigInteger cur = BigInteger.valueOf(0);
	
	


	//Methode zur Berechnung der Fibonacci-Folge
	public BigInteger fib(BigInteger n){
		
		BigInteger n0 = BigInteger.valueOf(0);
		BigInteger n1 = BigInteger.valueOf(1);
		BigInteger summe = BigInteger.valueOf(0);
		
		for(BigInteger i = BigInteger.valueOf(0); i.compareTo(n) > 0 ; i = i.add(BigInteger.ONE)){
		
			BigInteger n2 = n0.add(n1);
			BigInteger even = BigInteger.valueOf(2);
			BigInteger test = BigInteger.valueOf(0);
			n0 = n1;
			n1 = n2;
			
			if(n2.mod(even) == test){
				summe = summe.add(n2);
			}
		
		}
		
		return summe;
	}
	
	
	//Methode, die tatsächliche Summe bildet
	//Grenze = 4 Millionen wird als Parameter übergeben
	public BigInteger berechnung(BigInteger grenze){
		
		 
		
		for(BigInteger i= BigInteger.valueOf(0); 
				i.compareTo(grenze) > 0; i = i.add(BigInteger.ONE) ){			//Schleifenkopf mit oberer Grenze und Zählvariable
			
			//für jeden Wert i wird die obige fib-Methode aufgerufender 
			//in der fib-Methode berechnete Wert wird in cur geschrieben
			cur = fib(i);
			BigInteger even = BigInteger.valueOf(2);
			BigInteger test = BigInteger.valueOf(0);
			if(cur.mod(even) == test){					//Prüfe, ob der in cur gespeicherte Wert gerade ist
				sum = sum.add(cur);						//Falls gerade, so speichere in sum
		
			}
		}
		
		return sum;								//gebe am Ende das Ergebnis aus
	
	}
	
	
	
	public static void main(String[] args){
		
		Problem2 pr2 = new Problem2();
		
		BigInteger max = BigInteger.valueOf(4000000);
		
		
		System.out.println("Die Summe der geraden Terme unter 4 Mil. : "  + pr2.berechnung(max));
		
		
		}
		
			
		
	

}


aber das Programm terminiert zwar, aber da kommt als Ergebnis immer 0 raus. Ich such den Fehler, kann ihn allerdings nicht finden
 
Zuletzt bearbeitet:

stg

Top Contributor
Du vergleichst BigInteger-Objekte (!) mit
Code:
==
. Du willst aber nicht prüfen, ob die Objekte identisch sind, sondern nur, ob sie den gleichen Wert haben. Solche Vergleiche machst du über die
Code:
equals
-Methode.

Schau dir mal an, was die
Code:
compareTo
-Methode zurückgibt. So wie du es jetzt dort stehen hast, springt dein Programm niemals in die for-Schleifen.

Die Methode
Code:
berechnung
kannst du dir komplett sparen. Du berechnest doch (so, wie es sein soll, da du sonst eine katastrophale Laufzeit hättest) innerhalb der Methode
Code:
fib
schon das, was du tatsächlich berechnen willst. Beachte bei der Ausgabe allerdings noch, dass die Fibonacci Zahl f_n natürlich die (n+1)te Zahl der Fibanacci-Folge ist. Wenn du also unter den ersten 4.000.000 Fibonacci-Zahlen aufsummieren willst, dann musst du deine Methode mit dem Wert 3.999.999 aufrufen.

Je nachdem, wie gut du in Mathe bist, kansnt du ja auch noch meinen Hinweis von der letzten Seite beachten, und versuchen eine explizite Formel für den von dir gewünschten Wert zu bestimmen. Somit erreichst du sogar konstante Laufzeit. Wenn es dir aber nur um die Programmierübung geht, dann vergiss die Anmerkung einfach.
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
N Hey Leute und zwar versuche ich gerade ein 2D Spiel zu Programmieren aber die Figur will sich nicht nach links oder rechts bewegen :( Java Basics - Anfänger-Themen 12
JavaBeginner22 Punkt auf Gerade Java Basics - Anfänger-Themen 59
D Gerade oder ungerade Zahl mittels Methoden Java Basics - Anfänger-Themen 13
B Methoden Rekursiv festellen, ob eine Zahl gerade-oft vorkommt oder nicht Java Basics - Anfänger-Themen 4
macle Rekursive String Methode, Gerade Zahlen rausfiltern Java Basics - Anfänger-Themen 10
P Herausfinden, auf welchem Panel des CardLayouts man gerade ist? Java Basics - Anfänger-Themen 12
D Guten Tag mache gerade eine Umschulung zum FiSi war leider jetzt 2 Wochen Krank und wir hatten Prozendurale Programmierung. Java Basics - Anfänger-Themen 3
Henri ich verstehe gerade nicht die Methode Java Basics - Anfänger-Themen 6
D Ausgeben welcher Thread gerade Arbeitet Java Basics - Anfänger-Themen 8
W Erste Schritte Zweidimensionales Array - Gerade Zahlen anzeigen lassen Java Basics - Anfänger-Themen 3
H Gerade Zahlen aus Array entfernen Java Basics - Anfänger-Themen 8
M Gerade/ungerade---alter Forenbeitrag Java Basics - Anfänger-Themen 4
C DoublyLinkedList - Gerade zahlen ausgeben lassen Java Basics - Anfänger-Themen 2
Thallius String und \n. Habe wohl gerade Brett vorm Kopf Java Basics - Anfänger-Themen 13
K Rekursion gerade Zahlen addieren Java Basics - Anfänger-Themen 11
P Gerade Zahl sortieren Java Basics - Anfänger-Themen 11
K Schnitt zweier Ebenen ergibt Gerade Java Basics - Anfänger-Themen 10
F Zugriff auf Pfad des gerade ausgeführten Programms? Java Basics - Anfänger-Themen 14
J Erste Schritte Array: Häufigkeiten bzw. gerade/ungerade Zahlen Java Basics - Anfänger-Themen 5
T Erste Schritte Berechnung von gerade und ungerade Zahlen Java Basics - Anfänger-Themen 10
M Gerade Zahlen aus einer Zahl summieren Java Basics - Anfänger-Themen 9
S Gerade bzw. Ungerade Zufallszahl generieren Java Basics - Anfänger-Themen 5
C Nachprüfung 2.: Gerade Zahlen ausgeben Java Basics - Anfänger-Themen 14
M Ausgabe einer gerade Zahl nur mit Addition,subtraktion und vergleichsoperatoren! Java Basics - Anfänger-Themen 4
F kleines Programm für ungerade oder gerade Zahl. Java Basics - Anfänger-Themen 18
Xtracter 3 gerade, 3 ungerade, 3 gerade, usw. Zahlen aufzählen Java Basics - Anfänger-Themen 20
S Senkrechte Gerade Java Basics - Anfänger-Themen 11
R Wird Programm gerade beendet? Java Basics - Anfänger-Themen 10
W Fange gerade an zu programmieren! Java Basics - Anfänger-Themen 6
K zufallszahlen int / double, gerade / ungerade problem . Java Basics - Anfänger-Themen 2
J Habe gerade erst mit Java begonnen - Frage zu JTabbedPane Java Basics - Anfänger-Themen 3
M gerade und ungerade Zahl ermitteln Java Basics - Anfänger-Themen 11
X Werte vergleichen ob gerade oder ungerade geht das? Java Basics - Anfänger-Themen 4
B Gerade ungerade Zahlen Java Basics - Anfänger-Themen 3
G gerade zahlen größer und kleiner null Java Basics - Anfänger-Themen 6
Y kann jemand die Terme mit Zahlen schreiben ?? Java Basics - Anfänger-Themen 4
W Terme Java Basics - Anfänger-Themen 5
J Eingabe arithmetischer Terme Java Basics - Anfänger-Themen 4
S Abwandlung der Fibonacci Folge Java Basics - Anfänger-Themen 3
T Fibonacci mit einer Hilfsmethode berechnen Java Basics - Anfänger-Themen 10
123456789sssssaaaa Which is the best way to Print Fibonacci Series in Java? Java Basics - Anfänger-Themen 3
jhCDtGVjcZGcfzug Fibonacci Zahlen rekursiv und iterativ Java Basics - Anfänger-Themen 21
J Fibonacci-Reihe Java Basics - Anfänger-Themen 12
G Fibonacci Zahlenreihe Fehler Java Basics - Anfänger-Themen 4
D Fibonacci overflow integer Java Basics - Anfänger-Themen 8
B Fibonacci Zahlen dynamische Programmierung Java Basics - Anfänger-Themen 7
N Dynamisches Programmieren/Fibonacci Java Basics - Anfänger-Themen 1
V Fibonacci Folge Java Basics - Anfänger-Themen 4
S Fibonacci Zahlen rekursiv Java Basics - Anfänger-Themen 1
A Fibonacci Zahlen Java Basics - Anfänger-Themen 1
M Methoden Fibonacci-Folge Java Basics - Anfänger-Themen 6
J Fibonacci -Folge rekursiv berechnen Java Basics - Anfänger-Themen 18
P Fibonacci -Verallgemeintert Java Basics - Anfänger-Themen 2
K Methoden Fibonacci in Array mit rekursiver Methoden Java Basics - Anfänger-Themen 19
M Fibonacci rekursiv mittels Cache Java Basics - Anfänger-Themen 17
T Stack Overflow - Rekursive Fibonacci Java Basics - Anfänger-Themen 10
K Fibonacci Zahlen Java Basics - Anfänger-Themen 3
B Fibonacci Zahlen rekursiv Array Java Basics - Anfänger-Themen 12
M Fibonacci-Folge mit while-Schleife Java Basics - Anfänger-Themen 4
P fibonacci - do while Statement Logik Fehler Java Basics - Anfänger-Themen 5
A Fibonacci-numbers Java Basics - Anfänger-Themen 9
K Rekursion Fibonacci Java Basics - Anfänger-Themen 3
J Fibonacci Zahlen berechnen Java Basics - Anfänger-Themen 3
Z Fibonacci rekursiv meine Erklärung stimmt so? Java Basics - Anfänger-Themen 2
Z Fibonacci Array Erklärung Java Basics - Anfänger-Themen 5
M Fibonacci, Fakultaet, GGT Java Basics - Anfänger-Themen 9
C Fibonacci Zahlen Java Basics - Anfänger-Themen 7
J Ausgabe der fibonacci Zahlen Java Basics - Anfänger-Themen 4
S Fibonacci Folge Java Basics - Anfänger-Themen 34
D Fibonacci Java Basics - Anfänger-Themen 11
M Fibonacci-Linear und Rekursiv Java Basics - Anfänger-Themen 14
W Fibonacci Zahlenberechnung Java Basics - Anfänger-Themen 9
X Fibonacci mit durchschnittlicher Zeit Java Basics - Anfänger-Themen 5
I Fibonacci-Folge , direkter Weg. Java Basics - Anfänger-Themen 5
G Fibonacci Algorithmus Java Basics - Anfänger-Themen 22
0 Fibonacci Zahlen seeeehr schnell berechnen Java Basics - Anfänger-Themen 9
S Fibonacci Rückrechnung! Java Basics - Anfänger-Themen 5
K Fibonacci Zahlen Java Basics - Anfänger-Themen 2
K Programmieren von den ersten 70 Fibonacci-Zahlen Java Basics - Anfänger-Themen 2
G fibonacci was stimmt an meinem code nicht? Java Basics - Anfänger-Themen 2
S Fibonacci Zahlenvergeich Java Basics - Anfänger-Themen 6
G Iterativer Algorithmus zur Berechnung der Fibonacci Zahlen Java Basics - Anfänger-Themen 1
P Fibonacci-Zahlen Java Basics - Anfänger-Themen 6

Ähnliche Java Themen

Neue Themen


Oben