Given a non-empty integer array of size n, find the minimum number of moves required to make all array elements equal, where a move is incrementing n - 1 elements by 1.

Example:

Input:
[1,2,3]

Output:
3

Explanation:
Only three moves are needed (remember each move increments two elements):

[1,2,3]  =>  [2,3,3]  =>  [3,4,3]  =>  [4,4,4]

Difficulty: introductory

Starter code:

class Solution:
    def minMoves(self, nums: List[int]) -> int:
        

Solutions:
class Solution:
     def minMoves(self, nums):
         """
         :type nums: List[int]
         :rtype: int
         """
         minx=min(nums)
         sums=sum(nums)
         return sums-len(nums)*minx


class Solution:
     def minMoves(self, nums):
         """
         :type nums: List[int]
         :rtype: int
         """
         # Adding n-1 elements by 1, same as subtracting one element by 1
         m = min(nums)
         res = 0
         for i in nums:
             res += (i - m)
         return res


class Solution:
     def minMoves(self, nums):
         """
         :type nums: List[int]
         :rtype: int
         """
         return sum(nums)-len(nums)*min(nums)


class Solution:
     
     def minMoves(self, nums):
         """
         :type nums: List[int]
         :rtype: int
         """
         
         if not nums:
             return 0
         
         lowest = nums[0]
         for num in nums:
             lowest = min(num, lowest)
             
         res = 0
         for num in nums:
             res += num - lowest
             
         return res

class Solution:
     def minMoves(self, nums):
         s = sum(nums)
         minimum = min(nums)
         n = len(nums)
         result = s - minimum * n
         return result
             
             


class Solution:
     def minMoves(self, nums):
         """
         :type nums: List[int]
         :rtype: int
         """
         return sum(nums)-min(nums)*len(nums)
         


class Solution:
     def minMoves(self, nums):
         """
         :type nums: List[int]
         :rtype: int
         """
         n=len(nums)
         mn=min(nums)
 
         return sum(nums)-n*mn

class Solution:
     def minMoves(self, nums):
         """
         :type nums: List[int]
         :rtype: int
         """
         min_num = min(nums)
         result = 0
         for num in nums:
             result += num-min_num
         return result

class Solution:
     def minMoves(self, nums):
         """
         :type nums: List[int]
         :rtype: int
         """
         count = 0
         smallest = min(nums)
                 
         for num in nums:
             count += abs(num - smallest)
             
         return(count)
         
         
         


class Solution:
     def minMoves(self, nums):
         """
         :type nums: List[int]
         :rtype: int
         """
         m = min(nums)
         return sum(i-m for i in nums)


class Solution:
     def minMoves(self, nums):
         """
         :type nums: List[int]
         :rtype: int
         """
         nums_min = nums[0]
         res = 0
         for i in range(len(nums)):
             if nums[i] >= nums_min:
                 res += nums[i] - nums_min
             else:
                 res += i * (nums_min - nums[i])
                 nums_min = nums[i]
                 
         return res

class Solution:
     def minMoves(self, nums):
         """
         :type nums: List[int]
         :rtype: int
 
         let’s define sum as the sum of all the numbers, before any moves; 
             minNum as the min number int the list; 
             n is the length of the list;
 
         After, say m moves, we get all the numbers as x , and we will get the following equation
 
         sum + m * (n - 1) = x * n
         and actually,
 
           x = minNum + m
         and finally, we will get
 
           sum - minNum * n = m
         So, it is clear and easy now.        
         """
         tt = 0
         mx = nums[0]
         n = 0
         for x in nums:
             tt += x
             n += 1
             if x < mx:
                 mx = x
         return tt - mx * n
                 
             


class Solution:
     def minMoves(self, nums):
         """
         :type nums: List[int]
         :rtype: int
         """
         return sum(nums) - min(nums) * len(nums)