# Fibonnacizahlen im Array berechnen



## avi (13. Dez 2010)

Hallo erstmal ich bin neu hier =) 

folgendes problem stellt sich mir: 
ich muss fibonaccizahlen bis 46 berechnen und ausgeben und ich versteh einfach nicht wie ich das anstellen soll. Vlt kann mir hier jmd weiter helfen. das wäre echt nice. 
Mein bisheriger Quellcode

```
public class Fibonacci
                {
                public static void main(String[] args)
                        {

                        int i, n, a;
                        int fibo[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 2$
                        int fibozahl = 0;

                        System.out.printf("\nZahl    Fibonacci-Zahl   Zahl   Fibanacci-Zahl");
                        System.out.printf("\n-------------------------------------------------------");

                        for(i = 0; i < 24; i++)
                        {
                        for(a = 24; a < 46; a++)
                        {
                        for(n = 0; n < 46; n++)
                        {

                        fibozahl = fibo[n-1]+fibo[n];
                        }
                        System.out.printf("\n %d           %d          %d         %d       ", i, fibozahl, a, fibozahl);
                        }
                        }
                        }
                }
```
Danke schonmal im vorraus xD


----------



## ARadauer (13. Dez 2010)

ich denke du musst sie ins array schreiben oder? 


```
int[] numbers = new int[49];
		for(int i = 0; i< numbers.length; i++){
			if(i<2){
				numbers[i] = 1;
			}else{
				numbers[i] = numbers[i-1]+numbers[i-2];
			}
		}
		System.out.println(Arrays.toString(numbers));
	}
```

das verstehe ich nicht...


```
for(i = 0; i < 24; i++)
                        {
                        for(a = 24; a < 46; a++)
                        {
                        for(n = 0; n < 46; n++)
                        {
```
was genau machst du da?


----------



## avi (13. Dez 2010)

ok ich probiere es gleich mal aus.
diese for schleifen sind dafür da, dass in der ausgabe unter zahl 1 2 3 4 5...23 und in der anderen spalte dann 24....46 steht. aber irgendwie wenn ich das programm starte wird 1 1 1 1 1 1 1 1 1 1 2 2 2 2.... gezählt also nicht einmal sondern ca 14 mal. wie löse ich dieses problem? wenn ich nur die for schleife für a laufen lasse gibt es die zahlen richtig aus also 1 2 3 4 5....23 

danke für deine hilfe


----------



## darekkay (13. Dez 2010)

Die *ersten *46 Fibonacci Zahlen oder die Zahlen *bis *46?
Bei 46 Zahlen kommt man nämlich schnell an die Grenzen von Integer, sodass dann fehlerhafte (negative) Ergebnisse rauskommen.

So oder so, würde ich die fibonacci-Funktion selbst erstmal auslagern. Schönerer Code auf Kosten der Effizienz ^^

```
private static int fibonacci(int n){
		if (n==0)
			return 0;
		else if (n==1)
			return 1;
		else return fibonacci(n-1) + fibonacci(n-2);
	}
```


----------



## ARadauer (13. Dez 2010)

fibonacci rekursiv zu lösen ist natürlich blödsinn... ich weiß nicht warum lehrer das immer als beispiel geben...


----------



## darekkay (13. Dez 2010)

ARadauer hat gesagt.:


> fibonacci rekursiv zu lösen ist natürlich blödsinn... ich weiß nicht warum lehrer das immer als beispiel geben...





darekkay hat gesagt.:


> Schönerer Code auf Kosten der Effizienz ^^



Wenn man einen normalen Rechner hat, und kein super-anspruchsvolles Programm macht, dann wird der Tausendstel einer Millisekunde nicht so viel ausmachen..

btw: deine lösung fängt bei 1 und nicht bei 0 an


----------



## ARadauer (13. Dez 2010)

darekkay hat gesagt.:


> Wenn man einen normalen Rechner hat, und kein super-anspruchsvolles Programm macht, dann wird der Tausendstel einer Millisekunde nicht so viel ausmachen..



