# Reduce the Array to 0 by decreasing elements by 1 or replacing at most K elements by 0

Given an array **arr[]** of **N** integers and a positive integer **K**, the task is to find the minimum number of operations required to reduce all array elements to **0** such that in each operation reduce any array element by **1** and independently **at most K** array element can be reduced to **0**.

**Examples:**

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**.

Input:arr[] = {4, 1, 5}, K = 1Output:5Explanation:Following are the operations performed to convert all array elements to 0:

Here K = 1, So replace arr[2] by 0, converts arr[] to {4, 1, 0} –> Number of operations = 0.

Decrease arr[1] by 1, converts arr[] to {4, 0, 0} –> Number of operations = 1.

Decrease arr[0] by 1 four times, converts arr[] to {0, 0, 0} –> Number of operations = 4.

Therefore, total number of operations = 0 + 1 + 4 = 5, which is minimum possible.

Input:arr[] = {4, 2, 10, 9, 18}, K = 2Output:15

**Approach:** The given problem can be solved by using the Greedy Approach which is based on the idea is that first sort the given array arr[] in non-decreasing order and then update the K largest element to **0** and perform the given operation on the remaining array elements. Follow the steps below to solve the given problem:

- If the value of
**N**is at most**K**, then replace all array elements with**0**. Therefore the number of operations required in this case will be**0**. - Sort the array
**arr[]**in non-decreasing order. - Replace last
**K**elements by**0**. - Print the sum of the first
**(N – K)**elements as the resultant count of operations.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to find the minimum number` `// operations needed to convert all the` `// array elements to 0` `int` `minOperations(vector<` `int` `> arr,` ` ` `int` `K, ` `int` `N)` `{` ` ` `// If K is greater then 0 then` ` ` `// replace all array elements to 0` ` ` `if` `(K >= N)` ` ` `return` `0;` ` ` `// Sort array in non-decreasing order` ` ` `sort(arr.begin(), arr.end());` ` ` `// Stores the count of operations` ` ` `// required` ` ` `int` `countOperations = 0;` ` ` `// Iterate loop until N - K times` ` ` `for` `(` `int` `i = 0; i < N - K; i++) {` ` ` `// Take sum of elements` ` ` `countOperations += arr[i];` ` ` `}` ` ` `// Return countOperations as` ` ` `// the required answer` ` ` `return` `countOperations;` `}` `// Driver Code` `int` `main()` `{` ` ` `vector<` `int` `> arr{ 4, 1, 5 };` ` ` `int` `N = arr.size();` ` ` `int` `K = 1;` ` ` `cout << minOperations(arr, K, N);` ` ` `return` `0;` `}` |

## Java

`// Java program for the above approach` `import` `java.util.Arrays;` `public` `class` `GFG {` ` ` ` ` `// Function to find the minimum number` ` ` `// operations needed to convert all the` ` ` `// array elements to 0` ` ` `static` `int` `minOperations(` `int` `[]arr,` ` ` `int` `K, ` `int` `N)` ` ` `{` ` ` ` ` `// If K is greater then 0 then` ` ` `// replace all array elements to 0` ` ` `if` `(K >= N)` ` ` `return` `0` `;` ` ` ` ` `// Sort array in non-decreasing order` ` ` `Arrays.sort(arr) ;` ` ` ` ` `// Stores the count of operations` ` ` `// required` ` ` `int` `countOperations = ` `0` `;` ` ` ` ` `// Iterate loop until N - K times` ` ` `for` `(` `int` `i = ` `0` `; i < N - K; i++) {` ` ` ` ` `// Take sum of elements` ` ` `countOperations += arr[i];` ` ` `}` ` ` ` ` `// Return countOperations as` ` ` `// the required answer` ` ` `return` `countOperations;` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `main (String[] args)` ` ` `{` ` ` ` ` `int` `[] arr = { ` `4` `, ` `1` `, ` `5` `};` ` ` `int` `N = arr.length;` ` ` `int` `K = ` `1` `;` ` ` ` ` `System.out.println(minOperations(arr, K, N));` ` ` `}` `}` `// This code is contributed by AnkThon` |

