Skip to content
Related Articles

Related Articles

Improve Article

Count of index range [L, R] in Array such that removing all its instances sorts the Array

  • Last Updated : 27 Sep, 2021
Geek Week

Given an array arr[] of length N, the task is to find the number of Good Ranges in the array arr[].

A Good Range is defined as the range of left and right indices, i.e, [L. R] in the array arr[] such that by removing all the numbers in the range [L, R] of the array arr[] and the appearances of those elements outside the range, the array arr[] becomes sorted in non-decreasing order.

Example:

Input: N=3, arr[] = {9, 8, 7}
Output: 3
Explanation: The good ranges are: (2, 3), (1, 3), (1, 2).
(2, 3) is a good range as the resultant array [9] is sorted (we deleted 8, 7).
(1, 3) is a good range as the resultant array [] which is sorted (we deleted 9, 8, 7)
(1, 2) is a good range as the resultant array [7] is sorted (we deleted 9, 8).

Input: N=5, arr[] = {5, 3, 1, 5, 2}
Output: 7
Explanation: The good ranges are: (1, 2), (1, 3), (1, 4), (1, 5), (2, 4), (2, 5), (3, 5).
(1, 2) is a good range as the resultant array [1, 2] is sorted 
(1, 3) is a good range as the resultant array [2] is sorted 
(1, 4) is a good range as the resultant array [2] is sorted 
(1, 5) is a good range as the resultant array [] is sorted 
(2, 4) is a good range as the resultant array [2] is sorted 
(2, 5) is a good range as the resultant array [] is sorted 
(3, 5) is a good range as the resultant array [3] is sorted 



Approach: The approach is to find every subarray [l, r] and check if the remaining array is sorted or not. If the array is sorted, then, with the left part of the range at l and right part from r to the end, every subarray will be the answer. Below is the implementation of the above approach:

  • Initialize the variable count as 0 to store the number of such subarrays.
  • Define a function chk_sorted(l, r, a) to check if the remaining array a[] is sorted or not:
  • Iterate over the range [0, N] using variable i and perform the following steps:
    • Iterate over the range [i+1, N] using variable i and perform the following steps:
      • Call the function chk_sorted(i, j, a) and if the function returns true, then, increase the value of count by len(a)-j and break the loop.
  • Return the value of count as the answer.

Below is the implementation of the above approach.

C++




// C++ program to implement the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to chk array is sorted or not
bool chk_sorted(int l, int r, vector<int> a)
{
     
    // Taking range element separately
    // to be removed
    vector<int> temp;
    unordered_set<int> s;
    for(int i = l; i <= r; i++)
    {
        temp.push_back(a[i]);
        s.insert(a[i]);
    }
 
    vector<int> chk;
    for(int i = 0; i < a.size(); i++)
    {
         
        // Checking is all range element
        // occurance is removed
        if (s.find(a[i]) == s.end())
        {
            chk.push_back(a[i]);
        }
    }
 
    vector<int> chk1 = chk;
 
    sort(chk1.begin(), chk1.end());
 
    // If array is sorted return true
    for(int i = 0; i < chk.size(); i++)
    {
        if (chk[i] != chk1[i])
        {
            return false;
        }
    }
    return true;
}
 
// Function to count all good ranges
int countp(vector<int> a)
{
     
    // Initial count 0
    int count = 0;
 
    // Nested loop implementation
    for(int i = 0; i < a.size(); i++)
    {
        for(int j = i + 1; j < a.size(); j++)
        {
             
            // Checking if range is good
            if (chk_sorted(i, j, a))
            {
                 
                // According to observation as given
                // in approach
                count += a.size() - j;
                break;
            }
        }
    }
    return count;
}
 
// Driver code
int main()
{
    int N = 5;
    vector<int> A = { 5, 3, 1, 5, 2 };
     
    cout << (countp(A));
}
 
// This code is contributed by Potta Lokesh

Java




// Java program to implement the above approach
import java.util.*;
 
