# Tribonacci Numbers

The tribonacci series is a generalization of the Fibonacci sequence where each term is the sum of the three preceding terms.

The Tribonacci Sequence :
0, 0, 1, 1, 2, 4, 7, 13, 24, 44, 81, 149, 274, 504, 927, 1705, 3136, 5768, 10609, 19513, 35890, 66012, 121415, 223317, 410744, 755476, 1389537, 2555757, 4700770, 8646064, 15902591, 29249425, 53798080, 98950096, 181997601, 334745777, 615693474, 1132436852… so on

General Form of Tribonacci number:

```a(n) = a(n-1) + a(n-2) + a(n-3)
with
a(0) = a(1) = 0, a(2) = 1.
```

Given a value N, task is to print first N Tribonacci Numbers.
Examples :

```Input : 5
Output : 0, 0, 1, 1, 2

Input : 10
Output : 0, 0, 1, 1, 2, 4, 7, 13, 24, 44

Input : 20
Output : 0, 0, 1, 1, 2, 4, 7, 13, 24, 44,
81, 149, 274, 504, 927, 1705, 3136,
5768, 10609, 19513
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

A simple solution is to simply follow recursive formula and write recursive code for it,

## C++

 `// A simple recursive CPP program to print ` `// first n Tribinacci numbers. ` `#include ` `using` `namespace` `std; ` ` `  `int` `printTribRec(``int` `n) ` `{ ` `    ``if` `(n == 0 || n == 1 || n == 2) ` `        ``return` `0; ` ` `  `    ``if` `(n == 3) ` `        ``return` `1; ` `    ``else` `        ``return` `printTribRec(n - 1) +  ` `               ``printTribRec(n - 2) +  ` `               ``printTribRec(n - 3); ` `} ` ` `  `void` `printTrib(``int` `n) ` `{ ` `    ``for` `(``int` `i = 1; i < n; i++) ` `        ``cout << printTribRec(i) << ``" "``; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `n = 10; ` `    ``printTrib(n); ` `    ``return` `0; ` `} `

## Java

 `// A simple recursive CPP program ` `// first n Tribinacci numbers. ` `import` `java.io.*; ` ` `  `class` `GFG { ` `     `  `    ``// Recursion Function ` `    ``static` `int` `printTribRec(``int` `n) ` `    ``{ ` `         `  `        ``if` `(n == ``0` `|| n == ``1` `|| n == ``2``) ` `            ``return` `0``; ` `             `  `        ``if` `(n == ``3``) ` `            ``return` `1``; ` `        ``else` `            ``return` `printTribRec(n - ``1``) +  ` `                   ``printTribRec(n - ``2``) + ` `                   ``printTribRec(n - ``3``); ` `    ``} ` `     `  `    ``static` `void` `printTrib(``int` `n) ` `    ``{ ` `        ``for` `(``int` `i = ``1``; i < n; i++) ` `            ``System.out.print(printTribRec(i) ` `                             ``+``" "``); ` `    ``} ` `      `  `    ``// Driver code ` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``int` `n = ``10``; ` ` `  `        ``printTrib(n); ` `    ``} ` `} ` ` `  `// This code is contributed by Nikita tiwari. `

## Python

 `# A simple recursive CPP program to print ` `# first n Tribinacci numbers. ` ` `  `def` `printTribRec(n) : ` `    ``if` `(n ``=``=` `0` `or` `n ``=``=` `1` `or` `n ``=``=` `2``) : ` `        ``return` `0` `    ``elif` `(n ``=``=` `3``) : ` `        ``return` `1` `    ``else` `: ` `        ``return` `(printTribRec(n ``-` `1``) ``+`  `                ``printTribRec(n ``-` `2``) ``+` `                ``printTribRec(n ``-` `3``)) ` `         `  ` `  `def` `printTrib(n) : ` `    ``for` `i ``in` `range``(``1``, n) : ` `        ``print``( printTribRec(i) , ``" "``, end ``=` `"") ` `         `  ` `  `# Driver code ` `n ``=` `10` `printTrib(n) ` ` `  ` `  `# This code is contributed by Nikita Tiwari. `

