Fibonacci-Reihe in Java

Bei der Fibonacci-Reihe handelt es sich um den Prozess, dass jede Zahl als Summe zweier vorangehender Werte fungiert und die Folge immer mit den Basis-Ganzzahlen 0 und 1 beginnt. Fibonacci-Zahlen sind eng mit dem Goldenen Schnitt verbunden. In diesem Thema werden wir uns mit der Fibonacci-Reihe in Java befassen.

Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

Formel:

an = an − 2 + an − 1

Fibonacci series for first 21 numbers
F0	F1	F2	F3	F4	F5	F6	F7	F8	F9	F10	F11	F12	F13	F14	F15	F16	F17	F18	F19	F20
0	1	1	2	3	5	8	13	21	34	55	89	144	233	377	610	987	1597	2584	4181	6765

Fibonacci-Reihe für die ersten 21 Zahlen

F₀

F₁

F₂

F₃

F₄

F₅

F₆

F₇

F₈

F₉

F₁₀

F₁₁

F₁₂

F₁₃

F₁₄

F₁₅

F₁₆

F₁₇

F₁₈

F₁₉

F₂₀

0

1

1

2

3

5

8

13

21

34

55

89

144

233

377

610

987

1597

2584

4181

6765

Schlüsselanwendungen

Hier sind die wichtigsten Anwendungen der Fibonacci-Reihe in Java unten aufgeführt:

• Meilen in Kilometer und Kilometer in Meilen umrechnen.
• Einige Beispiele der agilen Methodik.
• Die Berechnung der Laufzeitanalyse des Euklid-Algorithmus wird mit dieser Reihentechnik durchgeführt.
• Fibonacci-Statistiken werden mathematisch von einigen Pseudozufallszahlengeneratoren verwendet.
• Der Pokerplanungsprozess beinhaltet die Verwendung dieser Technik.
• Die Datenstrukturtechnik des Fibonacci-Heaps wird mithilfe der Fibonacci-Reihentechnik erreicht.
• Während in der Optik ein Lichtstrahl vom Anfang bis zum Ende zweier gestapelter durchscheinender Platten aus unterschiedlichen Materialien mit unterschiedlichen Brechungsindizes ausstrahlt, kann er von drei Oberflächen zurückfallen: der Spitzen-, der Mittel- und der Basisfläche die beiden Teller. Die Zahl des unterschiedlichen Strahlengangs, der Reflexionen haben soll, für k > 1, ist die {display style k} die Fibonacci-Zahl.

Fibonacci-Reihenprogramm (nicht rekursives Programm)

Es folgt ein Fibonacci-Reihenprogramm:

Code:

// Fibonacci series program
public class Fibonacci {
// main program
public static void main(String[] args) {
int count = 10, var1 = 0, var2 = 1;
System.out.print("First " + count + " terms: ");
// Fibonacci series formation loop
for (int i = 1; i <= count; ++i)
{
System.out.print(var1 + " + ");
int added_sum= var1 + var2;
var1 = var2;
var2 = added_sum;
}
}
}

Ausgabe:

Erklärung:

• Dieses Programm berechnet die Fibonacci-Reihe für einen bestimmten Zahlenbereich.
• Hier wird dieser Prozess ohne rekursive Technik erreicht.

Programmalgorithmus

• Eine Wurzelklasse Fibonacci wird mit der Notwendigkeit deklariert, dass alle in diese Klasse eingebetteten Programmcodes die Funktionalität zum Erreichen einer Fibonacci-Zahlenreihe berücksichtigen.
• Innerhalb der Stammklasse wird die Hauptmethode deklariert. Die Hauptmethode fungiert in der Regel als signifikante Java-Methode. Die JVM-Ausführung findet nicht statt, ohne dass die Hauptmethode im Programm vorhanden ist. Nachfolgend finden Sie eine Erläuterung der verschiedenen Unterkomponenten der Hauptmethode
• Als nächstes wird der Abschnitt zur Variableninitialisierung impliziert. In diesem Abschnitt geht es um die Initialisierung von drei verschiedenen Variablen. Zwei davon dienen dazu, die Fibonacci-Logik durch einen Werteaustausch auf variabler Ebene zu erreichen, und eine weitere Variable dient der Regulierung der Anzahl der Werte, für die die Fibonacci-Logik generiert werden muss.
• Die Schlüssellogik des Fibonacci-Reihenprogramms wird mithilfe der unten angegebenen for-Schleife im Programmabschnitt erreicht.

Code:

for (int i = 1; i <= count; ++i)
{
System.out.print(var1 + " + ");
int added_sum= var1 + var2;
var1 = var2;
var2 = added_sum;
}

