Count the occurrence of Nth term in first N terms of Van Eck’s sequence

Prerequisite: Van Eck’s sequence Given a positive integer N, the task is to count the occurrences of N^th term in the first N terms of Van Eck’s sequence. Examples:

Input: N = 5 Output: 1 Explanation: First 5 terms of Van Eck’s Sequence 0, 0, 1, 0, 2 Occurrence of 5th term i.e 2 = 1 Input: 11 Output: 5 Explanation: First 11 terms of Van Eck’s Sequence 0, 0, 1, 0, 2, 0, 2, 2, 1, 6, 0, Occurrence of 11th term i.e 0 is 5

1. Naive Approach:
   • Generate Van Eck’s sequence upto N^th term
   • Iterate through the generated sequence and count the occurrence of N^th term.

Below is the implementation of the above approach:

C++

// C++ program to count the occurrence
// of nth term in first n terms
// of Van Eck's sequence

#include <bits/stdc++.h>
using namespace std;

#define MAX 100000
int sequence[MAX + 1];

// Utility function to compute
// Van Eck's sequence
void vanEckSequence()
{

    // Initialize sequence array
    for (int i = 0; i < MAX; i++) {
        sequence[i] = 0;
    }

    // Loop to generate sequence
    for (int i = 0; i < MAX; i++) {

        // Check if sequence[i] has occurred
        // previously or is new to sequence
        for (int j = i - 1; j >= 0; j--) {
            if (sequence[j] == sequence[i]) {

                // If occurrence found
                // then the next term will be
                // how far back this last term
                // occurred previously
                sequence[i + 1] = i - j;
                break;
            }
        }
    }
}

// Utility function to count
// the occurrence of nth term
// in first n terms of the sequence
int getCount(int n)
{

    // Get nth term of the sequence
    int nthTerm = sequence[n - 1];

    int count = 0;

    // Count the occurrence of nth term
    // in first n terms of the sequence
    for (int i = 0; i < n; i++) {

        if (sequence[i] == nthTerm)
            count++;
    }

    // Return count
    return count;
}

// Driver code
int main()
{

    // Pre-compute Van Eck's sequence
    vanEckSequence();

    int n = 5;

    // Print count of the occurrence of nth term
    // in first n terms of the sequence
    cout << getCount(n) << endl;

    n = 11;

    // Print count of the occurrence of nth term
    // in first n terms of the sequence
    cout << getCount(n) << endl;

    return 0;
}

Java

// Java program to count the occurrence
// of nth term in first n terms
// of Van Eck's sequence

class GFG {

    static int MAX = 100000;
    static int sequence[] = new int[MAX + 1];

    // Utility function to compute
    // Van Eck's sequence
    static void vanEckSequence()
    {

        // Initialize sequence array
        for (int i = 0; i < MAX; i++) {
            sequence[i] = 0;
        }

        // Loop to generate sequence
        for (int i = 0; i < MAX; i++) {

            // Check if sequence[i] has occurred
            // previously or is new to sequence
            for (int j = i - 1; j >= 0; j--) {
                if (sequence[j] == sequence[i]) {

                    // If occurrence found
                    // then the next term will be
                    // how far back this last term
                    // occurred previously
                    sequence[i + 1] = i - j;
                    break;
                }
            }
        }
    }

    // Utility function to count
    // the occurrence of nth term
    // in first n terms of the sequence
    static int getCount(int n)
    {

        // Get nth term of the sequence
        int nthTerm = sequence[n - 1];

        int count = 0;

        // Count the occurrence of nth term
        // in first n terms of the sequence
        for (int i = 0; i < n; i++) {

            if (sequence[i] == nthTerm)
                count++;
        }

        // Return count
        return count;
    }

    // Driver code
    public static void main(String[] args)
    {

        // Pre-compute Van Eck's sequence
        vanEckSequence();

        int n = 5;

        // Print count of the occurrence of nth term
        // in first n terms of the sequence
        System.out.println(getCount(n));

        n = 11;

        // Print count of the occurrence of nth term
        // in first n terms of the sequence
        System.out.println(getCount(n));
    }
}

Python3

# Python3 program to count the occurrence
# of nth term in first n terms
# of Van Eck's sequence

MAX = 10000
sequence = [0]*(MAX + 1);