## C#

 `// A simple recursive C# program ` `// first n Tribinacci numbers. ` `using` `System; ` ` `  `class` `GFG { ` `     `  `    ``// Recursion Function ` `    ``static` `int` `printTribRec(``int` `n) ` `    ``{ ` `         `  `        ``if` `(n == 0 || n == 1 || n == 2) ` `            ``return` `0; ` `             `  `        ``if` `(n == 3) ` `            ``return` `1; ` `        ``else` `            ``return` `printTribRec(n - 1) +  ` `                   ``printTribRec(n - 2) + ` `                   ``printTribRec(n - 3); ` `    ``} ` `     `  `    ``static` `void` `printTrib(``int` `n) ` `    ``{ ` `        ``for` `(``int` `i = 1; i < n; i++) ` `            ``Console.Write(printTribRec(i) ` `                                    ``+``" "``); ` `    ``} ` `     `  `    ``// Driver code ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int` `n = 10; ` ` `  `        ``printTrib(n); ` `    ``} ` `} ` ` `  `// This code is contributed by vt_m. `

## PHP

 ` `

Output :

```0 0 1 1 2 4 7 13 24 44
```

Time complexity of above solution is exponential.

A better solution is to use Dynamic Programming.

## C++

 `// A DP based CPP ` `// program to print ` `// first n Tribinacci ` `// numbers. ` `#include ` `using` `namespace` `std; ` ` `  `int` `printTrib(``int` `n) ` `{ ` `    ``int` `dp[n]; ` `    ``dp = dp = 0; ` `    ``dp = 1; ` ` `  `    ``for` `(``int` `i = 3; i < n; i++) ` `        ``dp[i] = dp[i - 1] +  ` `                ``dp[i - 2] + ` `                ``dp[i - 3]; ` ` `  `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``cout << dp[i] << ``" "``; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `n = 10; ` `    ``printTrib(n); ` `    ``return` `0; ` `} `

## Java

 `// A DP based Java program ` `// to print first n ` `// Tribinacci numbers. ` `import` `java.io.*; ` ` `  `class` `GFG { ` `     `  `    ``static` `void` `printTrib(``int` `n) ` `    ``{ ` `        ``int` `dp[]=``new` `int``[n]; ` `        ``dp[``0``] = dp[``1``] = ``0``; ` `        ``dp[``2``] = ``1``; ` `     `  `        ``for` `(``int` `i = ``3``; i < n; i++) ` `            ``dp[i] = dp[i - ``1``] + ` `                    ``dp[i - ``2``] + ` `                    ``dp[i - ``3``]; ` `     `  `        ``for` `(``int` `i = ``0``; i < n; i++) ` `            ``System.out.print(dp[i] + ``" "``); ` `    ``} ` `     `  `    ``// Driver code ` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``int` `n = ``10``; ` `        ``printTrib(n); ` `    ``} ` `} ` ` `  `/* This code is contributed by Nikita Tiwari.*/`

## Python3

 `# A DP based ` `# Python 3  ` `# program to print ` `# first n Tribinacci ` `# numbers. ` ` `  `def` `printTrib(n) : ` ` `  `    ``dp ``=` `[``0``] ``*` `n ` `    ``dp[``0``] ``=` `dp[``1``] ``=` `0``; ` `    ``dp[``2``] ``=` `1``; ` ` `  `    ``for` `i ``in` `range``(``3``,n) : ` `        ``dp[i] ``=` `dp[i ``-` `1``] ``+` `dp[i ``-` `2``] ``+` `dp[i ``-` `3``]; ` ` `  `    ``for` `i ``in` `range``(``0``,n) : ` `        ``print``(dp[i] , ``" "``, end``=``"") ` `         `  ` `  `# Driver code ` `n ``=` `10` `printTrib(n) ` ` `  `# This code is contributed by Nikita Tiwari. `

