# 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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 ` `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:

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 ` `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 DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up self motivated and passionate programmer

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.