 Open in App
Not now

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

• Last Updated : 26 Oct, 2021

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++

 `// C++ program for the above approach``#include ``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);` `    ``// Function Call``    ``print_result(restore(arr, N));``    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;``class` `GFG{` `// Function that returns the restored``// permutation``static` `Vector restore(``int` `arr[], ``int` `N)``{``    ``// Vector to store the result``    ``Vector result = ``new` `Vector<>();` `    ``// Map to mark the elements``    ``// which are taken in result``    ``HashMap mp = ``new` `HashMap();``    ``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 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`

## Python3

 `# 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`

## C#

 `// 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`

## Javascript

 ``

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++

 `// C++ program for the above approach``#include ``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);` `    ``// Function Call``    ``print_result(restore(arr, N));``    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{` `// Function that returns the restored``// permutation``static` `Vector restore(``int` `arr[], ``int` `N)``{``    ` `    ``// Vector to store the result``    ``Vector result = ``new` `Vector();``    ` `    ``int` `count1 = ``1``;` `    ``// Set to insert unique elements``    ``HashSet s = ``new` `HashSet();``    ` `    ``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 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`

## Python3

 `# Python3 program for the``# above approach` `# Function that returns the``# restored permutation``def` `restore(arr, N):` `    ``# Vector to store the``    ``# result``    ``result ``=` `[]``    ``count1 ``=` `1` `    ``# Set to insert unique``    ``# elements``    ``s ``=` `set``([])``    ` `    ``for` `i ``in` `range``(N):``        ``s.add(arr[i])` `        ``# Check if the element is``        ``# coming first time``        ``if` `(``len``(s) ``=``=` `count1):` `            ``# Push in result vector``            ``result.append(arr[i])` `            ``count1 ``+``=` `1` `    ``return` `result` `# Function to print the``# result``def` `print_result(result):` `    ``for` `i ``in` `range``(``len``(result)):``        ``print``(result[i],``              ``end ``=` `" "``)` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``# Given Array``    ``arr ``=` `[``1``, ``13``, ``1``, ``24``,``           ``13``, ``24``, ``2``, ``2``]` `    ``N ``=` `len``(arr)` `    ``# Function Call``    ``print_result(restore(arr, N))` `# This code is contributed by Chitranayal`

## C#

 `// 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`

## Javascript

 ``

Output:

`1 13 24 2`

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

My Personal Notes arrow_drop_up