## C#

 `// A DP based C# program ` `// to print first n ` `// Tribinacci numbers. ` `using` `System; ` ` `  `class` `GFG { ` `     `  `    ``static` `void` `printTrib(``int` `n) ` `    ``{ ` `        ``int` `[]dp = ``new` `int``[n]; ` `        ``dp = dp = 0; ` `        ``dp = 1; ` `     `  `        ``for` `(``int` `i = 3; i < n; i++) ` `            ``dp[i] = dp[i - 1] + ` `                    ``dp[i - 2] + ` `                    ``dp[i - 3]; ` `     `  `        ``for` `(``int` `i = 0; i < n; i++) ` `        ``Console.Write(dp[i] + ``" "``); ` `    ``} ` `     `  `    ``// Driver code ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int` `n = 10; ` `        ``printTrib(n); ` `    ``} ` `} ` ` `  `/* This code is contributed by vt_m.*/`

## PHP

 ` `

Output :

```0 0 1 1 2 4 7 13 24 44
```

Time complexity of above is linear, but it requires extra space. We can optimizes space used in above solution using three variables to keep track of previous three numbers.

## C++

 `// A space optimized ` `// based CPP program to ` `// print first n ` `// Tribinacci numbers. ` `#include ` `using` `namespace` `std; ` ` `  `void` `printTrib(``int` `n) ` `{ ` `    ``if` `(n < 1) ` `        ``return``; ` ` `  `    ``// Initialize first ` `    ``// three numbers ` `    ``int` `first = 0, second = 0; ` `    ``int` `third = 1; ` ` `  `    ``cout << first << ``" "``; ` `    ``if` `(n > 1) ` `        ``cout << second << ``" "``; ` `     `  `    ``if` `(n > 2) ` `        ``cout << second << ``" "``; ` ` `  `    ``// Loop to add previous  ` `    ``// three numbers for ` `    ``// each number starting  ` `    ``// from 3 and then assign ` `    ``// first, second, third ` `    ``// to second, third, and  ` `    ``// curr to third respectively ` `    ``for` `(``int` `i = 3; i < n; i++)  ` `    ``{ ` `        ``int` `curr = first + second + third; ` `        ``first = second; ` `        ``second = third; ` `        ``third = curr; ` ` `  `        ``cout << curr << ``" "``; ` `    ``} ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `n = 10; ` `    ``printTrib(n); ` `    ``return` `0; ` `} `

## Java

 `// A space optimized ` `// based Java program ` `// to print first n  ` `// Tribinacci numbers. ` `import` `java.io.*; ` ` `  `class` `GFG { ` `     `  `    ``static` `void` `printTrib(``int` `n) ` `    ``{ ` `        ``if` `(n < ``1``) ` `            ``return``; ` `     `  `        ``// Initialize first ` `        ``// three numbers ` `        ``int` `first = ``0``, second = ``0``; ` `        ``int` `third = ``1``; ` `     `  `        ``System.out.print(first + ``" "``); ` `        ``if` `(n > ``1``) ` `            ``System.out.print(second + ``" "``); ` `         `  `        ``if` `(n > ``2``) ` `            ``System.out.print(second + ``" "``); ` `     `  `        ``// Loop to add previous ` `        ``// three numbers for ` `        ``// each number starting ` `        ``// from 3 and then assign ` `        ``// first, second, third ` `        ``// to second, third, and curr ` `        ``// to third respectively ` `        ``for` `(``int` `i = ``3``; i < n; i++)  ` `        ``{ ` `            ``int` `curr = first + second + third; ` `            ``first = second; ` `            ``second = third; ` `            ``third = curr; ` `     `  `            ``System.out.print(curr +``" "``); ` `        ``} ` `    ``} ` `     `  `    ``// Driver code ` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``int` `n = ``10``; ` `        ``printTrib(n); ` `    ``} ` `} ` ` `  `// This code is contributed by Nikita Tiwari. `

