Skip to content
Related Articles

Related Articles

Split the array elements into strictly increasing and decreasing sequence
  • Difficulty Level : Medium
  • Last Updated : 06 May, 2019

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



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

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to implement
// the above approach
#include <bits/stdc++.h>
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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<Integer> v1 = new Vector<Integer>(), 
                    v2 = new Vector<Integer>(); 
  
    // Used for hashing 
    HashMap<Integer, Integer> 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


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.

My Personal Notes arrow_drop_up
Recommended Articles
Page :