# Tetranacci Numbers

The tetranacci numbers are a generalization of the Fibonacci numbers defined by the recurrence relation

T(n) = T(n-1) + T(n-2) + T(n-3) + T(n-4)

with T(0)=0, T(1)=1, T(2)=1, T(3)=2,

For n>=4. They represent the n=4 case of the Fibonacci n-step numbers. The first few terms for n=0, 1, … are 0, 1, 1, 2, 4, 8, 15, 29, 56, 108, 208, …

Given a number N. The task is to find the N-th tetranacci number.

Examples:

```Input: 5
Output: 4

Input: 9
Output: 108
```

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

A naive approach is to follow the recurrence for finding the number and use recursion to solve it.

Below is the implementation of the above approach.

## C++

 `// A simple recursive CPP program to print ` `// the nth tetranacci numbers. ` `#include ` `using` `namespace` `std; ` ` `  `// Function to return the ` `// N-th tetranacci number ` `int` `printTetraRec(``int` `n) ` `{ ` `    ``// base cases ` `    ``if` `(n == 0) ` `        ``return` `0; ` `    ``// base cases ` `    ``if` `(n == 1 || n == 2) ` `        ``return` `1; ` `    ``// base cases ` `    ``if` `(n == 3) ` `        ``return` `2; ` ` `  `    ``else` `        ``return` `printTetraRec(n - 1) + printTetraRec(n - 2) ` `               ``+ printTetraRec(n - 3) + printTetraRec(n - 4); ` `} ` ` `  `// function to print the nth tetranacci number ` `void` `printTetra(``int` `n) ` `{ ` `    ``cout << printTetraRec(n) << ``" "``; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `n = 10; ` `    ``printTetra(n); ` `    ``return` `0; ` `} `

## Java

 `// A simple recursive Java  ` `// program to print the nth ` `// tetranacci numbers. ` `class` `GFG ` `{ ` `// Function to return the ` `// N-th tetranacci number ` `static` `int` `printTetraRec(``int` `n) ` `{ ` `    ``// base cases ` `    ``if` `(n == ``0``) ` `        ``return` `0``; ` `    ``// base cases ` `    ``if` `(n == ``1` `|| n == ``2``) ` `        ``return` `1``; ` `    ``// base cases ` `    ``if` `(n == ``3``) ` `        ``return` `2``; ` ` `  `    ``else` `        ``return` `printTetraRec(n - ``1``) +  ` `               ``printTetraRec(n - ``2``) +  ` `               ``printTetraRec(n - ``3``) +  ` `               ``printTetraRec(n - ``4``); ` `} ` ` `  `// function to print the  ` `// Nth tetranacci number ` `static` `void` `printTetra(``int` `n) ` `{ ` `    ``System.out.println(printTetraRec(n) + ``" "``); ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `n = ``10``; ` `    ``printTetra(n); ` `} ` `} ` ` `  `// This code is contributed by mits `

## Python3

 `# A simple recursive Python3 program  ` `# to print the nth tetranacci numbers. ` ` `  `# Function to return the ` `# N-th tetranacci number ` `def` `printTetraRec(n): ` `     `  `    ``# base cases ` `    ``if` `(n ``=``=` `0``): ` `        ``return` `0``; ` `         `  `    ``# base cases ` `    ``if` `(n ``=``=` `1` `or` `n ``=``=` `2``): ` `        ``return` `1``; ` `         `  `    ``# base cases ` `    ``if` `(n ``=``=` `3``): ` `        ``return` `2``; ` ` `  `    ``else``: ` `        ``return` `(printTetraRec(n ``-` `1``) ``+`  `                ``printTetraRec(n ``-` `2``) ``+`  `                ``printTetraRec(n ``-` `3``) ``+`  `                ``printTetraRec(n ``-` `4``)); ` ` `  `# function to print the  ` `# nth tetranacci number ` `def` `printTetra(n): ` `    ``print``(printTetraRec(n), end ``=` `" "``); ` ` `  `# Driver code ` `n ``=` `10``; ` `printTetra(n); ` ` `  `# This code is contributed  ` `# by mits `