rechne mir mal die 72. fibonacci zahl mit deinem programm... :lol:

und dann mit meinem... und du hattest natürlich recht.. die zahl passt nicht mehr in ein int.. man muss ein long[] array nehemen...


----------



## avi (13. Dez 2010)

also vlt um zuverdeutlichen was das programm schluss endlich ausgeben soll sieht wie folgt aus:
zahl fibonaccizahl zahl  fibonaccizahl
1          1            24
2          3            25
3          .             26
4          .             27
.                         . 
.                         .
.                         .
23                      46

hmm leertasten mag das forum hier nicht ;-)
ja es sollen die zahlen von 1-46 gerechnet werden also dann werde ich ein long array benutzten.


----------



## darekkay (13. Dez 2010)

überzeugt ^^

@avi: sieh dir den Code von ARadauer an - damit hast du alles, was du brauchst. Jetzt bloß in deine gewünschte Form bringen..


----------



## ARadauer (13. Dez 2010)

> also vlt um zuverdeutlichen was das programm schluss endlich ausgeben soll sieht wie folgt aus:


also fehlt dir jetzt noch noch die ausgabe? Hast du dazu eine konkrete frage?


----------



## avi (13. Dez 2010)

nun rechnet er aufjedenfall aber so ganz stimmen die zahlen nicht. was noch ein problem ist sind die for zählschleifen für die zahlen 1-23 und 24-46 wie kann man dieses problem lösen?
zudem rechnet er ab der 3ten zahl nur noch +2 also 9 11 13 15 17....
also er spuckt sowas aus 

 9           1          24            1
 9           1          24            1
 9           5          24            5
 9           7          24            7
 9           9          24            9
 9           11          24            11
 9           13          24            13
 9           15          24            15
 9           17          24            17
 9           19          24            19
 9           21          24            21
 9           23          24            23
 9           25          24            25
 9           27          24            27
 9           29          24            29
 9           31          24            31
 9           33          24            33


----------



## ARadauer (13. Dez 2010)

> wie kann man dieses problem lösen?


... es richtig machen...
also dein code ist kompett falsch... sieht man daran das die ausgabe komplett falsch ist... wie sieht den dein code im moment aus?


----------



## ARadauer (13. Dez 2010)

also ein array zweipaltig ausgeben....


```
int half = numbers.lenght/2;
for(int i = 0; i < half; i++){
    System.out.println(i+1+" "+numbers[i]+"  "+(i+half+1)+" "+numbers[i+half]);
}
```


----------



## timbeau (13. Dez 2010)

Hast du überhaupt verstanden was Fibonaccizahlen sind?

Mein Vorschlag wäre ein Array mit [0] = 0 und [1] = 1 zu initialisieren. Und dann addierst du immer die letzen beiden Zahlen. 

Du brauchst doch nur eine Schleife fürs Rechnen und dann nochmal für die Ausgabe.


----------



## avi (13. Dez 2010)

```
public class Fibonacci
                {
                public static void main(String[] args)
                        {

                        int i, n, a;
                        long fibo[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29$
                        long fibozahl = 0;

                        System.out.printf("\nZahl    Fibonacci-Zahl   Zahl   Fibanacci-Zahl");
                        System.out.printf("\n-------------------------------------------------------");

                        for(n = 0; n < fibo.length ; n++)
                        {
                        if(n < 2)
                        {
                        fibozahl = 1;
                        }
                        else
                        {
                        fibozahl = fibo[n]+fibo[n-1];
                        }
                        int half = fibo.lenght/2;
                        for(i = 0; i < half; i++)
                        {
                        System.out.println(i+1+"+fibo[n]+"  "+(i+half+1)+"  "+fibo[i+half]");
                        }
                        }
                        }
                }
```


----------



## timbeau (13. Dez 2010)

Deine Fibozahlen sind falsch!

Im übrigen sollst du die Zahlen doch rechnen und nicht in ein Array schreiben und vordefinieren. 

