Skip to content
Related Articles

Related Articles

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
    

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up
Recommended Articles
Page :