Eine Zahl gegebenN, druckenn-te Fibonacci-Zahl.
Die Fibonacci-Zahlen sind die Zahlen in der folgenden ganzzahligen Folge:0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, ……..
Beispiele:
Eingabe:n = 1
Ausgang :1
Eingabe:n = 9
Ausgang :34
Eingabe:n = 10
Ausgang :55
Empfohlene Praxis
N-te Fibonacci-Zahl
Versuch es!
Iterativer Ansatz zum Suchen und Drucken von N-ten Fibonacci-Zahlen:
Mathematisch gesehen wird die Folge Fn der Fibonacci-Zahlen durch die Rekursionsrelation definiert:
mit Saatwerten und
C++
// Fibonacci-Reihe mit raumoptimierter Methode
#include
verwenden Namensraum std;
int Flunkerei(int N)
{
int a = 0, b = 1, c, i;
Wenn (n == 0)
zurückkehren A;
für (i = 2; i <= n; i++) {
c = a + b;
a = b;
b = c;
}
zurückkehren B;
}
// Treibercode
int hauptsächlich()
{
int n = 9;
cout << fib(n);
zurückkehren 0;
}
// Dieser Code wird von Code_Mech beigesteuert
C
// Fibonacci-Reihe mit raumoptimierter Methode
#include
int Flunkerei(int N)
{
int a = 0, b = 1, c, i;
Wenn (n == 0)
zurückkehren A;
für (i = 2; i <= n; i++) {
c = a + b;
a = b;
b = c;
}
zurückkehren B;
}
int hauptsächlich()
{
int n = 9;
printf("%D", fib(n));
getchar();
zurückkehren 0;
}
Java
// Java-Programm für Fibonacci-Reihen mit Space
// Optimierte Methode
öffentlich Klasse Fibonacci {
statisch int Flunkerei(int N)
{
int a =0, b =1, C;
Wenn (n ==0)
zurückkehren A;
für (int ich =2; i <= n; i++) {
c = a + b;
a = b;
b = c;
}
zurückkehren B;
}
öffentlich statisch Leere main(String args[])
{
int n =9;
System.out.println(fib(n));
}
};
// Dieser Code wurde von Mihir Joshi beigesteuert
Python3
# Funktion für die n-te Fibonacci-Zahl – Raumoptimierung
# Nimm die ersten beiden Fibonacci-Zahlen als 0 und 1
def Fibonacci(n):
A= 0
B= 1
Wenn n <0:
drucken(„Falsche Eingabe“)
elif N== 0:
zurückkehren A
elif N== 1:
zurückkehren B
anders:
für ichIn Bereich(2, N+1):
C= A+ B
A= B
B= C
zurückkehren B
# Treiberprogramm
drucken(Fibonacci(9))
# Dieser Code wurde von Saket Modi beigesteuert
C#
// C#-Programm für die Fibonacci-Reihe
// unter Verwendung der platzoptimierten Methode
verwenden System;
Namensraum Fib {
öffentlich Klasse GFG {
statisch int Flunkerei(int N)
{
int a = 0, b = 1, c = 0;
// Um die erste Fibonacci-Zahl zurückzugeben
Wenn (n == 0)
zurückkehren A;
für (int ich = 2; i <= n; i++) {
c = a + b;
a = b;
b = c;
}
zurückkehren B;
}
// Treiberfunktion
öffentlich statisch Leere Hauptsächlich(Zeichenfolge[] args)
{
int n = 9;
Console.Write(„{0}“, Fib(n));
}
}
}
// Dieser Code wurde von Sam007 beigesteuert.
Javascript
// Javascript-Programm für Fibonacci-Serien mit platzoptimierter Methode
Funktion fib(n)
{
sei a = 0, b = 1, c, i;
Wenn( n == 0)
zurückkehren A;
für(i = 2; i <= n; i++)
{
c = a + b;
a = b;
b = c;
}
zurückkehren B;
}
// Treibercode
sei n = 9;
document.write(fib(n));
// Dieser Code wurde von Mayank Tyagi beigesteuert
PHP
// PHP-Programm für Fibonacci-Serien
// unter Verwendung der platzoptimierten Methode
Funktion Flunkerei($n)
{
$a = 0;
$b = 1;
$c;
$i;
Wenn($n == 0)
zurückkehren $a;
für($i = 2;$i <=$n;$i++)
{
$c =$a +$b;
$a =$b;
$b =$c;
}
zurückkehren $b;
}
// Treibercode
$n = 9;
Echo Flunkerei($n);
// Dieser Code wurde von anuj_67 beigesteuert.
?>
Ausgang
34
Zeitkomplexität: An)
Hilfsraum: O(1)
Rekursionsansatz zum Suchen und Drucken von N-ten Fibonacci-Zahlen:
Mathematisch gesehen wird die Folge Fn der Fibonacci-Zahlen durch die Rekursionsrelation definiert:
Die N-te Fibonacci-Zahl kann mithilfe der oben gezeigten Wiederholungsbeziehung ermittelt werden:
- WennN= 0, dann 0 zurückgeben.
- Wenn n = 1, sollte 1 zurückgegeben werden.
- Für n > 1 sollte F zurückgegeben werdenn-1+ Fn-2
Nachfolgend finden Sie die Umsetzung des oben genannten Ansatzes:
C++
// Fibonacci-Reihe mit Rekursion
#include
verwenden Namensraum std;
int Flunkerei(int N)
{
Wenn (n <= 1)
zurückkehren N;
zurückkehren fib(n – 1) + fib(n – 2);
}
int hauptsächlich()
{
int n = 5;
cout << n <<"th Fibonacci-Zahl:" << fib(n);
zurückkehren 0;
}
// Dieser Code wurde beigesteuert
// von Akanksha Rai
C
// Fibonacci-Reihe mit Rekursion
#include
int Flunkerei(int N)
{
Wenn (n <= 1)
zurückkehren N;
zurückkehren fib(n – 1) + fib(n – 2);
}
int hauptsächlich()
{
int n = 5;
printf(„%dth Fibonacci-Zahl: %d“, n, fib(n));
zurückkehren 0;
}
Java
// Fibonacci-Reihe mit Rekursion
importieren java.io.*;
Klasse Fibonacci {
statisch int Flunkerei(int N)
{
Wenn (n <=1)
zurückkehren N;
zurückkehren fib(n -1) + fib(n -2);
}
öffentlich statisch Leere main(String args[])
{
int n =5;
System.out.println(
n +"th Fibonacci-Zahl:" + fib(n));
}
}
/* Dieser Code wurde von Rajat Mishra beigesteuert */
Python3
# Fibonacci-Reihe mit Rekursion
def Fibonacci(n):
Wenn n <= 1:
zurückkehren N
zurückkehren Fibonacci (n-1)+ Fibonacci (n-2)
Wenn __Name__== "__hauptsächlich__":
N= 5
drucken(N,"th Fibonacci-Zahl:")
drucken(Fibonacci(n))
# Dieser Code wurde von Manan Tyagi beigesteuert.
C#
// C#-Programm für die Fibonacci-Reihe
// Rekursion verwenden
verwenden System;
öffentlich Klasse GFG {
öffentlich statisch int Flunkerei(int N)
{
Wenn (n <= 1) {
zurückkehren N;
}
anders {
zurückkehren Fib(n – 1) + Fib(n – 2);
}
}
// Treibercode
öffentlich statisch Leere Hauptsächlich(Zeichenfolge[] args)
{
int n = 5;
Console.Write(n +"th Fibonacci-Zahl:" + Fib(n));
}
}
// Dieser Code wurde von Sam007 beigesteuert
Javascript
// Javascript-Programm für die Fibonacci-Serie
// Rekursion verwenden
Funktion Fib(n) {
Wenn (n <= 1) {
zurückkehren N;
}anders {
zurückkehren Fib(n – 1) + Fib(n – 2);
}
}
// Treibercode
sei n = 5;
console.log(n +"th Fibonacci-Zahl:" + Fib(n));
PHP
// PHP-Programm für Fibonacci-Serien
// Rekursion verwenden
Funktion Flunkerei($n)
{
Wenn ($n <= 1) {
zurückkehren $n;
}
anders {
zurückkehren Flunkerei($n - 1) + Fib($n - 2);
}
}
// Treibercode
$n = 5;
Echo $n ."th Fibonacci-Zahl:" . Flunkerei($n);
// Dieser Code wurde von Sam007 beigesteuert
?>
Ausgang
34
Zeitkomplexität: Exponentiell,da jede Funktion zwei andere Funktionen aufruft.
Komplexität des Hilfsraums:O(n), da die maximale Tiefe des Rekursionsbaums n beträgt.
Dynamischer Programmieransatz zum Suchen und Drucken von N-ten Fibonacci-Zahlen:
Betrachten Sie den Rekursionsbaum für die 5. Fibonacci-Zahl aus dem obigen Ansatz:
Fib(5)
/ \
Fib(4) Fib(3)
/ \ / \
Fib(3) Fib(2) Fib(2) Fib(1)
/ \ / \ / \
fib(2) fib(1) fib(1) fib(0) fib(1) fib(0)
/ \
fib(1) fib(0)
Wenn Sie sehen, wird derselbe Methodenaufruf mehrmals für denselben Wert ausgeführt. Dies kann mit Hilfe der dynamischen Programmierung optimiert werden. Wir können die wiederholte Arbeit des Rekursionsansatzes vermeiden, indem wir die bisher berechneten Fibonacci-Zahlen speichern.
Dynamischer Programmieransatz zum Suchen und Drucken von N-ten Fibonacci-Zahlen:
Nachfolgend finden Sie die Umsetzung des oben genannten Ansatzes:
C++
// C++-Programm für die Fibonacci-Reihe
// mit dynamischer Programmierung
#include
verwenden Namensraum std;
Klasse GFG {
öffentlich:
int Flunkerei(int N)
{
// Ein zu speicherndes Array deklarieren
// Fibonacci-Zahlen.
// 1 zusätzlich zu verarbeiten
// Fall, n = 0
int f[n + 2];
int ich;
// 0. und 1. Zahl der
// Serien sind 0 und 1
f[0] = 0;
f[1] = 1;
für (i = 2; i <= n; i++) {
// Addiere die beiden vorherigen Zahlen
// in die Serie einfügen und speichern
f[i] = f[i - 1] + f[i - 2];
}
zurückkehren f[n];
}
};
// Treibercode
int hauptsächlich()
{
GFG g;
int n = 9;
cout << g.fib(n);
zurückkehren 0;
}
// Dieser Code wurde von SoumikMondal beigesteuert
C
// Fibonacci-Reihe mit dynamischer Programmierung
#include
int Flunkerei(int N)
{
/* Deklarieren Sie ein Array zum Speichern von Fibonacci-Zahlen. */
int f[n + 2];// 1 Extra zur Behandlung von Groß- und Kleinschreibung, n = 0
int ich;
/* 0. und 1. Zahl der Reihe sind 0 und 1*/
f[0] = 0;
f[1] = 1;
für (i = 2; i <= n; i++) {
/* Addiere die beiden vorherigen Zahlen in der Reihe
und speichern */
f[i] = f[i - 1] + f[i - 2];
}
zurückkehren f[n];
}
int hauptsächlich()
{
int n = 9;
printf("%D", fib(n));
getchar();
zurückkehren 0;
}
Java
// Fibonacci-Reihe mit dynamischer Programmierung
öffentlich Klasse Fibonacci {
statisch int Flunkerei(int N)
{
/* Deklarieren Sie ein Array zum Speichern von Fibonacci-Zahlen. */
int F[]
=neu int[N
+2];// 1 Extra zur Behandlung von Groß- und Kleinschreibung, n = 0
int ich;
/* 0. und 1. Zahl der Reihe sind 0 und 1*/
F[0] =0;
F[1] =1;
für (ich =2; i <= n; i++) {
/* Addiere die beiden vorherigen Zahlen in der Reihe
und speichern */
f[i] = f[i -1] + f[i -2];
}
zurückkehren f[n];
}
öffentlich statisch Leere main(String args[])
{
int n =9;
System.out.println(fib(n));
}
};
/* Dieser Code wurde von Rajat Mishra beigesteuert */
Python3
# Fibonacci-Reihe mit dynamischer Programmierung
def Fibonacci(n):
# Nimm die ersten beiden Fibonacci-Zahlen als 0 und 1
F= [0,1]
für ichIn Bereich(2, N+1):
f.append(f[i-1]+ f[i-2])
zurückkehren f[n]
drucken(Fibonacci(9))
C#
// C#-Programm für die Fibonacci-Reihe
// mit dynamischer Programmierung
verwenden System;
Klasse Fibonacci {
statisch int Flunkerei(int N)
{
// Ein Array deklarieren für
// Fibonacci-Zahlen speichern.
// 1 zusätzlich zu verarbeiten
// Fall, n = 0
int[] f =neu int[n + 2];
int ich;
/* 0. und 1. Zahl der
Serien sind 0 und 1 */
f[0] = 0;
f[1] = 1;
für (i = 2; i <= n; i++) {
/* Addiere die beiden vorherigen Zahlen
in der Serie und speichern Sie es */
f[i] = f[i - 1] + f[i - 2];
}
zurückkehren f[n];
}
// Treibercode
öffentlich statisch Leere Hauptsächlich()
{
int n = 9;
Console.WriteLine(fib(n));
}
}
// Dieser Code wurde von anuj_67 beigesteuert.
Javascript
// Fibonacci-Reihe mit dynamischer Programmierung
Funktion fib(n)
{
/* Deklarieren Sie ein Array zum Speichern von Fibonacci-Zahlen. */
sei f =neu Array(n+2);// 1 Extra zur Behandlung von Groß- und Kleinschreibung, n = 0
lass ich;
/* 0. und 1. Zahl der Reihe sind 0 und 1*/
f[0] = 0;
f[1] = 1;
für (i = 2; i <= n; i++)
{
/* Addiere die beiden vorherigen Zahlen in der Reihe
und speichern */
f[i] = f[i-1] + f[i-2];
}
zurückkehren f[n];
}
sei n=9;
document.write(fib(n));
// Dieser Code wurde von avanitrachhadiya2155 beigesteuert
PHP
//Fibonacci-Reihe mit Dynamic
// Programmierung
Funktion Flunkerei($n)
{
/* Ein zu speicherndes Array deklarieren
Fibonacci-Zahlen. */
// 1 extra für den Koffer,
// n = 0
$f =Array();
$i;
/* 0. und 1. Zahl der
Serien sind 0 und 1*/
$f[0] = 0;
$f[1] = 1;
für ($i = 2;$i <=$n;$i++)
{
/* Füge die vorherigen 2 hinzu
Zahlen in der Reihe
und speichern */
$f[$i] =$f[$i-1] +$f[$i-2];
}
zurückkehren $f[$n];
}
$n = 9;
Echo Flunkerei($n);
// Dieser Code wurde beigesteuert von
// anuj_67.
?>
Ausgang
34
Zeitkomplexität: O(n) für gegebenes n
Hilfsraum: An)
N-ter Potenz-Matrix-Ansatz zum Finden und Drucken von N-ten Fibonacci-Zahlen
Dieser Ansatz beruht auf der Tatsache, dass wir die (n+1)-te Fibonacci-Zahl als Element in Zeile und Spalte (0, 0) in der resultierenden Matrix erhalten, wenn wir die Matrix M = {{1,1},{1,0}} n-mal mit sich selbst multiplizieren (mit anderen Worten die Potenz (M, n) berechnen).
- Wenn n gerade ist, dann ist k = n/2:
- Daher ist die N-te Fibonacci-Zahl = F(n) = [2*F(k-1) + F(k)]*F(k)
- Wenn n ungerade ist, dann ist k = (n + 1)/2:
- Daher ist die N-te Fibonacci-Zahl = F(n) = F(k)*F(k) + F(k-1)*F(k-1)
Wie funktioniert diese Formel?
Die Formel kann aus der Matrixgleichung abgeleitet werden.
Wenn wir die Determinante auf beiden Seiten nehmen, erhalten wir (-1)N= Fn+1Fn-1- FN2
Darüber hinaus, da ANAM= An+mFür jede quadratische Matrix A können die folgenden Identitäten abgeleitet werden (sie werden aus zwei verschiedenen Koeffizienten des Matrixprodukts erhalten):
FMFN+ Fm-1Fn-1= Fm+n-1 —————————(1)
Indem man n = n+1 in Gleichung (1) einsetzt,
FMFn+1+ Fm-1FN= Fm+n ————————–(2)
Setzen Sie m = n in Gleichung (1).
F2n-1= FN2+ Fn-12
Einsetzen von m = n in Gleichung (2)
F2n= (Fn-1+ Fn+1)FN= (2Fn-1+ FN)FN——–
(Indem man Fn+1 = Fn + Fn-1 setzt)
Um die Formel zu beweisen, müssen wir lediglich Folgendes tun
- Wenn n gerade ist, können wir k = n/2 setzen
- Wenn n ungerade ist, können wir k = (n+1)/2 setzen
Nachfolgend finden Sie die Umsetzung des oben genannten Ansatzes
C++
// Fibonacci-Reihe mit optimierter Methode
#include
verwenden Namensraum std;
Leere multiplizieren(int F[2][2],int M[2][2]);
Leere Leistung(int F[2][2],int N);
// Funktion, die die n-te Fibonacci-Zahl zurückgibt
int Flunkerei(int N)
{
int F[2][2] = { { 1, 1 }, { 1, 0 } };
Wenn (n == 0)
zurückkehren 0;
Leistung(F, n - 1);
zurückkehren F[0][0];
}
// Optimierte Version von power() in Methode 4
Leere Leistung(int F[2][2],int N)
{
Wenn (n == 0 || n == 1)
zurückkehren;
int M[2][2] = { { 1, 1 }, { 1, 0 } };
Leistung(F, n / 2);
multipliziere(F, F);
Wenn (n % 2 != 0)
multipliziere(F, M);
}
Leere multiplizieren(int F[2][2],int M[2][2])
{
int x = F[0][0] * M[0][0] + F[0][1] * M[1][0];
int y = F[0][0] * M[0][1] + F[0][1] * M[1][1];
int z = F[1][0] * M[0][0] + F[1][1] * M[1][0];
int w = F[1][0] * M[0][1] + F[1][1] * M[1][1];
F[0][0] = x;
F[0][1] = y;
F[1][0] = z;
F[1][1] = w;
}
// Treibercode
int hauptsächlich()
{
int n = 9;
cout << fib(9);
getchar();
zurückkehren 0;
}
// Dieser Code wurde von Nidhi_biet beigesteuert
C
#include
Leere multiplizieren(int F[2][2],int M[2][2]);
Leere Leistung(int F[2][2],int N);
/* Funktion, die die n-te Fibonacci-Zahl zurückgibt */
int Flunkerei(int N)
{
int F[2][2] = { { 1, 1 }, { 1, 0 } };
Wenn (n == 0)
zurückkehren 0;
Leistung(F, n - 1);
zurückkehren F[0][0];
}
/* Optimierte Version von power() in Methode 4 */
Leere Leistung(int F[2][2],int N)
{
Wenn (n == 0 || n == 1)
zurückkehren;
int M[2][2] = { { 1, 1 }, { 1, 0 } };
Leistung(F, n / 2);
multipliziere(F, F);
Wenn (n % 2 != 0)
multipliziere(F, M);
}
Leere multiplizieren(int F[2][2],int M[2][2])
{
int x = F[0][0] * M[0][0] + F[0][1] * M[1][0];
int y = F[0][0] * M[0][1] + F[0][1] * M[1][1];
int z = F[1][0] * M[0][0] + F[1][1] * M[1][0];
int w = F[1][0] * M[0][1] + F[1][1] * M[1][1];
F[0][0] = x;
F[0][1] = y;
F[1][0] = z;
F[1][1] = w;
}
/* Treiberprogramm zum Testen der oben genannten Funktion */
int hauptsächlich()
{
int n = 9;
printf("%D", fib(9));
getchar();
zurückkehren 0;
}
Java
// Fibonacci-Reihe mit optimierter Methode
öffentlich Klasse Fibonacci {
/* Funktion, die die n-te Fibonacci-Zahl zurückgibt */
statisch int Flunkerei(int N)
{
int F[][] =neu int[][] { {1,1 }, {1,0 } };
Wenn (n ==0)
zurückkehren 0;
Leistung(F, n -1);
zurückkehren F[0][0];
}
statisch Leere multiplizieren(int F[][],int M[][])
{
int x = F[0][0] * M[0][0] + F[0][1] * M[1][0];
int y = F[0][0] * M[0][1] + F[0][1] * M[1][1];
int z = F[1][0] * M[0][0] + F[1][1] * M[1][0];
int w = F[1][0] * M[0][1] + F[1][1] * M[1][1];
F[0][0] = x;
F[0][1] = y;
F[1][0] = z;
F[1][1] = w;
}
/* Optimierte Version von power() in Methode 4 */
statisch Leere Leistung(int F[][],int N)
{
Wenn (n ==0 || n ==1)
zurückkehren;
int M[][] =neu int[][] { {1,1 }, {1,0 } };
Leistung(F, n /2);
multipliziere(F, F);
Wenn (N %2 !=0)
multipliziere(F, M);
}
/* Treiberprogramm zum Testen der oben genannten Funktion */
öffentlich statisch Leere main(String args[])
{
int n =9;
System.out.println(fib(n));
}
};
/* Dieser Code wurde von Rajat Mishra beigesteuert */
Python3
# Verwendung der Fibonacci-Reihe
# Optimierte Methode
# Funktion, die n-tes zurückgibt
# Fibonacci-Zahl
def fib(n):
F= [[1,1],
[1,0]]
Wenn (N== 0):
zurückkehren 0
Leistung(F, n- 1)
zurückkehren F[0][0]
def multiplizieren(F, M):
X= (F[0][0]* M[0][0]+
F[0][1]* M[1][0])
j= (F[0][0]* M[0][1]+
F[0][1]* M[1][1])
z= (F[1][0]* M[0][0]+
F[1][1]* M[1][0])
w= (F[1][0]* M[0][1]+
F[1][1]* M[1][1])
F[0][0]= X
F[0][1]= j
F[1][0]= z
F[1][1]= w
# Optimierte Version von
# power() in Methode 4
def Leistung(F, n):
Wenn(N== 0 oder N== 1):
zurückkehren
M= [[1,1],
[1,0]]
Leistung(F, n// 2)
multiplizieren(F, F)
Wenn (N% 2 != 0):
multiplizieren(F, M)
# Fahrercode
Wenn __Name__== "__hauptsächlich__":
N= 9
drucken(fib(n))
# Dieser Code wurde beigesteuert
# von ChitraNayal
C#
// Fibonacci-Reihe mit
// Optimierte Methode
verwenden System;
Klasse GFG {
/* Funktion, die zurückgibt
n-te Fibonacci-Zahl */
statisch int Flunkerei(int N)
{
int[, ] F =neu int[, ] { { 1, 1 }, { 1, 0 } };
Wenn (n == 0)
zurückkehren 0;
Leistung(F, n - 1);
zurückkehren F[0, 0];
}
statisch Leere multiplizieren(int[, ] F,int[, ] M)
{
int x = F[0, 0] * M[0, 0] + F[0, 1] * M[1, 0];
int y = F[0, 0] * M[0, 1] + F[0, 1] * M[1, 1];
int z = F[1, 0] * M[0, 0] + F[1, 1] * M[1, 0];
int w = F[1, 0] * M[0, 1] + F[1, 1] * M[1, 1];
F[0, 0] = x;
F[0, 1] = y;
F[1, 0] = z;
F[1, 1] = w;
}
/* Optimierte Version von
power() in Methode 4 */
statisch Leere Leistung(int[, ] F,int N)
{
Wenn (n == 0 || n == 1)
zurückkehren;
int[, ] M =neu int[, ] { { 1, 1 }, { 1, 0 } };
Leistung(F, n / 2);
multipliziere(F, F);
Wenn (n % 2 != 0)
multipliziere(F, M);
}
// Treibercode
öffentlich statisch Leere Hauptsächlich()
{
int n = 9;
Console.Write(fib(n));
}
}
// Dieser Code wurde beigesteuert
// von ChitraNayal
Javascript
// Fibonacci-Reihe mit optimierter Methode
// Funktion, die die n-te Fibonacci-Zahl zurückgibt
Funktion fib(n)
{
War F = [ [ 1, 1 ], [ 1, 0 ] ];
Wenn (n == 0)
zurückkehren 0;
Leistung(F, n - 1);
zurückkehren F[0][0];
}
Funktion multiplizieren(F, M)
{
War x = F[0][0] * M[0][0] + F[0][1] * M[1][0];
War y = F[0][0] * M[0][1] + F[0][1] * M[1][1];
War z = F[1][0] * M[0][0] + F[1][1] * M[1][0];
War w = F[1][0] * M[0][1] + F[1][1] * M[1][1];
F[0][0] = x;
F[0][1] = y;
F[1][0] = z;
F[1][1] = w;
}
// Optimierte Version von power() in Methode 4 */
Funktion Leistung(F, n)
{
Wenn (n == 0 || n == 1)
zurückkehren;
War M = [ [ 1, 1 ], [ 1, 0 ] ];
Leistung(F, n / 2);
multipliziere(F, F);
Wenn (n % 2 != 0)
multipliziere(F, M);
}
// Treibercode
War n = 9;
document.write(fib(n));
// Dieser Code wurde von gauravrajput1 beigesteuert
Ausgang
34
Zeitkomplexität: O(Log n)
Hilfsraum:O(Log n), wenn wir die Größe des Funktionsaufrufstapels berücksichtigen, andernfalls O(1).
In Verbindung stehende Artikel:
Große Fibonacci-Zahlen in Java
Letzte Aktualisierung :14. Juli 2023
Gefällt mir Artikel
Artikel speichern
FAQs
What is the 10 nth Fibonacci number? ›
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181.
How do you find the 10th number in the Fibonacci sequence? ›The first 10 Fibonacci numbers are 1, 1, 2, 3, 5, 8, 13, 21, 34, 55. To find these numbers, we start with the fact that the first two Fibonacci numbers are both 1, and then we calculate each subsequent number in the Fibonacci sequence by adding the two preceding terms.
How do you write a program to check a given number is Fibonacci or not? ›def is_fib_number(num): a = 0 b = 1 while b<num: c = a+b a = b b = c if b==num or a==num: return True if b > num: return False num = 13 if is_fib_number(num): print(f"{num} is a fibonacci number.") else: print(f"{num} is not a fibonacci number.")
How do you write a Python program to check if a given number is a Fibonacci number? ›num=int(input("Enter the number you want to check\n")) temp=1 k=0 a=0 summ=0 while summ<=num: summ=temp+k temp=summ k=temp if summ==num: a=a+1 print("Yes. {} is a fibonnaci number". format(num)) break if a==0: print("No. {} is NOT a fibonacci number".
How do you calculate the nth term in the Fibonacci sequence? ›The Fibonacci sequence formula deals with the Fibonacci sequence, finding its missing terms. The Fibonacci formula is given as, Fn = Fn-1 + Fn-2, where n > 1. It is used to generate a term of the sequence by adding its previous two terms.
What is the sum of the first 10 terms Fibonacci numbers? ›Thus, the sum of the first ten Fibonacci numbers is 88.
What is the tenth term of the sequence 1 1 2 3 5 8? ›tenth term in Fibonacci series is 55.
What is the sequence 1 1 2 3 5 8? ›The sequence follows the rule that each number is equal to the sum of the preceding two numbers. The Fibonacci sequence begins with the following 14 integers: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233 ... Each number, starting with the third, adheres to the prescribed formula.
How do you write Fibonacci code? ›- #include<stdio.h>
- int main()
- {
- int n1=0,n2=1,n3,i,number;
- printf("Enter the number of elements:");
- scanf("%d",&number);
- printf("\n%d %d",n1,n2);//printing 0 and 1.
- for(i=2;i<number;++i)//loop starts from 2 because 0 and 1 are already printed.
Method: 1 - By using a while loop
We will use a while loop for printing the sequence of the Fibonacci sequence. Step 2: Initialize the count = 0, n_1 = 0 and n_2 = 1. Step 5: if n_terms = 1, it will print n_1 value. Step9: we will update the variable, n_1 = n_2, n_2 = nth and so on, up to the required term.
How do you write a Fibonacci series with a while loop in Python? ›
Input the number of values we want to generate the Fibonacci sequence and initialize a=0, b=1, sum=0, and count=1. Start a while loop using the condition count<=n and print the sum every time the condition works. Increment the count variable, swap 'a' and 'b,' and store the addition of a and b in the sum.
What is Fibonacci series in Python example? ›The Fibonacci numbers are the numbers in the following integer sequence. 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, …….. In mathematical terms, the sequence Fn of Fibonacci numbers is defined by the recurrence relation.
What is the pattern of 1 1 2 3 5 8 in Java? ›In Java, a Fibonacci series is a sequence of numbers in which every third number equals the sum of the preceding two numbers. The fibonacci series' first two integers are 0 and 1. The Fibonacci Series Looks like this : 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89.............
What is the 9th and 10th term of Fibonacci sequence? ›9th term is 34 and 10th term is 55 .
Is the 10th number in the Fibonacci sequence 34? ›Answer: The 10th term is 34. Step-by-step explanation: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377 and so on.