Given an array arr[] of size N, the task is to rearrange the array elements such that the count of local minima in the array is maximum.
Note: An element arr[x] is said to be a local minimum if it is less than or equal to both its adjacent elements. The first and last array elements can’t be considered as local minima.
Examples:
Input: arr[]= {1, 2, 3, 4, 5}
Output: 3 1 4 2 5
Explanation:
Rearranging array elements to {3, 1, 4, 2, 5}. The count of local minima in the array is 2, i.e. {arr[1], arr[3]}, which is the maximum possible count of local minima that can be obtained from the array. Therefore, the required output is 3 1 4 2 5.Input: arr[]= {1, 2, 3, 4, 5, 6}
Output: 4 1 5 2 6 3
Approach: The idea is to use sorting algorithms and two pointer technique to solve this problem. Follow the steps below to solve this problem:
- Sort the array in ascending order.
- Initialize two variables, say left = 0 and right = N / 2 to store the index of the left and right pointers respectively.
- Traverse the array and in each traversal, first print the value of arr[right] and then print the value of arr[left] and increment the value of left and right by 1.
Below is the implementation for the above approach:
// C++ program to implement // the above approach #include <bits/stdc++.h> using namespace std;
// Function to rearrange array elements to // maximize count of local minima in the array void rearrangeArrMaxcntMinima( int arr[], int N)
{ // Sort the array in
// ascending order
sort(arr, arr + N);
// Stores index of
// left pointer
int left = 0;
// Stores index of
// right pointer
int right = N / 2;
// Traverse the array elements
while (left < N / 2 || right < N) {
// if right is less than N
if (right < N) {
// Print array element
cout << arr[right] << " " ;
// Update right
right++;
}
if (left < N / 2) {
// Print array element
cout << arr[left] << " " ;
// Update left
left++;
}
}
} // Driver Code int main()
{ int arr[] = { 1, 2, 3, 4, 5 };
int N = sizeof (arr) / sizeof (arr[0]);
rearrangeArrMaxcntMinima(arr, N);
return 0;
} |
// Java program to implement // the above approach import java.util.*;
class GFG{
// Function to rearrange array elements to // maximize count of local minima in the array static void rearrangeArrMaxcntMinima( int arr[],
int N)
{ // Sort the array in
// ascending order
Arrays.sort(arr);
// Stores index of
// left pointer
int left = 0 ;
// Stores index of
// right pointer
int right = N / 2 ;
// Traverse the array elements
while (left < N / 2 || right < N)
{
// If right is less than N
if (right < N)
{
// Print array element
System.out.print(arr[right] + " " );
// Update right
right++;
}
if (left < N / 2 )
{
// Print array element
System.out.print(arr[left] + " " );
// Update left
left++;
}
}
} // Driver Code public static void main(String[] args)
{ int arr[] = { 1 , 2 , 3 , 4 , 5 };
int N = arr.length;
rearrangeArrMaxcntMinima(arr, N);
} } // This code is contributed by code_hunt |
# Python3 program to implement # the above approach # Function to rearrange array # elements to maximize count of # local minima in the array def rearrangeArrMaxcntMinima(arr, N):
# Sort the array in
# ascending order
arr.sort()
# Stores index of
# left pointer
left = 0
# Stores index of
# right pointer
right = N / / 2
# Traverse the array elements
while (left < N / / 2 or
right < N):
# if right is less
# than N
if (right < N):
# Print array element
print (arr[right],
end = " " )
# Update right
right + = 1
if (left < N / / 2 ):
# Print array element
print (arr[left],
end = " " )
# Update left
left + = 1
# Driver Code if __name__ = = "__main__" :
arr = [ 1 , 2 , 3 , 4 , 5 ]
N = len (arr)
rearrangeArrMaxcntMinima(arr, N)
# This code is contributed by Chitranayal |
// C# program to implement // the above approach using System;
class GFG{
// Function to rearrange array elements to // maximize count of local minima in the array static void rearrangeArrMaxcntMinima( int []arr,
int N)
{ // Sort the array in
// ascending order
Array.Sort(arr);
// Stores index of
// left pointer
int left = 0;
// Stores index of
// right pointer
int right = N / 2;
// Traverse the array elements
while (left < N / 2 || right < N)
{
// If right is less than N
if (right < N)
{
// Print array element
Console.Write(arr[right] + " " );
// Update right
right++;
}
if (left < N / 2)
{
// Print array element
Console.Write(arr[left] + " " );
// Update left
left++;
}
}
} // Driver Code public static void Main(String[] args)
{ int []arr = { 1, 2, 3, 4, 5 };
int N = arr.Length;
rearrangeArrMaxcntMinima(arr, N);
} } // This code is contributed by Rajput-Ji |
<script> // Javascript program to implement // the above approach // Function to rearrange array elements to // maximize count of local minima in the array function rearrangeArrMaxcntMinima(arr, N)
{ // Sort the array in
// ascending order
arr.sort( function (a, b){ return a - b;});
// Stores index of
// left pointer
let left = 0;
// Stores index of
// right pointer
let right = Math.floor(N / 2);
// Traverse the array elements
while (left < Math.floor(N / 2) || right < N)
{
// If right is less than N
if (right < N)
{
// Print array element
document.write(arr[right] + " " );
// Update right
right++;
}
if (left < Math.floor(N / 2))
{
// Print array element
document.write(arr[left] + " " );
// Update left
left++;
}
}
} // Driver Code let arr = [ 1, 2, 3, 4, 5 ]; let N = arr.length; rearrangeArrMaxcntMinima(arr, N); // This code is contributed by avanitrachhadiya2155 </script> |
3 1 4 2 5
Time Complexity: O(N log(N))
Auxiliary Space:O(1)