## C#

 `// A simple recursive C#  ` `// program to print the nth ` `// tetranacci numbers. ` `class` `GFG ` `{ ` `     `  `// Function to return the ` `// N-th tetranacci number ` `static` `int` `printTetraRec(``int` `n) ` `{ ` `    ``// base cases ` `    ``if` `(n == 0) ` `        ``return` `0; ` `    ``// base cases ` `    ``if` `(n == 1 || n == 2) ` `        ``return` `1; ` `    ``// base cases ` `    ``if` `(n == 3) ` `        ``return` `2; ` ` `  `    ``else` `        ``return` `printTetraRec(n - 1) +  ` `               ``printTetraRec(n - 2) +  ` `               ``printTetraRec(n - 3) +  ` `               ``printTetraRec(n - 4); ` `} ` ` `  `// function to print the  ` `// Nth tetranacci number ` `static` `void` `printTetra(``int` `n) ` `{ ` `    ``System.Console.WriteLine( ` `           ``printTetraRec(n) + ``" "``); ` `} ` ` `  `// Driver code ` `static` `void` `Main() ` `{ ` `    ``int` `n = 10; ` `    ``printTetra(n); ` `} ` `} ` ` `  `// This code is contributed by mits `

## PHP

 ` `

Output:

```208
```

Time Complexity: O(4N)

A better solution is to use Dynamic Programming (memoisation) as there are multiple overlaps.

Given below is the recursive tree for N=10.

```                                        rec(10)

/         /       \          \

rec(9)      rec(8)     rec(7)     rec(6)

/      /     \     \

rec(8) rec(7)  rec(6)  rec(5)

```

In the above partial recursion tree, rec(8), rec(7), rec(6) has been solved twice. On drawing the complete recursion tree, it has been observed that there are many subproblems which are solved again and again. So this problem has Overlapping Substructure property and recomputation of same subproblems can be avoided by either using Memoization or Tabulation.

Below is the implementation of the above approach

## C++

 `// A DP based CPP ` `// program to print ` `// the nth tetranacci number ` `#include ` `using` `namespace` `std; ` ` `  `// Function to print the ` `// N-th tetranacci number ` `int` `printTetra(``int` `n) ` `{ ` `    ``int` `dp[n + 5]; ` `    ``// base cases ` `    ``dp = 0; ` `    ``dp = dp = 1; ` `    ``dp = 2; ` ` `  `    ``for` `(``int` `i = 4; i <= n; i++) ` `        ``dp[i] = dp[i - 1] + dp[i - 2] + ` `                ``dp[i - 3] + dp[i - 4]; ` ` `  `    ``cout << dp[n]; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `n = 10; ` `    ``printTetra(n); ` `    ``return` `0; ` `} `

## Java

 `// A DP based Java ` `// program to print ` `// the nth tetranacci number ` ` `  `class` `GFG{ ` `// Function to print the ` `// N-th tetranacci number ` `static` `void` `printTetra(``int` `n) ` `{ ` `    ``int``[] dp=``new` `int``[n + ``5``]; ` `    ``// base cases ` `    ``dp[``0``] = ``0``; ` `    ``dp[``1``] = dp[``2``] = ``1``; ` `    ``dp[``3``] = ``2``; ` ` `  `    ``for` `(``int` `i = ``4``; i <= n; i++) ` `        ``dp[i] = dp[i - ``1``] + dp[i - ``2``] + ` `                ``dp[i - ``3``] + dp[i - ``4``]; ` ` `  `    ``System.out.print(dp[n]); ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `n = ``10``; ` `    ``printTetra(n); ` `} ` `} ` `// This code is contributed by mits `

## Python3

 `# A DP based Python3 program to print ` `# the nth tetranacci number ` ` `  `# Function to print the ` `# N-th tetranacci number ` `def` `printTetra(n): ` `    ``dp ``=` `[``0``] ``*` `(n ``+` `5``); ` `     `  `    ``# base cases ` `    ``dp[``0``] ``=` `0``; ` `    ``dp[``1``] ``=` `1``; ` `    ``dp[``2``] ``=` `1``; ` `    ``dp[``3``] ``=` `2``; ` ` `  `    ``for` `i ``in` `range``(``4``, n ``+` `1``): ` `        ``dp[i] ``=` `(dp[i ``-` `1``] ``+` `dp[i ``-` `2``] ``+` `                 ``dp[i ``-` `3``] ``+` `dp[i ``-` `4``]); ` ` `  `    ``print``(dp[n]); ` ` `  `# Driver code ` `n ``=` `10``; ` `printTetra(n); ` ` `  `# This code is contributed by mits `

