# Interesting facts about Fibonacci numbers

We know Fibonacci number, Fn = Fn-1 + Fn-2.

First few Fibonacci numbers are 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, …. .

Here are some interesting facts about Fibonacci number :

1. Pattern in Last digits of Fibonacci numbers :
Last digits of first few Fibonacci Numbers are :

`0, 1, 1, 2, 3, 5, 8, 3, 1, 4, 5, 9, 4, 3, 7, 0, 7, ... `

The series of last digits repeats with a cycle length of 60 (Refer this for explanations of this result).

## C

 `// C program to demonstrate that sequence of last  ` `// digits of Fibonacci numbers repeats after 60. ` `#include ` `#define max 100 ` `int` `main() ` `{ ` `    ``long` `long` `int` `arr[max]; ` `    ``arr = 0; ` `    ``arr = 1; ` ` `  `    ``// storing Fibonacci numbers ` `    ``for` `(``int` `i = 2; i < max; i++) ` `        ``arr[i] = arr[i-1] + arr[i-2]; ` ` `  `    ``// Traversing through store numbers ` `    ``for` `(``int` `i = 1; i < max - 1; i++) ` `    ``{ ` `        ``// Since first two number are 0 and 1 ` `        ``// so, if any two consecutive number encounter 0 and 1 ` `        ``// at their unit place, then it clearly means that ` `        ``// number is repeating/ since we just have to find ` `        ``// the sum of previous two number ` `        ``if` `((arr[i] % 10 == 0) && (arr[i+1] % 10 == 1)) ` `            ``break``; ` `    ``} ` `    ``printf``(``"Sequence is repeating after index %d"``, i); ` `} `

## Java

 `// Java program to demonstrate that sequence of last  ` `// digits of Fibonacci numbers repeats after 60.  ` ` `  `class` `GFG{ ` `static` `int` `max=``100``;  ` `public` `static` `void` `main(String[] args)  ` `{  ` `    ``long``[] arr=``new` `long``[max];  ` `    ``arr[``0``] = ``0``;  ` `    ``arr[``1``] = ``1``; ` `    ``int` `i=``0``; ` ` `  `    ``// storing Fibonacci numbers  ` `    ``for` `(i = ``2``; i < max; i++)  ` `        ``arr[i] = arr[i-``1``] + arr[i-``2``];  ` ` `  `    ``// Traversing through store numbers  ` `    ``for` `(i = ``1``; i < max - ``1``; i++)  ` `    ``{  ` `        ``// Since first two number are 0 and 1  ` `        ``// so, if any two consecutive number encounter 0 and 1  ` `        ``// at their unit place, then it clearly means that  ` `        ``// number is repeating/ since we just have to find  ` `        ``// the sum of previous two number  ` `        ``if` `((arr[i] % ``10` `== ``0``) && (arr[i+``1``] % ``10` `== ``1``))  ` `            ``break``;  ` `    ``}  ` `    ``System.out.println(``"Sequence is repeating after index "``+i);  ` `}  ` `} ` `// This code is conributed by mits `

## Python3

 `# Python3 program to demonstrate that sequence of last ` `# digits of Fibonacci numbers repeats after 60. ` ` `  ` `  `if` `__name__``=``=``'__main__'``: ` `    ``max` `=` `100` `    ``arr ``=` `[``0` `for` `i ``in` `range``(``max``)] ` `    ``arr[``0``] ``=` `0` `    ``arr[``1``] ``=` `1` ` `  `# storing Fibonacci numbers ` `    ``for` `i ``in` `range``(``2``, ``max``): ` `        ``arr[i] ``=` `arr[i ``-` `1``] ``+` `arr[i ``-` `2``] ` ` `  `    ``# Traversing through store numbers ` `    ``for` `i ``in` `range``(``1``, ``max` `-` `1``): ` `         `  ` `  `    ``# Since first two number are 0 and 1 ` `    ``# so, if any two consecutive number encounter 0 and 1 ` `    ``# at their unit place, then it clearly means that ` `    ``# number is repeating/ since we just have to find ` `    ``# the sum of previous two number ` `        ``if``((arr[i] ``%` `10` `=``=` `0``) ``and` `(arr[i ``+` `1``] ``%` `10` `=``=` `1``)): ` `            ``break` ` `  `    ``print``(``"Sequence is repeating after index"``, i) ` ` `  `# This code is contributed by ` `# Sanjit_Prasad `

