# Equalizing array using increment under modulo 3

Given an array A containing N non-negative integers. Only following operation can be performed on the array:
A[i] = ( A[i] + 1 ) % 3
where A[i] is the element of array A at index i, and performing this operation once costs 1 unit. Find the minimum cost to make all elements equal.

Examples :

```Input : 1 0 3 2
Output : 4 units
Explanation: First 3 is converted to 1(3 + 1 % 3 = 1).
Then, if we try to make all elements equal to 1, then
converting 0 to 1 will cost "1" and 2 to 1 will cost "2".
Therefore, in total cost=3 + 1(to convert 3 to 1) = 4,
which is minimum.

Input : 98 4 3 1
Output : 6 units
Explanation: 98, 4 and 3 are converted to 0, 2 and 1.
So, now array becomes {0, 2, 1, 1}. If we try to convert
every element in our new array equal to 1, then converting
0 to 1 will cost "1" and 2 to 1 will cost "2". So, total
cost= 3+ 3(conversion of 98, 4 and 3) = 6, which is the minimum cost.
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: At first, we will try to convert all the numbers greater than 2 to a number between 0 to 2.Since, numbers from 0 to 2 will not exceed 2 using the only allowed operation A(i)=(A(i)+1) % 3(No matter how many times we do this operation). Then we will fix one of the 3 possible values(0 to 2) and find the cost of making all elements equal to it.
Minimum cost out of the three + the extra cost to convert all numbers greater than 2 to a number between 0 to 2 will be our answer.One special case we need look here is, if all the elements are equal by default (like in array {7, 7, 7, 7}), then our answer will be zero.

## C++

 `// CPP program to find minimum cost to ` `// equalize an array with increment under ` `// modulo 3 operation. ` `#include ` `using` `namespace` `std; ` ` `  `int` `mincost(``int` `a[], ``int` `n) ` `{ ` `    ``int` `c = 1; ` `     `  `    ``// loop to check whether all  ` `    ``// elements are equal or not ` `    ``for` `(``int` `i = 0; i < n; i++)  ` `        ``if` `(a[i] == a[i + 1]) ` `            ``c++; ` `     `  `    ``// A special case when all  ` `    ``// elements are equal ` `    ``if` `(c == n) ` `        ``return` `0; ` ` `  `    ``// variable that counts total  ` `    ``// numbers greater 2 ` `    ``int` `x = 0;  ` `     `  `    ``// loop to convert all numbers greater  ` `    ``// than 2 to a range between 0 to 2. ` `    ``for` `(``int` `i = 0; i < n; i++)  ` `    ``{ ` `        ``if` `(a[i] > 2) { ` `             `  `            ``// number greater than 2 gets  ` `            ``// converted to a number between 0 to 2. ` `            ``a[i] = (a[i] + 1) % 3;  ` `            ``x += 1; ` `        ``} ` `    ``} ` ` `  `    ``// variables to count 3 possible ways ` `    ``// to make all elements equal after ` `    ``// reducing them to range [0, 2] ` `    ``int` `c0 = 0, c1 = 0, c2 = 0;  ` ` `  `    ``// loop that counts total cost to ` `    ``// make all elements equal to 0. ` `    ``for` `(``int` `i = 0; i < n; i++)  ` `    ``{ ` `        ``if` `(a[i] == 1) { ` `             `  `            ``// since we will have to use the  ` `            ``// operation 2 times to convert 1 to 0 ` `            ``// (1+1)%3=2 and then (2+1)%3=0  ` `            ``c0 += 2; ` `        ``} ` ` `  `        ``// here we use it once since (2+1%3=0)         ` `        ``else` `if` `(a[i] == 2)  ` `            ``c0 += 1; ` `    ``} ` ` `  `    ``// loop that counts total cost to  ` `    ``// make all elements equal to 1 ` `    ``for` `(``int` `i = 0; i < n; i++)  ` `    ``{ ` `        ``// since (2+1%3=0) and (0+1%3=1) ` `        ``if` `(a[i] == 2)  ` `            ``c1 += 2; ` `         `  `        ``// since (0+1%3=1) ` `        ``else` `if` `(a[i] == 0)     ` `            ``c1 += 1;  ` `    ``} ` ` `  `    ``// loop that counts total cost  ` `    ``// to make all elements equal to 2 ` `    ``for` `(``int` `i = 0; i < n; i++) { ` ` `  `        ``// since 0+1%3=1 and 1+1%3=2 ` `        ``if` `(a[i] == 0)  ` `            ``c2 += 2;         ` `        ``else` `if` `(a[i] == 1)  ` `            ``c2 += 1;          ` `    ``} ` ` `  `    ``// finally the one with minimum  ` `    ``// cost will be our answer ` `    ``return` `x + min({ c0, c1, c2 }); ` `} ` ` `  `// Driver program to run above function ` `int` `main() ` `{ ` `    ``int` `a[] = { 98, 4, 3, 1 }; ` `    ``int` `n = ``sizeof``(a)/``sizeof``(a); ` `    ``cout << mincost(a, n)<<``" units"``; ` `    ``return` `0; ` `} `