class GFG{
 
// Function to chk array is sorted or not
static boolean chk_sorted(int l, int r, int []a)
{
     
    // Taking range element separately
    // to be removed
    Vector<Integer> temp = new Vector<Integer>();
    HashSet<Integer> s = new HashSet<Integer>();
    for(int i = l; i <= r; i++)
    {
        temp.add(a[i]);
        s.add(a[i]);
    }
 
    Vector<Integer> chk=new Vector<Integer>();
    for(int i = 0; i < a.length; i++)
    {
         
        // Checking is all range element
        // occurance is removed
        if (!s.contains(a[i]))
        {
            chk.add(a[i]);
        }
    }
 
    Vector<Integer> chk1 = new Vector<Integer>(chk);
 
    Collections.sort(chk1);
 
    // If array is sorted return true
    for(int i = 0; i < chk.size(); i++)
    {
        if (chk.get(i) != chk1.get(i))
        {
            return false;
        }
    }
    return true;
}
 
// Function to count all good ranges
static int countp(int []a)
{
     
    // Initial count 0
    int count = 0;
 
    // Nested loop implementation
    for(int i = 0; i < a.length; i++)
    {
        for(int j = i + 1; j < a.length; j++)
        {
             
            // Checking if range is good
            if (chk_sorted(i, j, a))
            {
                 
                // According to observation as given
                // in approach
                count += a.length - j;
                break;
            }
        }
    }
    return count;
}
 
// Driver code
public static void main(String[] args)
{
    int N = 5;
    int [] A = { 5, 3, 1, 5, 2 };
     
    System.out.print(countp(A));
}
}
// This code is contributed by shikhasingrajput

Python3




# Python program to implement the above approach
 
# function to chk array is sorted or not
def chk_sorted(l, r, a):
 
    # taking range element separately
    # to be removed
    l = list(a[l:r + 1])
 
    chk = []
    for i in a:
        # checking is all range element
        # occurance is removed
        if(i not in l):
            chk.append(i)
    chk1 = list(chk)
    chk1.sort()
    # if array is sorted return true
    if(chk1 == chk):
        return True
    else:
        return False
 
 
# function to count all good ranges
def countp(a):
 
    # initial count 0
    count = 0
 
    # nested loop implementation
    for i in range(len(a)):
        for j in range(i + 1, len(a)):
 
            # checking if range is good
            if(chk_sorted(i, j, a)):
 
                # according to observation as given
                # in approach
                count += len(a)-j
                break
    return count
 
 
# Driver code
N = 5
A = [5, 3, 1, 5, 2]
print(countp(A))

C#




// C# program to implement the above approach
using System;
using System.Collections.Generic;
 
class GFG {
 
    // Function to chk array is sorted or not
    static bool chk_sorted(int l, int r, int[] a)
    {
 
        // Taking range element separately
        // to be removed
        List<int> temp = new List<int>();
        HashSet<int> s = new HashSet<int>();
        for (int i = l; i <= r; i++) {
            temp.Add(a[i]);
            s.Add(a[i]);
        }
 
        List<int> chk = new List<int>();
        for (int i = 0; i < a.Length; i++) {
 
            // Checking is all range element
            // occurance is removed
            if (!s.Contains(a[i])) {
                chk.Add(a[i]);
            }
        }
 
        List<int> chk1 = new List<int>(chk);
 
        chk1.Sort();
 
        // If array is sorted return true
        for (int i = 0; i < chk.Count; i++) {
            if (chk[i] != chk1[i]) {
                return false;
            }
        }
        return true;
    }
 
    // Function to count all good ranges
    static int countp(int[] a)
    {
 
        // Initial count 0
        int count = 0;
 
        // Nested loop implementation
        for (int i = 0; i < a.Length; i++) {
            for (int j = i + 1; j < a.Length; j++) {
 
                // Checking if range is good
                if (chk_sorted(i, j, a)) {
 
                    // According to observation as given
                    // in approach
                    count += a.Length - j;
                    break;
                }
            }
        }
        return count;
    }
 
    // Driver code
    public static void Main(string[] args)
    {
        int[] A = { 5, 3, 1, 5, 2 };
 
        Console.WriteLine(countp(A));
    }
}
 
// This code is contributed by ukasp.

Javascript




<script>
 
// JavaScript program to implement the above approach
 
// function to chk array is sorted or not
function chk_sorted(l, r, a){
 
    // taking range element separately
    // to be removed
    l = a.slice(l, r + 1)
 
 
    let chk = []
    for (let i of a){
        // checking is all range element
        // occurance is removed
        if(!l.includes(i)){
            chk.push(i)
        }
    }
 
 
    let chk1 = [...chk]
 
    chk1.sort()
     
    // if array is sorted return true
 
    if(chk1.every((val, index) => val == chk[index]))
        return true
    else
        return false
}
 
 
// function to count all good ranges
function countp(a){
 
    // initial count 0
    let count = 0
 
    // nested loop implementation
    for (let i  = 0; i < a.length; i++){
        for(let j = i + 1; j < a.length; j++){
 
            // checking if range is good
            if(chk_sorted(i, j, a)){
 
                // according to observation as given
                // in approach
                count += a.length - j
                break
            }
        }
    }
    return count
}
 
 
// Driver code
let N = 5
let A = [5, 3, 1, 5, 2]
document.write(countp(A))
 
</script>
Output
7

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

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 :