Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Maximum number of partitions that can be sorted individually to make sorted

  • Difficulty Level : Medium
  • Last Updated : 30 Dec, 2021

Given an array arr[] of size n such that elements of arr[] in range [0, 1, ..n-1] where every number is present at most once. Our task is to divide the array into maximum number of partitions that can be sorted individually, then concatenated to make the whole array sorted.
Examples : 

Input : arr[] = [2, 1, 0, 3]
Output : 2
If divide arr[] into two partitions
{2, 1, 0} and {3}, sort then and concatenate
then, we get the whole array sorted.

Input : arr[] = [2, 1, 0, 3, 4, 5]
Output : 4
The maximum number of partitions are four, we
get these partitions as {2, 1, 0}, {3}, {4} 
and {5}

Input : arr[] = [0, 1, 2, 3, 4, 5]
Output : 6
The maximum number of partitions are six, we
get these partitions as {0}, {1}, {2}, {3}, {4} 
and {5}

The idea is based on the fact that if an element at i is maximum of prefix arr[0..i], then we can make a partition ending with i.  

C++




// CPP program to find Maximum number of partitions
// such that we can get a sorted array.
#include <bits/stdc++.h>
using namespace std;
 
// Function to find maximum partitions.
int maxPartitions(int arr[], int n)
{
    int ans = 0, max_so_far = 0;
    for (int i = 0; i < n; ++i) {
 
        // Find maximum in prefix arr[0..i]
        max_so_far = max(max_so_far, arr[i]);
 
        // If maximum so far is equal to index,
        // we can make a new partition ending at
        // index i.
        if (max_so_far == i)
            ans++;
    }
    return ans;
}
 
