## Pages

### HackerRank Equal

We have a list of integers, and we want to know in how many rounds we could make them all equal. In each round we add to all the items in the list but one the same number chosen among 1, 2, and 5. Pay special attention when you solve this problem on HackerRank. Currently (April 2018) its enunciation says each increase should be of one, three, or five. However, this is not what the solution is tested for.
It looks like someone decided to change 2 for 3 a few months ago, edited the description and then forgot to modify the testing part. Who knows what is going to happen next. Be ready to be surprised.
Besides, it is inserted in the Algorithms - Dynamic Programming section, but I don't think that is the right approach to follow.

Simplifying the problem

Instead of applying the weird addition process stated in the problem, we could decrease each time a single item. For instance, given in input [2, 2, 3, 7], a solution to the original problem is:
```2, 2, 3, 7
+5 +5 +5  = (1)
7, 7, 8, 7
+1 +1  = +1 (2)
8, 8, 8, 8
```
We could solve it in this way instead:
```2, 2, 3, 7
=  =  = -5 (1)
2, 2, 3, 2
=  = -1  = (2)
2, 2, 2, 2
```
Since we are asked to calculate the number of steps to get to the equal state, in both ways we get the same result.

Base cases

A sort of rough algorithm is already emerging. We get the lowest value in the list, and decrease all the other elements using the available alternatives until we reach it. We start from the biggest value (5) and only when we are forced to, we fall back to the shorter steps.

To better understand how we should manage the last steps, I put the base cases on paper.
If x is at level 1, 2 or 5, we could get zero at cost 1. But if x is at level 3 or 4, it costs 2 to us. Notice that if, instead of getting to level zero, we move both the lowest element and the x element at level -2, we get to the result in the same number of moves. For instance, if our input list is [10, 13]
```10, 13
-2 (1)
-1 (2)
10, 10

10, 13
-2     (1)
-5 (2)
8,  8
```
If the input list is [0, 3, 3] getting down to the bottom from 3 in just one move gives us an advantage:
```10, 13, 13
-2      (1)
-1      (2)
-2  (3)
-1  (4)
10, 10, 10

10, 13, 13
-2          (1)
-5      (2)
-5  (3)
8,  8,  8
```
The algorithm

I think I've got it. Firstly I find the minimum value, M, in the input list. That is a possible target for all the items to be reach. However I have to check other two alternatives, M-1 and M-2.
I loop on all the items in the list. For all the three possible targets, I calculate the difference between it and the current value, count the number of steps to get there, and add it to the total number of steps required for getting to that target.
And then I choose as a result the cheapest target to reach.

The code

Using Python as implementation language, I started with a couple of test cases, and then added a few ones along the way, when I bumped into troubles, and I ended up with this code.
```SHIFT = [0, 1, 2]  # 1

def solution(data):
lowest = min(data)  # 2

results = [0] * len(SHIFT)  # 3
for item in data:
for i in SHIFT:
gap = item - lowest + i  # 4
results[i] += gap // 5 + SHIFT[(gap%5 + 1) // 2]  # 5
return min(results)  # 6
```
1. Represents the three possible targets, from the minimal value in the list down to -2.
2. Get the minimal value in the list.
3. Buffer for the results when using the different targets.
4. Distance that has to be split.
5. Add the current number of steps to the current buffer. Firstly I get the number of long moves dividing gap by 5. Now I am in the base case, as showed in the picture above. Notice that the cost of moving from X to target is [0, 1, 1, 2, 2] for gap in [0..5], if we take gap, apply modulo five, increase it and then divide by two, we get the index in SHIFT to the number of steps actually needed. Admittedly an obscure way to get there, if this was production code, I would have probably resisted temptation to use it.
6. Get the minimal result and return it.

All tests passed in hackerrank, python script and test case pushed to GitHub.