N-th Tribonacci Number - Practice Coding Problems

N-th Tribonacci Number - Problem

The Tribonacci sequence is a fascinating extension of the famous Fibonacci sequence! While Fibonacci numbers are formed by adding the previous two numbers, Tribonacci numbers are formed by adding the previous three numbers.

The sequence is defined as:

T₀ = 0
T₁ = 1
T₂ = 1
T_n = T_n-3 + T_n-2 + T_n-1 for n ≥ 3

For example: 0, 1, 1, 2, 4, 7, 13, 24, 44, 81...

Goal: Given an integer n, return the n-th Tribonacci number T_n.

Input & Output

example_1.py — Python

$ Input: n = 4

› Output: 4

💡 Note: T(4) = T(3) + T(2) + T(1) = 2 + 1 + 1 = 4

example_2.py — Python

$ Input: n = 25

› Output: 1389537

💡 Note: The 25th Tribonacci number, calculated efficiently using the sliding window approach

example_3.py — Python

$ Input: n = 0

› Output: 0

💡 Note: Base case: T(0) = 0 by definition

Constraints

0 ≤ n ≤ 37
Answer is guaranteed to fit within a 32-bit integer
The sequence grows exponentially, similar to Fibonacci

Visualization

Tap to expand

Understanding the Visualization

Foundation

Start with floors 0, 1, 2 having heights 0, 1, 1

Build Up

Each new floor = sum of previous 3 floors

Slide Window

Keep only the last 3 floor heights in memory

Reach Target

Continue until we reach the desired floor n

Key Takeaway

🎯 Key Insight: The sliding window approach with three variables gives us optimal O(n) time and O(1) space complexity, making it the perfect balance of simplicity and efficiency!

Asked in

G Google 12 a Amazon 8 ⊞ Microsoft 6 f Meta 4

The optimal solution uses a sliding window approach with three variables to build the Tribonacci sequence bottom-up. This achieves O(n) time and O(1) space complexity, making it both efficient and memory-friendly. The key insight is that we only need the last three values to compute the next number in the sequence.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Solution (Exponential Time)	O(3^n)	O(n)	Direct recursive implementation following the mathematical definition
Bottom-Up DP (Optimal Space)	O(n)	O(1)	Build solution iteratively using only three variables
Memoization (Top-Down DP)	O(n)	O(n)	Cache results of recursive calls to avoid redundant calculations

Recursive Solution (Exponential Time) — Algorithm Steps

Handle base cases: T0 = 0, T1 = 1, T2 = 1
For n ≥ 3, recursively call tribonacci(n-1) + tribonacci(n-2) + tribonacci(n-3)
Return the computed result

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Call

tribonacci(4) starts the recursion

First Level

Branches into T(3), T(2), T(1)

Second Level

T(3) further branches into T(2), T(1), T(0)

Redundancy

Notice T(2) and T(1) are calculated multiple times

Code -

solution.c — C

#include <stdio.h>

int tribonacci(int n) {
    // Base cases
    if (n == 0) return 0;
    if (n == 1 || n == 2) return 1;
    
    // Recursive case
    return tribonacci(n-1) + tribonacci(n-2) + tribonacci(n-3);
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%d\n", tribonacci(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(3^n)

Each call branches into 3 recursive calls, creating a tree of depth n

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth can go up to n levels deep

⚡ Linearithmic Space

87.5K Views

Medium Frequency

~12 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Recursive Solution (Exponential Time) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler