# Minimize swaps to rearrange Array such that remainder of any element and its index with 3 are same

• Difficulty Level : Hard
• Last Updated : 29 Oct, 2021

Given an array arr[]. The task is to minimize the number of swaps required such that for each i in arr[], arr[i]%3 = i%3. If such rearrangement is not possible, print -1.

Examples:

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: arr[ ] = {4, 3, 5, 2, 9, 7}
Output: 3
Explanation: Following are the operations performed in arr[]
Initially, index % 3 = {0, 1, 2, 0, 1, 2} and arr[i] % 3 = {1, 0, 2, 2, 0, 1}.
swap arr[0] and arr[1] updates arr[] to arr[]  % 3 = {0, 1, 2, 2, 0, 1}
swap arr[3] and arr[4] updates arr[] to arr[] % 3 = {0, 1, 2, 0, 2, 1}
swap arr[4] and arr[5] updates arr[] to arr[] % 3 = {0, 1, 2, 0, 1, 2}
Therefore, 3 swaps are required to get the resultant array which is minimum possible.

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

Approach: This problem is implementation-based and related to modulo properties. Follow the steps below to solve the given problem.

• Iterate the array with i from i = 0 to i=n-1
• if arr[i] % 3 equals 0 then, continue.
• else, find the index j from i+1 to n-1, where i % 3 = arr[j] % 3 and j % 3 = arr[i] % 3.
• With above step move two array elements at their wanted positions.
• If no such j is found, then find an index k form i+1 to n-1, where i % 3 = arr[k] % 3, and swap the elements.
• The base case will be count of indices such that index%3 = arr[i] % 3.
• Return the final count as the required answer.

Below is the implementation of the above approach:

## C++

 `// C++ Program for above approach``#include ``using` `namespace` `std;` `// Function to swap two array elements.``void` `swapping(``int` `arr[], ``int` `i, ``int` `j)``{``    ``int` `temp = arr[i];``    ``arr[i] = arr[j];``    ``arr[j] = temp;``}` `// Function to count the Swaps required such that``// for all i in arr[] arr[]% 3 = i % 3``int` `CountMinSwaps(``int` `arr[], ``int` `n)``{` `    ``// index_mod_i = count of indexes which``    ``// give i on modulo 3: index%3==i``    ``int` `index_mod_0 = 0,``        ``index_mod_1 = 0,``        ``index_mod_2 = 0;` `    ``// array_mod_i = count of array elements``    ``// which give i on modulo 3: arr[i]%3==i``    ``int` `array_mod_0 = 0,``        ``array_mod_1 = 0,``        ``array_mod_2 = 0;` `    ``int` `i, j, count = 0;` `    ``for` `(i = 0; i < n; i++) {``        ``if` `(i % 3 == 0)``            ``index_mod_0 += 1;` `        ``else` `if` `(i % 3 == 1)``            ``index_mod_1 += 1;` `        ``else` `if` `(i % 3 == 2)``            ``index_mod_2 += 1;` `        ``if` `(arr[i] % 3 == 0)``            ``array_mod_0 += 1;` `        ``else` `if` `(arr[i] % 3 == 1)``            ``array_mod_1 += 1;` `        ``else` `if` `(arr[i] % 3 == 2)``            ``array_mod_2 += 1;``    ``}` `    ``// check for base condition.``    ``if` `(index_mod_0 != array_mod_0``        ``|| index_mod_1 != array_mod_1``        ``|| index_mod_2 != array_mod_2)``        ``return` `-1;` `    ``// count the swaps now.``    ``for` `(i = 0; i < n; i++) {` `        ``// If already in right format``        ``// Then goto next index``        ``if` `(i % 3 == arr[i] % 3)``            ``continue``;` `        ``int` `index_org = i % 3;``        ``int` `array_org = arr[i] % 3;` `        ``// Initially set swapped to false``        ``bool` `swapped = ``false``;` `        ``for` `(j = i + 1; j < n; j++) {``            ``int` `index_exp = j % 3;``            ``int` `array_exp = arr[j] % 3;` `            ``if` `(index_org == array_exp``                ``&& array_org == index_exp) {``                ``swapping(arr, i, j);` `                ``// Set swapped to true to make sure``                ``// any value is swapped``                ``swapped = ``true``;` `                ``// Increment the count``                ``count += 1;``                ``break``;``            ``}``        ``}` `        ``// Check if element is swapped or not``        ``if` `(swapped == ``false``) {``            ``for` `(j = i + 1; j < n; j++) {``                ``int` `array_exp = arr[j] % 3;``                ``if` `(index_org == array_exp) {``                    ``// Swap indices i and j``                    ``swapping(arr, i, j);` `                    ``// Increment the count of swaps``                    ``count += 1;``                    ``break``;``                ``}``            ``}``        ``}``    ``}` `    ``// Return the final result``    ``return` `count;``}` `// Driver Code``int` `main()``{``    ``int` `arr[6] = { 4, 3, 5, 2, 9, 7 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``int` `swaps = CountMinSwaps(arr, n);` `    ``cout << swaps << endl;``}`

