# Minimum times K should be added to any element to sort given Array

Given an unsorted array **A[] **of **N **integers and integer **K, **the task is to count the minimum number of times **K** should be added to the array elements to make the array sorted.

**Examples:**

Input:A[] = {2, 4, 3, 5, 9}, K = 3Output: 2Explanation:In the above array element at index 3 is 3 which is less than its previous element.So, add K with the element and array becomes {2, 4,6,5, 9}.Now element at index 4 is less than its previous so add K.Final array {2, 4, 6, 8, 9} which is sorted.

Input:A[] = {3, 6, 8, 5, 3}, K = 4Output: 3Explanation:Perform operation at index 4 once and twice at index 5.

**Approach:** The problem can be solved by using the following idea:

If the array element at index

iis greater than that of the element at(i-1)then no addition is required. Otherwise, addKwith the value atithindex until it is greater than the(i-1)thelement.

Follow the steps to solve the problem:

- Create two pointers
**i**and**j**,**i**starts from 0 and**j**from 1. - Then run a while loop till
**i < N**and**j < N**- Check if
**arr[i] <= arr[j]**or not if it is then simply increment both the pointers by**1**. - If
**arr[i] > arr[j]**then add integer**K**to**arr[j]**until it become greater than or equal to**arr[i]**and for each addition of**K,**increment a count by 1 after that increment both the pointers by 1.

- Check if
- Lastly, return the count.

Below is the implementation of the above approach:

## C++

`// C++ implementation of above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to count min no of operations` `int` `minOperation(vector<` `int` `> arr,` ` ` `int` `N, ` `int` `K)` `{` ` ` `int` `i = 0, j = 1, count = 0;` ` ` `while` `(i < N && j < N) {` ` ` `// If current elements are sorted` ` ` `// Increment i and j by 1` ` ` `if` `(arr[i] <= arr[j]) {` ` ` `i++;` ` ` `j++;` ` ` `}` ` ` `// If current elements are not` ` ` `// Sorted then add K to arr[j] till` ` ` `// It become greater than equal to` ` ` `// arr[i] and then increment` ` ` `// i and j by 1` ` ` `else` `{` ` ` `while` `(arr[i] > arr[j]) {` ` ` `arr[j] += K;` ` ` `// Increment count in` ` ` `// Each operation` ` ` `count++;` ` ` `}` ` ` `i++;` ` ` `j++;` ` ` `}` ` ` `}` ` ` `return` `count;` `}` `// Driver Code` `int` `main()` `{` ` ` `vector<` `int` `> arr = { 3, 6, 8, 5, 3 };` ` ` `int` `N = 5, K = 4;` ` ` `// Function call` ` ` `cout << minOperation(arr, N, K);` ` ` `return` `0;` `}` |

## Java

`// Java program for above approach` `import` `java.util.*;` `class` `GFG` `{` ` ` `// Function to count min no of operations` ` ` `static` `int` `minOperation(` `int` `[] arr, ` `int` `N, ` `int` `K)` ` ` `{` ` ` `int` `i = ` `0` `, j = ` `1` `, count = ` `0` `;` ` ` `while` `(i < N && j < N) {` ` ` `// If current elements are sorted` ` ` `// Increment i and j by 1` ` ` `if` `(arr[i] <= arr[j]) {` ` ` `i++;` ` ` `j++;` ` ` `}` ` ` `// If current elements are not` ` ` `// Sorted then add K to arr[j] till` ` ` `// It become greater than equal to` ` ` `// arr[i] and then increment` ` ` `// i and j by 1` ` ` `else` `{` ` ` `while` `(arr[i] > arr[j]) {` ` ` `arr[j] += K;` ` ` `// Increment count in` ` ` `// Each operation` ` ` `count++;` ` ` `}` ` ` `i++;` ` ` `j++;` ` ` `}` ` ` `}` ` ` `return` `count;` ` ` `}` ` ` `// Driver code` ` ` `public` `static` `void` `main(String[] args)` ` ` `{` ` ` `int` `[] arr = { ` `3` `, ` `6` `, ` `8` `, ` `5` `, ` `3` `};` ` ` `int` `N = ` `5` `, K = ` `4` `;` ` ` `// Function call` ` ` `System.out.print(minOperation(arr, N, K));` ` ` `}` `}` `// This code is contributed by sanjoy_62.` |

