> For the complete documentation index, see [llms.txt](https://maksimdan.gitbook.io/interview-practice-problems/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://maksimdan.gitbook.io/interview-practice-problems/leetcode_sessions/517-super-washing-machines.md).

# 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
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.