Skip to content
Related Articles

Related Articles

Improve Article

Split array into three continuous subarrays with negative, 0 and positive product respectively

  • Last Updated : 22 Jun, 2021

Given an array arr[] size N such that each array element is either -1, 0, or 1, the task is to check if is it possible to split the array into 3 contiguous subarrays such that the product of the first, second and third subarrays is negative, 0 and positive respectively.

Examples:

Input: arr[] = {-1, 0, 1}, N = 3
Output: -1
0
1
Explanation: Split the array into subarrays {-1}, {0}, {1}.

Input: arr[] = {1, -1, 1, -1}, N = 4
Output: Not Possible

 

Approach: The problem can be solved by greedily selecting the elements up to first ‘-1‘ having no 0′s as the first subarray and then selecting the elements from the last until the product becomes 1 as the third subarray and the remaining elements as the second subarray. Follow the steps below to solve the problem:



  • Initialize two variables, say l and r as -1, to store the index of the last element of the first subarray and the first element of the third subarray.
  • Traverse the array arr[] and if l is -1 and arr[i] is 0, then print “Not possible”. Otherwise, if arr[i] is -1, then assign i to l and break out of the loop.
  • Traverse the array arr[] in reverse order and if the product in the range [i, N – 1] is greater than 0, then assign i to r and break out of the loop.
  • Check if the value l or r is -1 or l ≥ r or count of 0s in the range [l, r] is 0. If any of the condition is true, print “Not Possible”.
  • Print the first subarray over the range [0, l], the second subarray over the range [l+1, r-1], and then the last subarray over the range [r, N-1].

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to split an array into 3 contiguous
// subarrays satisfying the given condition
void PrintAllArrays(int arr[], int N)
{
    // Store the index of rightmost
    // element of the first and leftmost
    // element of the third subarray
    int l = -1, r = -1;
 
    // Traverse the array arr[]
    for (int i = 0; i < N; i++) {
 
        // If l is equal to -1
        if (l == -1) {
 
            // If arr[i] is -1
            if (arr[i] == -1) {
 
                l = i;
                break;
            }
 
            // If arr[i] is 0
            if (arr[i] == 0) {
 
                cout << "Not Possible" << endl;
                return;
            }
        }
    }
 
    // Stores the product
    // of the last subarray
    int p = 1;
 
    // Traverse the array in reverse
    for (int i = N - 1; i >= 0; i--) {
 
        // Update the product
        p *= arr[i];
 
        // If p is greater than 0,
        // assign i to r and break
        if (p > 0) {
            r = i;
            break;
        }
    }
 
    // If l or r is -1 or l to r, there
    // P are no 0's, print "Not possible"
    if (l == -1 || r == -1 || l >= r
        || count(arr + l, arr + r + 1, 0) == 0) {
 
        cout << "Not Possible" << endl;
        return;
    }
 
    // Print the three subarrays
    for (int i = 0; i <= l; i++)
        cout << arr[i] << " ";
 
    cout << "\n";
 
    for (int i = l + 1; i < r; i++)
        cout << arr[i] << " ";
    cout << "\n";
 
    for (int i = r; i < N; i++)
        cout << arr[i] << " ";
}
 
// Driver Code
int main()
{
    // Given Input
    int arr[] = { -1, 0, 1 };
    int N = sizeof(arr) / sizeof(int);
 
    PrintAllArrays(arr, N);
 
    return 0;
}

Java




// Java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;
 