## Python3

`# Python3 program for the above approach` `# Function to find the minimum number` `# operations needed to convert all the` `# array elements to 0` `def` `minOperations(arr, K, N) :` ` ` `# If K is greater then 0 then` ` ` `# replace all array elements to 0` ` ` `if` `(K >` `=` `N) :` ` ` `return` `0` `;` ` ` `# Sort array in non-decreasing order` ` ` `arr.sort();` ` ` `# Stores the count of operations` ` ` `# required` ` ` `countOperations ` `=` `0` `;` ` ` `# Iterate loop until N - K times` ` ` `for` `i ` `in` `range` `(N ` `-` `K) :` ` ` `# Take sum of elements` ` ` `countOperations ` `+` `=` `arr[i];` ` ` `# Return countOperations as` ` ` `# the required answer` ` ` `return` `countOperations;` `# Driver Code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` `arr ` `=` `[ ` `4` `, ` `1` `, ` `5` `];` ` ` `N ` `=` `len` `(arr);` ` ` `K ` `=` `1` `;` ` ` `print` `(minOperations(arr, K, N));` ` ` ` ` `# This code is contributed by AnkThon` |

## C#

`// C# program for the above approach` `using` `System;` `public` `class` `GFG` `{` ` ` ` ` `// Function to find the minimum number` ` ` `// operations needed to convert all the` ` ` `// array elements to 0` ` ` `static` `int` `minOperations(` `int` `[]arr,` ` ` `int` `K, ` `int` `N)` ` ` `{` ` ` ` ` `// If K is greater then 0 then` ` ` `// replace all array elements to 0` ` ` `if` `(K >= N)` ` ` `return` `0;` ` ` ` ` `// Sort array in non-decreasing order` ` ` `Array.Sort(arr) ;` ` ` ` ` `// Stores the count of operations` ` ` `// required` ` ` `int` `countOperations = 0;` ` ` ` ` `// Iterate loop until N - K times` ` ` `for` `(` `int` `i = 0; i < N - K; i++) {` ` ` ` ` `// Take sum of elements` ` ` `countOperations += arr[i];` ` ` `}` ` ` ` ` `// Return countOperations as` ` ` `// the required answer` ` ` `return` `countOperations;` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `Main (` `string` `[] args)` ` ` `{` ` ` ` ` `int` `[] arr = { 4, 1, 5 };` ` ` `int` `N = arr.Length;` ` ` `int` `K = 1;` ` ` ` ` `Console.WriteLine(minOperations(arr, K, N));` ` ` `}` `}` `// This code is contributed by AnkThon` |

## Javascript

`<script>` `// Javascript program for the above approach` `// Function to find the minimum number` `// operations needed to convert all the` `// array elements to 0` `function` `minOperations(arr, K, N)` `{` ` ` `// If K is greater then 0 then` ` ` `// replace all array elements to 0` ` ` `if` `(K >= N) ` `return` `0;` ` ` `// Sort array in non-decreasing order` ` ` `arr.sort((a, b) => a - b);` ` ` `// Stores the count of operations` ` ` `// required` ` ` `let countOperations = 0;` ` ` `// Iterate loop until N - K times` ` ` `for` `(let i = 0; i < N - K; i++) {` ` ` `// Take sum of elements` ` ` `countOperations += arr[i];` ` ` `}` ` ` `// Return countOperations as` ` ` `// the required answer` ` ` `return` `countOperations;` `}` `// Driver Code` `let arr = [4, 1, 5];` `let N = arr.length;` `let K = 1;` `document.write(minOperations(arr, K, N));` `// This code is contributed by saurabh_jaiswal.` `</script>` |

**Output:**

5

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