Watch 10 video solutions for Minimum Operations to Equalize Array, a easy level problem involving Array, Bit Manipulation, Brainteaser. This walkthrough by Programming Live with Larry has 441 views views. Want to try solving it yourself? Practice on FleetCode or read the detailed text solution.
You are given an integer array nums of length n.
In one operation, choose any subarray nums[l...r] (0 <= l <= r < n) and replace each element in that subarray with the bitwise AND of all elements.
Return the minimum number of operations required to make all elements of nums equal.
Example 1:
Input: nums = [1,2]
Output: 1
Explanation:
Choose nums[0...1]: (1 AND 2) = 0, so the array becomes [0, 0] and all elements are equal in 1 operation.
Example 2:
Input: nums = [5,5,5]
Output: 0
Explanation:
nums is [5, 5, 5] which already has all elements equal, so 0 operations are required.
Constraints:
1 <= n == nums.length <= 1001 <= nums[i] <= 105Problem Overview: You are given an array of integers and need the minimum number of operations required to make every element identical. Each operation effectively changes individual bits of numbers, so the task reduces to deciding the optimal final bit configuration shared by all elements.
Approach 1: Bit Counting / Single Pass (O(n * B) time, O(1) space)
Look at the array bit-by-bit instead of value-by-value. For any bit position b, some numbers have that bit set while others do not. If all numbers must become equal, every element must end up with the same value at that bit. The cheapest choice is whichever already appears more frequently. Count how many elements have bit b set (ones) and how many do not (zeros). Converting the minority side requires min(ones, zeros) operations. Repeat this logic for every bit position and sum the costs.
This works because each bit position is independent. Flipping a bit in one number does not affect other bits, so the optimal strategy is simply minimizing flips per bit. While iterating through the array once, update counts for each bit using standard Bit Manipulation operations like (num >> b) & 1. After processing the array, compute the minimal operations across all bit positions.
The approach behaves like a frequency problem applied to bits. Instead of comparing full integers, you align the binary representation column-by-column. This keeps the implementation simple and avoids sorting or repeated transformations often seen in typical Array equalization problems.
Recommended for interviews: The single-pass bit counting approach is what interviewers expect. It demonstrates that you recognized the independence of bit positions and reduced the problem to a counting task. A naive idea of repeatedly modifying numbers until they match shows intuition, but the bit-frequency insight proves you understand how bitwise operations simplify array transformation problems.
| Approach | Time | Space | When to Use |
|---|---|---|---|
| Brute Force Equalization | O(n^2) | O(1) | Conceptual baseline when trying every target value |
| Bit Counting (Single Pass) | O(n * B) | O(1) | Optimal approach; iterate once and minimize flips per bit |
| Frequency-Based Target Selection | O(n) | O(n) | Useful if explicitly transforming to the most common value |