Find original sequence from Array containing the sequence merged many times in order

Given a number N and an array arr[] that consist of merging N length sequence of distinct integers any number of times maintaining the relative order of elements in the initial sequence. The task is to find the initial sequence of length N maintaining the right order.

Examples:

Input: N = 4, arr[] = {1, 13, 1, 24, 13, 24, 2, 2}
Output: 1 13 24 2 
Explanation: 
Here the given sequence is obtained by merging 1 13 24 2 maintaining the relative order of elements. Therefore, the answer is 1 13 24 2.

Input: N = 3, arr[] = {3, 2, 3, 1, 2, 3, 2, 1, 1}
Output: 3 2 1
Explanation:
Here the given sequence is obtained by merging 3 2 1 maintaining the relative order of elements. Therefore, the answer is 3 2 1.

Approach: The idea is to observe that the element occurring first in the given sequence is the first element of the resultant restored sequence. Take that element in our restored sequence and don’t include duplicate from the given sequence. Perform the same for the rest of the elements until we reach the end. The idea can be implemented by both Map and Set in C++.



Using Map

  1. Traverse through the given sequence from left to right.
  2. The element coming for the first time in the sequence is taken into account and marked using a map.
  3. Elements that are marked while traversing are ignored.
  4. Step 2 and Step 3 is continued until the end of the given sequence is reached.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ prpgram for the above approach
#include <bits/stdc++.h>
using namespace std;
  
// Function that returns the restored
// permutation
vector<int> restore(int arr[], int N)
{
    // Vector to store the result
    vector<int> result;
  
    // Map to mark the elements
    // which are taken in result
    map<int, int> mp;
    for (int i = 0; i < N; i++) {
  
        // Check if the element is
        // coming first time
        if (mp[arr[i]] == 0) {
  
            // Push in result vector
            result.push_back(arr[i]);
  
            // Mark it in the map
            mp[arr[i]]++;
        }
    }
  
    // Return the answer
    return result;
}
  
// Function to print the result
void print_result(vector<int> result)
{
    for (int i = 0; i < result.size(); i++)
        cout << result[i] << " ";
}
  
