Program to find Nth term of the Van Eck’s Sequence

Given a positive integer N, the task is to print N^th term of the Van Eck’s sequence.
In mathematics, Van Eck’s sequence is an integer sequence which is defined recursively as follows: 

• Let the first term be 0 i.e a₀ = 0.
• Then for n >= 0, if there exists an m < n such that

am = an

• take the largest such m and set a_n+1 = n − m;
• Otherwise a_n+1 = 0.
• Start with a(1)=0.

First few terms of Van Eck’s Sequence are as follows: 

0, 0, 1, 0, 2, 0, 2, 2, 1, 6, 0, 5, 0, 2, 6, 5, 4, 0, 5 … 

Example:

Input: N = 5
Output: 2
Input: N = 10
Output: 6 

Approach:
As described above we can follow the below steps to generate Van Eck’s sequence: 

• Set the first term of the sequence as 0.
• Then Repeatedly apply: 
  • If the last term has not occurred yet and is new to the sequence so far then, set the next term as zero.
  • Otherwise, the next term is how far back this last term has occurred previously.
• Once the sequence is generated we can get our n^th term easily.

Below is the implementation of above approach: 

C++

// C++ program to print Nth
// term of Van Eck's sequence

#include <bits/stdc++.h>
using namespace std;

#define MAX 1000
int sequence[MAX];

// 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 return
// Nth term of sequence
int getNthTerm(int n)
{

    return sequence[n];
}

// Driver code
int main()
{

    // Pre-compute Van Eck's sequence
    vanEckSequence();

    int n = 6;

    // Print nth term of the sequence
    cout << getNthTerm(n) << endl;

    n = 100;

    // Print nth term of the sequence
    cout << getNthTerm(n) << endl;

    return 0;
}

Java

// Java program to print Nth
// term of Van Eck's sequence

class GFG {

    static int MAX = 1000;

    // Array to store terms of sequence
    static int sequence[] = new int[MAX];