## Python3

 `# A space optimized ` `# based Python 3  ` `# program to print ` `# first n Tribinacci  ` `# numbers. ` ` `  `def` `printTrib(n) : ` `    ``if` `(n < ``1``) : ` `        ``return` `  `  `    ``# Initialize first ` `    ``# three numbers ` `    ``first ``=` `0` `    ``second ``=` `0` `    ``third ``=` `1` ` `  `    ``print``( first , ``" "``, end``=``"") ` `    ``if` `(n > ``1``) : ` `        ``print``(second, ``" "``,end``=``"") ` `    ``if` `(n > ``2``) : ` `        ``print``(second, ``" "``, end``=``"") ` ` `  `    ``# Loop to add previous ` `    ``# three numbers for ` `    ``# each number starting ` `    ``# from 3 and then assign ` `    ``# first, second, third ` `    ``# to second, third, and curr ` `    ``# to third respectively ` `    ``for` `i ``in` `range``(``3``, n) : ` `        ``curr ``=` `first ``+` `second ``+` `third ` `        ``first ``=` `second ` `        ``second ``=` `third ` `        ``third ``=` `curr ` ` `  `        ``print``(curr , ``" "``, end``=``"") ` `     `  `     `  `# Driver code ` `n ``=` `10` `printTrib(n) ` ` `  `# This code is contributed by Nikita Tiwari. `

## C#

 `// A space optimized ` `// based C# program ` `// to print first n  ` `// Tribinacci numbers. ` `using` `System; ` ` `  `class` `GFG { ` `     `  `    ``static` `void` `printTrib(``int` `n) ` `    ``{ ` `        ``if` `(n < 1) ` `            ``return``; ` `     `  `        ``// Initialize first ` `        ``// three numbers ` `        ``int` `first = 0, second = 0; ` `        ``int` `third = 1; ` `     `  `        ``Console.Write(first + ``" "``); ` `        ``if` `(n > 1) ` `        ``Console.Write(second + ``" "``); ` `         `  `        ``if` `(n > 2) ` `        ``Console.Write(second + ``" "``); ` `     `  `        ``// Loop to add previous ` `        ``// three numbers for ` `        ``// each number starting ` `        ``// from 3 and then assign ` `        ``// first, second, third ` `        ``// to second, third, and curr ` `        ``// to third respectively ` `        ``for` `(``int` `i = 3; i < n; i++)  ` `        ``{ ` `            ``int` `curr = first + second + third; ` `            ``first = second; ` `            ``second = third; ` `            ``third = curr; ` `     `  `            ``Console.Write(curr +``" "``); ` `        ``} ` `    ``} ` `     `  `    ``// Driver code ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int` `n = 10; ` `        ``printTrib(n); ` `    ``} ` `} ` ` `  `// This code is contributed by vt_m. `

## PHP

 ` 1) ` `        ``echo` `\$second` `, ``" "``; ` `     `  `    ``if` `(``\$n` `> 2) ` `        ``echo` `\$second` `, ``" "``; ` ` `  `    ``// Loop to add previous  ` `    ``// three numbers for ` `    ``// each number starting  ` `    ``// from 3 and then assign ` `    ``// first, second, third ` `    ``// to second, third, and  ` `    ``// curr to third respectively ` `    ``for` `(``\$i` `= 3; ``\$i` `< ``\$n``; ``\$i``++)  ` `    ``{ ` `        ``\$curr` `= ``\$first` `+ ``\$second` `+ ``\$third``; ` `        ``\$first` `= ``\$second``; ` `        ``\$second` `= ``\$third``; ` `        ``\$third` `= ``\$curr``; ` ` `  `        ``echo` `\$curr` `, ``" "``; ` `    ``} ` `} ` ` `  `    ``// Driver code ` `    ``\$n` `= 10; ` `    ``printTrib(``\$n``); ` ` `  `// This code is contributed by m_kit ` `?> `

Output :

```0 0 0 1 2 4 7 13 24 44
```

Below is more efficient solution using matrix exponentiation.

