Prerequisite: Van Eck’s sequence Given a positive integer N, the task is to count the occurrences of Nth term in the 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
-
Naive Approach:
- Generate Van Eck’s sequence upto Nth term
- Iterate through the generated sequence and count the occurrence of Nth term.
Below is the implementation of the above approach:
// 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 occurred
// 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
// occurred 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 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 occurred
// 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
// occurred 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 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 occurred
# 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
# occurred 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# 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 occurred
// 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
// occurred 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));
}
} |
// Define MAX const MAX = 10000; // Create sequence array let sequence = new Array(MAX + 1).fill(0);
//Javascript Equivalent // Utility function to compute Van Eck's sequence function vanEckSequence() {
// Loop to generate sequence
for (let i = 0; i <= MAX; i++) {
// Check if sequence[i] has occurred previously or is new to sequence
for (let 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 occurred previously
sequence[i + 1] = i - j;
break ;
}
}
}
} // Utility function to count the occurrence // of nth term in first n terms of the sequence function getCount(n) {
// Get nth term of the sequence
let nthTerm = sequence[n - 1];
let count = 0;
// Count the occurrence of nth term
// in first n terms of the sequence
for (let i = 0; i < n; i++) {
if (sequence[i] == nthTerm) {
count++;
}
}
// Return count
return count;
} // Driver code // Pre-compute Van Eck's sequence
vanEckSequence();
let n = 5;
// Print count of the occurrence of nth
// term in first n terms of the sequence
console.log(getCount(n));
n = 11;
// Print count of the occurrence of nth
// term in first n terms of the sequence
console.log(getCount(n));
|
1 5
-
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 the count and do the same for (N- SN+1)th term
- And if SN+1 is zero then stop.
Below is the implementation of the above approach:
// 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 occurred
// 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
// occurred 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 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 occurred
// 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
// occurred 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 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 occurred
# 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
# occurred 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# 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 occurred
// 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
// occurred 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));
}
} |
// JS program to count the occurrence // of nth term in first n terms // of Van Eck's sequence let MAX = 100000; let sequence = new Array(MAX + 1);
// Utility function to compute // Van Eck's sequence function vanEckSequence()
{ // Initialize sequence array
for ( var i = 0; i < MAX; i++) {
sequence[i] = 0;
}
// Loop to generate sequence
for ( var i = 0; i < MAX; i++) {
// Check if sequence[i] has occurred
// previously or is new to sequence
for ( var 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
// occurred previously
sequence[i + 1] = i - j;
break ;
}
}
}
} // Utility function to count // the occurrence of nth term // in first n terms of the sequence function getCount(n)
{ // Initialize count as 1
let count = 1;
let 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 // Pre-compute Van Eck's sequence vanEckSequence(); let n = 5; // Print count of the occurrence of nth term // in first n terms of the sequence console.log(getCount(n)); n = 11; // Print count of the occurrence of nth term // in first n terms of the sequence console.log(getCount(n)); // This code is contributed by phasing17 |
1 5
Time Complexity: O(MAX*MAX)
Auxiliary Space: O(MAX)