## C#

 `// A DP based C# ` `// program to print ` `// the nth tetranacci number ` ` `  `class` `GFG{ ` `// Function to print the ` `// N-th tetranacci number ` `static` `void` `printTetra(``int` `n) ` `{ ` `    ``int``[] dp=``new` `int``[n + 5]; ` `    ``// base cases ` `    ``dp = 0; ` `    ``dp = dp = 1; ` `    ``dp = 2; ` ` `  `    ``for` `(``int` `i = 4; i <= n; i++) ` `        ``dp[i] = dp[i - 1] + dp[i - 2] + ` `                ``dp[i - 3] + dp[i - 4]; ` ` `  `    ``System.Console.WriteLine(dp[n]); ` `} ` ` `  `// Driver code ` `static` `void` `Main() ` `{ ` `    ``int` `n = 10; ` `    ``printTetra(n); ` `} ` `} ` `// This code is contributed by mits `

## PHP

 ` `

Output:

```208
```

Time Complexity: O(N)
Auxiliary Space: O(N)

The time complexity of above is linear, but it requires extra space. Space used can be optimized in the above solution by using four variables to keep track of the previous four numbers.

Below is the implementation of the above approach

## C++

 `// A space optimized ` `// based CPP program to ` `// print the nth tetranacci number ` `#include ` `using` `namespace` `std; ` ` `  `// Function to print the ` `// N-th tetranacci number ` `void` `printTetra(``int` `n) ` `{ ` `    ``if` `(n < 0) ` `        ``return``; ` ` `  `    ``// Initialize first ` `    ``// four numbers to base cases ` `    ``int` `first = 0, second = 1; ` `    ``int` `third = 1, fourth = 2; ` ` `  `    ``// declare a current variable ` `    ``int` `curr; ` ` `  `    ``if` `(n == 0) ` `        ``cout << first; ` `    ``else` `if` `(n == 1 || n == 2) ` `        ``cout << second; ` ` `  `    ``else` `if` `(n == 3) ` `        ``cout << fourth; ` ` `  `    ``else` `{ ` ` `  `        ``// Loop to add previous ` `        ``// four numbers for ` `        ``// each number starting ` `        ``// from 4 and then assign ` `        ``// first, second, third ` `        ``// to second, third, fourth and ` `        ``// curr to fourth respectively ` `        ``for` `(``int` `i = 4; i <= n; i++) { ` `            ``curr = first + second + third + fourth; ` `            ``first = second; ` `            ``second = third; ` `            ``third = fourth; ` `            ``fourth = curr; ` `        ``} ` `        ``cout << curr; ` `    ``} ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `n = 10; ` `    ``printTetra(n); ` `    ``return` `0; ` `} `

## Java

 `// A space optimized ` `// based Java program to ` `// print the nth tetranacci number ` `import` `java.io.*; ` `import` `java.util.*; ` `import` `java.lang.*; ` ` `  `class` `GFG{ ` `// Function to print the ` `// N-th tetranacci number ` `static` `void` `printTetra(``int` `n) ` `{ ` `    ``if` `(n < ``0``) ` `        ``return``; ` ` `  `    ``// Initialize first ` `    ``// four numbers to base cases ` `    ``int` `first = ``0``, second = ``1``; ` `    ``int` `third = ``1``, fourth = ``2``; ` ` `  `    ``// declare a current variable ` `    ``int` `curr = ``0``; ` ` `  `    ``if` `(n == ``0``) ` `        ``System.out.print(first); ` `    ``else` `if` `(n == ``1` `|| n == ``2``) ` `        ``System.out.print(second); ` ` `  `    ``else` `if` `(n == ``3``) ` `        ``System.out.print(fourth); ` ` `  `    ``else`  `    ``{ ` ` `  `        ``// Loop to add previous ` `        ``// four numbers for ` `        ``// each number starting ` `        ``// from 4 and then assign ` `        ``// first, second, third ` `        ``// to second, third, fourth and ` `        ``// curr to fourth respectively ` `        ``for` `(``int` `i = ``4``; i <= n; i++)  ` `        ``{ ` `            ``curr = first + second + third + fourth; ` `            ``first = second; ` `            ``second = third; ` `            ``third = fourth; ` `            ``fourth = curr; ` `        ``} ` `        ``System.out.print(curr); ` `    ``} ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `n = ``10``; ` `    ``printTetra(n); ` `} ` `} ` ` `  `// This code is contributed ` `// by Akanksha Rai(Abby_akku) `

