更改数组，使| arr [i] – M |所需的最少操作<= 1

给定整数array [] ，任务将找到更改数组元素所需的最小操作数，以便对于任何正整数M ， | arr [i] – M | ≤1对所有有效的I。

在单个操作中，可以将数组的任何元素增加或减少1。

例子：

Input: arr[] = {10, 1, 4}
Output: 7
If we change 1 into 2 and 10 into 4 with count of operations being |1 – 2| + |10 – 4| = 7
After changing, array becomes {4, 2, 4} where every element’s absolute difference with M = 3 is ≤ 1

Input: arr[] = {5, 7, 4, 1, 4}
Output: 4

方法：从数组的最小元素到数组的最大元素(即num) ，计算更改每个元素以使其与num的绝对差≤1所需的操作数。所有可能的操作中的最小值是必需的答案。

下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
using namespace std;
  
// Function to return the minimum
// number of operations required
int changeTheArray(int arr[], int n)
{
  
    // Minimum and maximum elements from the array
    int minEle = *(std::min_element(arr, arr + n));
    int maxEle = *(std::max_element(arr, arr + n));
  
    // To store the minimum number of
    // operations required
    int minOperations = INT_MAX;
    for (int num = minEle; num <= maxEle; num++) {
  
        // To store the number of operations required
        // to change every element to either
        // (num - 1), num or (num + 1)
        int operations = 0;
        for (int i = 0; i < n; i++) {
  
            // If current element is not already num
            if (arr[i] != num) {
  
                // Add the count of operations
                // required to change arr[i]
                operations += (abs(num - arr[i]) - 1);
            }
        }
  
        // Update the minimum operations so far
        minOperations = min(minOperations, operations);
    }
  
    return minOperations;
}
  
// Driver code
int main()
{
    int arr[] = { 10, 1, 4 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << changeTheArray(arr, n);
  
    return 0;
}

Java

// Java implementation of the approach
import java.util.*;
  
class GFG {
  
    // Function to return the minimum
    // number of operations required
    static int changeTheArray(int arr[], int n)
    {
  
        // Minimum and maximum elements from the array
        int minEle = Arrays.stream(arr).min().getAsInt();
        int maxEle = Arrays.stream(arr).max().getAsInt();
  
        // To store the minimum number of
        // operations required
        int minOperations = Integer.MAX_VALUE;
        for (int num = minEle; num <= maxEle; num++) {
  
            // To store the number of operations required
            // to change every element to either
            // (num - 1), num or (num + 1)
            int operations = 0;
            for (int i = 0; i < n; i++) {
  
                // If current element is not already num
                if (arr[i] != num) {
  
                    // Add the count of operations
                    // required to change arr[i]
                    operations += (Math.abs(num - arr[i]) - 1);
                }
            }
  
            // Update the minimum operations so far
            minOperations = Math.min(minOperations, operations);
        }
  
        return minOperations;
    }
  
    // Driver code
    public static void main(String args[])
    {
        int arr[] = { 10, 1, 4 };
        int n = arr.length;
        System.out.println(changeTheArray(arr, n));
    }
}
  
// This code has been contributed by 29AjayKumar

Python3

# Python3 implementation of the approach 
import math
import sys
  
# Function to return the minimum 
# number of operations required 
def changeTheArray(arr, n):
      
    # Minimum and maximum elements
    # from the array 
    minEle = min(arr)
    maxEle = max(arr)
  
    # To store the minimum number of 
    # operations required 
    minOperations = sys.maxsize
  
    for num in range(minEle, maxEle + 1):
          
        # To store the number of operations required 
        # to change every element to either 
        # (num - 1), num or (num + 1) 
        operations = 0
        for i in range(n):
  
                # If current element is not already num
                if arr[i] != num:
                        operations += (abs(num - arr[i]) - 1)
          
        # Update the minimum operations so far 
        minOperations = min(minOperations, operations)
    return minOperations
  
# Driver code
if __name__=='__main__':
    arr = [10, 1, 4]
    n = len(arr)
    print(changeTheArray(arr, n))
  
# This code is contributed by Vikash Kumar 37

C#

// C# implementation of the approach
using System;
using System.Linq;
  
class GFG 
{ 
  
    // Function to return the minimum 
    // number of operations required 
    static int changeTheArray(int []arr, int n) 
    { 
  
        // Minimum and maximum elements from the array 
        int minEle = arr.Min(); 
        int maxEle = arr.Max(); 
  
        // To store the minimum number of 
        // operations required 
        int minOperations = int.MaxValue; 
        for (int num = minEle; num <= maxEle; num++) 
        { 
  
            // To store the number of operations required 
            // to change every element to either 
            // (num - 1), num or (num + 1) 
            int operations = 0; 
            for (int i = 0; i < n; i++) 
            { 
  
                // If current element is not already num 
                if (arr[i] != num)
                { 
  
                    // Add the count of operations 
                    // required to change arr[i] 
                    operations += (Math.Abs(num - arr[i]) - 1); 
                } 
            } 
  
            // Update the minimum operations so far 
            minOperations = Math.Min(minOperations, operations); 
        } 
  
        return minOperations; 
    } 
  
    // Driver code 
    public static void Main(String []args) 
    { 
        int []arr = { 10, 1, 4 }; 
        int n = arr.Length; 
        Console.WriteLine(changeTheArray(arr, n)); 
    } 
} 
  
// This code is contributed by Rajput-Ji

输出：

7