# Interesting facts about Fibonacci numbers

• Difficulty Level : Medium
• Last Updated : 27 May, 2022

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 ` `using` `namespace` `std;`   `#define max 100`   `int` `main()` `{` `    ``long` `long` `int` `arr[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` `        ``cout << i << endl;` `        ``if` `((arr[i] % 10 == 0) && (arr[i + 1] % 10 == 1)) {` `            ``break``;` `        ``}` `    ``}` `    ``cout << ``"Sequence is repeating after index "` `<< i` `         ``<< endl;` `}`

## 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] = 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``;` `    ``}` `    ``printf``(``"Sequence is repeating after index %d"``, i);` `}`   `// The code is contributed by Gautam goel (gautamgoel962)`

## 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 contributed 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] = 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.Console.WriteLine(``"Sequence is repeating after index "``+i); ` `} ` `}` `// This code is contributed by mits`

## PHP

 ``

## Javascript

 ``

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` `using` `namespace` `std;` `#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] = 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` `    ``cout<<``"Index of Fibonacci numbers divisible by"` `           ``" 2 are :\n"``;` `    ``for` `(``int` `i = 0; i < c1; i++)` `        ``cout<<``" "``<< index1[i];` `    ``cout<<``"\n"``;`   `    ``cout<<``"Index of Fibonacci number divisible by"` `           ``" 3 are :\n"``;` `    ``for` `(``int` `i = 0; i < c2; i++)` `        ``cout<<``"  "``<< index2[i];` `    ``cout<<``"\n"``;`   `    ``cout<<``"Index of Fibonacci number divisible by"` `           ``" 5 are :\n"``;` `    ``for` `(``int` `i = 0; i < c3; i++)` `        ``cout<<``"  "``<< index3[i];` `    ``cout<<``"\n"``;`   `    ``cout<<``"Index of Fibonacci number divisible by"` `           ``" 8 are :\n"``;` `    ``for` `(``int` `i = 0; i < c4; i++)` `        ``cout<<``" "``<

## 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] = 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` `    ``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] = 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.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

 ``

## Javascript

 `// JavaScript program to demonstrate divisibility of Fibonacci ` `// numbers. `   `var` `MAX=90; `   `// Driver code`   `    ``// indexes variable stores index of number that ` `    ``// is divisible by 2, 3, 5 and 8 ` `    ``var` `arr=``new` `Array(MAX);` `    ``var` `index1= ``new` `Array(MAX);` `    ``var` `index2= ``new` `Array(MAX); ` `    ``var` `index3= ``new` `Array(MAX);` `    ``var` `index4= ``new` `Array(MAX); `   `    ``// storing fibonacci numbers ` `    ``arr[0] = 0; ` `    ``arr[1] = 1; ` `    ``for` `(``var` `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 ` `    ``var` `c1 = 0, c2 = 0, c3 = 0, c4 = 0; `   `    ``// separating fibonacci number into their ` `    ``// respective array ` `    ``for` `(``var` `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 ` `    ``document.write(``"Index of Fibonacci numbers divisible by"` `+` `        ``" 2 are :\n"``); ` `    ``for` `(``var` `i = 0; i < c1; i++) ` `        ``document.write(index1[i] + ``" "``); ` `    ``document.write(``"\n"``); `   `    ``document.write(``"Index of Fibonacci number divisible by"` `+` `        ``" 3 are :\n"``); ` `    ``for` `(``var` `i = 0; i < c2; i++) ` `        ``document.write(index2[i] + ``" "``); ` `    ``document.write(``"\n"``); `   `    ``document.write(``"Index of Fibonacci number divisible by"` `+ ` `        ``" 5 are :\n"``); ` `    ``for` `(``var` `i = 0; i < c3; i++) ` `        ``document.write(index3[i] + ``" "``); ` `    ``document.write(``"\n"``); `   `    ``document.write(``"Index of Fibonacci number divisible by"` `+` `        ``" 8 are :\n"``); ` `    ``for` `(``var` `i = 0; i < c4; i++) ` `        ``document.write(index4[i] + ``" "``); ` `    ``document.write(``"\n"``); `       `// This code is contributed by shivanisinghss2110`

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` `using` `namespace` `std;` `#define MAX 100`   `int` `main()` `{` `  `  `    ``// storing Fibonacci numbers` `    ``long` `long` `int` `arr[MAX];` `    ``arr[0] = 0;` `    ``arr[1] = 1;` `    ``for` `(``int` `i = 2; i < MAX; i++)` `        ``arr[i] = arr[i-1] + arr[i-2];`   `    ``cout<<``"Fibonacci numbers divisible by "` `          ``"their indexes are :\n"``;` `    ``for` `(``int` `i = 1; i < MAX; i++)` `        ``if` `(arr[i] % i == 0)` `            ``cout<<``"  "``<< i;` `}`   `// This code is contributed by shivanisinghss2110`

## 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] = 0;` `    ``arr[1] = 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] = 0; ` `    ``arr[1] = 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`

## Javascript

 `// JavaScript program to demonstrate that Fibonacci numbers ` `// that are divisible by their indexes have indexes ` `// as either power of 5 or multiple of 12. `   `var` `MAX = 100; ` ` `  `    ``// storing Fibonacci numbers ` `    ``var` `arr = ``new` `Array(MAX); ` `    ``arr[0] = 0; ` `    ``arr[1] = 1; ` `    ``for` `(``var` `i = 2; i < MAX; i++) ` `        ``arr[i] = arr[i - 1] + arr[i - 2]; `   `    ``document.write(``"Fibonacci numbers divisible by their indexes are :"``); ` `    ``for` `(``var` `i = 1; i < MAX; i++) ` `        ``if` `(arr[i] % i == 0) ` `            ``document.write(i + ``" "``); `     `// This code is contributed by shivanisinghss2110`

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.

Reference :
http://www.maths.surrey.ac.uk/hosted-sites/R.Knott/Fibonacci/fibmaths.html