将所有奇数元素更改为偶数后最小化差异

给定N个正整数的数组arr [] 。我们必须对给定数组中的每个奇数元素执行一个运算，即，将给定数组中的每个奇数元素乘以2，任务是在执行给定操作后找到数组中任意两个元素之间的最小差。

例子：

Input: arr[] = {2, 8, 15, 29, 40}
Output: 1
Explanation:
Multiply the third element 15 by 2 so it will become 30.
Now you have 30 and 29, so the minimum difference will become 1.

Input: arr[] = { 3, 8, 13, 30, 50 }
Output : 2
Explanation:
Multiply 3 by 2 so it will become 6.
Now you have 6 and 8, so the minimum difference will become 2.

方法：

1. 将给定数组中的每个奇数乘以2，即可将其转换为偶数。
2. 将给定数组按升序排序。
3. 在上述排序数组中找到任意两个连续元素之间的最小差。
4. 上面计算出的差是执行给定操作后数组中任何两个元素之间的最小差。

下面是上述方法的实现：

C++

// C++ program for the above approach
#include 
using namespace std;
#define ll long long
  
// Function to minimize the difference
// between two elements of array
void minDiff(vector a, int n)
{
  
    // Find all the element which are
    // possible by multiplying
    // 2 to odd numbers
    for (int i = 0; i < n; i++) {
        if (a[i] % 2 == 1)
            a.push_back(a[i] * 2);
    }
  
    // Sort the array
    sort(a.begin(), a.end());
  
    ll mindifference = a[1] - a[0];
  
    // Find the minimum difference
    // Iterate and find which adjacent
    // elements have the minimum difference
    for (int i = 1; i < a.size(); i++) {
  
        mindifference = min(mindifference,
                            a[i] - a[i - 1]);
    }
  
    // Print the minimum difference
    cout << mindifference << endl;
}
  
// Driver Code
int main()
{
    // Given array
    vector arr = { 3, 8, 13, 30, 50 };
  
    int n = sizeof(arr) / sizeof(arr[0]);
  
    // Function Call
    minDiff(arr, n);
  
    return 0;
}

Java

// Java program for the above approach 
import java.util.*;
class GFG{
      
// Function to minimize the difference 
// between two elements of array 
public static void minDiff(long[] a, int n) 
{ 
      
    // Find all the element which are 
    // possible by multiplying 
    // 2 to odd numbers 
    for(int i = 0; i < n; i++)
    { 
       if (a[i] % 2 == 1) 
           a[i] *= 2; 
    } 
  
    // Sort the array 
    Arrays.sort(a); 
  
    long mindifference = a[1] - a[0]; 
  
    // Find the minimum difference 
    // Iterate and find which adjacent 
    // elements have the minimum difference 
    for(int i = 1; i < a.length; i++)
    { 
       mindifference = Math.min(mindifference, 
                                a[i] - a[i - 1]); 
    } 
      
    // Print the minimum difference 
    System.out.println(mindifference); 
} 
  
// Driver Code 
public static void main(String []args) 
{ 
      
    // Given array 
    long [] arr = { 3, 8, 13, 30, 50 }; 
  
    int n = arr.length; 
  
    // Function call 
    minDiff(arr, n); 
} 
}
  
// This code is contributed by jrishabh99

Python3

# Python3 program for the above approach
  
# Function to minimize the difference
# between two elements of array
def minDiff(a,n):
  
    # Find all the element which are
    # possible by multiplying
    # 2 to odd numbers
    for i in range(n):
        if (a[i] % 2 == 1):
            a.append(a[i] * 2)
  
    # Sort the array
    a = sorted(a)
  
    mindifference = a[1] - a[0]
  
    # Find the minimum difference
    # Iterate and find which adjacent
    # elements have the minimum difference
    for i in range(1, len(a)):
  
        mindifference = min(mindifference,
                            a[i] - a[i - 1])
  
    # Print the minimum difference
    print(mindifference)
  
# Driver Code
if __name__ == '__main__':
    arr = [3, 8, 13, 30, 50]
  
    n = len(arr)
  
    # Function Call
    minDiff(arr, n)
  
# This code is contributed by Mohit Kumar

C#

// C# program for the above approach 
using System;
class GFG{
      
// Function to minimize the difference 
// between two elements of array 
public static void minDiff(long[] a, int n) 
{ 
      
    // Find all the element which are 
    // possible by multiplying 
    // 2 to odd numbers 
    for(int i = 0; i < n; i++)
    { 
        if (a[i] % 2 == 1) 
            a[i] *= 2; 
    } 
  
    // Sort the array 
    Array.Sort(a); 
  
    long mindifference = a[1] - a[0]; 
  
    // Find the minimum difference 
    // Iterate and find which adjacent 
    // elements have the minimum difference 
    for(int i = 1; i < a.Length; i++)
    { 
        mindifference = Math.Min(mindifference, 
                                 a[i] - a[i - 1]); 
    } 
      
    // Print the minimum difference 
    Console.Write(mindifference); 
} 
  
// Driver Code 
public static void Main() 
{ 
      
    // Given array 
    long []arr = { 3, 8, 13, 30, 50 }; 
  
    int n = arr.Length; 
  
    // Function call 
    minDiff(arr, n); 
} 
}
  
// This code is contributed by Code_Mech

输出：

2

时间复杂度： O(N * log ₂ N)