Given an array arr[] of integers, the task is to arrange them in a way similar to the to-and-fro movement of a Pendulum without using any extra space.
Pendulum Arrangement:
- The minimum element out of the list of integers must come in the center position of the array.
- The number in the ascending order next to the minimum, goes to the right, the next higher number goes to the left of minimum number and it continues.
- As higher numbers are reached, one goes to one side in a to-and-fro manner similar to that of a Pendulum.
Examples:
Input: arr[] = {2, 3, 5, 1, 4}
Output: 5 3 1 2 4
The minimum element is 1, so it is moved to the middle.
The next higher element 2 is moved to the right of the
middle element while the next higher element 3 is
moved to the left of the middle element and
this process is continued.
Input: arr[] = {11, 2, 4, 55, 6, 8}
Output: 11 6 2 4 8 55
Approach: An approach which uses an auxiliary array has been discussed in this article. Here’s an approach without using extra space:
- Sort the given array.
- Move all the odd position element in the right side of the array.
- Reverse the element from 0 to (n-1)/2 position of the array.
For example, let arr[] = {2, 3, 5, 1, 4}
Sorted array will be arr[] = {1, 2, 3, 4, 5}.
After moving all odd index position elements to the right,
arr[] = {1, 3, 5, 2, 4} (1 and 3 are the odd index positions)
After reversing elements from 0 to (n – 1) / 2,
arr[] = {5, 3, 1, 2, 4} which is the required array.
Below is the implementation of the above approach:
// C++ implementation of the approach #include <bits/stdc++.h> using namespace std;
// Function to print the Pendulum // arrangement of the given array void pendulumArrangement( int arr[], int n)
{ // Sort the array
sort(arr, arr + n);
int odd, temp, in, pos;
// pos stores the index of
// the last element of the array
pos = n - 1;
// odd stores the last odd index in the array
if (n % 2 == 0)
odd = n - 1;
else
odd = n - 2;
// Move all odd index positioned
// elements to the right
while (odd > 0) {
temp = arr[odd];
in = odd;
// Shift the elements by one position
// from odd to pos
while (in != pos) {
arr[in] = arr[in + 1];
in++;
}
arr[in] = temp;
odd = odd - 2;
pos = pos - 1;
}
// Reverse the element from 0 to (n - 1) / 2
int start = 0, end = (n - 1) / 2;
for (; start < end; start++, end--) {
temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
// Printing the pendulum arrangement
for ( int i = 0; i < n; i++)
cout << arr[i] << " " ;
} // Driver code int main()
{ int arr[] = { 11, 2, 4, 55, 6, 8 };
int n = sizeof (arr) / sizeof (arr[0]);
pendulumArrangement(arr, n);
return 0;
} |
// Java implementation of the approach import java.util.Arrays;
import java.io.*;
class GFG {
// Function to print the Pendulum
// arrangement of the given array
static void pendulumArrangement( int arr[], int n)
{
// Sort the array
// sort(arr, arr + n);
Arrays.sort(arr);
int odd, temp, in, pos;
// pos stores the index of
// the last element of the array
pos = n - 1 ;
// odd stores the last odd index in the array
if (n % 2 == 0 )
odd = n - 1 ;
else
odd = n - 2 ;
// Move all odd index positioned
// elements to the right
while (odd > 0 ) {
temp = arr[odd];
in = odd;
// Shift the elements by one position
// from odd to pos
while (in != pos) {
arr[in] = arr[in + 1 ];
in++;
}
arr[in] = temp;
odd = odd - 2 ;
pos = pos - 1 ;
}
// Reverse the element from 0 to (n - 1) / 2
int start = 0 , end = (n - 1 ) / 2 ;
for (; start < end; start++, end--) {
temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
// Printing the pendulum arrangement
for ( int i = 0 ; i < n; i++)
System.out.print(arr[i] + " " );
}
// Driver code
public static void main(String[] args)
{
int arr[] = { 11 , 2 , 4 , 55 , 6 , 8 };
int n = arr.length;
pendulumArrangement(arr, n);
}
} // This code is contributed by akt_mit |
# Python 3 implementation of the approach # Function to print the Pendulum # arrangement of the given array def pendulumArrangement(arr, n):
# Sort the array
arr.sort(reverse = False )
# pos stores the index of
# the last element of the array
pos = n - 1
# odd stores the last odd index in the array
if (n % 2 = = 0 ):
odd = n - 1
else :
odd = n - 2
# Move all odd index positioned
# elements to the right
while (odd > 0 ):
temp = arr[odd]
in1 = odd
# Shift the elements by one position
# from odd to pos
while (in1 ! = pos):
arr[in1] = arr[in1 + 1 ]
in1 + = 1
arr[in1] = temp
odd = odd - 2
pos = pos - 1
# Reverse the element from 0 to (n - 1) / 2
start = 0
end = int ((n - 1 ) / 2 )
while (start < end):
temp = arr[start]
arr[start] = arr[end]
arr[end] = temp
start + = 1
end - = 1
# Printing the pendulum arrangement
for i in range (n):
print (arr[i], end = " " )
# Driver code if __name__ = = '__main__' :
arr = [ 11 , 2 , 4 , 55 , 6 , 8 ]
n = len (arr)
pendulumArrangement(arr, n)
# This code is contributed by # Surendra_Gangwar |
// C# implementation of the approach using System;
class GFG
{ // Function to print the Pendulum
// arrangement of the given array
static void pendulumArrangement( int [] arr, int n)
{
// Sort the array
// sort(arr, arr + n);
Array.Sort(arr);
int odd, temp, p, pos;
// pos stores the index of
// the last element of the array
pos = n - 1;
// odd stores the last odd index in the array
if (n % 2 == 0)
odd = n - 1;
else
odd = n - 2;
// Move all odd index positioned
// elements to the right
while (odd > 0)
{
temp = arr[odd];
p = odd;
// Shift the elements by one position
// from odd to pos
while (p != pos)
{
arr[p] = arr[p + 1];
p++;
}
arr[p] = temp;
odd = odd - 2;
pos = pos - 1;
}
// Reverse the element from 0 to (n - 1) / 2
int start = 0, end = (n - 1) / 2;
for (; start < end; start++, end--)
{
temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
// Printing the pendulum arrangement
for ( int i = 0; i < n; i++)
Console.Write(arr[i] + " " );
}
// Driver code
public static void Main()
{
int [] arr = { 11, 2, 4, 55, 6, 8 };
int n = arr.Length;
pendulumArrangement(arr, n);
}
} // This code is contributed by ChitraNayal |
<?php // PHP implementation of the approach // Function to print the Pendulum // arrangement of the given array function pendulumArrangement( $arr , $n )
{ // Sort the array
sort( $arr ) ;
// pos stores the index of
// the last element of the array
$pos = $n - 1;
// odd stores the last odd index in the array
if ( $n % 2 == 0)
$odd = $n - 1;
else
$odd = $n - 2;
// Move all odd index positioned
// elements to the right
while ( $odd > 0)
{
$temp = $arr [ $odd ];
$in = $odd ;
// Shift the elements by one position
// from odd to pos
while ( $in != $pos )
{
$arr [ $in ] = $arr [ $in + 1];
$in ++;
}
$arr [ $in ] = $temp ;
$odd = $odd - 2;
$pos = $pos - 1;
}
// Reverse the element from 0 to (n - 1) / 2
$start = 0;
$end = floor (( $n - 1) / 2);
for (; $start < $end ; $start ++, $end --)
{
$temp = $arr [ $start ];
$arr [ $start ] = $arr [ $end ];
$arr [ $end ] = $temp ;
}
// Printing the pendulum arrangement
for ( $i = 0; $i < $n ; $i ++)
echo $arr [ $i ], " " ;
} // Driver code $arr = array ( 11, 2, 4, 55, 6, 8 );
$n = count ( $arr );
pendulumArrangement( $arr , $n );
// This code is contributed by AnkitRai01 ?> |
<script> // Javascript implementation of the approach
// Function to print the Pendulum
// arrangement of the given array
function pendulumArrangement(arr, n)
{
// Sort the array
// sort(arr, arr + n);
arr.sort( function (a, b){ return a - b});
let odd, temp, p, pos;
// pos stores the index of
// the last element of the array
pos = n - 1;
// odd stores the last odd index in the array
if (n % 2 == 0)
odd = n - 1;
else
odd = n - 2;
// Move all odd index positioned
// elements to the right
while (odd > 0)
{
temp = arr[odd];
p = odd;
// Shift the elements by one position
// from odd to pos
while (p != pos)
{
arr[p] = arr[p + 1];
p++;
}
arr[p] = temp;
odd = odd - 2;
pos = pos - 1;
}
// Reverse the element from 0 to (n - 1) / 2
let start = 0, end = parseInt((n - 1) / 2, 10);
for (; start < end; start++, end--)
{
temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
// Printing the pendulum arrangement
for (let i = 0; i < n; i++)
document.write(arr[i] + " " );
}
let arr = [ 11, 2, 4, 55, 6, 8 ];
let n = arr.length;
pendulumArrangement(arr, n);
</script> |
11 6 2 4 8 55
Time Complexity: O(n2)
Auxiliary Space: O(1)