## C++

 `#include ` `using` `namespace` `std; ` ` `  `// Program to print first n  ` `// tribonacci numbers Matrix  ` `// Multiplication function  ` `// for 3*3 matrix ` `void` `multiply(``int` `T, ``int` `M) ` `{ ` `    ``int` `a, b, c, d, e, f, g, h, i; ` `    ``a = T * M +  ` `        ``T * M +  ` `        ``T * M; ` `    ``b = T * M +  ` `        ``T * M +  ` `        ``T * M; ` `    ``c = T * M +  ` `        ``T * M +  ` `        ``T * M; ` `    ``d = T * M +  ` `        ``T * M +  ` `        ``T * M; ` `    ``e = T * M +  ` `        ``T * M +  ` `        ``T * M; ` `    ``f = T * M +  ` `        ``T * M +  ` `        ``T * M; ` `    ``g = T * M +  ` `        ``T * M +  ` `        ``T * M; ` `    ``h = T * M +  ` `        ``T * M +  ` `        ``T * M; ` `    ``i = T * M +  ` `        ``T * M +  ` `        ``T * M; ` `    ``T = a; ` `    ``T = b; ` `    ``T = c; ` `    ``T = d; ` `    ``T = e; ` `    ``T = f; ` `    ``T = g; ` `    ``T = h; ` `    ``T = i; ` `} ` ` `  `// Recursive function to raise  ` `// the matrix T to the power n ` `void` `power(``int` `T, ``int` `n) ` `{ ` `    ``// base condition. ` `    ``if` `(n == 0 || n == 1) ` `        ``return``; ` `    ``int` `M = {{ 1, 1, 1 },  ` `                   ``{ 1, 0, 0 },  ` `                   ``{ 0, 1, 0 }}; ` ` `  `    ``// recursively call to ` `    ``// square the matrix ` `    ``power(T, n / 2); ` ` `  `    ``// calculating square  ` `    ``// of the matrix T ` `    ``multiply(T, T); ` ` `  `    ``// if n is odd multiply  ` `    ``// it one time with M ` `    ``if` `(n % 2) ` `        ``multiply(T, M); ` `} ` `int` `tribonacci(``int` `n) ` `{ ` `    ``int` `T = {{ 1, 1, 1 },  ` `                   ``{ 1, 0, 0 }, ` `                   ``{ 0, 1, 0 }}; ` ` `  `    ``// base condition ` `    ``if` `(n == 0 || n == 1) ` `        ``return` `0; ` `    ``else` `        ``power(T, n - 2); ` ` `  `    ``// T contains the  ` `    ``// tribonacci number so ` `    ``// return it ` `    ``return` `T; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``int` `n = 10; ` `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``cout << tribonacci(i) << ``" "``; ` `    ``cout << endl; ` `    ``return` `0; ` `} `