class GFG{
 
// Function to split an array into 3 contiguous
// subarrays satisfying the given condition
static void PrintAllArrays(int arr[], int N)
{
     
    // Store the index of rightmost
    // element of the first and leftmost
    // element of the third subarray
    int l = -1, r = -1;
 
    // Traverse the array arr[]
    for(int i = 0; i < N; i++)
    {
         
        // If l is equal to -1
        if (l == -1)
        {
             
            // If arr[i] is -1
            if (arr[i] == -1)
            {
                l = i;
                break;
            }
 
            // If arr[i] is 0
            if (arr[i] == 0)
            {
                System.out.println("Not Possible");
                return;
            }
        }
    }
 
    // Stores the product
    // of the last subarray
    int p = 1;
 
    // Traverse the array in reverse
    for(int i = N - 1; i >= 0; i--)
    {
         
        // Update the product
        p *= arr[i];
 
        // If p is greater than 0,
        // assign i to r and break
        if (p > 0)
        {
            r = i;
            break;
        }
    }
 
    // If l or r is -1 or l to r, there
    // P are no 0's, print "Not possible"
    if (l == -1 || r == -1 || l >= r ||
       count(arr, l, r + 1, 0) == 0)
    {
        System.out.println("Not Possible");
        return;
    }
 
    // Print the three subarrays
    for(int i = 0; i <= l; i++)
        System.out.print(arr[i] + " ");
         
    System.out.println();
 
    for(int i = l + 1; i < r; i++)
        System.out.print(arr[i] + " ");
         
    System.out.println();
 
    for(int i = r; i < N; i++)
        System.out.print(arr[i] + " ");
}
 
// Function to return the number of occurrence of
// the element 'val' in the range [start, end).
static int count(int arr[], int start,
                 int end, int val)
{
    int count = 0;
    for(int i = start; i < end; i++)
    {
        if (arr[i] == val)
        {
            count++;
        }
    }
    return count;
}
 
// Driver Code
public static void main(String[] args)
{
     
    // Given Input
    int arr[] = { -1, 0, 1 };
    int N = arr.length;
 
    PrintAllArrays(arr, N);
}
}
 
// This code is contributed by Kingash

Python3




# Python3 program for the above approach
 
# Function to split an array into 3 contiguous
# subarrays satisfying the given condition
def PrintAllArrays(arr, N):
     
    # Store the index of rightmost
    # element of the first and leftmost
    # element of the third subarray
    l = -1
    r = -1
 
    # Traverse the array arr[]
    for i in range(N):
         
        # If l is equal to -1
        if (l == -1):
             
            # If arr[i] is -1
            if (arr[i] == -1):
                l = i
                break
             
            # If arr[i] is 0
            if (arr[i] == 0):
                print("Not Possible")
                return
             
    # Stores the product
    # of the last subarray
    p = 1
 
    # Traverse the array in reverse
    for i in range(N - 1, -1, -1):
         
        # Update the product
        p *= arr[i]
 
        # If p is greater than 0,
        # assign i to r and break
        if (p > 0):
            r = i
            break
         
    # If l or r is -1 or l to r, there
    # P are no 0's, pr"Not possible"
    if (l == -1 or r == -1 or l >= r or
       count(arr, l, r + 1, 0) == 0):
        print("Not Possible")
        return
 
    # Printthe three subarrays
    for i in range(0, l + 1, 1):
        print(arr[i], end = " ")
         
    print()
 
    for i in range(l + 1, r, 1):
        print(arr[i], end = " ")
         
    print()
 
    for i in range(r, N, 1):
        print(arr[i], end = " ")
 
# Function to return the number of occurrence of
# the element 'val' in the range [start, end).
def count(arr, start, end, val):
     
    count = 0
    for i in range(start, end, 1):
        if (arr[i] == val):
            count += 1
         
    return count
 
# Driver Code
 
# Given Input
arr = [ -1, 0, 1 ]
N = len(arr)
 
PrintAllArrays(arr, N)
  
# This code is contriobuted by code_hunt

C#




// C# program for the above approach
using System;
 