• Die Logik dahinter für den Schleifenabschnitt ist wie folgt; Zunächst wird ein Wertebereich in einer Schleife ausgeführt. Die Schleife erfolgt mit einem Inkrement des Bereichswerts für jeden Fluss. Zusätzlich wird in jedem Fluss der Wert der beiden Swap-Variablen in einer dritten Variablen summiert.
• Nach der Summierung wird der zweite Variablenwert in die erste Variable impliziert, sodass der erste Variablenwert aus diesem Prozess entfernt wird. Im nächsten Schritt wird der summierte Wert der zweiten Variablen zugewiesen.

Am Ende dieser Instanz werden also für einen einzelnen Logikfluss die folgenden Ereignisse angewendet:

• Der Wert der ersten Variablen wird weggespült.
• Der vorhandene zweite Variablenwert wird in die erste Variable eingetragen.
• Der summierte Wert wird in die zweite Variable verschoben.

Beim Ausführen der folgenden Logiksequenz für die gegebene erforderliche Anzahl von Werten kann die Fibonacci-Reihe erreicht werden.

1. Fibonacci-Reihenprogramm (unter Verwendung von Arrays)

Code:

import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int Count = 15;
long[] array = new long[Count];
array[0] = 0;
array[1] = 1;
for (int x = 2; x < Count; x++) {
array[x] = array[x - 1] + array[x - 2];
}
System.out.print(Arrays.toString(array));
}
}

Ausgabe :

Erklärung:

•  Impliziert die oben entworfene Programmlogik, aber in diesem Fall werden die Fibonacci-Eingaben als Teil von Arrays gespeichert.
• Alle oben genannten Operationen werden also in Bezug auf ein Array ausgeführt.

2. Fibonacci-Reihenprogramm (ohne irgendwelche Schleifen implizieren)

Code:

public class Fibonaccifunction
{
private static int indexvalue = 0;
private static int endPoint = 9;
public static void main (String[] args)
{
int number1 = 0;
int number2 = 1;
fibonaccifunction(number1, number2);
}
public static void fibonaccifunction(int number1, int number2)
{
System.out.println("index value : " + indexvalue + " -> " + number1);
if (indexvalue == endPoint)
return;
indexvalue++;
fibonaccifunction(number2, number1+number2);
}
}

Ausgabe :

Erklärung:

•  Impliziert die oben entworfene Programmlogik, aber in diesem Fall werden die Fibonacci-Eingaben rekursiv mithilfe einer Funktion namens Fibonacci verarbeitet.

3. Fibonacci-Reihenprogramm (Ohne irgendwelche Schleifen implizieren, sondern nur unter Verwendung von Bedingungen erreichen)

Code:

public class Fibonacci_with_conditions
{
static int number2=1;
static int number1=0;
static int next=0;
public static  void Fibonacci_conditions( int number)
{
if(number<10)
{
if(number == 0)
{
System.out.print(" "+number);
number++;
Fibonacci_conditions (number);
}
else
if(number == 1)
{
System.out.print(" "+number);
number++;
Fibonacci_conditions(number);
}
else{
next=number1+number2;
System.out.print(" "+next);
number1=number2;
number2=next;
number++;
Fibonacci_conditions(number);
}
}
}
public static void main(String[] args)
{
Fibonacci_conditions(0);
}
}

Ausgabe:

Erklärung:

• Implying the program logic drafted above, but at this instance, the Fibonacci inputs are regulated only through necessary conditional statements.
• According to the conditions, the swapping of the variables is necessarily carried out.

4. Fibonacci Series Program( Without Loops, the Concepts of Looping is Achieved using Nextint Method)

Code:

import java.util.*;
public class Fibonacci_series
{
public static void main(String[] args)
{
System.out.println("Input:");
int number= 10,value1=1,value2=0,value3=0;
num(number, value1, value2, value3);
}
public static void num(int number,int value1,int value2,int value3)
{
if(value1 <= number)
{
System.out.println(value1);
value3=value2;
value2=value1;
value1=value2+value3;
num(number,value1,value2,value3);
}
}
}

Output:

Explanation:

• Implying the program logic drafted above, but at this instance, the Fibonacci inputs are handled recursively using a function named num, and the loop is carried out using the nextInt function.

Conclusion – Fibonacci Series in Java

These programs are implied to achieve the Fibonacci series for a given integer value.  A largely classified set of techniques are implied in the given list of examples. Techniques like an array-oriented approach and a condition-alone approach are very much peculiar.

Das obige ist der detaillierte Inhalt vonFibonacci-Reihe in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!