Program to print an array in Pendulum Arrangement with constant space
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++
#include <bits/stdc++.h>
using namespace std;
void pendulumArrangement( int arr[], int n)
{
sort(arr, arr + n);
int odd, temp, in, pos;
pos = n - 1;
if (n % 2 == 0)
odd = n - 1;
else
odd = n - 2;
while (odd > 0) {
temp = arr[odd];
in = odd;
while (in != pos) {
arr[in] = arr[in + 1];
in++;
}
arr[in] = temp;
odd = odd - 2;
pos = pos - 1;
}
int start = 0, end = (n - 1) / 2;
for (; start < end; start++, end--) {
temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
for ( int i = 0; i < n; i++)
cout << arr[i] << " " ;
}
int main()
{
int arr[] = { 11, 2, 4, 55, 6, 8 };
int n = sizeof (arr) / sizeof (arr[0]);
pendulumArrangement(arr, n);
return 0;
}
|
Java
import java.util.Arrays;
import java.io.*;
class GFG {
static void pendulumArrangement( int arr[], int n)
{
Arrays.sort(arr);
int odd, temp, in, pos;
pos = n - 1 ;
if (n % 2 == 0 )
odd = n - 1 ;
else
odd = n - 2 ;
while (odd > 0 ) {
temp = arr[odd];
in = odd;
while (in != pos) {
arr[in] = arr[in + 1 ];
in++;
}
arr[in] = temp;
odd = odd - 2 ;
pos = pos - 1 ;
}
int start = 0 , end = (n - 1 ) / 2 ;
for (; start < end; start++, end--) {
temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
for ( int i = 0 ; i < n; i++)
System.out.print(arr[i] + " " );
}
public static void main(String[] args)
{
int arr[] = { 11 , 2 , 4 , 55 , 6 , 8 };
int n = arr.length;
pendulumArrangement(arr, n);
}
}
|
Python3
def pendulumArrangement(arr, n):
arr.sort(reverse = False )
pos = n - 1
if (n % 2 = = 0 ):
odd = n - 1
else :
odd = n - 2
while (odd > 0 ):
temp = arr[odd]
in1 = odd
while (in1 ! = pos):
arr[in1] = arr[in1 + 1 ]
in1 + = 1
arr[in1] = temp
odd = odd - 2
pos = pos - 1
start = 0
end = int ((n - 1 ) / 2 )
while (start < end):
temp = arr[start]
arr[start] = arr[end]
arr[end] = temp
start + = 1
end - = 1
for i in range (n):
print (arr[i], end = " " )
if __name__ = = '__main__' :
arr = [ 11 , 2 , 4 , 55 , 6 , 8 ]
n = len (arr)
pendulumArrangement(arr, n)
|
C#
using System;
class GFG
{
static void pendulumArrangement( int [] arr, int n)
{
Array.Sort(arr);
int odd, temp, p, pos;
pos = n - 1;
if (n % 2 == 0)
odd = n - 1;
else
odd = n - 2;
while (odd > 0)
{
temp = arr[odd];
p = odd;
while (p != pos)
{
arr[p] = arr[p + 1];
p++;
}
arr[p] = temp;
odd = odd - 2;
pos = pos - 1;
}
int start = 0, end = (n - 1) / 2;
for (; start < end; start++, end--)
{
temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
for ( int i = 0; i < n; i++)
Console.Write(arr[i] + " " );
}
public static void Main()
{
int [] arr = { 11, 2, 4, 55, 6, 8 };
int n = arr.Length;
pendulumArrangement(arr, n);
}
}
|
PHP
<?php
function pendulumArrangement( $arr , $n )
{
sort( $arr ) ;
$pos = $n - 1;
if ( $n % 2 == 0)
$odd = $n - 1;
else
$odd = $n - 2;
while ( $odd > 0)
{
$temp = $arr [ $odd ];
$in = $odd ;
while ( $in != $pos )
{
$arr [ $in ] = $arr [ $in + 1];
$in ++;
}
$arr [ $in ] = $temp ;
$odd = $odd - 2;
$pos = $pos - 1;
}
$start = 0;
$end = floor (( $n - 1) / 2);
for (; $start < $end ; $start ++, $end --)
{
$temp = $arr [ $start ];
$arr [ $start ] = $arr [ $end ];
$arr [ $end ] = $temp ;
}
for ( $i = 0; $i < $n ; $i ++)
echo $arr [ $i ], " " ;
}
$arr = array ( 11, 2, 4, 55, 6, 8 );
$n = count ( $arr );
pendulumArrangement( $arr , $n );
?>
|
Javascript
<script>
function pendulumArrangement(arr, n)
{
arr.sort( function (a, b){ return a - b});
let odd, temp, p, pos;
pos = n - 1;
if (n % 2 == 0)
odd = n - 1;
else
odd = n - 2;
while (odd > 0)
{
temp = arr[odd];
p = odd;
while (p != pos)
{
arr[p] = arr[p + 1];
p++;
}
arr[p] = temp;
odd = odd - 2;
pos = pos - 1;
}
let start = 0, end = parseInt((n - 1) / 2, 10);
for (; start < end; start++, end--)
{
temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
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>
|
Time Complexity: O(n2)
Auxiliary Space: O(1)
Last Updated :
23 Jun, 2022
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...