Skip to content
Related Articles

Related Articles

Delete array elements which are smaller than next or become smaller

View Discussion
Improve Article
Save Article
Like Article
  • Difficulty Level : Easy

Given an array arr[] and a number k. The task is to delete k elements which are smaller than next element (i.e., we delete arr[i] if arr[i] < arr[i+1]) or become smaller than next because next element is deleted.

Examples: 

Input       : arr[] = { 3, 100, 1 }
              k = 1
Output      : 100, 1
Explanation : arr[0] < arr[1] means 3 is less than
              100, so delete 3

Input       : arr[] = {20, 10, 25, 30, 40}
              k = 2
Output      : 25 30 40
Explanation : First we delete 10 because it follows
              arr[i] < arr[i+1]. Then we delete 20
              because 25 is moved next to it and it
              also starts following the condition.

Input       : arr[] = { 23, 45, 11, 77, 18}
              k = 3
Output      : 77, 18
Explanation : We delete 23, 45 and 11 as they follow  
              the condition arr[i] < arr[i+1]

Approach: Stack is used to solving this problem. First we push arr[0] in stack S and then initialize count as 0, then after traverse a loop from 1 to n and then we check that s.top() < arr[i] if condition is true then we pop the element from stack and increase the count if count == k then we stop the loop and then store the value of stack in another array and then print that array. 

C++




// C++ program to delete elements from array.
#include <bits/stdc++.h>
using namespace std;
 
// Function for deleting k elements
void deleteElements(int arr[], int n, int k)
{
    // Create a stack and push arr[0]
    stack<int> s;
    s.push(arr[0]);
 
    int count = 0;
     
    // traversing a loop from i = 1 to n
    for (int i=1; i<n; i++) {
         
        // condition for deleting an element
        while (!s.empty() && s.top() < arr[i]
                            && count < k) {                                    
            s.pop();
            count++;
        }
         
        s.push(arr[i]);
    }
     
    // Putting elements of stack in a vector
    // from end to begin.
    int m = s.size();
    vector<int> v(m); // Size of vector is m
    while (!s.empty()) {
         
        // push element from stack to vector v
        v[--m] = s.top();
        s.pop();
    }
     
    // printing result
    for (auto x : v)
        cout << x << " ";
         
    cout << endl;
}
 
// Driver code
int main()
{
    int n = 5, k = 2;
    int arr[] = {20, 10, 25, 30, 40};
    deleteElements(arr, n, k);
    return 0;
}


Java




import java.util.*;
 
//Java program to delete elements from array.
class GFG {
 
// Function for deleting k elements
    static void deleteElements(int arr[], int n, int k) {
        // Create a stack and push arr[0]
        Stack<Integer> s = new Stack<>();
        s.push(arr[0]);
 
        int count = 0;
 
        // traversing a loop from i = 1 to n
        for (int i = 1; i < n; i++) {
 
            // condition for deleting an element
            while (!s.empty() && s.peek() < arr[i]
                    && count < k) {
                s.pop();
                count++;
            }
 
            s.push(arr[i]);
        }
 
        // Putting elements of stack in a vector
        // from end to begin.
        int m = s.size();
        Integer[] v = new Integer[m]; // Size of vector is m
        while (!s.empty()) {
 
            // push element from stack to vector v
            v[--m] = s.peek();
            s.pop();
        }
 
        // printing result
        for (Integer x : v) {
            System.out.print(x + " ");
        };
 
        System.out.println("");
    }
 
// Driver code
    public static void main(String[] args) {
        int n = 5, k = 2;
        int arr[] = {20, 10, 25, 30, 40};
        deleteElements(arr, n, k);
    }
}
// This code is contributed by PrinciRaj1992


Python3




# Function to delete elements
def deleteElements(arr, n, k):
     
    # create an empty stack st
    st = []
    st.append(arr[0])
     
    # index to maintain the top
    # of the stack
    top = 0
    count = 0
 
    for i in range(1, n):
         
        # pop till the present element
        # is greater than stack's top
        # element
        while(len(st) != 0 and count < k
                   and st[top] < arr[i]):
            st.pop()
            count += 1
            top -= 1
 
        st.append(arr[i])
        top += 1
 
    # print the remaining elements
    for i in range(0, len(st)):
        print(st[i], " ", end="")
 
# Driver code
k = 2
arr = [20, 10, 25, 30, 40]
deleteElements(arr, len(arr), k)
 
# This code is contributed by himan085.


C#




// C# program to delete elements from array.
using System;
using System.Collections.Generic;
 
class GFG {
 
    // Function for deleting k elements
    static void deleteElements(int []arr, int n, int k)
    {
        // Create a stack and push arr[0]
        Stack<int> s = new Stack<int>();
        s.Push(arr[0]);
 
        int count = 0;
 
        // traversing a loop from i = 1 to n
        for (int i = 1; i < n; i++)
        {
 
            // condition for deleting an element
            while (s.Count != 0 && s.Peek() < arr[i]
                    && count < k)
            {
                s.Pop();
                count++;
            }
 
            s.Push(arr[i]);
        }
 
        // Putting elements of stack in a vector
        // from end to begin.
        int m = s.Count;
        int[] v = new int[m]; // Size of vector is m
        while (s.Count != 0)
        {
 
            // push element from stack to vector v
            v[--m] = s.Peek();
            s.Pop();
        }
 
        // printing result
        foreach (int x in v)
        {
            Console.Write(x + " ");
        };
 
        Console.Write("");
    }
 
    // Driver code
    public static void Main()
    {
        int n = 5, k = 2;
        int []arr = {20, 10, 25, 30, 40};
        deleteElements(arr, n, k);
    }
}
 
// This code is contributed by 29AjayKumar


Javascript




<script>
 
// Javascript program to delete elements from array.
 
// Function for deleting k elements
function deleteElements(arr, n, k)
{
     
    // Create a stack and push arr[0]
    var s = [];
    s.push(arr[0]);
 
    var count = 0;
     
    // Traversing a loop from i = 1 to n
    for(var i = 1; i < n; i++)
    {
         
        // condition for deleting an element
        while (s.length != 0 && s[s.length - 1] < arr[i] &&
               count < k)
        {                                    
            s.pop();
            count++;
        }
        s.push(arr[i]);
    }
     
    // Putting elements of stack in a vector
    // from end to begin.
    var m = s.length;
    var v = Array(m).fill(0); // Size of vector is m
    while (s.length != 0)
    {
         
        // push element from stack to vector v
        m--;
        v[m] = s[s.length - 1];
        s.pop();
    }
     
    // printing result
    v.forEach(x => {
        document.write(x + " ");
    });
}
 
// Driver code
var n = 5, k = 2;
var arr = [ 20, 10, 25, 30, 40 ]
 
deleteElements(arr, n, k);
 
// This code is contributed by itsok
 
</script>


Output: 

25 30 40 

 

Time Complexity: O(n2)

Auxiliary Space: O(n + m)


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!