Recaman's sequence

Last Updated : 29 Mar, 2025

Given an integer n. Print first n elements of Recaman’s sequence. Recaman's Sequence starts with 0 as the first term. For each next term, calculate previous term - index (if positive and not already in sequence); otherwise, use previous term + index.

Examples:

Input: n = 6
Output: 0, 1, 3, 6, 2, 7
Explanation: According to Recaman's Sequence:
0 (first term)
0 - 1 is negative, so use 0 + 1 = 1
1 - 2 is negative, so use 1 + 2 = 3
3 - 3 is 0, already in sequence, so use 3 + 3 = 6
6 - 4 = 2 (not in sequence, so use it)
2 - 5 is negative, so use 2 + 5 = 7
Input: n = 17
Output: 0, 1, 3, 6, 2, 7, 13, 20, 12, 21, 11, 22, 10, 23, 9, 24, 8

Table of Content

[Brute Force Approach] Using 2 Nested Loops - O(n^2) Time and O(1) Space
[Expected Approach] Using Hashing - O(n) Time and O(n) Space

[Brute Force Approach] Using 2 Nested Loops - O(n^2) Time and O(1) Space

The idea is to generate the first n terms of Recaman’s sequence by following its recurrence rule. We start with 0 and iteratively compute the next term as previous term - index if it is positive and not already in sequence; otherwise, we use previous term + index.

C++

// C++ Code to print first n terms 
// in Recaman's sequence using 
// BruteForce Approach
#include <bits/stdc++.h>
using namespace std;

// Function to generate Recaman's sequence
vector<int> recamanSequence(int n) {
    vector<int> res(n); 
    res[0] = 0;

    // Generate the sequence
    for (int i = 1; i < n; i++) {
        
        // Calculate previous term - index
        int curr = res[i - 1] - i;
        
        // Check if curr is valid and 
        // not in sequence
        bool exists = false;
        for (int j = 0; j < i; j++) {
            if (res[j] == curr) {
                exists = true;
                break;
            }
        }
        
        // If curr is invalid, use 
        // previous term + index
        if (curr < 0 || exists) {
            curr = res[i - 1] + i;
        }
        
        res[i] = curr; 
    }
    
    return res;
}

int main() {
    int n = 6; 
    vector<int> res = recamanSequence(n);

    for (int x : res) {
        cout << x << " ";
    }
    
    return 0;
}

Java

// Function to generate Recaman's sequence
public class Recaman {
    public static int[] recamanSequence(int n) {
        int[] res = new int[n];
        res[0] = 0;

        // Generate the sequence
        for (int i = 1; i < n; i++) {
            // Calculate previous term - index
            int curr = res[i - 1] - i;

            // Check if curr is valid and not in sequence
            boolean exists = false;
            for (int j = 0; j < i; j++) {
                if (res[j] == curr) {
                    exists = true;
                    break;
                }
            }

            // If curr is invalid, use previous term + index
            if (curr < 0 || exists) {
                curr = res[i - 1] + i;
            }
            res[i] = curr;
        }
        return res;
    }

    public static void main(String[] args) {
        int n = 6;
        int[] res = recamanSequence(n);
        for (int x : res) {
            System.out.print(x + " ");
        }
    }
}

Python

# Function to generate Recaman's sequence
def recaman_sequence(n):
    res = [0] * n

    # Generate the sequence
    for i in range(1, n):
        # Calculate previous term - index
        curr = res[i - 1] - i
        
        # Check if curr is valid and not in sequence
        exists = False
        for j in range(i):
            if res[j] == curr:
                exists = True
                break
        
        # If curr is invalid, use previous term + index
        if curr < 0 or exists:
            curr = res[i - 1] + i
        
        res[i] = curr
    
    return res

n = 6
res = recaman_sequence(n)

for x in res:
    print(x, end=' ')

// Function to generate Recaman's sequence
using System;
using System.Linq;

class Recaman {
    public static int[] RecamanSequence(int n) {
        int[] res = new int[n];
        res[0] = 0;

        // Generate the sequence
        for (int i = 1; i < n; i++) {
            // Calculate previous term - index
            int curr = res[i - 1] - i;

            // Check if curr is valid and not in sequence
            bool exists = res.Take(i).Contains(curr);

            // If curr is invalid, use previous term + index
            if (curr < 0 || exists) {
                curr = res[i - 1] + i;
            }
            res[i] = curr;
        }
        return res;
    }

    static void Main() {
        int n = 6;
        int[] res = RecamanSequence(n);
        foreach (var x in res) {
            Console.Write(x + " ");
        }
    }
}

JavaScript

// Function to generate Recaman's sequence
function recamanSequence(n) {
    let res = new Array(n);
    res[0] = 0;

    // Generate the sequence
    for (let i = 1; i < n; i++) {
        // Calculate previous term - index
        let curr = res[i - 1] - i;
        
        // Check if curr is valid and not in sequence
        let exists = false;
        for (let j = 0; j < i; j++) {
            if (res[j] === curr) {
                exists = true;
                break;
            }
        }
        
        // If curr is invalid, use previous term + index
        if (curr < 0 || exists) {
            curr = res[i - 1] + i;
        }
        
        res[i] = curr;
    }
    
    return res;
}

