Geek-onacci Number

Given four integers A, B, C and N, where A, B, C represents the first three numbers of the geekonacci series, the task is to find the N^th term of the geekonacci series.

The N^th term of the geekonacci series is the sum of its previous three terms in the series i.e., sum of (N – 1)^th, (N – 2)^th, and (N – 3)^th geekonacci numbers.

Examples:

Input: A = 1, B = 3, C = 2, N = 4
Output: 6
Explanation: The geekonacci series is 1, 3, 2, 6, 11, 19, ……
Therefore, the 4^th geekonacci number is 6.

Input: A = 1, B = 3, C = 2, N = 6
Output: 19

Recursive Approach: The ‘find' function is implemented using recursion to calculate the Nth term of the geekonacci series. Let’s understand how the recursion works step by step:

if N==1, then return A.
if N==2, then return B.
if N==3, then return C.
If N > 3, recursively call find(A, B, C, N – 1) +find(A, B, C, N – 2) +find(A, B, C, N – 3).
Finally, the function returns the sum of the three recursive calls, which represents the Nth term of the geekonacci series.

Below is the implementation of the above approach:

C++

// Fibonacci Series using Recursion
#include <iostream>

using namespace std;
 
int find(int A, int B, int C, int N)
{

    if (N == 1)

        return A;

    else if (N == 2)

        return B;

    else if (N == 3)

        return C;
 
    return find(A, B, C, N - 1) +

           find(A, B, C, N - 2) +

           find(A, B, C, N - 3);
}
// Driver code

int main()
{

    int A = 1, B = 3, C = 2, N = 4;

    int result = find(A, B, C, N);

    cout << result << endl;

    return 0;
}
// This code is contributed by Abhishek Kumar

// Fibonacci Series using Recursion
#include <stdio.h>

int find(int A, int B, int C, int N)
{

    if (N == 1)

        return A;

    else if (N == 2)

        return B;

    else if (N == 3)

        return C;
 
    return find(A, B, C, N - 1) +

           find(A, B, C, N - 2) +

           find(A, B, C, N - 3);
}
// Driver code

int main()
{

    int A = 1, B = 3, C = 2, N = 4;

    int result = find(A, B, C, N);

    printf("%d\n", result);

    return 0;
}
// This code is contributed by Abhishek Kumar

Java

// Fibonacci Series using Recursion

import java.io.*;

class GFG
{

    static int find(int A, int B, int C, int N)

    {

        if (N == 1)

            return A;

        else if (N == 2)

            return B;

        else if (N == 3)

            return C;
 
        return find(A, B, C, N - 1) +

               find(A, B, C, N - 2) +

               find(A, B, C, N - 3);

    }
// Driver code

    public static void main(String args[])

    {

        int A = 1, B = 3, C = 2, N = 4;

        int result = find(A, B, C, N);

        System.out.println(result);

    }
}
// This code is contributed by Abhishek Kumar

Python3

#Fibonacci Series using Recursion

def find(A, B, C, N):

    if N == 1:

        return A

    elif N == 2:

        return B

    elif N == 3:

        return C
 
    return find(A, B, C, N - 1) + find(A, B, C, N - 2) + find(A, B, C, N - 3)
 
#Driver code

A = 1

B = 3

C = 2

N = 4
 
result = find(A, B, C, N)

print(result)
#This code is contributed by Abhishek Kumar

// Fibonacci Series using Recursion
 
using System;
 
public class Gfg{

    static int find(int A, int B, int C, int N)

    {

        if (N == 1)

            return A;

        else if (N == 2)

            return B;

        else if (N == 3)

            return C;

        return find(A, B, C, N - 1) +

               find(A, B, C, N - 2) +

               find(A, B, C, N - 3);

    }

    // Driver code

    public static void Main(string[] args)

    {

        int A = 1, B = 3, C = 2, N = 4;

        int result = find(A, B, C, N);

        Console.Write(result);

    }
}

Javascript

function find(A, B, C, N) {

    if (N == 1)

        return A;

    else if (N == 2)

        return B;

    else if (N == 3)

        return C;
 
    return find(A, B, C, N - 1) + find(A, B, C, N - 2) + find(A, B, C, N - 3);
}
 
const A = 1, B = 3, C = 2, N = 4;
const result = find(A, B, C, N);
console.log(result);

Output

Time Complexity: O(3^n)
Auxiliary Space: O(n)

Approach: The given problem can be solved by generating the geekonacci series upto N terms and print the N^th term of the series obtained. Follow the steps below to solve this problem:

Initialize an array arr[] of size N and initialize arr[0] = A, arr[1] = B, and arr[2] = C.
Iterate over the range [3, N – 1] and update the value of each every i^th element, i.e. arr[i] as (arr[i – 1] + arr[i – 2] + arr[i – 3]) to get the i^th term of the geekonacci series.
After completing the above steps, print the value of arr[N – 1] as the resultant N^th number of the geekonacci series.

Below is the implementation of the above approach:

C++

#include <bits/stdc++.h>

using namespace std;
 
// Function to calculate the
// N-th Geek-onacci Number

int find(int A, int B,

                int C, int N)
{

    // Stores the geekonacci series

    int arr[N];
 
    // Store the first three

    // terms of the series

    arr[0] = A;

    arr[1] = B;

    arr[2] = C;
 
    // Iterate over the range [3, N]

    for (int i = 3; i < N; i++) {
 
        // Update the value of arr[i]

        // as the sum of previous 3

        // terms in the series

        arr[i] = arr[i - 1]

                 + arr[i - 2]

                 + arr[i - 3];

    }
 
    // Return the last element

    // of arr[] as the N-th term

    return arr[N - 1];
}
 
// Driver Code

int main()
{

  int A = 1, B = 3, C = 2, N = 4;

  cout<<(find(A, B, C, N));
 
  return 0;
}
 
// This code is contributed by mohit kumar 29.

Java

// Java program for the above approach
 
import java.io.*;

import java.lang.*;

import java.util.*;
 
class GFG {
 
    // Function to calculate the

    // N-th Geek-onacci Number

    static int find(int A, int B,

                    int C, int N)

    {

        // Stores the geekonacci series

        int[] arr = new int[N];
 
        // Store the first three

        // terms of the series

        arr[0] = A;

        arr[1] = B;

        arr[2] = C;
 
        // Iterate over the range [3, N]

        for (int i = 3; i < N; i++) {
 
            // Update the value of arr[i]

            // as the sum of previous 3

            // terms in the series

            arr[i] = arr[i - 1]

                     + arr[i - 2]

                     + arr[i - 3];

        }
 
        // Return the last element

        // of arr[] as the N-th term

        return arr[N - 1];

    }
 
    // Driver Code

    public static void main(String[] args)

    {

        int A = 1, B = 3, C = 2, N = 4;

        System.out.print(find(A, B, C, N));

    }
}

Python3

# Python3 program for the above approach
 
# Function to calculate the
# N-th Geek-onacci Number

def find(A, B, C, N) :

    # Stores the geekonacci series

    arr = [0] * N
 
    # Store the first three

    # terms of the series

    arr[0] = A

    arr[1] = B

    arr[2] = C
 
    # Iterate over the range [3, N]

    for i in range(3, N): 
 
        # Update the value of arr[i]

        # as the sum of previous 3

        # terms in the series

        arr[i] = (arr[i - 1]

                 + arr[i - 2]

                 + arr[i - 3])

    # Return the last element

    # of arr[] as the N-th term

    return arr[N - 1]
 
# Driver Code

A = 1

B = 3

C = 2

N = 4
 
print(find(A, B, C, N))
 
# This code is contributed by sanjoy_62.

// C# program for the above approach

using System;
 
class GFG{
 
  // Function to calculate the

  // N-th Geek-onacci Number

  static int find(int A, int B,

                  int C, int N)

  {

    // Stores the geekonacci series

    int[] arr = new int[N];
 
    // Store the first three

    // terms of the series

    arr[0] = A;

    arr[1] = B;

    arr[2] = C;
 
    // Iterate over the range [3, N]

    for (int i = 3; i < N; i++) {
 
      // Update the value of arr[i]

      // as the sum of previous 3

      // terms in the series

      arr[i] = arr[i - 1]

        + arr[i - 2]

        + arr[i - 3];

    }
 
    // Return the last element

    // of arr[] as the N-th term

    return arr[N - 1];

  }
 
  // Driver Code

  public static void Main(string[] args)

  {

    int A = 1, B = 3, C = 2, N = 4;

    Console.Write(find(A, B, C, N));

  }
}
 
// This code is contributed by code_hunt.

Javascript

<script>
 
// Javascript program for the above approach
 
    // Function to calculate the

    // N-th Geek-onacci Number

    function find(A, B, C, N)

    {

        // Stores the geekonacci series

        let arr = new Array(N).fill(0);
 
        // Store the first three

        // terms of the series

        arr[0] = A;

        arr[1] = B;

        arr[2] = C;
 
        // Iterate over the range [3, N]

        for (let i = 3; i < N; i++) {
 
            // Update the value of arr[i]

            // as the sum of previous 3

            // terms in the series

            arr[i] = arr[i - 1]

                     + arr[i - 2]

                     + arr[i - 3];

        }
 
        // Return the last element

        // of arr[] as the N-th term

        return arr[N - 1];

    }
 