## C#

 `// C# program to demonstrate that sequence of last  ` `// digits of Fibonacci numbers repeats after 60.  ` ` `  `class` `GFG{ ` `static` `int` `max=100;  ` `public` `static` `void` `Main()  ` `{  ` `    ``long``[] arr=``new` `long``[max];  ` `    ``arr = 0;  ` `    ``arr = 1; ` `    ``int` `i=0; ` ` `  `    ``// storing Fibonacci numbers  ` `    ``for` `(i = 2; i < max; i++)  ` `        ``arr[i] = arr[i-1] + arr[i-2];  ` ` `  `    ``// Traversing through store numbers  ` `    ``for` `(i = 1; i < max - 1; i++)  ` `    ``{  ` `        ``// Since first two number are 0 and 1  ` `        ``// so, if any two consecutive number encounter 0 and 1  ` `        ``// at their unit place, then it clearly means that  ` `        ``// number is repeating/ since we just have to find  ` `        ``// the sum of previous two number  ` `        ``if` `((arr[i] % 10 == 0) && (arr[i+1] % 10 == 1))  ` `            ``break``;  ` `    ``}  ` `    ``System.Console.WriteLine(``"Sequence is repeating after index "``+i);  ` `}  ` `} ` `// This code is conributed by mits `

## PHP

 ` `

Output:

```Sequence is repeating after index 60
```

2. Factors of Fibonacci number : On careful observation, we can observe the following thing :

• Every 3-rd Fibonacci number is a multiple of 2
• Every 4-th Fibonacci number is a multiple of 3
• Every 5-th Fibonacci number is a multiple of 5
• Every 6-th Fibonacci number is a multiple of 8

Refer this for details.

## C

 `// C program to demonstrate divisibility of Fibonacci ` `// numbers. ` `#include ` `#define MAX 90 ` ` `  `int` `main() ` `{ ` `    ``// indexes variable stores index of number that ` `    ``// is divisible by 2, 3, 5 and 8 ` `    ``long` `long` `int` `arr[MAX], index1[MAX], index2[MAX]; ` `    ``long` `long` `int` `index3[MAX], index4[MAX]; ` ` `  `    ``// storing fibonacci numbers ` `    ``arr = 0; ` `    ``arr = 1; ` `    ``for` `(``int` `i = 2; i < MAX; i++) ` `        ``arr[i] = arr[i-1] + arr[i-2]; ` ` `  `    ``// c1 keeps track of number of index of number ` `    ``// divisible by 2 and others c2, c3 and c4 for ` `    ``// 3, 5 and 8 ` `    ``int` `c1 = 0, c2 = 0, c3 = 0, c4 = 0; ` ` `  `    ``// separating fibonacci number into their ` `    ``// respective array ` `    ``for` `(``int` `i = 0; i < MAX; i++) ` `    ``{ ` `        ``if` `(arr[i] % 2 == 0) ` `            ``index1[c1++] = i; ` `        ``if` `(arr[i] % 3 == 0) ` `            ``index2[c2++] = i; ` `        ``if` `(arr[i] % 5 == 0) ` `            ``index3[c3++] = i; ` `        ``if` `(arr[i] % 8 == 0) ` `            ``index4[c4++] = i; ` `    ``} ` ` `  `    ``// printing index arrays ` `    ``printf``(``"Index of Fibonacci numbers divisible by"` `           ``" 2 are :\n"``); ` `    ``for` `(``int` `i = 0; i < c1; i++) ` `        ``printf``(``"%d  "``, index1[i]); ` `    ``printf``(``"\n"``); ` ` `  `    ``printf``(``"Index of Fibonacci number divisible by"` `           ``" 3 are :\n"``); ` `    ``for` `(``int` `i = 0; i < c2; i++) ` `        ``printf``(``"%d  "``, index2[i]); ` `    ``printf``(``"\n"``); ` ` `  `    ``printf``(``"Index of Fibonacci number divisible by"` `           ``" 5 are :\n"``); ` `    ``for` `(``int` `i = 0; i < c3; i++) ` `        ``printf``(``"%d  "``, index3[i]); ` `    ``printf``(``"\n"``); ` ` `  `    ``printf``(``"Index of Fibonacci number divisible by"` `           ``" 8 are :\n"``); ` `    ``for` `(``int` `i = 0; i < c4; i++) ` `        ``printf``(``"%d  "``, index4[i]); ` `    ``printf``(``"\n"``); ` `} `