## Java

 `// Java code for the above approach``import` `java.io.*;` `class` `GFG {``  ` `// Function to swap two array elements.``static` `void` `swapping(``int` `arr[], ``int` `i, ``int` `j)``{``    ``int` `temp = arr[i];``    ``arr[i] = arr[j];``    ``arr[j] = temp;``}` `// Function to count the Swaps required such that``// for all i in arr[] arr[]% 3 = i % 3``static` `int` `CountMinSwaps(``int` `arr[], ``int` `n)``{` `    ``// index_mod_i = count of indexes which``    ``// give i on modulo 3: index%3==i``    ``int` `index_mod_0 = ``0``,``        ``index_mod_1 = ``0``,``        ``index_mod_2 = ``0``;` `    ``// array_mod_i = count of array elements``    ``// which give i on modulo 3: arr[i]%3==i``    ``int` `array_mod_0 = ``0``,``        ``array_mod_1 = ``0``,``        ``array_mod_2 = ``0``;` `    ``int` `i, j, count = ``0``;` `    ``for` `(i = ``0``; i < n; i++) {``        ``if` `(i % ``3` `== ``0``)``            ``index_mod_0 += ``1``;` `        ``else` `if` `(i % ``3` `== ``1``)``            ``index_mod_1 += ``1``;` `        ``else` `if` `(i % ``3` `== ``2``)``            ``index_mod_2 += ``1``;` `        ``if` `(arr[i] % ``3` `== ``0``)``            ``array_mod_0 += ``1``;` `        ``else` `if` `(arr[i] % ``3` `== ``1``)``            ``array_mod_1 += ``1``;` `        ``else` `if` `(arr[i] % ``3` `== ``2``)``            ``array_mod_2 += ``1``;``    ``}` `    ``// check for base condition.``    ``if` `(index_mod_0 != array_mod_0``        ``|| index_mod_1 != array_mod_1``        ``|| index_mod_2 != array_mod_2)``        ``return` `-``1``;` `    ``// count the swaps now.``    ``for` `(i = ``0``; i < n; i++) {` `        ``// If already in right format``        ``// Then goto next index``        ``if` `(i % ``3` `== arr[i] % ``3``)``            ``continue``;` `        ``int` `index_org = i % ``3``;``        ``int` `array_org = arr[i] % ``3``;` `        ``// Initially set swapped to false``        ``boolean` `swapped = ``false``;` `        ``for` `(j = i + ``1``; j < n; j++) {``            ``int` `index_exp = j % ``3``;``            ``int` `array_exp = arr[j] % ``3``;` `            ``if` `(index_org == array_exp``                ``&& array_org == index_exp) {``                ``swapping(arr, i, j);` `                ``// Set swapped to true to make sure``                ``// any value is swapped``                ``swapped = ``true``;` `                ``// Increment the count``                ``count += ``1``;``                ``break``;``            ``}``        ``}` `        ``// Check if element is swapped or not``        ``if` `(swapped == ``false``) {``            ``for` `(j = i + ``1``; j < n; j++) {``                ``int` `array_exp = arr[j] % ``3``;``                ``if` `(index_org == array_exp) {``                    ``// Swap indices i and j``                    ``swapping(arr, i, j);` `                    ``// Increment the count of swaps``                    ``count += ``1``;``                    ``break``;``                ``}``            ``}``        ``}``    ``}` `    ``// Return the final result``    ``return` `count;``}` `    ``public` `static` `void` `main (String[] args) {``      ``int` `arr[] = { ``4``, ``3``, ``5``, ``2``, ``9``, ``7` `};``    ``int` `n = arr.length;` `    ``int` `swaps = CountMinSwaps(arr, n);` `        ``System.out.println(swaps );``    ``}``}` `// This code is contributed by Potta Lokesh`