## Java

 `// Java program to find minimum  ` `// cost to equalize an array  ` `// with increment under  ` `// modulo 3 operation. ` `import` `java.io.*; ` ` `  `class` `GFG  ` `{ ` `     `  `// Function to find minimum cost  ` `static` `int` `mincost(``int` `a[], ``int` `n) ` `{ ` `    ``int` `c = ``1``; ` `     `  `    ``// loop to check whether all  ` `    ``// elements are equal or not ` `    ``for` `(``int` `i = ``0``; i < n - ``1``; i++)  ` `        ``if` `(a[i] == a[i + ``1``]) ` `            ``c++; ` `     `  `    ``// A special case when all  ` `    ``// elements are equal ` `    ``if` `(c == n) ` `        ``return` `0``; ` ` `  `    ``// variable that counts total  ` `    ``// numbers greater 2 ` `    ``int` `x = ``0``;  ` `     `  `    ``// loop to convert all numbers  ` `    ``// greater than 2 to a range ` `    ``// between 0 to 2. ` `    ``for` `(``int` `i = ``0``; i < n - ``1``; i++)  ` `    ``{ ` `        ``if` `(a[i] > ``2``)  ` `        ``{ ` `             `  `            ``// number greater than 2  ` `            ``// gets converted to a ` `            ``// number between 0 to 2. ` `            ``a[i] = (a[i] + ``1``) % ``3``;  ` `            ``x += ``1``; ` `        ``} ` `    ``} ` ` `  `    ``// variables to count 3 possible  ` `    ``// ways to make all elements equal ` `    ``// after reducing them to range [0, 2] ` `    ``int` `c0 = ``0``, c1 = ``0``, c2 = ``0``;  ` ` `  `    ``// loop that counts total cost to ` `    ``// make all elements equal to 0. ` `    ``for` `(``int` `i = ``0``; i < n - ``1``; i++)  ` `    ``{ ` `        ``if` `(a[i] == ``1``)  ` `        ``{ ` `             `  `            ``// since we will have to  ` `            ``// use the operation 2  ` `            ``// times to convert 1 to 0 ` `            ``// (1+1)%3=2 and then (2+1)%3=0  ` `            ``c0 += ``2``; ` `        ``} ` ` `  `        ``// here we use it  ` `        ``// once since (2+1%3=0)  ` `        ``else` `if` `(a[i] == ``2``)  ` `            ``c0 += ``1``; ` `    ``} ` ` `  `    ``// loop that counts total cost to  ` `    ``// make all elements equal to 1 ` `    ``for` `(``int` `i = ``0``; i < n - ``1``; i++)  ` `    ``{ ` `        ``// since (2+1%3=0)  ` `        ``// and (0+1%3=1) ` `        ``if` `(a[i] == ``2``)  ` `            ``c1 += ``2``; ` `         `  `        ``// since (0+1%3=1) ` `        ``else` `if` `(a[i] == ``0``)  ` `            ``c1 += ``1``;  ` `    ``} ` ` `  `    ``// loop that counts total cost  ` `    ``// to make all elements equal to 2 ` `    ``for` `(``int` `i = ``0``; i < n - ``1``; i++)  ` `    ``{ ` ` `  `        ``// since 0+1%3=1  ` `        ``// and 1+1%3=2 ` `        ``if` `(a[i] == ``0``)  ` `            ``c2 += ``2``;      ` `        ``else` `if` `(a[i] == ``1``)  ` `            ``c2 += ``1``;          ` `    ``} ` ` `  `    ``// finally the one with minimum  ` `    ``// cost will be our answer ` `    ``return` `x + Math.min(c0,  ` `               ``Math.min(c1, c2)); ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main (String[] args)  ` `{ ` `    ``int` `a[] = ``new` `int``[]{``98``, ``4``, ``3``, ``1``}; ` `    ``int` `n = a.length; ` `    ``System.out.println(mincost(a, n) +  ` `                       ``" "` `+ ``"units"``); ` `} ` `} ` ` `  `// This code is contributed by ajit `