Außerdem ist dein Code falsch und schlecht formatiert. Eine gute IDE wie Eclipse z.B. zeigt dir sowas an.


----------



## XHelp (13. Dez 2010)

Das Array brauchst du am Anfang nicht mit Werten vollpacken. Es ist ja der Sinn des Programms die Fibo-Zahlen zu finden.
Außerdem ist die Zeile 7 falsch. Und die Ausgabe am Ende ist auch nicht so sinnvoll


----------



## avi (13. Dez 2010)

meinst du die zahlen in dem array fibo[]? das ist mir klar das es nicht die fibonaccizahlen sind.
das sind die werte die in den array speichert sind welche dann addiert werden sprich 
feld 0 = 1 + feld 1 = 2 sprich die fibonaccizahl 3
ok gut hab das array jetzt in long fibo[45] geändert.


----------



## XHelp (13. Dez 2010)

Dennoch ist es komisch was du machst. Du musst das Array (wenn überhaupt) dann selber während der Laufzeit füllen


----------



## timbeau (13. Dez 2010)

So errechnet man aber nicht diese Folge! Jetzt lies es dir doch wenigstens mal durch und wenns nur kurz auf Wiki ist. Ist ja kein Hexenwerk.

Die Folge fängt mit 01235 an

Was ist denn wenn dein Programm bis 1200 ausgeben soll? Schreibst du dann auch alles auf? 

Es geht auch mit Sicherheit nicht um die 3. F.-Zahl (oder 46.) sondern um die Fibonacci-Zahl3 die aus Fib2 + Fib1 gebildet wird.


----------



## avi (13. Dez 2010)

ich hab schon verstanden wie die zahlen berechnet werden timbeau. in dem post war eben nur ein zahlen dreher...so nochmal der quellcode denn ich habe und jmd kann mir genau sagen woran es hackt das er nichts rechnet.

```
public class Fibonacci
                {
                public static void main(String[] args)
                        {

                        int i, n, a;
                        long[] fibo = new long[45];
                        long fibozahl = 0;

                        System.out.printf("\nZahl    Fibonacci-Zahl   Zahl   Fibanacci-Zahl");
                        System.out.printf("\n-------------------------------------------------------");

                        for(n = 0; n < fibo.length ; n++)
                        {
                        if(n < 2)
                        {
                        fibo[n] = 1;
                        }
                        else
                        {
                        fibo[n] = fibo[n-1]+fibo[n];
                        fibo[n] = fibozahl;
                        }
                        for(i = 1; i < 24; i++)
                        {
                        System.out.printf("\n %d          %d                              ",i ,fibozahl);
                        }
                        }
                        }
                }
```


----------



## XHelp (13. Dez 2010)

Der else-Zweig ist falsch. Überlege, was da tatsächlich passiert


----------



## avi (14. Dez 2010)

ich sehe den wald vorlauter bäumen nicht :rtfm: 
in der for schleife wird n immer weiter erhöht bis 45 erreicht wird 
wenn der fall eintrifft das n kleiner als 2 ist soll er 1 ausgeben
ansonsten fibo = (fibo-1)+fibo
sprich wenn zB die for schleife das 3te mal durchläuft trifft die if anweisung nicht mehr zu
also ist n = 2
also fibo = fibo(2-1) + fibo(2)
sprich es sollte 3 ausgegeben werden


----------



## XHelp (14. Dez 2010)

Was steht bei Wiki? Steht da fibo(n) = fibo(n-1)+fibo(n) ... dadurch würdest du einen Funktionswert durch sich selber definieren
Oder steht da: fibo(n) = fibo(n-1)+fibo(n-2)?
Außerdem hast du da 2 Zuweisungen in der Schleife. Die eine ergibt nur ein wenig kein Sinn, die andere ergibt überhaupt kein Sinn.


----------



## avi (14. Dez 2010)