## Python3

 `# A space optimized based Python3 program  ` `# to print the nth tetranacci number  ` ` `  `# Function to print the N-th  ` `# tetranacci number  ` `def` `printTetra(n):  ` ` `  `    ``if` `(n < ``0``):  ` `        ``return``;  ` ` `  `    ``# Initialize first four  ` `    ``# numbers to base cases  ` `    ``first ``=` `0``;  ` `    ``second ``=` `1``;  ` `    ``third ``=` `1``;  ` `    ``fourth ``=` `2``;  ` ` `  `    ``# declare a current variable  ` `    ``curr ``=` `0``;  ` ` `  `    ``if` `(n ``=``=` `0``):  ` `        ``print``(first);  ` `    ``elif` `(n ``=``=` `1` `or` `n ``=``=` `2``):  ` `        ``print``(second);  ` ` `  `    ``elif` `(n ``=``=` `3``):  ` `        ``print``(fourth);  ` ` `  `    ``else``: ` ` `  `        ``# Loop to add previous four numbers  ` `        ``# for each number starting from 4  ` `        ``# and then assign first, second,  ` `        ``# third to second, third, fourth  ` `        ``# and curr to fourth respectively  ` `        ``for` `i ``in` `range``(``4``, n ``+` `1``): ` `            ``curr ``=` `first ``+` `second ``+` `third ``+` `fourth;  ` `            ``first ``=` `second;  ` `            ``second ``=` `third;  ` `            ``third ``=` `fourth;  ` `            ``fourth ``=` `curr;  ` `         `  `    ``print``(curr);  ` ` `  `# Driver code  ` `n ``=` `10``;  ` `printTetra(n);  ` ` `  `# This code is contributed by mits `

## C#

 `// A space optimized based C# program to  ` `// print the nth tetranacci number  ` `using` `System; ` ` `  `class` `GFG{ ` `     `  `// Function to print the  ` `// N-th tetranacci number  ` `static` `void` `printTetra(``int` `n)  ` `{  ` `    ``if` `(n < 0)  ` `        ``return``;  ` ` `  `    ``// Initialize first  ` `    ``// four numbers to base cases  ` `    ``int` `first = 0, second = 1;  ` `    ``int` `third = 1, fourth = 2;  ` ` `  `    ``// declare a current variable  ` `    ``int` `curr = 0;  ` ` `  `    ``if` `(n == 0)  ` `        ``Console.Write(first);  ` `    ``else` `if` `(n == 1 || n == 2)  ` `        ``Console.Write(second);  ` ` `  `    ``else` `if` `(n == 3)  ` `        ``Console.Write(fourth);  ` ` `  `    ``else` `    ``{  ` ` `  `        ``// Loop to add previous  ` `        ``// four numbers for  ` `        ``// each number starting  ` `        ``// from 4 and then assign  ` `        ``// first, second, third  ` `        ``// to second, third, fourth and  ` `        ``// curr to fourth respectively  ` `        ``for` `(``int` `i = 4; i <= n; i++)  ` `        ``{  ` `            ``curr = first + second + third + fourth;  ` `            ``first = second;  ` `            ``second = third;  ` `            ``third = fourth;  ` `            ``fourth = curr;  ` `        ``}  ` `        ``Console.Write(curr);  ` `    ``}  ` `}  ` ` `  `    ``// Driver code  ` `    ``static` `public` `void` `Main () ` `    ``{ ` `         `  `        ``int` `n = 10;  ` `        ``printTetra(n);  ` `    ``}  ` `}  ` ` `  `// This code is contributed ajit `

## PHP

 ` `

Output:

```208
```

Time Complexity: O(N)
Auxiliary Space: O(1)

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 Check out this Author's contributed articles.

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 Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.