Move from brute-force thinking to an efficient approach using two pointers strategy.
You are given a 0-indexed string s of even length n. The string consists of exactly n / 2 opening brackets '[' and n / 2 closing brackets ']'.
A string is called balanced if and only if:
AB, where both A and B are balanced strings, or[C], where C is a balanced string.You may swap the brackets at any two indices any number of times.
Return the minimum number of swaps to make s balanced.
Example 1:
Input: s = "][][" Output: 1 Explanation: You can make the string balanced by swapping index 0 with index 3. The resulting string is "[[]]".
Example 2:
Input: s = "]]][[[" Output: 2 Explanation: You can do the following to make the string balanced: - Swap index 0 with index 4. s = "[]][][". - Swap index 1 with index 5. s = "[[][]]". The resulting string is "[[][]]".
Example 3:
Input: s = "[]" Output: 0 Explanation: The string is already balanced.
Constraints:
n == s.length2 <= n <= 106n is even.s[i] is either '[' or ']'.'[' equals n / 2, and the number of closing brackets ']' equals n / 2.Problem summary: You are given a 0-indexed string s of even length n. The string consists of exactly n / 2 opening brackets '[' and n / 2 closing brackets ']'. A string is called balanced if and only if: It is the empty string, or It can be written as AB, where both A and B are balanced strings, or It can be written as [C], where C is a balanced string. You may swap the brackets at any two indices any number of times. Return the minimum number of swaps to make s balanced.
Start with the most direct exhaustive search. That gives a correctness anchor before optimizing.
Pattern signal: Two Pointers · Stack · Greedy
"][]["
"]]][[["
"[]"
remove-invalid-parentheses)minimum-add-to-make-parentheses-valid)minimum-remove-to-make-valid-parentheses)minimum-insertions-to-balance-a-parentheses-string)Source-backed implementations are provided below for direct study and interview prep.
// Accepted solution for LeetCode #1963: Minimum Number of Swaps to Make the String Balanced
class Solution {
public int minSwaps(String s) {
int x = 0;
for (int i = 0; i < s.length(); ++i) {
char c = s.charAt(i);
if (c == '[') {
++x;
} else if (x > 0) {
--x;
}
}
return (x + 1) / 2;
}
}
// Accepted solution for LeetCode #1963: Minimum Number of Swaps to Make the String Balanced
func minSwaps(s string) int {
x := 0
for _, c := range s {
if c == '[' {
x++
} else if x > 0 {
x--
}
}
return (x + 1) / 2
}
# Accepted solution for LeetCode #1963: Minimum Number of Swaps to Make the String Balanced
class Solution:
def minSwaps(self, s: str) -> int:
x = 0
for c in s:
if c == "[":
x += 1
elif x:
x -= 1
return (x + 1) >> 1
// Accepted solution for LeetCode #1963: Minimum Number of Swaps to Make the String Balanced
impl Solution {
pub fn min_swaps(s: String) -> i32 {
let mut extra_close = 0;
let mut max_close = 0;
for c in s.chars() {
if c == '[' {
extra_close -= 1;
} else {
extra_close += 1;
}
max_close = max_close.max(extra_close);
}
(max_close + 1) / 2
}
}
// Accepted solution for LeetCode #1963: Minimum Number of Swaps to Make the String Balanced
function minSwaps(s: string): number {
let x = 0;
for (const c of s) {
if (c === '[') {
++x;
} else if (x) {
--x;
}
}
return (x + 1) >> 1;
}
Use this to step through a reusable interview workflow for this problem.
Two nested loops check every pair of elements. The outer loop picks one element, the inner loop scans the rest. For n elements that is n × (n−1)/2 comparisons = O(n²). No extra memory — just two loop variables.
Each pointer traverses the array at most once. With two pointers moving inward (or both moving right), the total number of steps is bounded by n. Each comparison is O(1), giving O(n) overall. No auxiliary data structures are needed — just two index variables.
Review these before coding to avoid predictable interview regressions.
Wrong move: Advancing both pointers shrinks the search space too aggressively and skips candidates.
Usually fails on: A valid pair can be skipped when only one side should move.
Fix: Move exactly one pointer per decision branch based on invariant.
Wrong move: Pushing without popping stale elements invalidates next-greater/next-smaller logic.
Usually fails on: Indices point to blocked elements and outputs shift.
Fix: Pop while invariant is violated before pushing current element.
Wrong move: Locally optimal choices may fail globally.
Usually fails on: Counterexamples appear on crafted input orderings.
Fix: Verify with exchange argument or monotonic objective before committing.