# Utility function to compute
# Van Eck's sequence
def vanEckSequence() :

    # Loop to generate sequence
    for i in range(MAX) :

        # Check if sequence[i] has occurred
        # previously or is new to sequence
        for j in range(i - 1, -1, -1) :
            if (sequence[j] == sequence[i]) :

                # If occurrence found
                # then the next term will be
                # how far back this last term
                # occurred previously
                sequence[i + 1] = i - j;
                break;

# Utility function to count
# the occurrence of nth term
# in first n terms of the sequence
def getCount(n) :

    # Get nth term of the sequence
    nthTerm = sequence[n - 1];

    count = 0;

    # Count the occurrence of nth term
    # in first n terms of the sequence
    for i in range(n) :

        if (sequence[i] == nthTerm) :
            count += 1;

    # Return count
    return count;

# Driver code
if __name__ == "__main__" :

    # Pre-compute Van Eck's sequence
    vanEckSequence();

    n = 5;

    # Print count of the occurrence of nth term
    # in first n terms of the sequence
    print(getCount(n));

    n = 11;

    # Print count of the occurrence of nth term
    # in first n terms of the sequence
    print(getCount(n));

# This code is contributed by AnkitRai01

C#

// C# program to count the occurrence
// of nth term in first n terms
// of Van Eck's sequence

using System;
class GFG {

    static int MAX = 100000;
    static int[] sequence = new int[MAX + 1];

    // Utility function to compute
    // Van Eck's sequence
    static void vanEckSequence()
    {

        // Initialize sequence array
        for (int i = 0; i < MAX; i++) {
            sequence[i] = 0;
        }

        // Loop to generate sequence
        for (int i = 0; i < MAX; i++) {

            // Check if sequence[i] has occurred
            // previously or is new to sequence
            for (int j = i - 1; j >= 0; j--) {
                if (sequence[j] == sequence[i]) {

                    // If occurrence found
                    // then the next term will be
                    // how far back this last term
                    // occurred previously
                    sequence[i + 1] = i - j;
                    break;
                }
            }
        }
    }

    // Utility function to count
    // the occurrence of nth term
    // in first n terms of the sequence
    static int getCount(int n)
    {

        // Get nth term of the sequence
        int nthTerm = sequence[n - 1];

        int count = 0;

        // Count the occurrence of nth term
        // in first n terms of the sequence
        for (int i = 0; i < n; i++) {

            if (sequence[i] == nthTerm)
                count++;
        }

        // Return count
        return count;
    }

    // Driver code
    public static void Main()
    {

        // Pre-compute Van Eck's sequence
        vanEckSequence();

        int n = 5;

        // Print count of the occurrence of nth term
        // in first n terms of the sequence
        Console.WriteLine(getCount(n));

        n = 11;

        // Print count of the occurrence of nth term
        // in first n terms of the sequence
        Console.WriteLine(getCount(n));
    }
}

Javascript

// Define MAX
const MAX = 10000;

// Create sequence array
let sequence = new Array(MAX + 1).fill(0);
//Javascript Equivalent

// Utility function to compute Van Eck's sequence
function vanEckSequence() {

    // Loop to generate sequence
    for (let i = 0; i <= MAX; i++) {

        // Check if sequence[i] has occurred previously or is new to sequence
        for (let j = i - 1; j >= 0; j--) {
            if (sequence[j] == sequence[i]) {

                // If occurrence found then the next term
                // will be how far back this last term occurred previously
                sequence[i + 1] = i - j;
                break;
            }
        }
    }
}

// Utility function to count the occurrence
// of nth term in first n terms of the sequence
function getCount(n) {
    // Get nth term of the sequence
    let nthTerm = sequence[n - 1];

    let count = 0;

    // Count the occurrence of nth term
    // in first n terms of the sequence
    for (let i = 0; i < n; i++) {
        if (sequence[i] == nthTerm) {
            count++;
        }
    }

    // Return count
    return count;
}

// Driver code
    // Pre-compute Van Eck's sequence
    vanEckSequence();

    let n = 5;

    // Print count of the occurrence of nth
    // term in first n terms of the sequence
    console.log(getCount(n));

    n = 11;

    // Print count of the occurrence of nth
    // term in first n terms of the sequence
    console.log(getCount(n));

Output

1
5