// Driver Code
int main()
{
    // Given Array
    int arr[] = { 1, 13, 1, 24, 13, 24, 2, 2 };
  
    int N = sizeof(arr) / sizeof(arr[0]);
  
    // Function Call
    print_result(restore(arr, N));
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java prpgram for the above approach
import java.util.*;
class GFG{
  
// Function that returns the restored
// permutation
static Vector<Integer> restore(int arr[], int N)
{
    // Vector to store the result
    Vector<Integer> result = new Vector<>();
  
    // Map to mark the elements
    // which are taken in result
    HashMap<Integer,
            Integer> mp = new HashMap<Integer,
                                      Integer>();
    for (int i = 0; i < N; i++)
    {
  
        // Check if the element is
        // coming first time
        if (mp.containsKey(arr[i]) && 
            mp.get(arr[i]) == 0
        {
  
            // Push in result vector
            result.add(arr[i]);
  
            // Mark it in the map
            if(mp.containsKey(arr[i]))
            {
                mp.put(arr[i], mp.get(arr[i]) + 1);
            }
            else
            {
                mp.put(arr[i], 1);
            }
        }
        else
            mp.put(arr[i], 0);
    }
  
    // Return the answer
    return result;
}
  
// Function to print the result
static void print_result(Vector<Integer> result)
{
    for (int i = 0; i < result.size(); i++)
        System.out.print(result.get(i) + " ");
}
  
// Driver Code
public static void main(String[] args)
{
    // Given Array
    int arr[] = { 1, 13, 1, 24, 13, 24, 2, 2 };
  
    int N = arr.length;
  
    // Function Call
    print_result(restore(arr, N));
}
}
  
// This code is contributed by Rajput-Ji

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program for the above approach
  
# Function that returns the restored
# permutation
def restore(arr, N):
      
    # List to store the result
    result = []
      
    # Map to mark the elements
    # which are taken in result
    mp = {}
      
    for i in range(N):
          
        # Checking if the element is 
        # coming first time
        if not arr[i] in mp:
              
            # Push in result vector
            result.append(arr[i])
              
            # Mark it in the map
            mp[arr[i]] = 1
              
    # Return the answer
    return result
  
# Function to print the result
def print_result(result):
      
    for i in range(len(result)):
        print(result[i], end = " ")
          
# Driver code
def main():
      
    # Given array
    arr = [ 1, 13, 1, 24, 13, 24, 2, 2 ]
    N = len(arr)
      
    # Function call
    print_result(restore(arr, N))
      
main()
      
# This code is contributed by Stuti Pathak

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for the above approach
using System;
using System.Collections.Generic;
  
class GFG{
  
// Function that returns the restored
// permutation
static List<int> restore(int []arr, int N)
{
      
    // List to store the result
    List<int> result = new List<int>();
  
    // Map to mark the elements
    // which are taken in result
    Dictionary<int,
               int> mp = new Dictionary<int,
                                        int>();
    for(int i = 0; i < N; i++)
    {
          
        // Check if the element is
        // coming first time
        if (mp.ContainsKey(arr[i]) && 
            mp[arr[i]] == 0) 
        {
              
            // Push in result vector
            result.Add(arr[i]);
  
            // Mark it in the map
            if(mp.ContainsKey(arr[i]))
            {
                mp[arr[i]] = mp[arr[i]] + 1;
            }
            else
            {
                mp.Add(arr[i], 1);
            }
        }
        else
            mp.Add(arr[i], 0);
    }
  
    // Return the answer
    return result;
}
  
// Function to print the result
static void print_result(List<int> result)
{
    for(int i = 0; i < result.Count; i++)
        Console.Write(result[i] + " ");
}
  
// Driver Code
public static void Main(String[] args)
{
      
    // Given Array
    int []arr = { 1, 13, 1, 24, 13, 24, 2, 2 };
  
    int N = arr.Length;
  
    // Function call
    print_result(restore(arr, N));
}
}
  
// This code is contributed by 29AjayKumar

chevron_right


Output: 

1 13 24 2

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

Using Set

  1. Traverse through the given sequence from left to right.
  2. A counter is taken and initialized as 1.
  3. Insert the elements into the set one by one. If at some point that the size of the set and the counter is the same, the element is taken into account and the counter is increased by 1.
  4. Step 3 and Step 4 is continued until the end of the given sequence is reached.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
  
// Function that returns the restored
// permutation
vector<int> restore(int arr[], int N)
{
    // Vector to store the result
    vector<int> result;
    int count1 = 1;
  
    // Set to insert unique elements
    set<int> s;
    for (int i = 0; i < N; i++) {
  
        s.insert(arr[i]);
  
        // Check if the element is
        // coming first time
        if (s.size() == count1) {
  
            // Push in result vector
            result.push_back(arr[i]);
  
            count1++;
        }
    }
  
    return result;
}
  
// Function to print the result
void print_result(vector<int> result)
{
    for (int i = 0; i < result.size(); i++)
        cout << result[i] << " ";
}
  
// Driver Code
int main()
{
    // Given Array
    int arr[] = { 1, 13, 1, 24, 13, 24, 2, 2 };
  
    int N = sizeof(arr) / sizeof(arr[0]);
  
    // Function Call
    print_result(restore(arr, N));
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program for the above approach
import java.util.*;
  
class GFG{
  
// Function that returns the restored
// permutation
static Vector<Integer> restore(int arr[], int N)
{
      
    // Vector to store the result
    Vector<Integer> result = new Vector<Integer>();
      
    int count1 = 1;
  
    // Set to insert unique elements
    HashSet<Integer> s = new HashSet<Integer>();
      
    for(int i = 0; i < N; i++) 
    {
        s.add(arr[i]);
  
        // Check if the element is
        // coming first time
        if (s.size() == count1)
        {
              
            // Push in result vector
            result.add(arr[i]);
            count1++;
        }
    }
    return result;
}
  
// Function to print the result
static void print_result(Vector<Integer> result)
{
    for(int i = 0; i < result.size(); i++)
        System.out.print(result.get(i) + " ");
}
  
// Driver Code
public static void main(String[] args)
{
      
    // Given Array
    int arr[] = { 1, 13, 1, 24, 13, 24, 2, 2 };
  
    int N = arr.length;
  
    // Function call
    print_result(restore(arr, N));
}
}
  
// This code is contributed by Princi Singh

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG{
  
// Function that returns the restored
// permutation
static List<int> restore(int []arr, int N)
{
      
    // List to store the result
    List<int> result = new List<int>();
      
    int count1 = 1;
  
    // Set to insert unique elements
    HashSet<int> s = new HashSet<int>();
      
    for(int i = 0; i < N; i++) 
    {
        s.Add(arr[i]);
  
        // Check if the element is
        // coming first time
        if (s.Count == count1)
        {
              
            // Push in result vector
            result.Add(arr[i]);
            count1++;
        }
    }
    return result;
}
  
// Function to print the result
static void print_result(List<int> result)
{
    for(int i = 0; i < result.Count; i++)
        Console.Write(result[i] + " ");
}
  
// Driver Code
public static void Main(String[] args)
{
      
    // Given Array
    int []arr = { 1, 13, 1, 24, 13, 24, 2, 2 };
  
    int N = arr.Length;
  
    // Function call
    print_result(restore(arr, N));
}
}
  
// This code is contributed by PrinciRaj1992

chevron_right


Output: 

1 13 24 2

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up

Recommended Posts:


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.