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

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.