## Python3

 `# python Program for above approach` `# Function to swap two array elements.``def` `swapping(arr, i, j):``    ``temp ``=` `arr[i]``    ``arr[i] ``=` `arr[j]``    ``arr[j] ``=` `temp` `# Function to count the Swaps required such that``# for all i in arr[] arr[]% 3 = i % 3``def` `CountMinSwaps(arr, n):` `    ``# index_mod_i = count of indexes which``    ``# give i on modulo 3: index%3==i``    ``index_mod_0 ``=` `0``    ``index_mod_1 ``=` `0``    ``index_mod_2 ``=` `0` `    ``# array_mod_i = count of array elements``    ``# which give i on modulo 3: arr[i]%3==i``    ``array_mod_0 ``=` `0``    ``array_mod_1 ``=` `0``    ``array_mod_2 ``=` `0` `    ``count ``=` `0` `    ``for` `i ``in` `range``(``0``, n):``        ``if` `(i ``%` `3` `=``=` `0``):``            ``index_mod_0 ``+``=` `1` `        ``elif` `(i ``%` `3` `=``=` `1``):``            ``index_mod_1 ``+``=` `1` `        ``elif` `(i ``%` `3` `=``=` `2``):``            ``index_mod_2 ``+``=` `1` `        ``if` `(arr[i] ``%` `3` `=``=` `0``):``            ``array_mod_0 ``+``=` `1` `        ``elif` `(arr[i] ``%` `3` `=``=` `1``):``            ``array_mod_1 ``+``=` `1` `        ``elif` `(arr[i] ``%` `3` `=``=` `2``):``            ``array_mod_2 ``+``=` `1` `    ``# check for base condition.``    ``if` `(index_mod_0 !``=` `array_mod_0 ``or` `index_mod_1 !``=` `array_mod_1 ``or` `index_mod_2 !``=` `array_mod_2):``        ``return` `-``1` `        ``# count the swaps now.``    ``for` `i ``in` `range``(``0``, n):` `                ``# If already in right format``                ``# Then goto next index``        ``if` `(i ``%` `3` `=``=` `arr[i] ``%` `3``):``            ``continue` `        ``index_org ``=` `i ``%` `3``        ``array_org ``=` `arr[i] ``%` `3` `        ``# Initially set swapped to false``        ``swapped ``=` `False` `        ``for` `j ``in` `range``(i``+``1``, n):``            ``index_exp ``=` `j ``%` `3``            ``array_exp ``=` `arr[j] ``%` `3` `            ``if` `(index_org ``=``=` `array_exp ``and` `array_org ``=``=` `index_exp):``                ``swapping(arr, i, j)` `                ``# Set swapped to true to make sure``                ``# any value is swapped``                ``swapped ``=` `True` `                ``# Increment the count``                ``count ``+``=` `1``                ``break` `                ``# Check if element is swapped or not``        ``if` `(swapped ``=``=` `False``):``            ``for` `j ``in` `range``(i``+``1``, n):``                ``array_exp ``=` `arr[j] ``%` `3``                ``if` `(index_org ``=``=` `array_exp):``                                        ``# Swap indices i and j``                    ``swapping(arr, i, j)` `                    ``# Increment the count of swaps``                    ``count ``+``=` `1``                    ``break` `        ``# Return the final result``    ``return` `count` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``4``, ``3``, ``5``, ``2``, ``9``, ``7``]``    ``n ``=` `len``(arr)` `    ``swaps ``=` `CountMinSwaps(arr, n)``    ``print``(swaps)` `    ``# This code is contributed by rakeshsahni`