    // Utility function to compute
    // Van Eck's sequence
    static void vanEckSequence()
    {

        // Initialize sequence array
        for (int i = 0; i < MAX - 1; i++) {
            sequence[i] = 0;
        }

        // Loop to generate sequence
        for (int i = 0; i < MAX - 1; 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 return
    // Nth term of sequence
    static int getNthTerm(int n)
    {

        return sequence[n];
    }

    // Driver code
    public static void main(String[] args)
    {

        // Pre-compute Van Eck's sequence
        vanEckSequence();

        int n = 6;

        // Print nth term of the sequence
        System.out.println(getNthTerm(n));

        n = 100;

        // Print nth term of the sequence
        System.out.println(getNthTerm(n));
    }
}

Python3

# Python3 program to print Nth
# term of Van Eck's sequence
MAX = 1000
sequence = [0] * (MAX + 1);

# Utility function to compute
# Van Eck's sequence
def vanEckSequence() :

    # Initialize sequence array
    for i in range(MAX) :
        sequence[i] = 0;

    # 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 return
# Nth term of sequence
def getNthTerm(n) :

    return sequence[n];

# Driver code
if __name__ == "__main__" :

    # Pre-compute Van Eck's sequence
    vanEckSequence();

    n = 6;

    # Print nth term of the sequence
    print(getNthTerm(n));

    n = 100;

    # Print nth term of the sequence
    print(getNthTerm(n));

# This code is contributed by kanugargng

C#

// C# program to print Nth
// term of Van Eck's sequence

using System;
class GFG {

    static int MAX = 1000;

    // Array to store terms of sequence
    static int[] sequence = new int[MAX];

    // Utility function to compute
    // Van Eck's sequence
    static void vanEckSequence()
    {

        // Initialize sequence array
        for (int i = 0; i < MAX - 1; i++) {
            sequence[i] = 0;
        }

        // Loop to generate sequence
        for (int i = 0; i < MAX - 1; 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 return
    // Nth term of sequence
    static int getNthTerm(int n)
    {

        return sequence[n];
    }

    // Driver code
    public static void Main()
    {

        // Pre-compute Van Eck's sequence
        vanEckSequence();

        int n = 6;

        // Print nth term of the sequence
        Console.WriteLine(getNthTerm(n));

        n = 100;

        // Print nth term of the sequence
        Console.WriteLine(getNthTerm(n));
    }
}

Javascript

<script>

function getVanEckSequence(n) {
    let result = [0];
      let dir = {};

      for( let i = 0 ; i < n ; i++) {
          const currentData = result[i];
        const currentPosition = i + 1;

        // If number is already there, then insert the difference of positions.
        if (dir[currentData]) {
            result.push(currentPosition - dir[currentData]);
        } else {
             result.push(0);
        }

        // Update with the latest position
        dir[currentData] = currentPosition;

    }
    return result;
}

console.log(getVanEckSequence(100));


// This code is contributed by Devesh
</script>

Output

2
23

Time Complexity: O(MAX²)
Auxiliary Space: O(MAX)

Method 2: Using lambda functions
There is no need to store the entire sequence to get the value of n^th term. We can recursively build the series upto nth term and find only the value of n^th term using the lambda expression.
Below is the implementation of the above approach using lambda function: 

C++

#include <iostream>
#include <vector>
using namespace std;

int vanEck(int n) {
    vector<int> s(n + 1, 0);
    int l = 0;
    for (int i = 1; i <= n; i++) {
        if (l == 0 || s[l] != 0) {
            s[i] = 0;
            l = (s[l] == 0) ? (i - 1) : (i - s[l]);
        } else {
            s[i] = 0;
            l = i - 1;
        }
    }
    return l;
}

int main() {
    int n = 6;
    cout << vanEck(n) << endl;

    n = 100;
    cout << vanEck(n) << endl;

    return 0;
}

Java

public class VanEckSequence {
    public static int vanEck(int n) {
        int[] s = new int[n + 1];
        int l = 0;
        for (int i = 1; i <= n; i++) {
            if (l == 0 || s[l] != 0) {
                s[i] = 0;
                l = s[l] == 0 ? i - 1 : i - s[l];
            } else {
                s[i] = 0;
                l = i - 1;
            }
        }
        return l;
    }

    public static void main(String[] args) {
        int n = 6;
        System.out.println(vanEck(n));

        n = 100;
        System.out.println(vanEck(n));
    }
}

Python3

# Python3 program to find
# Nth term of Van Eck's sequence
# using the lambda expression

# Lambda function
f = lambda n, l = 0, *s: f(n-1, l in s and ~s.index(l), l, *s) \
    if n else -l

# The above lambda function recursively
# build the sequence and store it in tuple s

# The expression l in s and ~s.index(l)
# returns False if l is not present in tuple s
# otherwise, returns the negation of the value of
# the index of l in tuple s
# and is appended to tuple s
# Thus, tuple s store negation of all the elements
# of the sequence in reverse order

# At the end, when n reaches 0, function converts
# the nth term back to its actual value
# and returns it.


# Driver code
n = 6

# Get Nth term of the sequence
print(f(n))

n = 100
# Get Nth term of the sequence
print(f(n))

C#

using System;

public class VanEckSequence
{
    public static int VanEck(int n)
    {
        int[] s = new int[n + 1];
        int l = 0;
        for (int i = 1; i <= n; i++)
        {
            if (l == 0 || s[l] != 0)
            {
                s[i] = 0;
                l = s[l] == 0 ? i - 1 : i - s[l];
            }
            else
            {
                s[i] = 0;
                l = i - 1;
            }
        }
        return l;
    }

    public static void Main(string[] args)
    {
        int n = 6;
        Console.WriteLine(VanEck(n));

        n = 100;
        Console.WriteLine(VanEck(n));
    }
}

Javascript

// Lambda function
const f = (n, l = 0, ...s) =>
  // Recursively build the sequence and store it in array s
  n ? f(n-1, s.includes(l) ? ~s.indexOf(l) : 0, l, ...s) :
  // Convert the nth term back to its actual value and return it
  -l;

// The expression s.includes(l) ? ~s.indexOf(l) : 0
// returns 0 if l is not present in array s
// otherwise, returns the negation of the value of
// the index of l in array s
// and is appended to array s
// Thus, array s store negation of all the elements
// of the sequence in reverse order

// Driver code
let x= 6;

// Get Nth term of the sequence
console.log(f(x));

x = 100;

// Get Nth term of the sequence
console.log(f(x));

Output

2
23

Time Complexity: O(n)
Auxiliary Space: O(n)

Reference: https://codegolf.stackexchange.com/questions/186654/nth-term-of-van-eck-sequence