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 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++

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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;
    }

    chevron_right

    
    

    Java

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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));
        }
    }

    chevron_right

    
    

    Python3

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    # 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

    chevron_right

    
    

    C#

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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));
        }
    }

    chevron_right

    
    

    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

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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;
    }

    chevron_right

    
    

    Java

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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));
        }
    }

    chevron_right

    
    

    Python3

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    # 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

    chevron_right

    
    

    C#

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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));
        }
    }

    chevron_right

    
    

    Output:

    1
    5
    



My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

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 Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : AnkitRai01

Article Tags :
Practice Tags :


Be the First to upvote.


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