1. Efficient Approach:
   • For a given term in Van Eck’s sequence, its next term indicates the distance between last occurrence of the given term.
   • So, for i^th term, its previous occurrence will be at i – value (i + 1)^th term. For example:
   • Also, if the next term in the sequence is 0 then this means that the term has not occurred before. For example:
   • Algorithm:
     • Let us consider N^th term of the sequence as S_N
     • If S_N+1 is non-zero then increment the count and do the same for (N- S_N+1)^th term
     • And if S_N+1 is zero then stop.

Below is the implementation of the above approach:

C++

// C++ program to count the occurrence
// of nth term in first n terms
// of Van Eck's sequence

#include <bits/stdc++.h>
using namespace std;

#define MAX 100000
int sequence[MAX + 1];

// Utility function to compute
// Van Eck's sequence
void vanEckSequence()
{

    // Initialize sequence array
    for (int i = 0; i < MAX; i++) {
        sequence[i] = 0;
    }

    // Loop to generate sequence
    for (int i = 0; i < MAX; i++) {

        // Check if sequence[i] has occurred
        // previously or is new to sequence
        for (int j = i - 1; j >= 0; j--) {
            if (sequence[j] == sequence[i]) {

                // If occurrence found
                // then the next term will be
                // how far back this last term
                // occurred previously
                sequence[i + 1] = i - j;
                break;
            }
        }
    }
}

// Utility function to count
// the occurrence of nth term
// in first n terms of the sequence
int getCount(int n)
{

    // Initialize count as 1
    int count = 1;

    int i = n - 1;

    while (sequence[i + 1] != 0) {

        // Increment count if (i+1)th term
        // is non-zero
        count++;

        // Previous occurrence of sequence[i]
        // will be it (i - sequence[i+1])th position
        i = i - sequence[i + 1];
    }

    // Return the count of occurrence
    return count;
}

// Driver code
int main()
{

    // Pre-compute Van Eck's sequence
    vanEckSequence();

    int n = 5;

    // Print count of the occurrence of nth term
    // in first n terms of the sequence
    cout << getCount(n) << endl;

    n = 11;

    // Print count of the occurrence of nth term
    // in first n terms of the sequence
    cout << getCount(n) << endl;

    return 0;
}

Java

// Java program to count the occurrence
// of nth term in first n terms
// of Van Eck's sequence

class GFG {

    static int MAX = 100000;
    static int sequence[] = new int[MAX + 1];

    // Utility function to compute
    // Van Eck's sequence
    static void vanEckSequence()
    {

        // Initialize sequence array
        for (int i = 0; i < MAX; i++) {
            sequence[i] = 0;
        }

        // Loop to generate sequence
        for (int i = 0; i < MAX; i++) {

            // Check if sequence[i] has occurred
            // previously or is new to sequence
            for (int j = i - 1; j >= 0; j--) {
                if (sequence[j] == sequence[i]) {

                    // If occurrence found
                    // then the next term will be
                    // how far back this last term
                    // occurred previously
                    sequence[i + 1] = i - j;
                    break;
                }
            }
        }
    }

    // Utility function to count
    // the occurrence of nth term
    // in first n terms of the sequence
    static int getCount(int n)
    {

        // Initialize count as 1
        int count = 1;

        int i = n - 1;
        while (sequence[i + 1] != 0) {

            // Increment count if (i+1)th term
            // is non-zero
            count++;

            // Previous occurrence of sequence[i]
            // will be it (i - sequence[i+1])th position
            i = i - sequence[i + 1];
        }

        // Return the count of occurrence
        return count;
    }

    // Driver code
    public static void main(String[] args)
    {

        // Pre-compute Van Eck's sequence
        vanEckSequence();

        int n = 5;

        // Print count of the occurrence of nth term
        // in first n terms of the sequence
        System.out.println(getCount(n));

        n = 11;

        // Print count of the occurrence of nth term
        // in first n terms of the sequence
        System.out.println(getCount(n));
    }
}

Python3

# Python3 program to count the occurrence
# of nth term in first n terms
# of Van Eck's sequence
MAX = 10000
sequence = [0] * (MAX + 1);

# Utility function to compute
# Van Eck's sequence
def vanEckSequence() :

    # Loop to generate sequence
    for i in range(MAX) :

        # Check if sequence[i] has occurred
        # previously or is new to sequence
        for j in range( i - 1, -1, -1) :
            if (sequence[j] == sequence[i]) :

                # If occurrence found
                # then the next term will be
                # how far back this last term
                # occurred previously
                sequence[i + 1] = i - j;
                break;