let n = 6;
let res = recamanSequence(n);

for (let x of res) {
    process.stdout.write(x + ' ');
}

Output

0 1 3 6 2 7

[Expected Approach] Using Hashing - O(n) Time and O(n) Space

The idea is to construct Recaman's sequence efficiently by using hashing to track visited numbers. The approach iterates from 1 to n, computing a candidate value as the previous term minus the index. If this candidate is negative or already exists in seen, we instead add the index. This ensures each number is unique while following the sequence rules.

C++

// C++ Code to print first n terms  
// in Recaman's sequence using  
// Hashing Approach  
#include <bits/stdc++.h>  
using namespace std;  

// Function to generate Recaman's sequence  
vector<int> recamanSequence(int n) {  
    unordered_set<int> s;  
    vector<int> res(n);  
    res[0] = 0;  
    s.insert(0);  

    // Generate the sequence  
    for (int i = 1; i < n; i++) {  
        
        // Calculate previous term - index  
        int curr = res[i - 1] - i;  
        
        // If curr is invalid, use  
        // previous term + index  
        if (curr < 0 || s.count(curr)) {  
            curr = res[i - 1] + i;  
        }  
        
        res[i] = curr;  
        s.insert(curr);  
    }  
    return res;  
}  

int main() {  
    int n = 6;   
    vector<int> res = recamanSequence(n);  
    for (int num : res) {  
        cout << num << " ";  
    }  
    cout << endl;  
    return 0;  
}

Java

import java.util.HashSet;
import java.util.Set;

public class Recaman {
    public static int[] recamanSequence(int n) {
        Set<Integer> s = new HashSet<>();
        int[] res = new int[n];
        res[0] = 0;
        s.add(0);

        // Generate the sequence
        for (int i = 1; i < n; i++) {
            // Calculate previous term - index
            int curr = res[i - 1] - i;

            // If curr is invalid, use previous term + index
            if (curr < 0 || s.contains(curr)) {
                curr = res[i - 1] + i;
            }

            res[i] = curr;
            s.add(curr);
        }
        return res;
    }

    public static void main(String[] args) {
        int n = 6;
        int[] res = recamanSequence(n);
        for (int num : res) {
            System.out.print(num + " ");
        }
    }
}

Python

# Function to generate Recaman's sequence

def recaman_sequence(n):
    s = set()
    res = [0] * n
    res[0] = 0
    s.add(0)

    # Generate the sequence
    for i in range(1, n):
        
        # Calculate previous term - index
        curr = res[i - 1] - i
        
        # If curr is invalid, use previous term + index
        if curr < 0 or curr in s:
            curr = res[i - 1] + i
        
        res[i] = curr
        s.add(curr)
    return res

n = 6
res = recaman_sequence(n)
print(' '.join(map(str, res)))

using System;
using System.Collections.Generic;

class Program {
    static int[] RecamanSequence(int n) {
        HashSet<int> s = new HashSet<int>();
        int[] res = new int[n];
        res[0] = 0;
        s.Add(0);

        // Generate the sequence
        for (int i = 1; i < n; i++) {
            // Calculate previous term - index
            int curr = res[i - 1] - i;

            // If curr is invalid, use previous term + index
            if (curr < 0 || s.Contains(curr)) {
                curr = res[i - 1] + i;
            }

            res[i] = curr;
            s.Add(curr);
        }
        return res;
    }

    static void Main() {
        int n = 6;
        int[] res = RecamanSequence(n);
        Console.WriteLine(string.Join(" ", res));
    }
}

JavaScript

// Function to generate Recaman's sequence

function recamanSequence(n) {
    const s = new Set();
    const res = new Array(n);
    res[0] = 0;
    s.add(0);

    // Generate the sequence
    for (let i = 1; i < n; i++) {
        // Calculate previous term - index
        let curr = res[i - 1] - i;
        
        // If curr is invalid, use previous term + index
        if (curr < 0 || s.has(curr)) {
            curr = res[i - 1] + i;
        }
        
        res[i] = curr;
        s.add(curr);
    }
    return res;
}

const n = 6;
const res = recamanSequence(n);
console.log(res.join(' '));

Output

0 1 3 6 2 7

Recamans sequence | DSA Problem

Analysis of Algorithms

Kishlay Verma

Improve

Article Tags :

Misc
DSA

Practice Tags :

Misc

Recaman's sequence

[Brute Force Approach] Using 2 Nested Loops - O(n^2) Time and O(1) Space

[Expected Approach] Using Hashing - O(n) Time and O(n) Space

Similar Reads

Basics & Prerequisites

Data Structures

Algorithms

Advanced

Interview Preparation

Practice Problem

Thank You!

What kind of Experience do you want to share?