Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

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

  • Last Updated : 07 Feb, 2020

Prerequisite: Van Eck’s sequence

Given a positive integer N, the task is to count the occurrences of Nth term in 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 Nth term
    • Iterate through the generated sequence and count the occurrence of Nth term.

    To serve multiple queries we can pre-compute the Van Eck’s sequence.

    Below is the implementation of 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 occured
            // 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
                    // occured 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 occured
                // 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
                        // occured 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 occured 
            # 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 
                    # occured 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 occured
                // 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
                        // occured 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));
        }
    }
    Output:
    1
5

  2. 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 ith 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 Nth term of the sequence as SN
      • If SN+1 is non-zero then increment count
        and do the same for (N- SN+1)th term
      • And if SN+1 is zero then stop.
    Below is the implementation of above approach:
    CPP



    // 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 occured
            // 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
                    // occured 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 occured
                // 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
                        // occured 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 occured 
            # 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 
                    # occured 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 occured
                // 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
                        // occured 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));
        }
    }
    Output:
    1
5


My Personal Notes
arrow_drop_up
Previous
Program to find Nth term of the Van Eck's Sequence
Next

Replace every element in a circular array by sum of next K elements
Recommended Articles
Page :
Nth term where K+1th term is product of Kth term with difference of max and min digit of Kth term
22, May 20
Program to find Nth term of the Van Eck's Sequence
25, Nov 19
Nth term of given recurrence relation having each term equal to the product of previous K terms
06, Oct 20
Nth term of a sequence formed by sum of current term with product of its largest and smallest digit
28, May 20
First term from given Nth term of the equation F(N) = (2 * F(N - 1)) % 10^9 + 7
29, Oct 20
Sum of P terms of an AP if Mth and Nth terms are given
10, Jan 19
Find Pth term of a GP if Mth and Nth terms are given
11, Jan 19
Print the sequence of size N in which every term is sum of previous K terms
17, Apr 20
Find the Nth term of the series where each term f[i] = f[i - 1] - f[i - 2]
19, Feb 19
Find Nth term of the series where each term differs by 6 and 2 alternately
09, Apr 20
Number of quadruples where the first three terms are in AP and last three terms are in GP
01, Mar 19
Finding nth term of any Polynomial Sequence
21, Feb 18
Find nth term of the Dragon Curve Sequence
24, Apr 18
Finding the Nth term in a sequence formed by removing digit K from natural numbers
21, Sep 21
Sum of first N terms of Quadratic Sequence 3 + 7 + 13 + ...
02, Nov 18
Print first N terms of Lower Wythoff sequence
21, Jun 19
Count sequences of length K having each term divisible by its preceding term
30, Jun 20
Ratio of mth and nth terms of an A. P. with given ratio of sums
10, Oct 18
Sum of nth terms of Modified Fibonacci series made by every pair of two arrays
30, Oct 18
Sum of series till N-th term whose i-th term is i^k - (i-1)^k
10, Aug 18
Count of distinct integers belonging to first N terms of at least one of given GPs
20, Sep 21
Print N terms of Withoff Sequence
12, Aug 19
Program to print the sum of the given nth term
14, Apr 18
Program to get the Sum of series: 1 - x^2/2! + x^4/4! -.... upto nth term
21, Dec 17
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
ihritik
@ihritik
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!