## Java

 `// Java program to demonstrate divisibility of Fibonacci  ` `// numbers.  ` ` `  `class` `GFG ` `{ ` `static` `int` `MAX=``90``;  ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args)  ` `{  ` `    ``// indexes variable stores index of number that  ` `    ``// is divisible by 2, 3, 5 and 8  ` `    ``long``[] arr=``new` `long``[MAX]; ` `    ``long``[] index1=``new` `long``[MAX]; ` `    ``long``[] index2=``new` `long``[MAX];  ` `    ``long``[] index3=``new` `long``[MAX]; ` `    ``long``[] index4=``new` `long``[MAX];  ` ` `  `    ``// storing fibonacci numbers  ` `    ``arr[``0``] = ``0``;  ` `    ``arr[``1``] = ``1``;  ` `    ``for` `(``int` `i = ``2``; i < MAX; i++)  ` `        ``arr[i] = arr[i - ``1``] + arr[i - ``2``];  ` ` `  `    ``// c1 keeps track of number of index of number  ` `    ``// divisible by 2 and others c2, c3 and c4 for  ` `    ``// 3, 5 and 8  ` `    ``int` `c1 = ``0``, c2 = ``0``, c3 = ``0``, c4 = ``0``;  ` ` `  `    ``// separating fibonacci number into their  ` `    ``// respective array  ` `    ``for` `(``int` `i = ``0``; i < MAX; i++)  ` `    ``{  ` `        ``if` `(arr[i] % ``2` `== ``0``)  ` `            ``index1[c1++] = i;  ` `        ``if` `(arr[i] % ``3` `== ``0``)  ` `            ``index2[c2++] = i;  ` `        ``if` `(arr[i] % ``5` `== ``0``)  ` `            ``index3[c3++] = i;  ` `        ``if` `(arr[i] % ``8` `== ``0``)  ` `            ``index4[c4++] = i;  ` `    ``}  ` ` `  `    ``// printing index arrays  ` `    ``System.out.print(``"Index of Fibonacci numbers divisible by"` `+ ` `        ``" 2 are :\n"``);  ` `    ``for` `(``int` `i = ``0``; i < c1; i++)  ` `        ``System.out.print(index1[i] + ``" "``);  ` `    ``System.out.print(``"\n"``);  ` ` `  `    ``System.out.print(``"Index of Fibonacci number divisible by"` `+ ` `        ``" 3 are :\n"``);  ` `    ``for` `(``int` `i = ``0``; i < c2; i++)  ` `        ``System.out.print(index2[i] + ``" "``);  ` `    ``System.out.print(``"\n"``);  ` ` `  `    ``System.out.print(``"Index of Fibonacci number divisible by"` `+  ` `        ``" 5 are :\n"``);  ` `    ``for` `(``int` `i = ``0``; i < c3; i++)  ` `        ``System.out.print(index3[i] + ``" "``);  ` `    ``System.out.print(``"\n"``);  ` ` `  `    ``System.out.print(``"Index of Fibonacci number divisible by"` `+ ` `        ``" 8 are :\n"``);  ` `    ``for` `(``int` `i = ``0``; i < c4; i++)  ` `        ``System.out.print(index4[i] + ``" "``);  ` `    ``System.out.print(``"\n"``);  ` `}  ` `} ` ` `  `// This code is contributed by mits `