# Utility function to count
# the occurrence of nth term
# in first n terms of the sequence
def getCount(n) :

    # Initialize count as 1
    count = 1;

    i = n - 1;

    while (sequence[i + 1] != 0) :

        # Increment count if (i+1)th term
        # is non-zero
        count += 1;

        # Previous occurrence of sequence[i]
        # will be it (i - sequence[i+1])th position
        i = i - sequence[i + 1];

    # Return the count of occurrence
    return count;

# Driver code
if __name__ == "__main__" :

    # Pre-compute Van Eck's sequence
    vanEckSequence();

    n = 5;

    # Print count of the occurrence of nth term
    # in first n terms of the sequence
    print(getCount(n));

    n = 11;

    # Print count of the occurrence of nth term
    # in first n terms of the sequence
    print(getCount(n)) ;

# This code is contributed by AnkitRai01

C#

// C# program to count the occurrence
// of nth term in first n terms
// of Van Eck's sequence

using System;
class GFG {

    static int MAX = 100000;
    static int[] sequence = new int[MAX + 1];

    // Utility function to compute
    // Van Eck's sequence
    static void vanEckSequence()
    {

        // Initialize sequence array
        for (int i = 0; i < MAX; i++) {
            sequence[i] = 0;
        }

        // Loop to generate sequence
        for (int i = 0; i < MAX; i++) {

            // Check if sequence[i] has occurred
            // previously or is new to sequence
            for (int j = i - 1; j >= 0; j--) {
                if (sequence[j] == sequence[i]) {

                    // If occurrence found
                    // then the next term will be
                    // how far back this last term
                    // occurred previously
                    sequence[i + 1] = i - j;
                    break;
                }
            }
        }
    }

    // Utility function to count
    // the occurrence of nth term
    // in first n terms of the sequence
    static int getCount(int n)
    {

        // Initialize count as 1
        int count = 1;
        int i = n - 1;

        while (sequence[i + 1] != 0) {

            // Increment count if (i+1)th term
            // is non-zero
            count++;

            // Previous occurrence of sequence[i]
            // will be it (i - sequence[i+1])th position
            i = i - sequence[i + 1];
        }

        // Return the count of occurrence
        return count;
    }

    // Driver code
    public static void Main(string[] args)
    {

        // Pre-compute Van Eck's sequence
        vanEckSequence();

        int n = 5;

        // Print count of the occurrence of nth term
        // in first n terms of the sequence
        Console.WriteLine(getCount(n));

        n = 11;

        // Print count of the occurrence of nth term
        // in first n terms of the sequence
        Console.WriteLine(getCount(n));
    }
}

Javascript

// JS program to count the occurrence
// of nth term in first n terms
// of Van Eck's sequence

let MAX = 100000;
let sequence = new Array(MAX + 1);

// Utility function to compute
// Van Eck's sequence
function vanEckSequence()
{

    // Initialize sequence array
    for (var i = 0; i < MAX; i++) {
        sequence[i] = 0;
    }

    // Loop to generate sequence
    for (var i = 0; i < MAX; i++) {

        // Check if sequence[i] has occurred
        // previously or is new to sequence
        for (var j = i - 1; j >= 0; j--) {
            if (sequence[j] == sequence[i]) {

                // If occurrence found
                // then the next term will be
                // how far back this last term
                // occurred previously
                sequence[i + 1] = i - j;
                break;
            }
        }
    }
}

// Utility function to count
// the occurrence of nth term
// in first n terms of the sequence
function getCount(n)
{

    // Initialize count as 1
    let count = 1;
    let i = n - 1;

    while (sequence[i + 1] != 0) {

        // Increment count if (i+1)th term
        // is non-zero
        count++;

        // Previous occurrence of sequence[i]
        // will be it (i - sequence[i+1])th position
        i = i - sequence[i + 1];
    }

    // Return the count of occurrence
    return count;
}

// Driver code

// Pre-compute Van Eck's sequence
vanEckSequence();

let n = 5;

// Print count of the occurrence of nth term
// in first n terms of the sequence
console.log(getCount(n));

n = 11;

// Print count of the occurrence of nth term
// in first n terms of the sequence
console.log(getCount(n));

// This code is contributed by phasing17

Output

1
5

Time Complexity: O(MAX*MAX)
Auxiliary Space: O(MAX)