// Driver code

    let A = 1, B = 3, C = 2, N = 4;

    document.write(find(A, B, C, N));

</script>

Output

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

Efficient approach : O(1) space complexity approach

Use variable instead of array to store previous computations because the current value if depend upon the previous 3 computations , So we just need 3 variable to optimize the space complexity.

Implementations Steps :

Initialize the last three terms in series prev1 , prev2 , prev3.
Use a loop to calculate the N-th term of the series (starting from 4).
For each iteration, calculate the current term as the sum of the previous 3 terms.
Update the previous 3 terms for the next iteration.
Return the N-th term of the series.

Implementation :

C++

// C++ program for above approach
#include <bits/stdc++.h>

using namespace std;
 
// Function to calculate the N-th Geek-onacci Number

int find(int A, int B, int C, int N)
{

    // Stores the last three terms in the series

    int prev1 = A, prev2 = B, prev3 = C;

    int curr;
 
    // Iterate over the range [4, N]

    for (int i = 4; i <= N; i++) {

        // Calculate the current term as the sum of previous 3 terms

        curr = prev1 + prev2 + prev3;

        // Update the previous terms for the next iteration

        prev1 = prev2;

        prev2 = prev3;

        prev3 = curr;

    }
 
    // Return the N-th term

    return curr;
}
 
// Driver Code

int main()
{

    int A = 1, B = 3, C = 2, N = 4;

    cout << find(A, B, C, N);
 
    return 0;
}
 
// this code is contributed by bhardwajji

Java

import java.util.*;
 
public class Main
{

  // Function to calculate the N-th Geek-onacci Number

  public static int find(int A, int B, int C, int N) 

  {
 
    // Stores the last three terms in the series

    int prev1 = A, prev2 = B, prev3 = C;

    int curr = 0;
 
    // Iterate over the range [4, N]

    for (int i = 4; i <= N; i++) 

    {

      // Calculate the current term as the sum of previous 3 terms

      curr = prev1 + prev2 + prev3;
 
      // Update the previous terms for the next iteration

      prev1 = prev2;

      prev2 = prev3;

      prev3 = curr;

    }
 
    // Return the N-th term

    return curr;

  }
 
  // Driver Code

  public static void main(String[] args) {

    int A = 1, B = 3, C = 2, N = 4;

    System.out.println(find(A, B, C, N));

  }
}

Python3

# Python program for above approach
 
# Function to calculate the N-th Geek-onacci Number

def find(A, B, C, N):

    # Stores the last three terms in the series

    prev1, prev2, prev3 = A, B, C
 
    # Iterate over the range [4, N]

    for i in range(4, N+1):

        # Calculate the current term as the sum of previous 3 terms

        curr = prev1 + prev2 + prev3

        # Update the previous terms for the next iteration

        prev1, prev2, prev3 = prev2, prev3, curr
 
    # Return the N-th term

    return curr
 
# Driver Code

if __name__ == '__main__':

    A, B, C, N = 1, 3, 2, 4

    print(find(A, B, C, N))

using System;
 
class Program {

    static int Find(int A, int B, int C, int N)

    {
 
        // Stores the last three terms

        // in the series

        int prev1 = A, prev2 = B, prev3 = C;

        int curr = 0;
 
        // Iterate over the range [4, N]

        for (int i = 4; i <= N; i++) {
 
            // Calculate the current term as

            // the sum of previous 3 terms

            curr = prev1 + prev2 + prev3;
 
            // Update the previous terms for

            // the next iteration

            prev1 = prev2;

            prev2 = prev3;

            prev3 = curr;

        }
 
        // Return the N-th term

        return curr;

    }
 
    // Driver Code

    static void Main(string[] args)

    {

        int A = 1, B = 3, C = 2, N = 4;

        Console.WriteLine(Find(A, B, C, N));

    }
}

Javascript

// Function to calculate the N-th Geek-onacci Number

function find(A, B, C, N)
{
 
// Stores the last three terms in the series
let prev1 = A, prev2 = B, prev3 = C;
let curr = 0;
 
// Iterate over the range [4, N]

for (let i = 4; i <= N; i++)
{
// Calculate the current term as the sum of previous 3 terms
curr = prev1 + prev2 + prev3;
 
// Update the previous terms for the next iteration
prev1 = prev2;
prev2 = prev3;
prev3 = curr;
}
 
// Return the N-th term

return curr;
}
 
// Driver Code
const A = 1, B = 3, C = 2, N = 4;
console.log(find(A, B, C, N));

Output

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

Article Tags :

DSA

Dynamic Programming

Mathematical

Recursion

series