## Java

 `// Java Program to print ` `// first n tribonacci numbers ` `// Matrix Multiplication ` `// function for 3*3 matrix ` `import` `java.io.*; ` ` `  `class` `GFG  ` `{ ` `    ``static` `void` `multiply(``int` `T[][], ``int` `M[][]) ` `    ``{ ` `        ``int` `a, b, c, d, e, f, g, h, i; ` `        ``a = T[``0``][``0``] * M[``0``][``0``] +  ` `            ``T[``0``][``1``] * M[``1``][``0``] +  ` `            ``T[``0``][``2``] * M[``2``][``0``]; ` `        ``b = T[``0``][``0``] * M[``0``][``1``] +  ` `            ``T[``0``][``1``] * M[``1``][``1``] +  ` `            ``T[``0``][``2``] * M[``2``][``1``]; ` `        ``c = T[``0``][``0``] * M[``0``][``2``] +  ` `            ``T[``0``][``1``] * M[``1``][``2``] +  ` `            ``T[``0``][``2``] * M[``2``][``2``]; ` `        ``d = T[``1``][``0``] * M[``0``][``0``] +  ` `            ``T[``1``][``1``] * M[``1``][``0``] +  ` `            ``T[``1``][``2``] * M[``2``][``0``]; ` `        ``e = T[``1``][``0``] * M[``0``][``1``] +  ` `            ``T[``1``][``1``] * M[``1``][``1``] +  ` `            ``T[``1``][``2``] * M[``2``][``1``]; ` `        ``f = T[``1``][``0``] * M[``0``][``2``] +  ` `            ``T[``1``][``1``] * M[``1``][``2``] +  ` `            ``T[``1``][``2``] * M[``2``][``2``]; ` `        ``g = T[``2``][``0``] * M[``0``][``0``] +  ` `            ``T[``2``][``1``] * M[``1``][``0``] +  ` `            ``T[``2``][``2``] * M[``2``][``0``]; ` `        ``h = T[``2``][``0``] * M[``0``][``1``] +  ` `            ``T[``2``][``1``] * M[``1``][``1``] +  ` `            ``T[``2``][``2``] * M[``2``][``1``]; ` `        ``i = T[``2``][``0``] * M[``0``][``2``] +  ` `            ``T[``2``][``1``] * M[``1``][``2``] +  ` `            ``T[``2``][``2``] * M[``2``][``2``]; ` `        ``T[``0``][``0``] = a; ` `        ``T[``0``][``1``] = b; ` `        ``T[``0``][``2``] = c; ` `        ``T[``1``][``0``] = d; ` `        ``T[``1``][``1``] = e; ` `        ``T[``1``][``2``] = f; ` `        ``T[``2``][``0``] = g; ` `        ``T[``2``][``1``] = h; ` `        ``T[``2``][``2``] = i; ` `    ``} ` `     `  `    ``// Recursive function to raise  ` `    ``// the matrix T to the power n ` `    ``static` `void` `power(``int` `T[][], ``int` `n) ` `    ``{ ` `        ``// base condition. ` `        ``if` `(n == ``0` `|| n == ``1``) ` `            ``return``; ` `        ``int` `M[][] = {{ ``1``, ``1``, ``1` `},  ` `                     ``{ ``1``, ``0``, ``0` `},  ` `                     ``{ ``0``, ``1``, ``0` `}}; ` `     `  `        ``// recursively call to  ` `        ``// square the matrix ` `        ``power(T, n / ``2``); ` `     `  `        ``// calculating square  ` `        ``// of the matrix T ` `        ``multiply(T, T); ` `     `  `        ``// if n is odd multiply ` `        ``// it one time with M ` `        ``if` `(n % ``2` `!= ``0``) ` `            ``multiply(T, M); ` `    ``} ` `    ``static` `int` `tribonacci(``int` `n) ` `    ``{ ` `        ``int` `T[][] = {{ ``1``, ``1``, ``1` `},  ` `                     ``{ ``1``, ``0``, ``0` `}, ` `                     ``{ ``0``, ``1``, ``0` `}}; ` `     `  `        ``// base condition ` `        ``if` `(n == ``0` `|| n == ``1``) ` `            ``return` `0``; ` `        ``else` `            ``power(T, n - ``2``); ` `     `  `        ``// T contains the  ` `        ``// tribonacci number so ` `        ``// return it ` `        ``return` `T[``0``][``0``]; ` `    ``} ` `     `  `    ``// Driver Code ` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``int` `n = ``10``; ` `        ``for` `(``int` `i = ``0``; i < n; i++) ` `        ``System.out.print(tribonacci(i) + ``" "``); ` `        ``System.out.println(); ` `    ``} ` `} ` ` `  `// This code is contributed by Nikita Tiwari. `