## Python3

 `# Python code to illustrate above approach ` `# function to calculate minimum cost ` `def` `mincost(a, n): ` ` `  `    ``# loop to check whether all elements  ` `    ``# are equal or not ` `    ``c ``=` `1` `    ``for` `i ``in` `range``(``0``, n``-``1``): ` `        ``if` `(a[i] ``=``=` `a[i ``+` `1``]): ` `            ``c ``+``=` `1` ` `  `    ``# A special case when all elements  ` `    ``# are equal ` `    ``if` `(c ``=``=` `n): ` `        ``return` `0` `     `  `    ``# loop to count total no of conversion  ` `    ``# of numbers greater than 2 to a ` `    ``# number between 0 to 2. ` `    ``x ``=` `0` `    ``for` `i ``in` `range``(n): ` `        ``if` `a[i]>``2``: ` `            ``a[i]``=``(a[i]``+``1``)``%` `3` `            ``x ``+``=` `1` `             `  `    ``# variables to count 3 possible ways ` `    ``# to make all elements equal after ` `    ``# reducing them to range [0, 2] ` `    ``c0 ``=` `c1 ``=` `c2 ``=` `0`     `     `  `    ``# loop that counts total cost to  ` `    ``# make all elements equal to 0. ` `    ``for` `i ``in` `a: ` `        ``if` `(i ``=``=` `1``): ` `            ``c0``+``=` `2` `        ``elif` `(i ``=``=` `2``): ` `            ``c0``+``=` `1` ` `  `    ``# loop that counts total cost to  ` `    ``# make all elements equal to 1.      ` `    ``for` `i ``in` `a: ` `        ``if` `(i ``=``=` `0``): ` `            ``c1``+``=` `1` `        ``elif` `(i ``=``=` `2``): ` `            ``c1``+``=` `2` `             `  `    ``# loop that counts total cost to ` `    ``# make all elements equal to 2. ` `    ``for` `i ``in` `a: ` `        ``if` `(i ``=``=` `0``): ` `            ``c2``+``=` `2` `        ``elif` `(i ``=``=` `1``): ` `            ``c2``+``=` `1` `             `  `    ``# finally the one with minimum cost  ` `    ``# plus the extra cost to convert numbers  ` `    ``# greater than 2 will be our answer ` `    ``return` `min``(c1, c2, c0)``+``x ` ` `  `# Driver code ` `n ``=` `4` `a ``=` `[``98``, ``4``, ``3``, ``1``] ` `c ``=` `1` `print``(mincost(a, n), ``"units"``) `

## C#

 `// C# program to find minimum cost to ` `// equalize an array with increment  ` `// under modulo 3 operation. ` `using` `System; ` ` `  `class` `GFG { ` ` `  `// Function to find minimum cost     ` `static` `int` `mincost(``int` `[]a, ``int` `n) ` `{ ` `    ``int` `c = 1; ` `     `  `    ``// loop to check whether all  ` `    ``// elements are equal or not ` `    ``for` `(``int` `i = 0; i < n - 1; i++)  ` `        ``if` `(a[i] == a[i + 1]) ` `            ``c++; ` `     `  `    ``// A special case when all  ` `    ``// elements are equal ` `    ``if` `(c == n) ` `        ``return` `0; ` ` `  `    ``// variable that counts total  ` `    ``// numbers greater 2 ` `    ``int` `x = 0;  ` `     `  `    ``// loop to convert all numbers greater  ` `    ``// than 2 to a range between 0 to 2. ` `    ``for` `(``int` `i = 0; i < n - 1; i++)  ` `    ``{ ` `        ``if` `(a[i] > 2) { ` `             `  `            ``// number greater than 2 gets  ` `            ``// converted to a number  ` `            ``// between 0 to 2. ` `            ``a[i] = (a[i] + 1) % 3;  ` `            ``x += 1; ` `        ``} ` `    ``} ` ` `  `    ``// variables to count 3 possible ways ` `    ``// to make all elements equal after ` `    ``// reducing them to range [0, 2] ` `    ``int` `c0 = 0, c1 = 0, c2 = 0;  ` ` `  `    ``// loop that counts total cost to ` `    ``// make all elements equal to 0. ` `    ``for` `(``int` `i = 0; i < n - 1; i++)  ` `    ``{ ` `        ``if` `(a[i] == 1)  ` `        ``{ ` `             `  `            ``// since we will have to use the  ` `            ``// operation 2 times to convert 1 to 0 ` `            ``// (1+1)%3=2 and then (2+1)%3=0  ` `            ``c0 += 2; ` `        ``} ` ` `  `        ``// here we use it once since (2+1%3=0)      ` `        ``else` `if` `(a[i] == 2)  ` `            ``c0 += 1; ` `    ``} ` ` `  `    ``// loop that counts total cost to  ` `    ``// make all elements equal to 1 ` `    ``for` `(``int` `i = 0; i < n - 1; i++)  ` `    ``{ ` `        ``// since (2+1%3=0) and (0+1%3=1) ` `        ``if` `(a[i] == 2)  ` `            ``c1 += 2; ` `         `  `        ``// since (0+1%3=1) ` `        ``else` `if` `(a[i] == 0)  ` `            ``c1 += 1;  ` `    ``} ` ` `  `    ``// loop that counts total cost  ` `    ``// to make all elements equal to 2 ` `    ``for` `(``int` `i = 0; i < n - 1; i++)  ` `    ``{ ` ` `  `        ``// since 0+1%3=1 and 1+1%3=2 ` `        ``if` `(a[i] == 0)  ` `            ``c2 += 2;      ` `        ``else` `if` `(a[i] == 1)  ` `            ``c2 += 1;          ` `    ``} ` ` `  `    ``// finally the one with minimum  ` `    ``// cost will be our answer ` `    ``return` `x + Math.Min(c0,  ` `               ``Math.Min(c1, c2) ); ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main()  ` `{  ` `        ``int` `[]a = ``new` `int``[]{98, 4, 3, 1}; ` `        ``int` `n = a.Length; ` `        ``Console.Write(mincost(a, n) +  ` `                      ``" "` `+ ``"units"``); ` `         `  `}  ` `} ` ` `  `// This code is contributed by Sam007. `

## PHP

 ` 2)  ` `        ``{ ` `             `  `            ``// number greater than 2  ` `            ``// gets converted to a ` `            ``// number between 0 to 2. ` `            ``\$a``[``\$i``] = (``\$a``[``\$i``] + 1) % 3;  ` `            ``\$x` `+= 1; ` `        ``} ` `    ``} ` ` `  `    ``// variables to count 3  ` `    ``// possible ways to make  ` `    ``// all elements equal after ` `    ``// reducing them to range [0, 2] ` `    ``\$c0` `= 0; ``\$c1` `= 0; ``\$c2` `= 0;  ` ` `  `    ``// loop that counts total  ` `    ``// cost to make all elements ` `    ``// equal to 0. ` `    ``for` `(``\$i` `= 0; ``\$i` `< ``\$n``; ``\$i``++)  ` `    ``{ ` `        ``if` `(``\$a``[``\$i``] == 1) ` `        ``{ ` `             `  `            ``// since we will have to ` `            ``// use the operation 2  ` `            ``// times to convert 1 to 0  ` `            ``// (1+1)%3=2 and then (2+1)%3=0  ` `            ``\$c0` `+= 2; ` `        ``} ` ` `  `        ``// here we use it  ` `        ``// once since (2+1%3=0)  ` `        ``else` `if` `(``\$a``[``\$i``] == 2)  ` `            ``\$c0` `+= 1; ` `    ``} ` ` `  `    ``// loop that counts total  ` `    ``// cost to make all  ` `    ``// elements equal to 1 ` `    ``for` `(``\$i` `= 0; ``\$i` `< ``\$n``; ``\$i``++)  ` `    ``{ ` `        ``// since (2+1%3=0) and  ` `        ``// (0+1%3=1) ` `        ``if` `(``\$a``[``\$i``] == 2)  ` `            ``\$c1` `+= 2; ` `         `  `        ``// since (0+1%3=1) ` `        ``else` `if` `(``\$a``[``\$i``] == 0)  ` `            ``\$c1` `+= 1;  ` `    ``} ` ` `  `    ``// loop that counts total  ` `    ``// cost to make all  ` `    ``// elements equal to 2 ` `    ``for` `(``\$i` `= 0; ``\$i` `< ``\$n``; ``\$i``++) ` `    ``{ ` ` `  `        ``// since 0+1%3=1  ` `        ``// and 1+1%3=2 ` `        ``if` `(``\$a``[``\$i``] == 0)  ` `            ``\$c2` `+= 2;  ` `        ``else` `if` `(``\$a``[``\$i``] == 1)  ` `            ``\$c2` `+= 1;      ` `    ``} ` ` `  `    ``// finally the one with  ` `    ``// minimum cost will  ` `    ``// be our answer ` `    ``return` `\$x` `+ min(``\$c0``, ``\$c1``, ``\$c2` `); ` `} ` ` `  `// Driver Code ` `\$a` `= ``array``(98, 4, 3, 1); ` `\$n` `= sizeof(``\$a``); ` `echo` `mincost(``\$a``, ``\$n``), ``" units"``; ` ` `  `// This code is contributed by ajit ` `?> `

Output :

```6 units
```

Time Complexity :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 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.

Improved By : Sam007, jit_t

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.