# Split the array elements into strictly increasing and decreasing sequence

Given an array of N elements. The task is to split the elements into two arrays say a1[] and a2[] such that one contains strictly increasing elements and the other contains strictly decreasing elements and a1.size() + a2.size() = a.size(). If it is not possible to do so, print -1 or else print both the arrays.

Note: There can be multiple answers and the order of elements needs not to be the same in the child arrays.

Examples:

Input: a[] = {7, 2, 7, 3, 3, 1, 4}
Output: a1[] = {1, 2, 3, 4, 7} , a2[] = {7, 3}

Input: a[] = {1, 2, 2, 1, 1}
Output: -1
It is not possile

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: The following steps are followed to solve the above problem:

• Initialize two vectors v1 and v2 which stores increasing and decreasing numbers.
• Use hashing to know the occurrence of the number in the array.
• If the number appears to come for the first time, then store it in v1.
• If the number appears to come for the second time, then store it in v2.
• If the number appears for more than 2 times, then it is not possible to store to create a strictly increasing and strictly decreasing array.
• At last, sort the first vector in increasing order and the second vector in decreasing order and print them.

Below is the implementation of the above approach:

 `// C++ program to implement ` `// the above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to print both the arrays ` `void` `PrintBothArrays(``int` `a[], ``int` `n) ` `{ ` ` `  `    ``// Store both arrays ` `    ``vector<``int``> v1, v2; ` ` `  `    ``// Used for hashing ` `    ``unordered_map<``int``, ``int``> mpp; ` ` `  `    ``// Iterate for every element ` `    ``for` `(``int` `i = 0; i < n; i++) { ` ` `  `        ``// Increase the count ` `        ``mpp[a[i]]++; ` ` `  `        ``// If first occurrence ` `        ``if` `(mpp[a[i]] == 1) ` `            ``v1.push_back(a[i]); ` ` `  `        ``// If second occurrence ` `        ``else` `if` `(mpp[a[i]] == 2) ` `            ``v2.push_back(a[i]); ` ` `  `        ``// If occurs more than 2 times ` `        ``else` `{ ` `            ``cout << ``"Not possible"``; ` `            ``return``; ` `        ``} ` `    ``} ` ` `  `    ``// Sort in increasing order ` `    ``sort(v1.begin(), v1.end()); ` ` `  `    ``// Print the increasing array ` `    ``cout << ``"Strictly increasing array is:\n"``; ` `    ``for` `(``auto` `it : v1) ` `        ``cout << it << ``" "``; ` ` `  `    ``// Sort in reverse order ` `    ``sort(v2.begin(), v2.end(), greater<``int``>()); ` ` `  `    ``// Print the decreasing array ` `    ``cout << ``"\nStrictly decreasing array is:\n"``; ` `    ``for` `(``auto` `it : v2) ` `        ``cout << it << ``" "``; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` ` `  `    ``int` `a[] = { 7, 2, 7, 3, 3, 1, 4 }; ` `    ``int` `n = ``sizeof``(a) / ``sizeof``(a[0]); ` `    ``PrintBothArrays(a, n); ` ` `  `    ``return` `0; ` `} `

 `// Java program to implement  ` `// the above approach ` `import` `java.util.*; ` ` `  `class` `GFG ` `{ ` `     `  `// Function to print both the arrays  ` `static` `void` `PrintBothArrays(``int` `a[], ``int` `n)  ` `{  ` ` `  `    ``// Store both arrays  ` `    ``Vector v1 = ``new` `Vector(),  ` `                    ``v2 = ``new` `Vector();  ` ` `  `    ``// Used for hashing  ` `    ``HashMap mpp = ``new` `HashMap<>();  ` ` `  `    ``// Iterate for every element  ` `    ``for` `(``int` `i = ``0``; i < n; i++)  ` `    ``{  ` ` `  `        ``// Increase the count  ` `        ``mpp.put(a[i],(mpp.get(a[i]) == ``null``?``0``:mpp.get(a[i]))+``1``);  ` ` `  `        ``// If first occurrence  ` `        ``if` `(mpp.get(a[i]) == ``1``)  ` `            ``v1.add(a[i]);  ` ` `  `        ``// If second occurrence  ` `        ``else` `if` `(mpp.get(a[i]) == ``2``)  ` `            ``v2.add(a[i]);  ` ` `  `        ``// If occurs more than 2 times  ` `        ``else`  `        ``{  ` `            ``System.out.println( ``"Not possible"``);  ` `            ``return``;  ` `        ``}  ` `    ``}  ` ` `  `    ``// Sort in increasing order  ` `    ``Collections.sort(v1);  ` ` `  `    ``// Print the increasing array  ` `    ``System.out.println(``"Strictly increasing array is:"``);  ` `    ``for` `(``int` `i = ``0``; i < v1.size(); i++)  ` `        ``System.out.print(v1.get(i) + ``" "``);  ` ` `  `    ``// Sort  ` `    ``Collections.sort(v2);  ` `    ``Collections.reverse(v2); ` ` `  `    ``// Print the decreasing array  ` `    ``System.out.println(``"\nStrictly decreasing array is:"``);  ` `    ``for` `(``int` `i = ``0``; i < v2.size(); i++)  ` `        ``System.out.print(v2.get(i) + ``" "``); ` `}  ` ` `  `// Driver code  ` `public` `static` `void` `main(String args[]) ` `{  ` `    ``int` `a[] = { ``7``, ``2``, ``7``, ``3``, ``3``, ``1``, ``4` `};  ` `    ``int` `n = a.length;  ` `    ``PrintBothArrays(a, n);  ` `} ` `}  ` ` `  `// This code is contributed by Arnab Kundu `

 `# Python3 program to implement  ` `# the above approach  ` ` `  `# Function to print both the arrays  ` `def` `PrintBothArrays(a, n) : ` ` `  `    ``# Store both arrays  ` `    ``v1, v2 ``=` `[], [];  ` ` `  `    ``# Used for hashing  ` `    ``mpp ``=` `dict``.fromkeys(a, ``0``);  ` ` `  `    ``# Iterate for every element  ` `    ``for` `i ``in` `range``(n) : ` ` `  `        ``# Increase the count  ` `        ``mpp[a[i]] ``+``=` `1``;  ` ` `  `        ``# If first occurrence  ` `        ``if` `(mpp[a[i]] ``=``=` `1``) : ` `            ``v1.append(a[i]);  ` ` `  `        ``# If second occurrence  ` `        ``elif` `(mpp[a[i]] ``=``=` `2``) :  ` `            ``v2.append(a[i]);  ` ` `  `        ``# If occurs more than 2 times  ` `        ``else` `:  ` `            ``print``(``"Not possible"``);  ` `            ``return``;  ` ` `  `    ``# Sort in increasing order  ` `    ``v1.sort();  ` ` `  `    ``# Print the increasing array  ` `    ``print``(``"Strictly increasing array is:"``);  ` `    ``for` `it ``in` `v1: ` `        ``print``(it, end ``=` `" "``);  ` ` `  `    ``# Sort in reverse order  ` `    ``v2.sort(reverse ``=` `True``);  ` ` `  `    ``# Print the decreasing array  ` `    ``print``(``"\nStrictly decreasing array is:"``);  ` `    ``for` `it ``in` `v2 :  ` `        ``print``(it, end ``=` `" "``)  ` ` `  `# Driver code  ` `if` `__name__ ``=``=` `"__main__"` `: ` ` `  `    ``a ``=` `[ ``7``, ``2``, ``7``, ``3``, ``3``, ``1``, ``4` `];  ` `    ``n ``=` `len``(a);  ` `    ``PrintBothArrays(a, n);  ` ` `  `# This code is contributed by Ryuga `

 `// C# program to implement  ` `// the above approach ` `using` `System; ` `using` `System.Collections;  ` `using` `System.Collections.Generic; ` ` `  `class` `GFG ` `{ ` `         `  `    ``// Function to print both the arrays  ` `    ``static` `void` `PrintBothArrays(``int` `[] a, ``int` `n)  ` `    ``{  ` `     `  `        ``// Store both arrays  ` `        ``List<``int``> v1 = ``new` `List<``int``>(); ` `        ``List<``int``> v2 = ``new` `List<``int``>(); ` `         `  `        ``// Used for hashing  ` `        ``Dictionary<``int``, ``int``> mpp = ``new` `Dictionary<``int``, ``int``>();  ` `     `  `        ``// Iterate for every element  ` `        ``for` `(``int` `i = 0; i < n; i++)  ` `        ``{  ` `     `  `            ``// Increase the Count ` `            ``if``(mpp.ContainsKey(a[i])) ` `                ``mpp[a[i]] = mpp[a[i]] + 1; ` `            ``else` `                ``mpp[a[i]] = 1; ` `     `  `            ``// If first occurrence  ` `            ``if` `(mpp[a[i]] == 1)  ` `                ``v1.Add(a[i]);  ` `     `  `            ``// If second occurrence  ` `            ``else` `if` `(mpp[a[i]] == 2)  ` `                ``v2.Add(a[i]);  ` `     `  `            ``// If occurs more than 2 times  ` `            ``else` `            ``{  ` `                ``Console.WriteLine( ``"Not possible"``);  ` `                ``return``;  ` `            ``}  ` `        ``}  ` `     `  `        ``// Sort in increasing order  ` `        ``v1.Sort();  ` `     `  `        ``// Print the increasing array  ` `        ``Console.WriteLine(``"Strictly increasing array is:"``);  ` `        ``for` `(``int` `i = 0; i < v1.Count; i++)  ` `            ``Console.Write(v1[i] + ``" "``);  ` `     `  `        ``// Sort  ` `        ``v2.Sort();  ` `        ``v2.Reverse(); ` `     `  `        ``// Print the decreasing array  ` `        ``Console.WriteLine(``"\nStrictly decreasing array is:"``);  ` `        ``for` `(``int` `i = 0; i < v2.Count; i++)  ` `            ``Console.Write(v2[i] + ``" "``); ` `    ``}  ` `     `  `    ``// Driver code  ` `    ``public` `static` `void` `Main() ` `    ``{  ` `        ``int` `[] a = { 7, 2, 7, 3, 3, 1, 4 };  ` `        ``int` `n = a.Length;  ` `        ``PrintBothArrays(a, n);  ` `    ``} ` `}  ` ` `  `// This code is contributed by ihritik `

Output:
```Strictly increasing array is:
1 2 3 4 7
Strictly decreasing array is:
7 3
```

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.

Striver(underscore)79 at Codechef and codeforces D

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.

Improved By : AnkitRai01, andrew1234, ihritik

Article Tags :
Practice Tags :