# Minimum number of operations required to make a permutation of first N natural numbers equal

Given an array **A[]** of size **N**, containing a permutation of first **N** natural numbers and an integer **K**, the task is to find the minimum number of operations required to make all array elements equal by selecting **K **(*1 < K ≤ N*) consecutive array elements and replacing them with the minimum of the selected elements.

**Examples:**

Input:A[] = {4, 2, 1, 5, 3}, K = 3, N = 5Output:2Explanation:Select consecutive elements from index 1 to 3 and replace with the minimum of {4, 2, 1}. Therefore, A[] becomes {1, 1, 1, 5, 3}.

Select consecutive elements from index from 3 to 5 and replace with minimum of {1, 5, 3}. Therefore, A becomes {1, 1, 1, 1, 1}.

Therefore, the total number of operations required are 2.

Input:A[] = {3, 6, 2, 1, 4, 5}, K = 2, N=6Output:5Explanation:Select consecutive elements from index 4 to 5 and replace with the minimum of {1, 4} is 1. Therefore, A[] becomes {3, 6, 2, 1, 1, 5}

Select consecutive elements from index 5 to 6 and replace with the minimum of {1, 5} is 1. Therefore, A[] becomes {3, 6, 2, 1, 1, 1}

Select consecutive elements from index 3 to 4 and replace with the minimum of {2, 1} is 1. Therefore, A[] becomes {3, 6, 1, 1, 1, 1}

Select consecutive elements from index 2 to 3 and replace with the minimum of {6, 1} is 1. Therefore, A[] becomes {3, 1, 1, 1, 1, 1}

Select consecutive elements from index 1 to 2 and replace with the minimum of {3, 1} is 1. Therefore, A[] becomes {1, 1, 1, 1, 1, 1}

Therefore, the total number of operations are 5.

**Approach:** The idea is based on the following observations:

- The permutation does not matter. It is the same as placing the minimum at the beginning.
- The optimal number of operations required can be calculated by starting with the minimum index and moving forward by
**K**.

The problem can be solved by imagining that the minimum is at the beginning of the array and from there onwards, selecting **K** consecutive elements. Follow the steps below to solve the problem:

- Initialize the variables
**i**and**count**as**0**, for iterating and counting the minimum number of operations respectively. - Loop while
**i**is less than**N – 1**because when**i**reaches**N – 1**, all elements have been made equal. In each current iteration, perform the following steps:- Increment
**count**by**1**. - Increment
**i**by**K-1**because the rightmost updated element would be used again for the next segment.

- Increment
- Print the value of
**count**as the result.

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 of operations required` `// to make all array elements equal` `int` `MinimumOperations(` `int` `A[],` ` ` `int` `N, ` `int` `K)` `{` ` ` `// Store the count of` ` ` `// operations required` ` ` `int` `Count = 0;` ` ` `int` `i = 0;` ` ` `while` `(i < N - 1) {` ` ` `// Increment by K - 1, as the last` ` ` `// element will be used again for` ` ` `// the next K consecutive elements` ` ` `i = i + K - 1;` ` ` `// Increment count by 1` ` ` `Count++;` ` ` `}` ` ` `// Return the result` ` ` `return` `Count;` `}` `// Driver Code` `int` `main()` `{` ` ` `// Given Input` ` ` `int` `A[] = { 5, 4, 3, 1, 2 };` ` ` `int` `K = 3;` ` ` `int` `N = ` `sizeof` `(A) / ` `sizeof` `(A[0]);` ` ` `cout << MinimumOperations(A, N, K) << endl;` ` ` `return` `0;` `}` |

## Java