## Python3

 `# Python3 program to demonstrate divisibility ` `# of Fibonacci numbers.  ` `MAX` `=` `90``;  ` ` `  `# indexes variable stores index of number  ` `# that is divisible by 2, 3, 5 and 8  ` `arr ``=` `[``0``] ``*` `(``MAX``); ` `index1 ``=` `[``0``] ``*` `(``MAX``); ` `index2 ``=` `[``0``] ``*` `(``MAX``);  ` `index3 ``=` `[``0``] ``*` `(``MAX``); ` `index4 ``=` `[``0``] ``*` `(``MAX``);  ` ` `  `# storing fibonacci numbers  ` `arr[``0``] ``=` `0``;  ` `arr[``1``] ``=` `1``;  ` `for` `i ``in` `range``(``2``, ``MAX``):  ` `    ``arr[i] ``=` `arr[i ``-` `1``] ``+` `arr[i ``-` `2``];  ` ` `  `# c1 keeps track of number of index  ` `# of number divisible by 2 and others   ` `# c2, c3 and c4 for 3, 5 and 8  ` `c1, c2, c3, c4 ``=` `0``, ``0``, ``0``, ``0``; ` ` `  `# separating fibonacci number into ` `# their respective array  ` `for` `i ``in` `range``(``MAX``):  ` `    ``if` `(arr[i] ``%` `2` `=``=` `0``):  ` `        ``index1[c1] ``=` `i; ` `        ``c1 ``+``=` `1``; ` `    ``if` `(arr[i] ``%` `3` `=``=` `0``):  ` `        ``index2[c2] ``=` `i; ` `        ``c2 ``+``=` `1``; ` `    ``if` `(arr[i] ``%` `5` `=``=` `0``):  ` `        ``index3[c3] ``=` `i; ` `        ``c3 ``+``=` `1``; ` `    ``if` `(arr[i] ``%` `8` `=``=` `0``):  ` `        ``index4[c4] ``=` `i; ` `        ``c4 ``+``=` `1``; ` ` `  `# printing index arrays  ` `print``(``"Index of Fibonacci numbers"``, ` `           ``"divisible by 2 are :"``);  ` `for` `i ``in` `range``(c1):  ` `    ``print``(index1[i], end ``=` `" "``);  ` `print``("");  ` ` `  `print``(``"Index of Fibonacci number"``,  ` `          ``"divisible by 3 are :"``);  ` `for` `i ``in` `range``(c2):  ` `    ``print``(index2[i], end ``=` `" "``);  ` `print``("");  ` ` `  `print``(``"Index of Fibonacci number"``,  ` `          ``"divisible by 5 are :"``);  ` `for` `i ``in` `range``(c3):  ` `    ``print``(index3[i], end ``=` `" "``);  ` `print``("");  ` ` `  `print``(``"Index of Fibonacci number"``,  ` `          ``"divisible by 8 are :"``);  ` `for` `i ``in` `range``(c4):  ` `    ``print``(index4[i], end ``=` `" "``);  ` `print``(""); ` ` `  `# This code is contributed by mits `