## C#

 `// C# code for the above approach``using` `System;``class` `GFG``{` `    ``// Function to swap two array elements.``    ``static` `void` `swapping(``int``[] arr, ``int` `i, ``int` `j)``    ``{``        ``int` `temp = arr[i];``        ``arr[i] = arr[j];``        ``arr[j] = temp;``    ``}` `    ``// Function to count the Swaps required such that``    ``// for all i in arr[] arr[]% 3 = i % 3``    ``static` `int` `CountMinSwaps(``int``[] arr, ``int` `n)``    ``{` `        ``// index_mod_i = count of indexes which``        ``// give i on modulo 3: index%3==i``        ``int` `index_mod_0 = 0,``            ``index_mod_1 = 0,``            ``index_mod_2 = 0;` `        ``// array_mod_i = count of array elements``        ``// which give i on modulo 3: arr[i]%3==i``        ``int` `array_mod_0 = 0,``            ``array_mod_1 = 0,``            ``array_mod_2 = 0;` `        ``int` `i, j, count = 0;` `        ``for` `(i = 0; i < n; i++)``        ``{``            ``if` `(i % 3 == 0)``                ``index_mod_0 += 1;` `            ``else` `if` `(i % 3 == 1)``                ``index_mod_1 += 1;` `            ``else` `if` `(i % 3 == 2)``                ``index_mod_2 += 1;` `            ``if` `(arr[i] % 3 == 0)``                ``array_mod_0 += 1;` `            ``else` `if` `(arr[i] % 3 == 1)``                ``array_mod_1 += 1;` `            ``else` `if` `(arr[i] % 3 == 2)``                ``array_mod_2 += 1;``        ``}` `        ``// check for base condition.``        ``if` `(index_mod_0 != array_mod_0``            ``|| index_mod_1 != array_mod_1``            ``|| index_mod_2 != array_mod_2)``            ``return` `-1;` `        ``// count the swaps now.``        ``for` `(i = 0; i < n; i++)``        ``{` `            ``// If already in right format``            ``// Then goto next index``            ``if` `(i % 3 == arr[i] % 3)``                ``continue``;` `            ``int` `index_org = i % 3;``            ``int` `array_org = arr[i] % 3;` `            ``// Initially set swapped to false``            ``Boolean swapped = ``false``;` `            ``for` `(j = i + 1; j < n; j++)``            ``{``                ``int` `index_exp = j % 3;``                ``int` `array_exp = arr[j] % 3;` `                ``if` `(index_org == array_exp``                    ``&& array_org == index_exp)``                ``{``                    ``swapping(arr, i, j);` `                    ``// Set swapped to true to make sure``                    ``// any value is swapped``                    ``swapped = ``true``;` `                    ``// Increment the count``                    ``count += 1;``                    ``break``;``                ``}``            ``}` `            ``// Check if element is swapped or not``            ``if` `(swapped == ``false``)``            ``{``                ``for` `(j = i + 1; j < n; j++)``                ``{``                    ``int` `array_exp = arr[j] % 3;``                    ``if` `(index_org == array_exp)``                    ``{``                        ``// Swap indices i and j``                        ``swapping(arr, i, j);` `                        ``// Increment the count of swaps``                        ``count += 1;``                        ``break``;``                    ``}``                ``}``            ``}``        ``}` `        ``// Return the final result``        ``return` `count;``    ``}` `    ``public` `static` `void` `Main()``    ``{``        ``int``[] arr = { 4, 3, 5, 2, 9, 7 };``        ``int` `n = arr.Length;` `        ``int` `swaps = CountMinSwaps(arr, n);` `        ``Console.Write(swaps);``    ``}``}` `// This code is contributed by Saurabh Jaiswal`

## Javascript

 ``

Output:
`3`

Time Complexity: O(N2), Where N is the size of arr[].

Auxiliary Space: O(1).

My Personal Notes arrow_drop_up