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:

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

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Output:

11 6 2 4 8 55


My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.