Count of right shifts for each array element to be in its sorted position

Given an array arr[] of size N that contains elements from the range [1, N], the task is to calculate the number of right shifts required for each element to reach its respective position if the array was sorted.
Examples: 
 

Input: arr[] = {1, 4, 3, 2, 5}, N = 5 
Output: 0 2 0 3 0 
Explanation: 
The sorted array is {1, 2, 3, 4, 5}. 
4 is at index 1, so right shift 2 times to reach index 3. (1->2->3) 
2 is at index 3, so right shift 3 times to reach index 1. (3->4->0->1) 
All the other elements are at their respective positions in the sorted array.
Input: arr[]={2, 4, 3, 1, 5}, N = 5 
Output: 2 1 0 2 0 
 

 

 

Approach: 
The idea is to calculate the difference between the actual position and the sorted position of each element of the array. As the elements are from 1 to N, the sorted position of each element can be determined without sorting the array. The sorted position of each element is given by (arr[i]-1). Therefore, the number of right shifts is given by (arr[i] – 1 – i + N) % N.

Below is the implementation of the above approach:
 



C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ Program to implement
// the approach
#include <bits/stdc++.h>
using namespace std;
  
// Function to find the right
// shifts required for each
// element to reach its sorted
// array position in A[]
void findShifts(int A[], int N)
{
    // Stores required number of
    // shifts for each element
    int shift[N];
  
    for (int i = 0; i < N; i++) {
  
        // If the element is
        // at sorted position
        if (i == A[i] - 1)
            shift[i] = 0;
  
        // Otherwise
        else
  
            // Calculate right shift
            shift[i]
                = (A[i] - 1 - i + N)
                  % N;
    }
  
    // Print the respective shifts
    for (int i = 0; i < N; i++)
        cout << shift[i] << " ";
}
  
// Driver Code
int main()
{
    int arr[] = { 1, 4, 3, 2, 5 };
  
    int N = sizeof(arr) / sizeof(arr[0]);
  
    findShifts(arr, N);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to implement 
// the approach
class GFG{
      
// Function to find the right 
// shifts required for each 
// element to reach its sorted 
// array position in A[] 
public static void findShifts(int[] A, int N) 
      
    // Stores required number of 
    // shifts for each element 
    int[] shift = new int[N]; 
  
    for(int i = 0; i < N; i++)
    
  
        // If the element is 
        // at sorted position 
        if (i == A[i] - 1
            shift[i] = 0
  
        // Otherwise 
        else
  
            // Calculate right shift 
            shift[i] = (A[i] - 1 - i + N) % N; 
    
  
    // Print the respective shifts 
    for(int i = 0; i < N; i++) 
        System.out.print(shift[i] + " ");
  
// Driver code
public static void main(String[] args)
{
    int arr[] = { 1, 4, 3, 2, 5 }; 
    int N = arr.length; 
  
    findShifts(arr, N); 
}
}
  
// This code is contributed by divyeshrabadiya07

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 Program to implement
# the approach
  
# Function to find the right
# shifts required for each
# element to reach its sorted
# array position in A[]
def findShifts(A, N):
  
    # Stores required number of
    # shifts for each element
    shift = [0 for i in range(N)]
  
    for i in range(N):
  
        # If the element is
        # at sorted position
        if (i == A[i] - 1):
            shift[i] = 0
  
        # Otherwise
        else:
  
            # Calculate right shift
            shift[i] = (A[i] - 1 - i + N) % N
  
    # Print the respective shifts
    for i in range(N):
        print(shift[i], end = " ")
  
# Driver Code
if __name__ == '__main__':
  
    arr = [ 1, 4, 3, 2, 5 ]
    N = len(arr)
  
    findShifts(arr, N)
  
# This code is contributed by mohit kumar 29

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to implement 
// the approach 
using System;
  
class GFG{ 
      
// Function to find the right 
// shifts required for each 
// element to reach its sorted 
// array position in []A 
public static void findShifts(int[] A, int N) 
      
    // Stores required number of 
    // shifts for each element 
    int[] shift = new int[N]; 
  
    for(int i = 0; i < N; i++) 
    
  
        // If the element is 
        // at sorted position 
        if (i == A[i] - 1) 
            shift[i] = 0; 
  
        // Otherwise 
        else
  
            // Calculate right shift 
            shift[i] = (A[i] - 1 - i + N) % N; 
    
  
    // Print the respective shifts 
    for(int i = 0; i < N; i++) 
        Console.Write(shift[i] + " "); 
  
// Driver code 
public static void Main(String[] args) 
    int []arr = { 1, 4, 3, 2, 5 }; 
    int N = arr.Length; 
  
    findShifts(arr, N); 
}
  
// This code is contributed by amal kumar choubey

chevron_right


Output: 

0 2 0 3 0

 

Time Complexity: O(N) 
Auxiliary Space: O(N)
 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up

Recommended Posts:


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.