## Python3

`# python3 implementation of above approach` `# Function to count min no of operations` `def` `minOperation(arr, N, K):` ` ` `i, j, count ` `=` `0` `, ` `1` `, ` `0` ` ` `while` `(i < N ` `and` `j < N):` ` ` `# If current elements are sorted` ` ` `# Increment i and j by 1` ` ` `if` `(arr[i] <` `=` `arr[j]):` ` ` `i ` `+` `=` `1` ` ` `j ` `+` `=` `1` ` ` `# If current elements are not` ` ` `# Sorted then add K to arr[j] till` ` ` `# It become greater than equal to` ` ` `# arr[i] and then increment` ` ` `# i and j by 1` ` ` `else` `:` ` ` `while` `(arr[i] > arr[j]):` ` ` `arr[j] ` `+` `=` `K` ` ` `# Increment count in` ` ` `# Each operation` ` ` `count ` `+` `=` `1` ` ` `i ` `+` `=` `1` ` ` `j ` `+` `=` `1` ` ` `return` `count` `# Driver Code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` `arr ` `=` `[` `3` `, ` `6` `, ` `8` `, ` `5` `, ` `3` `]` ` ` `N, K ` `=` `5` `, ` `4` ` ` `# Function call` ` ` `print` `(minOperation(arr, N, K))` `# This code is contributed by rakeshsahni` |

## C#

`// C# implementation of above approach` `using` `System;` `class` `GFG {` ` ` `// Function to count min no of operations` ` ` `static` `int` `minOperation(` `int` `[] arr, ` `int` `N, ` `int` `K)` ` ` `{` ` ` `int` `i = 0, j = 1, count = 0;` ` ` `while` `(i < N && j < N) {` ` ` `// If current elements are sorted` ` ` `// Increment i and j by 1` ` ` `if` `(arr[i] <= arr[j]) {` ` ` `i++;` ` ` `j++;` ` ` `}` ` ` `// If current elements are not` ` ` `// Sorted then add K to arr[j] till` ` ` `// It become greater than equal to` ` ` `// arr[i] and then increment` ` ` `// i and j by 1` ` ` `else` `{` ` ` `while` `(arr[i] > arr[j]) {` ` ` `arr[j] += K;` ` ` `// Increment count in` ` ` `// Each operation` ` ` `count++;` ` ` `}` ` ` `i++;` ` ` `j++;` ` ` `}` ` ` `}` ` ` `return` `count;` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `Main()` ` ` `{` ` ` `int` `[] arr = { 3, 6, 8, 5, 3 };` ` ` `int` `N = 5, K = 4;` ` ` `// Function call` ` ` `Console.Write(minOperation(arr, N, K));` ` ` `}` `}` `// This code is contributed by Samim Hossain Mondal.` |

## Javascript

`<script>` ` ` `// JavaScript code for the above approach` `// Function to count min no of operations` `function` `minOperation( arr,` ` ` `N, K)` `{` ` ` `let i = 0, j = 1, count = 0;` ` ` `while` `(i < N && j < N) {` ` ` `// If current elements are sorted` ` ` `// Increment i and j by 1` ` ` `if` `(arr[i] <= arr[j]) {` ` ` `i++;` ` ` `j++;` ` ` `}` ` ` `// If current elements are not` ` ` `// Sorted then add K to arr[j] till` ` ` `// It become greater than equal to` ` ` `// arr[i] and then increment` ` ` `// i and j by 1` ` ` `else` `{` ` ` `while` `(arr[i] > arr[j]) {` ` ` `arr[j] += K;` ` ` `// Increment count in` ` ` `// Each operation` ` ` `count++;` ` ` `}` ` ` `i++;` ` ` `j++;` ` ` `}` ` ` `}` ` ` `return` `count;` `}` `// Driver Code` ` ` `let arr = [3, 6, 8, 5, 3];` ` ` `let N = 5, K = 4;` ` ` `// Function call` ` ` `document.write(minOperation(arr, N, K));` ` ` ` ` `// This code is contributed by Potta Lokesh` ` ` `</script>` |

**Output**

3

**Time complexity:** O(N)**Auxiliary Space:** O(1)