Delete Array Elements which are Smaller than Next or Become Smaller

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.

Example:

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. 

Below is the Implementation of the above idea:

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(n)
Auxiliary Space: O(n + m)

Another Approach

In the previous approach, we used a stack that took an extra space. So in this approach, we are not going to use stack.

Here first we will store all elements of the array into a vector. Now we will run a for loop from 0 to (n-2)th index on that vector. So that in the worst case if we have to remove all the first n-1 elements then we can remove that. Now there will be a nested loop in that loop we checks if an element is less than its next element then that element will be deleted.

We have a count variable that is initially initialized to 0 and whenever we delete any element then we will increment the count by 1 and when the count will be equal to “k” then we will stop the loop and print that vector.

Code-

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)
{
  vector<int> vec;
  for(int i=0;i<n;i++){
      vec.push_back(arr[i]);
  }

  int count=0;
  for(int i=0;i<n-1;i++){
      auto ptr=vec.begin();
      for(auto itr=ptr+1; itr!=vec.end();itr++){
          if(*ptr<*itr){
              count++;
              vec.erase(ptr);
              break;
          }else{
              ptr++;
          }
      }

      if(count==k){break;}
  }
   // printing result
    for (auto x : vec)
        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.*;

public class Main {
    // Function for deleting k elements
    public static void deleteElements(int[] arr, int n,
                                      int k)
    {
        ArrayList<Integer> vec = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            vec.add(arr[i]);
        }
        int count = 0, i = 0;
        while (i < n - 1) {
            int ptr = 0;
            for (int j = 1; j < vec.size(); j++) {
                if (vec.get(ptr) < vec.get(j)) {
                    count++;
                    vec.remove(ptr);
                    break;
                }
                else {
                    ptr++;
                }
            }
            if (count == k) {
                break;
            }
            i++;
        }
        // printing result
        for (int x : vec) {
            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);
    }
}

Python3

# Python program to delete elements from array.
from typing import List

# Function for deleting k elements
def deleteElements(arr: List[int], n: int, k: int) -> None:
    vec = []
    for i in range(n):
        vec.append(arr[i])

    count = 0
    i = 0
    while i < n-1:
        ptr = 0
        for j in range(1, len(vec)):
            if vec[ptr] < vec[j]:
                count += 1
                del vec[ptr]
                break
            else:
                ptr += 1

        if count == k:
            break
        i += 1

    # printing result
    for x in vec:
        print(x, end=" ")

    print()

# Driver code
if __name__ == '__main__':
    n = 5
    k = 2
    arr = [20, 10, 25, 30, 40]
    deleteElements(arr, n, k)

C#

using System;
using System.Collections.Generic;

class Program {
    // Function for deleting k elements
    public static void deleteElements(int[] arr, int n, int k)
    {
        List<int> vec = new List<int>();
        for (int j = 0; j < n; j++) {
            vec.Add(arr[j]);
        }
        int count = 0, i = 0;
        while (i < n - 1) {
            int ptr = 0;
            for (int j = 1; j < vec.Count; j++) {
                if (vec[ptr] < vec[j]) {
                    count++;
                    vec.RemoveAt(ptr);
                    break;
                }
                else {
                    ptr++;
                }
            }
            if (count == k) {
                break;
            }
            i++;
        }
        // printing result
        foreach (int x in vec) {
            Console.Write(x + " ");
        }
        Console.WriteLine();
    }

    // Driver code
    public static void Main(string[] args){
        int n = 5, k = 2;
        int[] arr = { 20, 10, 25, 30, 40 };
        deleteElements(arr, n, k);
    }
}

Javascript

function deleteElements(arr, n, k) {
  let vec = [];
  for (let i = 0; i < n; i++) {
    vec.push(arr[i]);
  }

  let count = 0,
    i = 0;
  while (i < n - 1) {
    let ptr = 0;
    for (let j = 1; j < vec.length; j++) {
      if (vec[ptr] < vec[j]) {
        count++;
        vec.splice(ptr, 1);
        break;
      } else {
        ptr++;
      }
    }
    if (count == k) {
      break;
    }
    i++;
  }

  // printing result
  console.log(vec.join(" "));
}

// Driver code
let n = 5,
  k = 2;
let arr = [20, 10, 25, 30, 40];
deleteElements(arr, n, k);

Output

25 30 40 

Time Complexity: O(n²),because of nested for loops
Auxiliary Space: O(n),because of vector