## Python 3

 `# Program to print first n tribonacci  ` `# numbers Matrix Multiplication ` `# function for 3*3 matrix ` `def` `multiply(T, M): ` `     `  `    ``a ``=` `(T[``0``][``0``] ``*` `M[``0``][``0``] ``+` `T[``0``][``1``] ``*` `         ``M[``1``][``0``] ``+` `T[``0``][``2``] ``*` `M[``2``][``0``])              ` `    ``b ``=` `(T[``0``][``0``] ``*` `M[``0``][``1``] ``+` `T[``0``][``1``] ``*`  `         ``M[``1``][``1``] ``+` `T[``0``][``2``] ``*` `M[``2``][``1``])  ` `    ``c ``=` `(T[``0``][``0``] ``*` `M[``0``][``2``] ``+` `T[``0``][``1``] ``*`  `         ``M[``1``][``2``] ``+` `T[``0``][``2``] ``*` `M[``2``][``2``]) ` `    ``d ``=` `(T[``1``][``0``] ``*` `M[``0``][``0``] ``+` `T[``1``][``1``] ``*`  `         ``M[``1``][``0``] ``+` `T[``1``][``2``] ``*` `M[``2``][``0``])  ` `    ``e ``=` `(T[``1``][``0``] ``*` `M[``0``][``1``] ``+` `T[``1``][``1``] ``*`  `         ``M[``1``][``1``] ``+` `T[``1``][``2``] ``*` `M[``2``][``1``]) ` `    ``f ``=` `(T[``1``][``0``] ``*` `M[``0``][``2``] ``+` `T[``1``][``1``] ``*` `         ``M[``1``][``2``] ``+` `T[``1``][``2``] ``*` `M[``2``][``2``]) ` `    ``g ``=` `(T[``2``][``0``] ``*` `M[``0``][``0``] ``+` `T[``2``][``1``] ``*`  `         ``M[``1``][``0``] ``+` `T[``2``][``2``] ``*` `M[``2``][``0``]) ` `    ``h ``=` `(T[``2``][``0``] ``*` `M[``0``][``1``] ``+` `T[``2``][``1``] ``*`  `         ``M[``1``][``1``] ``+` `T[``2``][``2``] ``*` `M[``2``][``1``]) ` `    ``i ``=` `(T[``2``][``0``] ``*` `M[``0``][``2``] ``+` `T[``2``][``1``] ``*`  `         ``M[``1``][``2``] ``+` `T[``2``][``2``] ``*` `M[``2``][``2``]) ` `             `  `    ``T[``0``][``0``] ``=` `a ` `    ``T[``0``][``1``] ``=` `b ` `    ``T[``0``][``2``] ``=` `c ` `    ``T[``1``][``0``] ``=` `d ` `    ``T[``1``][``1``] ``=` `e ` `    ``T[``1``][``2``] ``=` `f ` `    ``T[``2``][``0``] ``=` `g ` `    ``T[``2``][``1``] ``=` `h ` `    ``T[``2``][``2``] ``=` `i ` ` `  `# Recursive function to raise  ` `# the matrix T to the power n ` `def` `power(T, n): ` ` `  `    ``# base condition. ` `    ``if` `(n ``=``=` `0` `or` `n ``=``=` `1``): ` `        ``return``; ` `    ``M ``=` `[[ ``1``, ``1``, ``1` `],  ` `                ``[ ``1``, ``0``, ``0` `],  ` `                ``[ ``0``, ``1``, ``0` `]] ` ` `  `    ``# recursively call to ` `    ``# square the matrix ` `    ``power(T, n ``/``/` `2``) ` ` `  `    ``# calculating square  ` `    ``# of the matrix T ` `    ``multiply(T, T) ` ` `  `    ``# if n is odd multiply  ` `    ``# it one time with M ` `    ``if` `(n ``%` `2``): ` `        ``multiply(T, M) ` ` `  `def` `tribonacci(n): ` `     `  `    ``T ``=` `[[ ``1``, ``1``, ``1` `],  ` `        ``[``1``, ``0``, ``0` `], ` `        ``[``0``, ``1``, ``0` `]] ` ` `  `    ``# base condition ` `    ``if` `(n ``=``=` `0` `or` `n ``=``=` `1``): ` `        ``return` `0` `    ``else``: ` `        ``power(T, n ``-` `2``) ` ` `  `    ``# T contains the  ` `    ``# tribonacci number so ` `    ``# return it ` `    ``return` `T[``0``][``0``] ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"``: ` `    ``n ``=` `10` `    ``for` `i ``in` `range``(n): ` `        ``print``(tribonacci(i),end``=``" "``) ` `    ``print``() ` ` `  `# This code is contributed by ChitraNayal `

