Related Articles

# Split the array elements into strictly increasing and decreasing sequence

• Difficulty Level : Medium
• Last Updated : 22 Jun, 2021

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 possible

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

 `// 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);``    ``PrintBothArrays(a, n);` `    ``return` `0;``}`

## Java

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

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

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

## Javascript

 ``
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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up