Skip to content
Related Articles

Related Articles

Program to print an array in Pendulum Arrangement with constant space
  • Difficulty Level : Medium
  • Last Updated : 12 May, 2021

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: 
 



  1. Sort the given array.
  2. Move all the odd position element in the right side of the array.
  3. 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++




// 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




// 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

Python3




# 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#




// 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
// 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
 
?>

Javascript




<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>
Output: 
11 6 2 4 8 55

 

My Personal Notes arrow_drop_up
Recommended Articles
Page :