class GFG{
     
// Function to split an array into 3 contiguous
// subarrays satisfying the given condition
static void PrintAllArrays(int[] arr, int N)
{
     
    // Store the index of rightmost
    // element of the first and leftmost
    // element of the third subarray
    int l = -1, r = -1;
 
    // Traverse the array arr[]
    for(int i = 0; i < N; i++)
    {
         
        // If l is equal to -1
        if (l == -1)
        {
             
            // If arr[i] is -1
            if (arr[i] == -1)
            {
                l = i;
                break;
            }
 
            // If arr[i] is 0
            if (arr[i] == 0)
            {
                Console.WriteLine("Not Possible");
                return;
            }
        }
    }
 
    // Stores the product
    // of the last subarray
    int p = 1;
 
    // Traverse the array in reverse
    for(int i = N - 1; i >= 0; i--)
    {
         
        // Update the product
        p *= arr[i];
 
        // If p is greater than 0,
        // assign i to r and break
        if (p > 0)
        {
            r = i;
            break;
        }
    }
 
    // If l or r is -1 or l to r, there
    // P are no 0's, print "Not possible"
    if (l == -1 || r == -1 || l >= r ||
       count(arr, l, r + 1, 0) == 0)
    {
        Console.WriteLine("Not Possible");
        return;
    }
 
    // Print the three subarrays
    for(int i = 0; i <= l; i++)
        Console.Write(arr[i] + " ");
         
    Console.WriteLine();
 
    for(int i = l + 1; i < r; i++)
        Console.Write(arr[i] + " ");
         
    Console.WriteLine();
 
    for(int i = r; i < N; i++)
        Console.Write(arr[i] + " ");
}
 
// Function to return the number of occurrence of
// the element 'val' in the range [start, end).
static int count(int[] arr, int start,
                 int end, int val)
{
    int count = 0;
    for(int i = start; i < end; i++)
    {
        if (arr[i] == val)
        {
            count++;
        }
    }
    return count;
}
 
// Driver code
public static void Main(String []args)
{
     
    // Given Input
    int[] arr = { -1, 0, 1 };
    int N = arr.Length;
     
    PrintAllArrays(arr, N);
}
}
 
// This code is contributed by sanjoy_62

Javascript




<script>
 
// JavaScript Program to implement
// the above approach
 
// Function to split an array into 3 contiguous
// subarrays satisfying the given condition
function PrintAllArrays(arr, N)
{
     
    // Store the index of rightmost
    // element of the first and leftmost
    // element of the third subarray
    let l = -1, r = -1;
 
    // Traverse the array arr[]
    for(let i = 0; i < N; i++)
    {
         
        // If l is equal to -1
        if (l == -1)
        {
             
            // If arr[i] is -1
            if (arr[i] == -1)
            {
                l = i;
                break;
            }
 
            // If arr[i] is 0
            if (arr[i] == 0)
            {
                document.write("Not Possible" + "<br/>");
                return;
            }
        }
    }
 
    // Stores the product
    // of the last subarray
    let p = 1;
 
    // Traverse the array in reverse
    for(let i = N - 1; i >= 0; i--)
    {
         
        // Update the product
        p *= arr[i];
 
        // If p is greater than 0,
        // assign i to r and break
        if (p > 0)
        {
            r = i;
            break;
        }
    }
 
    // If l or r is -1 or l to r, there
    // P are no 0's, print "Not possible"
    if (l == -1 || r == -1 || l >= r ||
       count(arr, l, r + 1, 0) == 0)
    {
        document.write("Not Possible" + "<br/>");
        return;
    }
 
    // Print the three subarrays
    for(let i = 0; i <= l; i++)
        document.write(arr[i] + " ");
         
    document.write("<br/>");
 
    for(let i = l + 1; i < r; i++)
        document.write(arr[i] + " ");
         
    document.write("<br/>");
 
    for(let i = r; i < N; i++)
        document.write(arr[i] + " ");
}
 
// Function to return the number of occurrence of
// the element 'val' in the range [start, end).
function count(arr, start, end, val)
{
    let count = 0;
    for(let i = start; i < end; i++)
    {
        if (arr[i] == val)
        {
            count++;
        }
    }
    return count;
}
 
// Driver Code
 
     // Given Input
    let arr = [ -1, 0, 1 ];
    let N = arr.length;
 
    PrintAllArrays(arr, N);
 
</script>
Output: 
-1 
0 
1

 

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

 

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
Recommended Articles
Page :