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

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

Java

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

Python3

# 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

C#

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

Javascript

<script>
// JavaScript program to implement
// the approach
 
// Function to find the right
// shifts required for each
// element to reach its sorted
// array position in A[]
function findShifts(A, N)
{
       
    // Stores required number of
    // shifts for each element
    let shift = Array.from({length: N}, (_, i) => 0);
   
    for(let 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(let i = 0; i < N; i++)
        document.write(shift[i] + " ");
}
 
// Driver Code   
     
    let arr = [ 1, 4, 3, 2, 5 ];
    let N = arr.length;
   
    findShifts(arr, N);
                               
</script>