1class Solution {
2    /**
3     * Determines the minimum number of operations needed.
4     *
5     * Logic:
6     * - If all elements in the array are identical, no operation is needed (return 0).
7     * - Otherwise, exactly one operation is sufficient (return 1).
8     *
9     * @param nums the input array of integers
10     * @return the minimum number of operations (0 or 1)
11     */
12    public int minOperations(int[] nums) {
13        // Iterate through every element in the array
14        for (int num : nums) {
15            // If any element differs from the first element,
16            // the array is not uniform, so one operation is required
17            if (num != nums[0]) {
18                return 1;
19            }
20        }
21        // All elements are identical; no operation is needed
22        return 0;
23    }
24}
25

1class Solution {
2public:
3    int minOperations(vector<int>& nums) {
4        // Iterate through every element in the array
5        for (int num : nums) {
6            // If any element differs from the first element,
7            // the array is not uniform, so one operation is needed
8            if (num != nums[0]) {
9                return 1;
10            }
11        }
12        // All elements are identical, so no operation is required
13        return 0;
14    }
15};
16```
17
18**Explanation of the logic:**
19
201. **Check uniformity**: The loop compares each element `num` against the first element `nums[0]`.
212. **Early exit**: As soon as a mismatch is found, the function returns `1`, meaning at least one operation is necessary.
223. **Default case**: If the loop completes without finding any difference, all elements are equal, and `0` is returned.
23
24**Alternative perspectives:**
25
26- **Using STL algorithms**: The same logic can be expressed more concisely with `std::all_of` or `std::adjacent_find`:
27
28```cpp
29class Solution {
30public:
31    int minOperations(vector<int>& nums) {
32        // Return 0 if all elements equal the first one, otherwise 1
33        return all_of(nums.begin(), nums.end(),
34                      [&](int num) { return num == nums[0]; }) ? 0 : 1;
35    }
36};
37

1/**
2 * Determines the minimum number of operations needed.
3 * If all elements in the array are identical, no operation is needed (returns 0).
4 * Otherwise, a single operation is sufficient (returns 1).
5 *
6 * @param nums - The input array of numbers
7 * @returns The minimum number of operations (0 or 1)
8 */
9function minOperations(nums: number[]): number {
10    // Iterate through each element in the array
11    for (const num of nums) {
12        // If any element differs from the first element,
13        // the array is not uniform, so one operation is required
14        if (num !== nums[0]) {
15            return 1;
16        }
17    }
18    // All elements are identical, so no operation is needed
19    return 0;
20}
21```
22
23**Explanation of the logic:**
24
251. **Iteration**: The function loops through every element of `nums`.
262. **Comparison**: Each element is compared against the first element `nums[0]`.
273. **Early exit**: As soon as a mismatch is found, the function returns `1`, since at least one operation is needed to make the array uniform.
284. **Uniform case**: If the loop completes without finding any mismatch, all elements are equal, so the function returns `0`.
29
30**Complexity analysis:**
31
32- **Time complexity**: O(n) — in the worst case, every element is checked once.
33- **Space complexity**: O(1) — only constant extra space is used.
34
35**Alternative approach** using built-in array methods:
36
37```typescript
38/**
39 * Alternative one-liner using Array.prototype.every.
40 * Returns 0 if all elements equal the first element, otherwise 1.
41 *
42 * @param nums - The input array of numbers
43 * @returns The minimum number of operations (0 or 1)
44 */
45function minOperations(nums: number[]): number {
46    // Check whether every element matches the first one
47    return nums.every((num) => num === nums[0]) ? 0 : 1;
48}
49