# 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```

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 Tribonacci 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 Tribonacci 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 Tribonacci 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 Tribinocci 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

 ``

## Javascript

 ``

Output

`0 0 1 1 2 4 7 13 24 `

Time complexity of above solution is exponential.
A better solution is to use Dynamic Programming

1) Top-Down Dp Memoization:

## C++

 `// A simple recursive CPP program to print` `// first n Tribonacci numbers.` `#include ` `using` `namespace` `std;`   `int` `printTribRec(``int` `n, vector<``int``> &dp)` `{` `    ``if` `(n == 0 || n == 1 || n == 2)` `        ``return` `0;` `  `  `    ``if``(dp[n] != -1){` `        ``return` `dp[n] ;` `    ``}`   `    ``if` `(n == 3)` `        ``return` `1;` `    ``else` `        ``return` `dp[n] = printTribRec(n - 1, dp) + ` `                       ``printTribRec(n - 2, dp) + ` `                       ``printTribRec(n - 3, dp);` `}`   `void` `printTrib(``int` `n)` `{` `    ``// dp vector to store subproblems` `    ``vector<``int``> dp(n+1, -1) ;` `    ``for` `(``int` `i = 1; i < n; i++)` `        ``cout << printTribRec(i, dp) << ``" "``;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `n = 10;` `    ``printTrib(n);` `    ``return` `0;` `}`

## Python3

 `def` `tribonacci(n): ` `    ``h``=``{} ``#creating the dictionary to store the results` `    ``def` `tribo(n):` `        ``if` `n ``in` `h:` `            ``return` `h[n]` `        ``if` `n``=``=``0``:` `            ``return` `0` `        ``elif` `n``=``=``1` `or` `n``=``=``2``:` `            ``return` `1` `        ``else``:` `            ``res``=``tribo(n``-``3``)``+``tribo(n``-``2``)``+``tribo(n``-``1``)` `            ``h[n]``=``res ``#storing the results so that we can reuse it again ` `        ``return` `res` `    ``return` `tribo(n)` `n``=``10` `for` `i ``in` `range``(n):` `    ``print``(tribonacci(i),end``=``' '``)`

## Javascript

 `// A simple recursive JS program to print` `// first n Tribonacci numbers.`   `function` `printTribRec(n, dp)` `{` `    ``if` `(n == 0 || n == 1 || n == 2)` `        ``return` `0;` `  `  `    ``if``(dp[n] != -1){` `        ``return` `dp[n] ;` `    ``}`   `    ``if` `(n == 3)` `        ``return` `1;` `    ``else` `        ``return` `dp[n] = printTribRec(n - 1, dp) + ` `                       ``printTribRec(n - 2, dp) + ` `                       ``printTribRec(n - 3, dp);` `}`   `function` `printTrib(n)` `{` `    ``// dp vector to store subproblems` `    ``let dp = ``new` `Array(n+1).fill(-1) ;` `    ``for` `(``var` `i = 1; i < n; i++)` `        ``process.stdout.write(printTribRec(i, dp) + ``" "``);` `}`   `// Driver code` `let n = 10;` `printTrib(n);`     `// This code is contributed by phasing17`

## C#

 `// A simple recursive C# program to print` `// first n Tribonacci numbers.`   `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG {` `    ``static` `int` `printTribRec(``int` `n, List<``int``> dp)` `    ``{` `        ``if` `(n == 0 || n == 1 || n == 2)` `            ``return` `0;`   `        ``if` `(dp[n] != -1) {` `            ``return` `dp[n];` `        ``}`   `        ``if` `(n == 3)` `            ``return` `1;` `        ``else` `            ``return` `dp[n] = printTribRec(n - 1, dp)` `                           ``+ printTribRec(n - 2, dp)` `                           ``+ printTribRec(n - 3, dp);` `    ``}`   `    ``static` `void` `printTrib(``int` `n)` `    ``{` `        ``// dp vector to store subproblems` `        ``List<``int``> dp = ``new` `List<``int``>();` `        ``for` `(``var` `i = 0; i <= n; i++)` `            ``dp.Add(-1);` `        ``for` `(``int` `i = 1; i < n; i++)` `            ``Console.Write(printTribRec(i, dp) + ``" "``);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{` `        ``int` `n = 10;` `        ``printTrib(n);` `    ``}` `}`   `// This code is contributed by phasing17`

## Java

 `// A simple recursive Java program to print` `// first n Tribonacci numbers.`   `import` `java.util.*;`     `class` `GFG {` `    ``static` `int` `printTribRec(``int` `n, ``int``[] dp)` `    ``{` `        ``if` `(n == ``0` `|| n == ``1` `|| n == ``2``)` `            ``return` `0``;`   `        ``if` `(dp[n] != -``1``) {` `            ``return` `dp[n];` `        ``}`   `        ``if` `(n == ``3``)` `            ``return` `1``;` `        ``else` `            ``return` `dp[n] = printTribRec(n - ``1``, dp)` `                           ``+ printTribRec(n - ``2``, dp)` `                           ``+ printTribRec(n - ``3``, dp);` `    ``}`   `    ``static` `void` `printTrib(``int` `n)` `    ``{` `        ``// dp vector to store subproblems` `        ``int``[] dp = ``new` `int``[n + ``1``];` `        ``for` `(var i = ``0``; i <= n; i++)` `            ``dp[i] = -``1``;` `        ``for` `(``int` `i = ``1``; i < n; i++)` `            ``System.out.print(printTribRec(i, dp) + ``" "``);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `n = ``10``;` `        ``printTrib(n);` `    ``}` `}`   `// This code is contributed by phasing17`

Output

`0 0 1 1 2 4 7 13 24 `

2) Bottom-Up DP Tabulation:

## C++

 `// A DP based CPP` `// program to print` `// first n Tribonacci` `// numbers.` `#include ` `using` `namespace` `std;`   `int` `printTrib(``int` `n)` `{` `    ``int` `dp[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++)` `        ``cout << dp[i] << ``" "``;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `n = 10;` `    ``printTrib(n);` `    ``return` `0;` `}`

## Java

 `// A DP based Java program` `// to print first n` `// Tribonacci 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 Tribonacci` `# 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` `// Tribonacci numbers.` `using` `System;`   `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++)` `        ``Console.Write(dp[i] + ``" "``);` `    ``}` `    `  `    ``// Driver code` `    ``public` `static` `void` `Main()` `    ``{` `        ``int` `n = 10;` `        ``printTrib(n);` `    ``}` `}`   `/* This code is contributed by vt_m.*/`

## PHP

 ``

## Javascript

 `    `

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` `// Tribonacci 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 ` `// Tribinocci 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 Tribinocci ` `# 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 ` `// Tribinocci 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` `?>`

## Javascript

 ``

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[3][3], ``int` `M[3][3])` `{` `    ``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` `void` `power(``int` `T[3][3], ``int` `n)` `{` `    ``// base condition.` `    ``if` `(n == 0 || n == 1)` `        ``return``;` `    ``int` `M[3][3] = {{ 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[3][3] = {{ 1, 1, 1 }, ` `                   ``{ 1, 0, 0 },` `                   ``{ 0, 1, 0 }};`   `    ``// base condition` `    ``if` `(n == 0 || n == 1)` `        ``return` `0;` `    ``else` `        ``power(T, n - 2);`   `    ``// T[0][0] contains the ` `    ``// tribonacci number so` `    ``// return it` `    ``return` `T[0][0];` `}`   `// 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[0][0] 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[0][0] 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[0][0] 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

 ``

## Javascript

 ``

Output

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

If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.