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:
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++ Program for above approach #include <iostream> 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 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 |
# 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# 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 |
<script> // JavaScript Program for above approach
// Function to swap two array elements.
const swapping = (arr, i, j) => {
let 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
const CountMinSwaps = (arr, n) => {
// index_mod_i = count of indexes which
// give i on modulo 3: index%3==i
let 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
let array_mod_0 = 0,
array_mod_1 = 0,
array_mod_2 = 0;
let 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 ;
let index_org = i % 3;
let array_org = arr[i] % 3;
// Initially set swapped to false
let swapped = false ;
for (j = i + 1; j < n; j++) {
let index_exp = j % 3;
let 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++) {
let 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
let arr = [4, 3, 5, 2, 9, 7];
let n = arr.length;
let swaps = CountMinSwaps(arr, n);
document.write(swaps);
// This code is contributed by rakeshsahni
</script> |
3
Time Complexity: O(N2), Where N is the size of arr[].
Auxiliary Space: O(1).