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

给定一个由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

Javascript

 
// Javascript implementation of the above approach
 
// Function to minimize the difference
// between two elements of array
function minDiff(a, n)
{
       
    // Find all the element which are
    // possible by multiplying
    // 2 to odd numbers
    for(let i = 0; i < n; i++)
    {
       if (a[i] % 2 == 1)
           a[i] *= 2;
    }
   
    // Sort the array
    a.sort((a, b) => a - b);
     
    let mindifference = a[1] - a[0];
   
    // Find the minimum difference
    // Iterate and find which adjacent
    // elements have the minimum difference
    for(let i = 1; i < a.length; i++)
    {
       mindifference = Math.min(mindifference,
                                a[i] - a[i - 1]);
    }
       
    // Print the minimum difference
     document.write(mindifference);
}
   
   
  // Driver Code
     
    // Given array
    let arr = [ 3, 8, 13, 30, 50 ];
   
    let n = arr.length;
   
    // Function call
    minDiff(arr, n);
 

输出：

2

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

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。