Given an array arr[] having N integers in the range [1, N] with at most one repeated element, the task is to find the minimum number of increment or decrement operations required to make the given array a permutation of numbers from 1 to N.
Examples:
Input: arr[] = {1, 2, 5, 3, 2}
Output: 2
Explanation: The given array contains 2 twice and 4 is missing from the array. Therefore, a 2 can be changed into 4 using two increment operations which is the minimum possible.Input: arr[] = {1, 2, 5, 3, 4}
Output: 0
Explanation: The given array already represents the permutation of integers from 1 to 5.
Naive Approach: The given problem can be solved simply by finding the duplicate element and the missing element in the given array. This can be easily done by sorting the given array and checking for the duplicate and the missing element.
Time Complexity: O(N*log N)
Auxiliary Space: O(1)
Efficient Approach: The given problem can be solved using a simple observation that the sum of all elements of a permutation of N integers is always equal to N*(N+1)/ 2. Hence, the number of required operations can simply be calculated by the formula | sum of array elements – N*(N+1)/ 2)|.
Below is the implementation of the above approach:
// C++ program of the above approach #include <bits/stdc++.h> using namespace std;
// Function to find the minimum number of // increment/decrement operations to change // the given array into a permutation int minCost( int arr[], int N)
{ // Stores the sum of array elements
int sumOfArray = 0;
// Loop to iterate through the array
for ( int i = 0; i < N; i++) {
sumOfArray += arr[i];
}
// Finding sum of first
// N natural numbers
int sumOfN = N * (N + 1) / 2;
// Find the absolute difference
int diff = sumOfArray - sumOfN;
diff = diff < 0 ? -1 * diff : diff;
// Return Answer
return diff;
} // Driver code int main()
{ int arr[] = { 1, 2, 5, 3, 2 };
int n = sizeof (arr) / sizeof ( int );
cout << minCost(arr, n);
return 0;
} |
// Java program of the above approach public class GFG {
// Function to find the minimum number of
// increment/decrement operations to change
// the given array into a permutation
static int minCost( int []arr, int N)
{
// Stores the sum of array elements
int sumOfArray = 0 ;
// Loop to iterate through the array
for ( int i = 0 ; i < N; i++) {
sumOfArray += arr[i];
}
// Finding sum of first
// N natural numbers
int sumOfN = N * (N + 1 ) / 2 ;
// Find the absolute difference
int diff = sumOfArray - sumOfN;
diff = diff < 0 ? - 1 * diff : diff;
// Return Answer
return diff;
}
// Driver code
public static void main (String[] args) {
int arr[] = { 1 , 2 , 5 , 3 , 2 };
int n = arr.length;
System.out.println(minCost(arr, n));
}
} // This code is contributed by AnkThon |
# python program of the above approach # Function to find the minimum number of # increment/decrement operations to change # the given array into a permutation def minCost(arr, N):
# Stores the sum of array elements
sumOfArray = 0
# Loop to iterate through the array
for i in range ( 0 , N):
sumOfArray + = arr[i]
# Finding sum of first
# N natural numbers
sumOfN = N * (N + 1 ) / / 2
# Find the absolute difference
diff = sumOfArray - sumOfN
if diff < 0 :
diff = - 1 * diff
# Return Answer
return diff
# Driver code if __name__ = = "__main__" :
arr = [ 1 , 2 , 5 , 3 , 2 ]
n = len (arr)
print (minCost(arr, n))
# This code is contributed by rakeshsahni
|
// C# program of the above approach using System;
class GFG {
// Function to find the minimum number of
// increment/decrement operations to change
// the given array into a permutation
static int minCost( int []arr, int N)
{
// Stores the sum of array elements
int sumOfArray = 0;
// Loop to iterate through the array
for ( int i = 0; i < N; i++) {
sumOfArray += arr[i];
}
// Finding sum of first
// N natural numbers
int sumOfN = N * (N + 1) / 2;
// Find the absolute difference
int diff = sumOfArray - sumOfN;
diff = diff < 0 ? -1 * diff : diff;
// Return Answer
return diff;
}
// Driver code
public static void Main () {
int []arr = { 1, 2, 5, 3, 2 };
int n = arr.Length;
Console.Write(minCost(arr, n));
}
} // This code is contributed by Samim Hossain Mondal |
<script> // JavaScript Program to implement
// the above approach
// Function to find the minimum number of
// increment/decrement operations to change
// the given array into a permutation
function minCost(arr, N)
{
// Stores the sum of array elements
let sumOfArray = 0;
// Loop to iterate through the array
for (let i = 0; i < N; i++) {
sumOfArray += arr[i];
}
// Finding sum of first
// N natural numbers
let sumOfN = N * (N + 1) / 2;
// Find the absolute difference
let diff = sumOfArray - sumOfN;
diff = diff < 0 ? -1 * diff : diff;
// Return Answer
return diff;
}
// Driver code
let arr = [1, 2, 5, 3, 2];
let n = arr.length;
document.write(minCost(arr, n));
// This code is contributed by Potta Lokesh
</script>
|
2
Time Complexity: O(N)
Auxiliary Space: O(1)