## C#

 `// C# program to demonstrate divisibility  ` `// of Fibonacci numbers.  ` ` `  `class` `GFG{ ` `static` `int` `MAX = 90;  ` ` `  `static` `void` `Main()  ` `{  ` `    ``// indexes variable stores index of number that  ` `    ``// is divisible by 2, 3, 5 and 8  ` `    ``long``[] arr = ``new` `long``[MAX]; ` `    ``long``[] index1 = ``new` `long``[MAX]; ` `    ``long``[] index2 = ``new` `long``[MAX];  ` `    ``long``[] index3 = ``new` `long``[MAX]; ` `    ``long``[] index4 = ``new` `long``[MAX];  ` ` `  `    ``// storing fibonacci numbers  ` `    ``arr = 0;  ` `    ``arr = 1;  ` `    ``for` `(``int` `i = 2; i < MAX; i++)  ` `        ``arr[i] = arr[i-1] + arr[i-2];  ` ` `  `    ``// c1 keeps track of number of index of number  ` `    ``// divisible by 2 and others c2, c3 and c4 for  ` `    ``// 3, 5 and 8  ` `    ``int` `c1 = 0, c2 = 0, c3 = 0, c4 = 0;  ` ` `  `    ``// separating fibonacci number into their  ` `    ``// respective array  ` `    ``for` `(``int` `i = 0; i < MAX; i++)  ` `    ``{  ` `        ``if` `(arr[i] % 2 == 0)  ` `            ``index1[c1++] = i;  ` `        ``if` `(arr[i] % 3 == 0)  ` `            ``index2[c2++] = i;  ` `        ``if` `(arr[i] % 5 == 0)  ` `            ``index3[c3++] = i;  ` `        ``if` `(arr[i] % 8 == 0)  ` `            ``index4[c4++] = i;  ` `    ``}  ` ` `  `    ``// printing index arrays  ` `    ``System.Console.Write(``"Index of Fibonacci numbers"` `+  ` `                    ``"divisible by 2 are :\n"``);  ` `    ``for` `(``int` `i = 0; i < c1; i++)  ` `        ``System.Console.Write(index1[i]+``" "``);  ` `    ``System.Console.Write(``"\n"``);  ` ` `  `    ``System.Console.Write(``"Index of Fibonacci number "``+ ` `                        ``" divisible by 3 are :\n"``);  ` `    ``for` `(``int` `i = 0; i < c2; i++)  ` `        ``System.Console.Write(index2[i]+``" "``);  ` `    ``System.Console.Write(``"\n"``);  ` ` `  `    ``System.Console.Write(``"Index of Fibonacci number "``+ ` `        ``"divisible by 5 are :\n"``);  ` `    ``for` `(``int` `i = 0; i < c3; i++)  ` `        ``System.Console.Write(index3[i]+``" "``);  ` `    ``System.Console.Write(``"\n"``);  ` ` `  `    ``System.Console.Write(``"Index of Fibonacci number "``+ ` `        ``"divisible by 8 are :\n"``);  ` `    ``for` `(``int` `i = 0; i < c4; i++)  ` `        ``System.Console.Write(index4[i]+``" "``);  ` `    ``System.Console.Write(``"\n"``);  ` `}  ` `} ` ` `  `// This code is contributed by mits `

## PHP

 ` `

Output:

```Index of Fibonacci numbers divisible by 2 are :
0 3 6 9 12 15 18 21 24 27 30 33 36 39 42 45
48 51 54 57 60 63 66 69 72 75 78 81 84 87
Index of Fibonacci number divisible by 3 are :
0 4 8 12 16 20 24 28 32 36 40 44 48 52
56 60 64 68 72 76 80 84 88
Index of Fibonacci number divisible by 5 are :
0 5 10 15 20 25 30 35 40 45 50
55 60 65 70 75 80 85
Index of Fibonacci number divisible by 8 are :
0 6 12 18 24 30 36 42 48
54 60 66 72 78 84
```

3. Fibonacci number with index number factor : We have some Fibonacci number like F(1) = 1 which is divisible by 1, F(5) = 5 which is divisible by 5, F(12) = 144 which is divisible by 12, F(24) = 46368 which is divisible by 24, F(25) = 75025 which is divisible by 25. This type of index number follow a certain pattern. First, let’s keep a look on those index number :
1, 5, 12, 24, 25, 36, 48, 60, 72, 84, 96, 108, 120, 125, 132, …..
On observing it, this series is made up of every number that is multiple of 12 as well as all the number that satisfies the condition of pow(5, k), where k = 0, 1, 2, 3, 4, 5, 6, 7, …….

