Related Articles
Equalizing array using increment under modulo 3
• Difficulty Level : Basic
• Last Updated : 15 Apr, 2021

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.```

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``?>`

## Javascript

 ``

Output :

`6 units`

Time Complexity :O(n)

My Personal Notes arrow_drop_up