ja schon klar hab gedacht das geht auch. aber wenn ich fibo[n] = fibo[n-1]+fibo[n-2];
nutzt kommt der fehler 
Exception in thread "main" java.lang.ArrayIndesException
        at Fibonacci.main(Fibonacci.java:15)


----------



## XHelp (14. Dez 2010)

Diese Exception existiert nicht. Ich vermute mal du meinst ArrayIndexOutOfBounds exception.
Ich habe keine Ahnung was jetzt bei dir im Code steht, von daher muss du selber durch Debugausgaben feststellen was da falsch läuft
(wenn du den Code postest, dann rück den richtig ein)


----------



## avi (14. Dez 2010)

ich hab keine debug funktionen da ich es an einem unix server schreibe und mit dem programm pico arbeiten muss...

```
public class Fibonacci
                {
                public static void main(String[] args)
                        {

                        int i, n, a;
                        long[] fibo = new long[45];
                        long fibozahl = 0;

                        System.out.printf("\nZahl    Fibonacci-Zahl   Zahl   Fibanacci-Zahl");
                        System.out.printf("\n-------------------------------------------------------");

                        for(n = 1; n < fibo.length ; n++)
                        {
                        fibo[n] = fibo[n-1]+fibo[n-2];

                        }
                        for(i = 1; i < 24; i++)
                        {
                        for(a = 24; a < 47; a++)
                        {
                        System.out.printf("\n %d          %d           %d         %d       ",i ,fibozahl, a, fibozahl);
                        }
                        }
                        }
                }
```


----------



## timbeau (14. Dez 2010)

Dein Programm bildet immer noch nicht die Funktion ab mit der FIbonaccizahlen berechnet werden. Diese Aufteilung von 1-25 und 26-46 oder so ist Unsinn. Was ist wenn die Aufgabe bis 52 geht. Schreibst du dann jedes Mal den Code um?

1. Schritt: Ein Array mit den Fibonaccizahlen füllen. 

2. Schritt: Die Ausgabe auslesen

Zu 1:

Array[0] == 0
Array[1] == 1

Und in der Schleife einfach die Wikifunktion implementieren. 



```
for(int i = 2; i < Array.length; i++){
//TODO
}
```



Zu 2:

Die passende Zahl steht immer im Index. Also Fib(5) steht dann in Array[5]


Und warum musst du um diese Zeit mit sowas arbeiten? An einem Unixserver?????


----------



## avi (14. Dez 2010)

für die uni...naja mein mitbewohner hat mir jetzt geholfen uns es läuft

```
public class Fibonacci
                {
                public static void main(String[] args)
                        {

                        int i, n;
                        int[] fibo = new int[46];
                        fibo[0] = 1;
                        fibo[1] = 1;

                        System.out.printf("\nZahl    Fibonacci-Zahl   Zahl   Fibanacci-Zahl");
                        System.out.printf("\n-------------------------------------------------------");

                        for(n = 2; n < fibo.length ; n++)
                        {
                        fibo[n] = fibo[n-1]+fibo[n-2];

                        }
                        for(n = 0; n < 23; n++)
                        {
                        System.out.printf("\n %d       \t %d        \t %d      \t %d       ",n+1 ,fibo[n], n+24, fibo[n+23]);
                        }
                        }

                }
```


----------



## timbeau (14. Dez 2010)

Ja, sieht korrekt aus. 

Aber auch wenn ich was für die Uni mache hab ich doch zu Hause nen Rechner und Eclipse läuft da Java auf Linux, Windows etc pp.

Da tue ich mir doch nicht son uralt Editor an


----------



## godi (14. Dez 2010)

Damit du noch ne weitere Lösung hast zum vergleichen:


```
public class fibonacci
{
	public static void main(String[] args)
	{

		fiboAusgabe(46);		

	}

	public static void fiboAusgabe(int anzahl) {

		System.out.println("Zahl\tFibonacci-Zahl\tZahl\tFibanacci-Zahl");
		System.out.println("----------------------------------------------");

		long[] fibo = fiboBerechnung(anzahl);

		int n = fibo.length/2;

		for (int i = 0; i<n; i++) {
			System.out.println((i+1) + "\t" + fibo[i] + "\t" + "\t" + (n+i+1) + "\t" + fibo[n+i] );
		}
	}

	public static long[] fiboBerechnung(int anzahl) {
		long[] fibo = new long[anzahl];

		for(int i = 0; i < fibo.length ; i++)
		{
			if(i < 2)
			{
				fibo[i] = 1;
			}
			else
			{
				fibo[i] = fibo[i-1]+fibo[i-2];				
			}
		}
		return fibo;
	}
}
```

Allerdings werden da nur gerade Anzahlen ausgegeben.
Für ungerade kannst dir ja noch was überlegen. 

godi


----------



## avi (14. Dez 2010)

ja ich hab eclispe auf meinem rechner. aber es ist nicht möglich was in pico reinzukopieren bzw ist es mir nicht bekannt. zudem müssen wir in der klausur mit papier und stief programmieren. also ist es dann weniger schlimm, wenn man ohnehin an ein simpeles programm gewöhnt ist.
danke für eure hilfe


----------



## ARadauer (14. Dez 2010)

hab ich nicht gestern abend schon die lösung gepostet?
http://www.java-forum.org/java-basi...bonnacizahlen-array-berechnen.html#post709732


----------



## Landei (14. Dez 2010)

ARadauer hat gesagt.:


> fibonacci rekursiv zu lösen ist natürlich blödsinn... ich weiß nicht warum lehrer das immer als beispiel geben...



Wieso Blödsinn? Geht doch prima:


```
public static long fib(long n) {
   return fib(1,0,n);
}

private static long fib(long a, long b, long n) {
   return n == 0 ? b : fib(b, a+b, n-1);
}
```


----------



## ARadauer (14. Dez 2010)

naja wenn man es so definiert schon ;-)
Aber die Grundaussage des Beispiels ist ja das fibonacci(n) = fibonacci(n-1) + fibonacci(n-2) ist
Lehrer geben das halt dann oft als Beispiel für Rekursion... was du machst ist halt nur die Iteration als eine Rekursion darzustellen


----------



## timbeau (14. Dez 2010)

Mit Landei macht das echt keinen Spaß. 

Wie lange und wieviel programmierst du schon? Ist schon heftig was man von dir liest:toll:


----------



## Gast2 (14. Dez 2010)

ARadauer hat gesagt.:


> Lehrer geben das halt dann oft als Beispiel für Rekursion... was du machst ist halt nur die Iteration als eine Rekursion darzustellen



Fibonacci rekursiv berechnen ist halt das Standardbeispiel in den ersten Semestern. Grade im Zusammenhang mit funktionalen Programmiersprachen wie z.B. Haskell. 

Irgendwie hat rekursives Programmieren in Java immer ein Nischendasein, auch wenn es manchmal wesentlich eleganter ist. Um Nachteile wie hohen Speicherverbrauch oder fehlende Abbruchbedingungen denken die wenigsten nach sondern haben eher das Problem Rekursion an für sich nicht nachvollziehen zu können.

Wie heißt es so schön (wenn auch nur bedingt richtig): Um Rekursion zu verstehen muss man erstmal Rekursion verstehen...


----------



## timbeau (14. Dez 2010)

Ich hab am Anfang gehört: "rekursiv geht meistens schief" und bin auch nicht wirklich gut darin.


----------



## darekkay (14. Dez 2010)

ARadauer hat gesagt.:


> was du machst ist halt nur die Iteration als eine Rekursion darzustellen



Endrekursion ? Wikipedia

Auch "iterativ rekursion", richtig. Rekursion ist halt nicht gleich Rekursion ^^



timbeau hat gesagt.:


> Ich hab am Anfang gehört: "rekursiv geht meistens schief" und bin auch nicht wirklich gut darin.



Seit Haskell macht Rekursion wirklich Spaß ^^


----------



## Landei (14. Dez 2010)

timbeau hat gesagt.:


> Mit Landei macht das echt keinen Spaß.


 Ich denke gern quer und lerne gern dazu.



> Wie lange und wieviel programmierst du schon? Ist schon heftig was man von dir liest:toll:



Beruflich seit zehn Jahren. Vorher natürlich auf der Brotkiste, in der Schule und im Studium.


----------



## Landei (14. Dez 2010)

darekkay hat gesagt.:


> Endrekursion ? Wikipedia
> 
> Auch "iterativ rekursion", richtig. Rekursion ist halt nicht gleich Rekursion ^^



Leider nützt Endrekursion nichts, wenn man den Oracle-Compiler verwendet (IBM's kanns wohl)



> Seit Haskell macht Rekursion wirklich Spaß ^^



Finde ich auch. Eine irre Sprache!


----------



## darekkay (14. Dez 2010)

Landei hat gesagt.:


> Leider nützt Endrekursion nichts, wenn man den Oracle-Compiler verwendet (IBM's kanns wohl)



Klar.. nimm eine echt-rekursive fibonacci-Funktion mit fib(52). Und nimm dann (deine) endrekursive Variante


----------



## Landei (15. Dez 2010)

Meine Version ist zwar performanter, würde aber auch irgendwann zum Stackoverflow führen (wenn sie nicht schon vorher einen numerischen Überlauf hätte), denn weder der Java Compiler noch die JVM von Oracle führen eine Optimierung bei Endrekursion durch. Probiere es doch aus: Diagnosing Java Code: Improve the performance of your Java code


----------



## darekkay (15. Dez 2010)

Landei hat gesagt.:


> Meine Version ist zwar performanter, würde aber auch irgendwann zum Stackoverflow führen (wenn sie nicht schon vorher einen numerischen Überlauf hätte), denn weder der Java Compiler noch die JVM von Oracle führen eine Optimierung bei Endrekursion durch. Probiere es doch aus: Diagnosing Java Code: Improve the performance of your Java code



oha, interessant ^^ danke


----------



## AlexBoesel (30. Jan 2011)

Hallo zusammen,
hatte dasselbe Problem und hab es folgendermaßen gelöst:

public class FiboSum {

	public static void main(String[] args) {
		int n = 20;
		int[] a = new int[n];

		int i = 0;
		int res = 0;

		if(n<0)
			System.out.print("Bitte nur positive Zahlen eingeben!");
		else{

		if((n==0)||(n==1)){
			res = 1;
		}
		else{
			a[0] = 1;
			a[1] = 1;

		for(i = 2; i < a.length; i++){
			n = i;
			a[n] = a[n-1] + a[n-2];
			res = a[n];
				}
			}
		}
		System.out.print(res);

	}

}

Habs für die 46 ausprobiert und es klappt.


----------



## Landei (30. Jan 2011)

Bitte [JAVA] Tags für deinen Code benutzen!

Sicher, eine iterative Variante hat keine Probleme mit Stackoverflows. Wenn du ein bisschen über die 46 hinauskommen willst (ein paar Sekunden für die Millionste Fibonacci-Zahl), solltest du allerdings diese Version nehmen: http://www.java-forum.org/java-basics-anfaenger-themen/112299-fibonacci.html#post722090


----------



## Widdsen (31. Jan 2011)

Hier noch ne Lösung von mir ! :

```
public class Fibonacci {
	
	
	
  public int[] alleFibonacciZahlenBis(int m)
  {  int[] zahl = new int[m];
     
    zahl[0] = 0;
    zahl[1] = 1;
    zahl[2] = 2;
    
   for(int index = 3; index < m; index++ )
    {   
        zahl[index] = zahl[index-1] + zahl[index-2] ;
     
    }
    
   
   
   
  
  return zahl;
	   
}

public static void main ( String [] arsch)
{

    Fibonacci fibo = new Fibonacci();
	 for(int i  :  fibo.alleFibonacciZahlenBis(48))
	    {
	    	System.out.println(i);
	    }

}
```


----------