// Driver code
int main()
{
    int arr[] = { 1, 0, 2, 3, 4 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << maxPartitions(arr, n);
    return 0;
}
Java



// java program to find Maximum number of partitions
// such that we can get a sorted array
 
import java.io.*;
 
class GFG
{
    // Function to find maximum partitions.
    static int maxPartitions(int arr[], int n)
    {
        int ans = 0, max_so_far = 0;
        for (int i = 0; i < n; ++i) {
     
            // Find maximum in prefix arr[0..i]
            max_so_far = Math.max(max_so_far, arr[i]);
     
            // If maximum so far is equal to index,
            // we can make a new partition ending at
            // index i.
            if (max_so_far == i)
                ans++;
        }
        return ans;
    }
     
    // Driver code
    public static void main (String[] args)
    {
        int arr[] = { 1, 0, 2, 3, 4 };
        int n = arr.length;
        System.out.println (maxPartitions(arr, n));
             
    }
}
 
// This code is contributed by vt_m.
Python3



# Python3 program to find Maximum
# number of partitions such that
# we can get a sorted array.
 
# Function to find maximum partitions.
def maxPartitions(arr, n):
 
    ans = 0; max_so_far = 0
    for i in range(0, n):
 
        # Find maximum in prefix arr[0..i]
        max_so_far = max(max_so_far, arr[i])
 
        # If maximum so far is equal to
        # index, we can make a new partition
        # ending at index i.
        if (max_so_far == i):
            ans += 1
     
    return ans
 
# Driver code
arr = [1, 0, 2, 3, 4]
n = len(arr)
print(maxPartitions(arr, n))
 
# This code is contributed by Smitha Dinesh Semwal.
C#



// C# program to find Maximum number of partitions
// such that we can get a sorted array
using System;
 
class GFG
{
    // Function to find maximum partitions.
    static int maxPartitions(int []arr, int n)
    {
        int ans = 0, max_so_far = 0;
        for (int i = 0; i < n; ++i)
        {
     
            // Find maximum in prefix arr[0..i]
            max_so_far = Math.Max(max_so_far, arr[i]);
     
            // If maximum so far is equal to index,
            // we can make a new partition ending at
            // index i.
            if (max_so_far == i)
                ans++;
        }
        return ans;
    }
     
    // Driver code
    public static void Main ()
    {
        int []arr = { 1, 0, 2, 3, 4 };
        int n = arr.Length;
        Console.Write (maxPartitions(arr, n));
             
    }
}
 
// This code is contributed by nitin mittal.
PHP



<?php
// PHP program to find Maximum
// number of partitions such
// that we can get a sorted array.
 
// Function to find maximum partitions.
function maxPartitions($arr, $n)
{
    $ans = 0;
    $max_so_far = 0;
    for ($i = 0; $i < $n; ++$i) {
 
        // Find maximum in prefix arr[0..i]
        $max_so_far = max($max_so_far, $arr[$i]);
 
        // If maximum so far is equal to index,
        // we can make a new partition ending at
        // index i.
        if ($max_so_far == $i)
            $ans++;
    }
    return $ans;
}
 
// Driver code
{
    $arr = array(1, 0, 2, 3, 4);
    $n = sizeof($arr) / sizeof($arr[0]);
    echo maxPartitions($arr, $n);
    return 0;
}
 
// This code is contributed by nitin mittal
?>
Javascript



<script>
    // Javascript program to find Maximum number of partitions
    // such that we can get a sorted array.
     
    // Function to find maximum partitions.
    function maxPartitions(arr, n)
    {
        let ans = 0, max_so_far = 0;
        for (let i = 0; i < n; ++i) {
 
            // Find maximum in prefix arr[0..i]
            max_so_far = Math.max(max_so_far, arr[i]);
 
            // If maximum so far is equal to index,
            // we can make a new partition ending at
            // index i.
            if (max_so_far == i)
                ans++;
        }
        return ans;
    }
     
    let arr = [ 1, 0, 2, 3, 4 ];
    let n = arr.length;
    document.write(maxPartitions(arr, n));
     
    // This code is contributed by divyesh072019.
</script>
Output: 
4
 
Time Complexity: O(N)
Space Complexity: O(1)

My Personal Notes
arrow_drop_up
Previous
Analysis of Algorithms | Big-O analysis
Next

Converting seconds into days, hours, minutes and seconds
Recommended Articles
Page :
Maximize partitions that if sorted individually makes the whole Array sorted
13, Jan 22
Sort the given Array after sorting each number individually
05, Dec 21
Largest subsequence such that all indices and all values are multiples individually
15, Jul 20
Minimum partitions of maximum size 2 and sum limited by given value
04, Sep 18
Maximum partitions possible of given Array with cost at most K and equal count of odd and even elements
21, Jun 21
Partitions possible such that the minimum element divides all the other elements of the partition
20, Jan 20
Minimum possible value T such that at most D Partitions of the Array having at most sum T is possible
21, Aug 20
Maximize sum of second minimums of each K length partitions of the array
13, Jan 21
Minimize Array partitions such that an element is repeated atmost once in each partition
23, Dec 21
Maximum in an array that can make another array sorted
24, May 18
Check if two sorted arrays can be merged to form a sorted array with no adjacent pair from the same array
16, Nov 20
Check if the array can be sorted only if the elements on given positions can be swapped
07, May 20
Maximum jumps to reach end of Array with condition that index i can make arr[i] jumps
10, Jul 21
Maximum types of candies a person can eat if only N/2 of them can be eaten
16, Jun 21
Minimum and maximum number of digits required to be removed to make a given number divisible by 3
02, Dec 20
Minimum number of deques required to make the array sorted
19, Oct 21
Count number of common elements between a sorted array and a reverse sorted array
12, May 21
Check if an array can be sorted by swapping adjacent elements such that each element is swapped even number of times
30, Jul 21
Check if end of a sorted Array can be reached by repeated jumps of one more, one less or same number of indices as previous jump
24, Nov 20
Minimum length of a rod that can be split into N equal parts that can further be split into given number of equal parts
16, May 21
Check if reversing a sub array make the array sorted
25, Feb 17
Minimum increment or decrement operations required to make the array sorted
15, Oct 19
Minimum elements to be removed from the ends to make the array sorted
27, Dec 19
Rearrange array to make decimal equivalents of reversed binary representations of array elements sorted
27, May 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Sagar Shukla
@Sagar Shukla
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!