# Leetcode Minimum Moves to Equal Array Elements problem solution

In this Leetcode Minimum Moves to Equal Array Elements problem solution we have given an integer array nums of size n, return the minimum number of moves required to make all array elements equal. In one move, you can increment n - 1 element of the array by 1.

## Problem solution in Python.

```class Solution:
def minMoves(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
if nums.count(nums[0]) == len(nums):
return 0

nums.sort()

step = 0

for i in range(nums.index(max(nums)), 0, -1):
step += (nums[i] - nums[i-1]) * (len(nums) - i)

return step
```

## Problem solution in Java.

```class Solution {
public int minMoves(int[] nums) {
if(nums.length == 0) return 0;

int sum = 0;
int smallest = nums[0];
for(int i:nums) {
sum +=i;
if (i < smallest)
smallest = i;
}
return sum - nums.length * smallest;
}
}
```

## Problem solution in C++.

```class Solution {
public:
int minMoves(vector<int>& nums) {
int count=0;
int mini=INT_MAX;
for(int num:nums){
mini=min(mini,num);
count+=num;
}
return count-mini*nums.size();
}
};
```

## Problem solution in C.

```int comp(const void* x, const void* y)
{
int a = *(int*)x;
int b = *(int*)y;

if (a > b)
return 1;
else if (a < b)
return -1;
else
return 0;
}

int minMoves(int* nums, int numsSize){
int i;
int f_n = 0;

if (numsSize <= 1)
return 0;

qsort(nums, numsSize, sizeof(*nums), comp);

for (i = 1; i <numsSize; i++) {
f_n = f_n + (nums[i] - nums[0]);
}

return f_n;
}
```