# Count of pass required to visit same index again by moving arr[i] to index arr[i]

• Last Updated : 15 Nov, 2021

Given an array(1-based indexing) arr[] of permutation of the first N natural numbers, the task for each element is to find the number of moves required to reach that index such that in each move, array element at index i moves to the array element at index arr[i].

Examples:

Input: arr[] = {2, 3, 1}
Output: 3 3 3
Explanation:
For array element arr = 2, the set of moves of indices are 1 -> 2 -> 3 -> 1. The total count of moves required is 3.
For array element arr = 3, the set of moves of indices are 2 -> 3 -> 1 -> 2. The total count of moves required is 3.
For array element arr = 1, the set of moves of indices are 3 -> 1 -> 2 -> 3. The total count of moves required is 3.

Input: arr[] = {4, 6, 2, 1, 5, 3}
Output: 2 3 3 2 1 3

Approach: The given problem can be solved by finding the number of moves required for every array element for each index. Follow the steps below to solve the given problem:

• Traverse the given array arr[] using the variable i and perform the following steps:
• Initialize a variable, say count that stores the total number of moves required.
• Initialize a variable, say K as i and iterate a do-while loop and in that loop update the value of K to arr[K] and increment the value of count by 1 until K is not the same as the value of i.
• After completing the above steps, print the value of count as the resultant count of move required for the current index.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to find the number of moves` `// required to visit the same index` `// again for every array element` `void` `numberOfPasses(vector<``int``> arr, ``int` `N)` `{` `    ``// Make given array 0 index based` `    ``for` `(``int` `i = 0; i < N; ++i) {` `        ``--arr[i];` `    ``}`   `    ``for` `(``int` `i = 0; i < N; ++i) {`   `        ``// Stores the number of moves` `        ``int` `cnt = 0;`   `        ``// Store index value` `        ``int` `k = i;`   `        ``do` `{`   `            ``// Update the value of cnt` `            ``++cnt;`   `            ``// Make a pass` `            ``k = arr[k];`   `        ``} ``while` `(k != i);`   `        ``// Print the value of cnt` `        ``cout << cnt << ``" "``;` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``vector<``int``> arr{ 4, 6, 2, 1, 5, 3 };` `    ``int` `N = arr.size();` `    ``numberOfPasses(arr, N);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.io.*;`   `class` `GFG` `{`   `  ``// Function to find the number of moves` `  ``// required to visit the same index` `  ``// again for every array element` `  ``static` `void` `numberOfPasses(``int``[] arr, ``int` `N)` `  ``{`   `    ``// Make given array 0 index based` `    ``for` `(``int` `i = ``0``; i < N; ++i) {` `      ``--arr[i];` `    ``}`   `    ``for` `(``int` `i = ``0``; i < N; ++i) {`   `      ``// Stores the number of moves` `      ``int` `cnt = ``0``;`   `      ``// Store index value` `      ``int` `k = i;`   `      ``do` `{`   `        ``// Update the value of cnt` `        ``++cnt;`   `        ``// Make a pass` `        ``k = arr[k];`   `      ``} ``while` `(k != i);`   `      ``// Print the value of cnt` `      ``System.out.print(cnt+``" "``);` `    ``}` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `main (String[] args)` `  ``{` `    ``int``[] arr = { ``4``, ``6``, ``2``, ``1``, ``5``, ``3` `};` `    ``int` `N = arr.length;` `    ``numberOfPasses(arr, N);`   `  ``}` `}`   `// This code is contributed by Potta Lokesh`

## Python3

 `# Python program for the above approach`   `# Function to find the number of moves` `# required to visit the same index` `# again for every array element` `def` `numberOfPasses(arr, N):`   `    ``# Make given array 0 index based` `    ``for` `i ``in` `range``(``0``, N):  ` `        ``arr[i] ``=` `arr[i] ``-` `1` `    `    `    ``for` `i ``in` `range``(``0``, N): `   `        ``# Stores the number of moves` `        ``cnt ``=` `0``;`   `        ``# Store index value` `        ``k ``=` `i;`   `        ``while``(``True``): `   `            ``# Update the value of cnt` `            ``cnt ``=` `cnt ``+` `1`   `            ``# Make a pass` `            ``k ``=` `arr[k]`   `            ``if` `(k ``=``=` `i):` `                ``break``;`   `        ``# Print the value of cnt` `        ``print``(cnt, end``=``" "``)` `    `  `# Driver Code`   `arr ``=` `[``4``, ``6``, ``2``, ``1``, ``5``, ``3``]` `N ``=` `len``(arr)` `numberOfPasses(arr, N)`   `# This code is contributed by ihritik`

## C#

 `// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG{`   `// Function to find the number of moves` `// required to visit the same index` `// again for every array element` `static` `void` `numberOfPasses(``int` `[]arr, ``int` `N)` `{`   `    ``// Make given array 0 index based` `    ``for` `(``int` `i = 0; i < N; ++i) {` `        ``--arr[i];` `    ``}`   `    ``for` `(``int` `i = 0; i < N; ++i) {`   `    ``// Stores the number of moves` `    ``int` `cnt = 0;`   `    ``// Store index value` `    ``int` `k = i;`   `    ``do` `{` `        ``// Update the value of cnt` `        ``++cnt;`   `        ``// Make a pass` `        ``k = arr[k];`   `    ``} ``while` `(k != i);`   `    ``// Print the value of cnt` `    ``Console.Write(cnt + ``" "``);` `    ``}` `}`   `// Driver Code` `public` `static` `void` `Main()` `{` `    ``int` `[]arr = { 4, 6, 2, 1, 5, 3 };` `    ``int` `N = arr.Length;` `    ``numberOfPasses(arr, N);` `}` `}`   `// This code is contributed by Samim Hossain Mondal`

## Javascript

 ``

Output

`2 3 3 2 1 3 `

Time Complexity: O(N2)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Recommended Articles
Page :