`// Java program for the above approach` `import` `java.io.*;` `class` `GFG {` ` ` ` ` `// Function to find the minimum` ` ` `// number of operations required` ` ` `// to make all array elements equal` ` ` `static` `int` `MinimumOperations(` `int` `[] A, ` `int` `N, ` `int` `K)` ` ` `{` ` ` `// Store the count of` ` ` `// operations required` ` ` `int` `Count = ` `0` `;` ` ` `int` `i = ` `0` `;` ` ` `while` `(i < N - ` `1` `) {` ` ` `// Increment by K - 1, as the last` ` ` `// element will be used again for` ` ` `// the next K consecutive elements` ` ` `i = i + K - ` `1` `;` ` ` `// Increment count by 1` ` ` `Count++;` ` ` `}` ` ` `// Return the result` ` ` `return` `Count;` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `main (String[] args) {` ` ` `// Given Input` ` ` `int` `[] A = { ` `5` `, ` `4` `, ` `3` `, ` `1` `, ` `2` `};` ` ` `int` `K = ` `3` `;` ` ` `int` `N = A.length;` ` ` `System.out.println(MinimumOperations(A, N, K));` ` ` `}` `}` `// This code is contributed by Dharanendra L V.` |

## Python3

`# Python3 program for the above approach` `# Function to find the minimum` `# number of operations required` `# to make all array elements equal` `def` `MinimumOperations(A, N, K):` ` ` ` ` `# Store the count of` ` ` `# operations required` ` ` `Count ` `=` `0` ` ` `i ` `=` `0` ` ` `while` `(i < N ` `-` `1` `):` ` ` `# Increment by K - 1, as the last` ` ` `# element will be used again for` ` ` `# the next K consecutive elements` ` ` `i ` `=` `i ` `+` `K ` `-` `1` ` ` `# Increment count by 1` ` ` `Count ` `+` `=` `1` ` ` `# Return the result` ` ` `return` `Count` `# Driver Code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` ` ` `# Given Input` ` ` `A ` `=` `[ ` `5` `, ` `4` `, ` `3` `, ` `1` `, ` `2` `]` ` ` `K ` `=` `3` ` ` `N ` `=` `len` `(A)` ` ` `print` `(MinimumOperations(A, N, K))` `# This code is contributed by mohit kumar 29` |

## C#

`// C# program for the above approach` `using` `System;` `class` `GFG {` ` ` `// Function to find the minimum` ` ` `// number of operations required` ` ` `// to make all array elements equal` ` ` `static` `int` `MinimumOperations(` `int` `[] A, ` `int` `N, ` `int` `K)` ` ` `{` ` ` `// Store the count of` ` ` `// operations required` ` ` `int` `Count = 0;` ` ` `int` `i = 0;` ` ` `while` `(i < N - 1) {` ` ` `// Increment by K - 1, as the last` ` ` `// element will be used again for` ` ` `// the next K consecutive elements` ` ` `i = i + K - 1;` ` ` `// Increment count by 1` ` ` `Count++;` ` ` `}` ` ` `// Return the result` ` ` `return` `Count;` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `Main()` ` ` `{` ` ` `// Given Input` ` ` `int` `[] A = { 5, 4, 3, 1, 2 };` ` ` `int` `K = 3;` ` ` `int` `N = A.Length;` ` ` `Console.WriteLine(MinimumOperations(A, N, K));` ` ` `}` `}` `// This code is contributed by ukasp.` |

## Javascript

`<script>` ` ` `// JavaScript program for the above approach` ` ` `// Function to find the minimum` ` ` `// number of operations required` ` ` `// to make all array elements equal` ` ` `function` `MinimumOperations(A, N, K) {` ` ` `// Store the count of` ` ` `// operations required` ` ` `let Count = 0;` ` ` `let i = 0;` ` ` `while` `(i < N - 1) {` ` ` `// Increment by K - 1, as the last` ` ` `// element will be used again for` ` ` `// the next K consecutive elements` ` ` `i = i + K - 1;` ` ` `// Increment count by 1` ` ` `Count++;` ` ` `}` ` ` `// Return the result` ` ` `return` `Count;` ` ` `}` ` ` `// Driver Code` ` ` `// Given Input` ` ` `let A = [5, 4, 3, 1, 2];` ` ` `let K = 3;` ` ` `let N = A.length;` ` ` `document.write(MinimumOperations(A, N, K));` ` ` `// This code is contributed by Hritik` ` ` `</script>` |

**Output:**

2

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