Tribonacci Numbers

2.5

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 Tribinacci numbers.
#include <iostream>
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.


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 <iostream>
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
// 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.

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 <iostream>
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.


Output:

0 0 1 1 2 4 7 13 24 44 

Below is more efficient solution using matrix exponentiation.

CPP

#include <iostream>
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.


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.

GATE CS Corner    Company Wise Coding Practice

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

Recommended Posts:



2.5 Average Difficulty : 2.5/5.0
Based on 6 vote(s)