# 517 Super Washing Machines

17 Super Washing Machines

You have**n**super washing machines on a line. Initially, each washing machine has some dresses or is empty.

For each**move**, you could choose**any m**(1 ≤ m ≤ n) washing machines, and pass**one dress**of each washing machine to one of its adjacent washing machines**at the same time**.

Given an integer array representing the number of dresses in each washing machine from left to right on the line, you should find the**minimum number of moves**to make all the washing machines have the same number of dresses. If it is not possible to do it, return -1.

**Example1**

```
Input:
 [1,0,5]


Output:
 3


Explanation:

1st move:    1     0 
<
-- 5    =
>
    1     1     4
2nd move:    1 
<
-- 1 
<
-- 4    =
>
    2     1     3    
3rd move:    2     1 
<
-- 3    =
>
    2     2     2
```

**Example2**

```
Input:
 [0,3,0]


Output:
 2


Explanation:

1st move:    0 
<
-- 3     0    =
>
    1     2     0    
2nd move:    1     2 --
>
 0    =
>
    1     1     1
```

**Example3**

```
Input:
 [0,2,0]


Output:
 -1


Explanation:

It's impossible to make all the three washing machines have the same number of dresses.
```

**Note:**

1. The range of n is \[1, 10000].
2. The range of dresses number in a super washing machine is \[0, 1e5].

**The Idea:** (not currently working)

* First check if it is possible to have an equivalent array. This is so, if the all the elements in the array can be equally divisible by the size of the array.
* The sort the array, and exchange elements from the min and max until the numbers are equivalent. A quicker operation would be to take the difference between them, and accumulate this as the number of exchanges.

```python
def findMindMoves(machines):
    """
    :type machines List[int]
    :rtype: int
    """

    total_sum = sum(machines)
    start = 0
    end = len(machines)

    if (not (((total_sum/end))).is_integer()):
        return -1

    machines.sort()
    swap_count = 0
    while (end > start):

        edge_diff = machines[end - 1] - machines[start]
        if (((edge_diff / 2)).is_integer()):
            swap_count += split_diff
        else:
            swap_count += int(split_diff) - 1

        start+=1
        end-=1

    return int(swap_count)


print(findMindMoves([1,0,5]))
print(findMindMoves([0,3,0]))
print(findMindMoves([0,2,0]))
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://maksimdan.gitbook.io/interview-practice-problems/leetcode_sessions/517-super-washing-machines.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.