1class Solution {
2    public int minMoves(int[] nums) {
3        // Number of elements in the array
4        int length = nums.length;
5
6        // Track the maximum value in the array
7        int maxValue = 0;
8
9        // Accumulate the sum of all elements
10        int sum = 0;
11
12        // Single pass to compute both the maximum value and the total sum
13        for (int value : nums) {
14            maxValue = Math.max(maxValue, value);
15            sum += value;
16        }
17
18        // Key insight:
19        // Incrementing n-1 elements by 1 is equivalent (in terms of relative
20        // differences) to decrementing a single element by 1.
21        // Therefore, the problem reduces to making every element equal to the
22        // minimum element by repeatedly subtracting 1 from larger elements.
23        //
24        // However, since we use maxValue here, the formula below works as well:
25        // To make all elements equal, the target value after all moves would be
26        // (maxValue + moves). Each move increases the sum by (length - 1).
27        // Solving sum + moves * (length - 1) == (maxValue + moves) * length
28        // yields: moves = maxValue * length - sum.
29        return maxValue * length - sum;
30    }
31}
32

1class Solution {
2public:
3    int minMoves(vector<int>& nums) {
4        int n = static_cast<int>(nums.size());
5        int maxValue = 0; // Track the maximum element in the array
6        int sum = 0;      // Track the sum of all elements
7
8        // Single pass to compute both the maximum value and the total sum
9        for (int num : nums) {
10            maxValue = max(maxValue, num);
11            sum += num;
12        }
13
14        // Incrementing n-1 elements by 1 is equivalent (in relative terms)
15        // to decrementing a single element by 1. Thus, the number of moves
16        // needed is the sum of differences between each element and the
17        // minimum element. This is algebraically equal to:
18        //   sum_i (maxValue - nums[i]) when leveling everything up to maxValue,
19        // but here we use the compact identity: maxValue * n - sum.
20        return maxValue * n - sum;
21    }
22};
23```
24
25A small note worth considering: the original code initializes `maxValue` (and `mx`) to `0`. This works correctly only when all elements are non-negative. If the array can contain negative values, initializing with `nums[0]` (or `INT_MIN`) would be safer. For the standard LeetCode constraints (`-10^9 <= nums[i] <= 10^9`), a more robust initialization is recommended:
26
27```cpp
28class Solution {
29public:
30    int minMoves(vector<int>& nums) {
31        int n = static_cast<int>(nums.size());
32        long long sum = 0;          // Use long long to avoid overflow
33        int minValue = nums[0];     // Track the minimum element
34
35        // Compute the running minimum and the total sum
36        for (int num : nums) {
37            minValue = min(minValue, num);
38            sum += num;
39        }
40
41        // Total moves = sum of (each element - minimum element)
42        return static_cast<int>(sum - static_cast<long long>(minValue) * n);
43    }
44};
45

1/**
2 * Calculates the minimum number of moves to make all array elements equal,
3 * where one move increments n - 1 elements by 1.
4 *
5 * Incrementing n - 1 elements by 1 is equivalent to decrementing 1 element by 1
6 * (in terms of relative differences). Therefore, the goal becomes reducing every
7 * element down to the minimum... but here we use the complementary formulation:
8 * the total number of moves equals (max * n) - sum, which represents the total
9 * amount needed to raise every element up to the maximum value.
10 *
11 * @param nums - The input array of numbers.
12 * @returns The minimum number of moves required.
13 */
14function minMoves(nums: number[]): number {
15    // Number of elements in the array.
16    const length: number = nums.length;
17
18    // The maximum value in the array (the target each element should reach).
19    const maxValue: number = Math.max(...nums);
20
21    // The sum of all elements in the array.
22    const sum: number = nums.reduce((acc: number, cur: number) => acc + cur, 0);
23
24    // Total moves: bringing every element up to maxValue costs (maxValue * length),
25    // and subtracting the existing sum gives the total increments needed.
26    return maxValue * length - sum;
27}
28