Minimum array elements to be changed to make Recaman’s sequence

Given an array arr[] of N elements. The task is to find the minimum number of elements to be changed in the array such that the array contains first N Recaman’s Sequence terms. Note that Recaman terms may be present in any order in the array.
First few terms of Recaman’s Sequence are:

0, 1, 3, 6, 2, 7, 13, 20, 12, 21, 11, 22, 10, 23, 9, 24, 8, …..

Examples:

Input: arr[] = {44, 0, 2, 3, 9}
Output: 2
N = 5 and first 5 Recaman Numbers are 0, 1, 3, 6 and 2
44 and 9 must be replaced with 6 and 1
Hence 2 changes are required.

Input: arr[] = {0, 33, 3, 1}
Output: 1



Approach:

  • Insert first N Recaman’s Sequence terms in a set.
  • Traverse the array from left to right and check if array element is present in the set.
  • If current element is present in the set that remove it from the set.
  • Minimum changes required is the size of the final reduced set.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
  
int recamanGenerator(int arr[], int n)
{
    // First term of the sequence is always 0
    arr[0] = 0;
  
    // Fill remaining terms using recursive
    // formula
    for (int i = 1; i <= n; i++) {
        int temp = arr[i - 1] - i;
        int j;
  
        for (j = 0; j < i; j++) {
  
            // If arr[i-1] - i is negative or
            // already exists
            if ((arr[j] == temp) || temp < 0) {
                temp = arr[i - 1] + i;
                break;
            }
        }
  
        arr[i] = temp;
    }
}
  
// Function that returns minimum changes required
int recamanArray(int arr[], int n)
{
  
    // Set to store first n Recaman numbers
    unordered_set<int> s;
  
    // Generate and store
    // first n Recaman numbers
    int recaman[n];
    recamanGenerator(recaman, n);
  
    // Insert first n Recaman numbers to set
    for (int i = 0; i < n; i++)
        s.insert(recaman[i]);
  
    for (int i = 0; i < n; i++) {
  
        // If current element of the array
        // is present in the set
        auto it = s.find(arr[i]);
        if (it != s.end())
            s.erase(it);
    }
  
    // Return the remaining number of
    // elements in the set
    return s.size();
}
  
// Driver code
int main()
{
  
    int arr[] = { 7, 11, 20, 4, 2, 1, 8, 6 };
    int n = sizeof(arr) / sizeof(arr[0]);
  
    cout << recamanArray(arr, n);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the approach
import java.util.*;
  
class GFG
{
  
static int recamanGenerator(int arr[], int n)
{
    // First term of the sequence is always 0
    arr[0] = 0;
  
    // Fill remaining terms using recursive
    // formula
    for (int i = 1; i <= n; i++) 
    {
        int temp = arr[i - 1] - i;
        int j;
  
        for (j = 0; j < i; j++)
        {
  
            // If arr[i-1] - i is negative or
            // already exists
            if ((arr[j] == temp) || temp < 0
            {
                temp = arr[i - 1] + i;
                break;
            }
        }
  
        arr[i] = temp;
    }
    return 0;
}
  
// Function that returns minimum changes required
static int recamanArray(int arr[], int n)
{
      
  
    // Set to store first n Recaman numbers
    Set<Integer> s=new HashSet<Integer>();
  
    // Generate and store
    // first n Recaman numbers
    int recaman[]=new int[n+1];
    recamanGenerator(recaman, n);
  
    // Insert first n Recaman numbers to set
    for (int i = 0; i < n; i++)
        s.add(recaman[i]);
  
    for (int i = 0; i < n; i++) 
    {
        // If current element of the array
        // is present in the set
        if (s.contains(arr[i]))
            s.remove(arr[i]);
    }
  
    // Return the remaining number of
    // elements in the set
    return s.size();
}
  
// Driver code
public static void main(String args[])
{
  
    int arr[] = { 7, 11, 20, 4, 2, 1, 8, 6 };
    int n = arr.length;
  
    System.out.print( recamanArray(arr, n));
}
}
  
// This code is contributed by Arnab Kundu

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation of the approach
def recamanGenerator(arr, n):
      
    # First term of the sequence
    # is always 0
    arr[0] = 0
  
    # Fill remaining terms using 
    # recursive formula
    for i in range(1, n):
        temp = arr[i - 1] - i
        j = 0
  
        for j in range(i):
  
            # If arr[i-1] - i is negative or
            # already exists
            if ((arr[j] == temp) or temp < 0):
                temp = arr[i - 1] + i
                break
  
        arr[i] = temp
  
# Function that returns minimum 
# changes required
def recamanArray(arr, n):
  
    # Set to store first n Recaman numbers
    s = dict()
  
    # Generate and store
    # first n Recaman numbers
    recaman = [0 for i in range(n)]
    recamanGenerator(recaman, n)
  
    # Insert first n Recaman numbers to set
    for i in range(n):
        s[recaman[i]] = s.get(recaman[i], 0) + 1
  
    for i in range(n):
  
        # If current element of the array
        # is present in the set
        if arr[i] in s.keys():
            del s[arr[i]]
  
    # Return the remaining number of
    # elements in the set
    return len(s)
  
# Driver code
arr = [7, 11, 20, 4, 2, 1, 8, 6 ]
n = len(arr)
  
print(recamanArray(arr, n))
  
# This code is contributed
# by mohit kumar

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the approach 
using System;
using System.Collections.Generic; 
  
class GFG 
  
static int recamanGenerator(int []arr, int n) 
    // First term of the sequence is always 0 
    arr[0] = 0; 
  
    // Fill remaining terms using recursive 
    // formula 
    for (int i = 1; i <= n; i++) 
    
        int temp = arr[i - 1] - i; 
        int j; 
  
        for (j = 0; j < i; j++) 
        
  
            // If arr[i-1] - i is negative or 
            // already exists 
            if ((arr[j] == temp) || temp < 0) 
            
                temp = arr[i - 1] + i; 
                break
            
        
  
        arr[i] = temp; 
    
    return 0; 
  
// Function that returns minimum changes required 
static int recamanArray(int []arr, int n) 
      
    // Set to store first n Recaman numbers 
    HashSet<int> s=new HashSet<int>(); 
  
    // Generate and store 
    // first n Recaman numbers 
    int[] recaman=new int[n+1]; 
    recamanGenerator(recaman, n); 
  
    // Insert first n Recaman numbers to set 
    for (int i = 0; i < n; i++) 
        s.Add(recaman[i]); 
  
    for (int i = 0; i < n; i++) 
    
        // If current element of the array 
        // is present in the set 
        if (s.Contains(arr[i])) 
            s.Remove(arr[i]); 
    
  
    // Return the remaining number of 
    // elements in the set 
    return s.Count; 
  
// Driver code 
static void Main() 
  
    int []arr = { 7, 11, 20, 4, 2, 1, 8, 6 }; 
    int n = arr.Length; 
  
    Console.Write( recamanArray(arr, n)); 
  
// This code is contributed by mits

chevron_right


Output:

3


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.





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.