Reduce the array by deleting elements which are greater than all elements to its left
Last Updated :
27 Jan, 2023
Given an array arr[] of N integers, the task is to delete the element from the given array if element to it’s left is smaller than it. Keep on deleting the elements from the array until no element has a smaller adjacent left element. Print the resultant array after above operation.
Examples:
Input: arr[] = {2, 4, 1, 3, 4}
Output: 2 1
Explanation:
Since 4 is greater than 2 remove 4, and arr become {2, 1, 3, 4}.
Now 3 is greater than 1 so remove 3 and arr become {2, 1, 4}.
Now 4 is greater than 1 so remove 4 and arr become {2, 1}.
Now no elements satisfy the removing criteria so the resultant array is {2, 1}.
Input: arr[] = {5, 4, 3, 2, 1}
Output: 5 4 3 2 1
Approach: The idea is to use the concept of Merge Sort.
- Divide the input array into sub-arrays till the size of each sub-array becomes 1.
- Start merging the element.
- While merging, delete elements from the left subarray till it’s rightmost element, which have a value greater than the leftmost element of the right subarray.
- Repeat the above steps in each merging step such all elements with value smaller to it’s left have been deleted.
- Finally print the resultant array.
Below is the implementation of the above approach:
C++
#include<bits/stdc++.h>
using namespace std;
vector< int > merge(vector< int > x, vector< int > y)
{
for ( auto i : y)
{
if (x[x.size() - 1] > i)
x.push_back(i);
}
return x;
}
vector< int > mergeDel(vector< int > l)
{
if (l.size() == 1)
return l;
int m = l.size() / 2;
vector< int > temp1 = {l.begin() + 0,
l.begin() + m};
vector< int > temp2 = {l.begin() + m,
l.end()};
return merge(mergeDel(temp1),
mergeDel(temp2));
}
int main()
{
vector< int > arr({ 5, 4, 3, 2, 1 });
vector< int > ans = mergeDel(arr);
cout << "[ " ;
for ( auto x: ans)
cout << x << ", " ;
cout << "]" ;
}
|
Java
import java.util.ArrayList;
import java.util.Arrays;
class GFG{
static ArrayList<Integer> merge(ArrayList<Integer> x,
ArrayList<Integer> y)
{
for (Integer i : y)
{
if (x.get(x.size() - 1 ) > i)
x.add(i);
}
return x;
}
static ArrayList<Integer> mergeDel(ArrayList<Integer> l)
{
if (l.size() == 1 )
return l;
int m = l.size() / 2 ;
ArrayList<Integer> temp1 = new ArrayList<>(
l.subList( 0 , m));
ArrayList<Integer> temp2 = new ArrayList<>(
l.subList(m, l.size()));
return merge(mergeDel(temp1), mergeDel(temp2));
}
public static void main(String[] args)
{
Integer[] ar = { 5 , 4 , 3 , 2 , 1 };
ArrayList<Integer> arr = new ArrayList<>(
Arrays.asList(ar));
ArrayList<Integer> ans = mergeDel(arr);
System.out.print( "[ " );
for (Integer x : ans)
System.out.print(x + ", " );
System.out.println( "]" );
}
}
|
Python3
def mergeDel(l):
if len (l) = = 1 :
return l
m = int ( len (l) / 2 )
return merge(mergeDel(l[ 0 : m ]),
mergeDel(l[ m : len (l)]) )
def merge(x, y):
for i in y:
if x[ - 1 ] > i :
x = x + [i]
return x
def main():
arr = [ 5 , 4 , 3 , 2 , 1 ]
print (mergeDel(arr))
main()
|
C#
using System;
using System.Collections.Generic;
class GFG{
static List< int > merge(List< int > x, List< int > y)
{
foreach ( int i in y)
{
if (x[x.Count - 1] > i)
x.Add(i);
}
return x;
}
static List< int > mergeDel(List< int > l)
{
if (l.Count == 1)
return l;
int m = l.Count / 2;
List< int > temp1 = l.GetRange(0, m);
List< int > temp2 = l.GetRange(m, l.Count - m);
return merge(mergeDel(temp1),
mergeDel(temp2));
}
public static void Main( string [] args)
{
List< int > arr = new List< int >{ 5, 4, 3, 2, 1 };
List< int > ans = mergeDel(arr);
Console.Write( "[ " );
foreach ( int x in ans)
Console.Write(x + ", " );
Console.Write( "]" );
}
}
|
Javascript
<script>
function merge(x,y)
{
for (let i=0;i<y.length;i++)
{
if (x[x.length - 1] > y[i])
x.push(y[i]);
}
return x;
}
function mergeDel(l)
{
if (l.length == 1)
return l;
let m = Math.floor(l.length / 2);
let temp1 = l.slice(0, m);
let temp2 = l.slice(m, l.length);
return merge(mergeDel(temp1), mergeDel(temp2));
}
let arr=[5, 4, 3, 2, 1];
let ans = mergeDel(arr);
document.write( "[ " );
document.write(ans.join( ", " ));
document.write( "]<br>" );
</script>
|
Time Complexity: O(N*log N)
Auxiliary Space: O(1)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...