## C#

 `// C# Program to print ` `// first n tribonacci numbers ` `// Matrix Multiplication ` `// function for 3*3 matrix ` `using` `System; ` ` `  `class` `GFG  ` `{ ` `    ``static` `void` `multiply(``int` `[,]T,  ` `                         ``int` `[,]M) ` `    ``{ ` `        ``int` `a, b, c, d, e, f, g, h, i; ` `        ``a = T[0,0] * M[0,0] +  ` `            ``T[0,1] * M[1,0] +  ` `            ``T[0,2] * M[2,0]; ` `        ``b = T[0,0] * M[0,1] +  ` `            ``T[0,1] * M[1,1] +  ` `            ``T[0,2] * M[2,1]; ` `        ``c = T[0,0] * M[0,2] +  ` `            ``T[0,1] * M[1,2] +  ` `            ``T[0,2] * M[2,2]; ` `        ``d = T[1,0] * M[0,0] +  ` `            ``T[1,1] * M[1,0] +  ` `            ``T[1,2] * M[2,0]; ` `        ``e = T[1,0] * M[0,1] +  ` `            ``T[1,1] * M[1,1] +  ` `            ``T[1,2] * M[2,1]; ` `        ``f = T[1,0] * M[0,2] +  ` `            ``T[1,1] * M[1,2] +  ` `            ``T[1,2] * M[2,2]; ` `        ``g = T[2,0] * M[0,0] +  ` `            ``T[2,1] * M[1,0] +  ` `            ``T[2,2] * M[2,0]; ` `        ``h = T[2,0] * M[0,1] +  ` `            ``T[2,1] * M[1,1] +  ` `            ``T[2,2] * M[2,1]; ` `        ``i = T[2,0] * M[0,2] +  ` `            ``T[2,1] * M[1,2] +  ` `            ``T[2,2] * M[2,2]; ` `        ``T[0,0] = a; ` `        ``T[0,1] = b; ` `        ``T[0,2] = c; ` `        ``T[1,0] = d; ` `        ``T[1,1] = e; ` `        ``T[1,2] = f; ` `        ``T[2,0] = g; ` `        ``T[2,1] = h; ` `        ``T[2,2] = i; ` `    ``} ` `     `  `    ``// Recursive function to raise  ` `    ``// the matrix T to the power n ` `    ``static` `void` `power(``int` `[,]T, ``int` `n) ` `    ``{ ` `        ``// base condition. ` `        ``if` `(n == 0 || n == 1) ` `            ``return``; ` `        ``int` `[,]M = {{ 1, 1, 1 },  ` `                    ``{ 1, 0, 0 },  ` `                    ``{ 0, 1, 0 }}; ` `     `  `        ``// recursively call to  ` `        ``// square the matrix ` `        ``power(T, n / 2); ` `     `  `        ``// calculating square  ` `        ``// of the matrix T ` `        ``multiply(T, T); ` `     `  `        ``// if n is odd multiply  ` `        ``// it one time with M ` `        ``if` `(n % 2 != 0) ` `            ``multiply(T, M); ` `    ``} ` `     `  `    ``static` `int` `tribonacci(``int` `n) ` `    ``{ ` `        ``int` `[,]T = {{ 1, 1, 1 },  ` `                    ``{ 1, 0, 0 }, ` `                    ``{ 0, 1, 0 }}; ` `     `  `        ``// base condition ` `        ``if` `(n == 0 || n == 1) ` `            ``return` `0; ` `        ``else` `            ``power(T, n - 2); ` `     `  `        ``// T contains the  ` `        ``// tribonacci number so ` `        ``// return it ` `        ``return` `T[0,0]; ` `    ``} ` `     `  `    ``// Driver Code ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int` `n = 10; ` `        ``for` `(``int` `i = 0; i < n; i++) ` `        ``Console.Write(tribonacci(i) + ``" "``); ` `        ``Console.WriteLine(); ` `    ``} ` `} ` ` `  `// This code is contributed by vt_m. `

## PHP

Output :

```0 0 1 1 2 4 7 13 24 44
```

This article is contributed by Sahil Rajput. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

1

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