## C++

 `// C program to demonstrate that Fibonacci numbers ` `// that are divisible by their indexes have indexes ` `// as either power of 5 or multiple of 12. ` `#include ` `#define MAX 100 ` ` `  `int` `main() ` `{ ` `    ``// storing Fibonacci numbers ` `    ``long` `long` `int` `arr[MAX]; ` `    ``arr = 0; ` `    ``arr = 1; ` `    ``for` `(``int` `i = 2; i < MAX; i++) ` `        ``arr[i] = arr[i-1] + arr[i-2]; ` ` `  `    ``printf``(``"Fibonacci numbers divisible by "` `          ``"their indexes are :\n"``); ` `    ``for` `(``int` `i = 1; i < MAX; i++) ` `        ``if` `(arr[i] % i == 0) ` `            ``printf``(``"%d  "``, i); ` `} `

## Java

 `// Java program to demonstrate that Fibonacci numbers  ` `// that are divisible by their indexes have indexes  ` `// as either power of 5 or multiple of 12.  ` ` `  `class` `GFG ` `{ ` ` `  `static` `int` `MAX = ``100``;  ` ` `  `public` `static` `void` `main(String[] args)  ` `{  ` `    ``// storing Fibonacci numbers  ` `    ``long``[] arr = ``new` `long``[MAX];  ` `    ``arr[``0``] = ``0``;  ` `    ``arr[``1``] = ``1``;  ` `    ``for` `(``int` `i = ``2``; i < MAX; i++)  ` `        ``arr[i] = arr[i - ``1``] + arr[i - ``2``];  ` ` `  `    ``System.out.print(``"Fibonacci numbers divisible by "``+ ` `        ``"their indexes are :\n"``);  ` `    ``for` `(``int` `i = ``1``; i < MAX; i++)  ` `        ``if` `(arr[i] % i == ``0``)  ` `            ``System.out.print(i + ``" "``);  ` `} ` `} ` ` `  `// This code is contributed by mits `

## Python3

 `# Python3 program to demonstrate that Fibonacci numbers ` `# that are divisible by their indexes have indexes ` `# as either power of 5 or multiple of 12. ` ` `  `if` `__name__``=``=``'__main__'``: ` `    ``MAX` `=` `100` `# storing Fibonacci numbers ` `    ``arr ``=` `[``0` `for` `i ``in` `range``(``MAX``)] ` `    ``arr[``0``] ``=` `0` `    ``arr[``1``] ``=` `1` `    ``for` `i ``in` `range``(``2``, ``MAX``): ` `        ``arr[i] ``=` `arr[i ``-` `1``] ``+` `arr[i ``-` `2``] ` ` `  `    ``print``(``"Fibonacci numbers divisible by their indexes are :"``) ` `    ``for` `i ``in` `range``(``1``, ``MAX``): ` `        ``if``(arr[i] ``%` `i ``=``=` `0``): ` `            ``print``(i,end``=``" "``) ` ` `  `# This code is contributed by ` `# Sanjit_Prasad `

## C#

 `// C# program to demonstrate that Fibonacci  ` `// numbers that are divisible by their  ` `// indexes have indexes as either power of 5  ` `// or multiple of 12.  ` `using` `System; ` ` `  `class` `GFG ` `{ ` `static` `int` `MAX = 100;  ` `static` `void` `Main()  ` `{  ` `    ``// storing Fibonacci numbers  ` `    ``long``[] arr = ``new` `long``[MAX];  ` `    ``arr = 0;  ` `    ``arr = 1;  ` `    ``for` `(``int` `i = 2; i < MAX; i++)  ` `        ``arr[i] = arr[i - 1] + arr[i - 2];  ` ` `  `    ``Console.Write(``"Fibonacci numbers divisible by "` `+ ` `                           ``"their indexes are :\n"``);  ` `    ``for` `(``int` `i = 1; i < MAX; i++)  ` `        ``if` `(arr[i] % i == 0)  ` `            ``System.Console.Write(i+``" "``);  ` `} ` `} ` ` `  `// This code is contributed by mits `

Output:

```Fibonacci numbers divisible by their indexes are :
1  5  12  24  25  36  48  60  72  96
```

4. Value of f(n-1)*f(n+1) – f(n)*f(n) is (-1)n. Please refer Cassini’s Identity for details.

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

2

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.